Add options to set PR to Approved or Needs Work

README.md

@@ -61,6 +61,8 @@ Select *Stash Pull Request Builder* then configure:
 - **Phrase to disable builds**: Don't build the PR if the specified phrase has been posted in a PR comment. Default: *NO TEST*
 - **Only build if asked with the build phrase**: Only trigger the build when the build phrase has been posted.
 - **Phrase to request a build**: Force (re-)building the PR if the specified phrase has been posted as a PR comment in Stash. This is useful when a build fails due to circumstances unrelated to the codebase. Starting a build in Jenkins GUI won't work, as the pull request data won't be available. Default: *test this please*
+- **Approve PR on build success**: Marks a PR as Approved when build succeeds.
+- **Mark PR with Needs Work on build failure**: Mark a PR with "Needs Work" when build fails.
 
 ## Building the merge of Source Branch into Target Branch
 

pom.xml

@@ -85,6 +85,12 @@
       <artifactId>credentials</artifactId>
       <version>2.1.5</version>
     </dependency>
+    <dependency>
+      <groupId>org.mockito</groupId>
+      <artifactId>mockito-core</artifactId>
+      <version>2.7.22</version>
+      <scope>test</scope>
+    </dependency>
   </dependencies>
 
   <repositories>

src/main/java/stashpullrequestbuilder/stashpullrequestbuilder/StashBuildTrigger.java

@@ -67,6 +67,8 @@ public class StashBuildTrigger extends Trigger<AbstractProject<?, ?>> {
     private final boolean onlyBuildOnComment;
     private final boolean deletePreviousBuildFinishComments;
     private final boolean cancelOutdatedJobsEnabled;
+    private final boolean approveOnBuildSuccessful;
+    private final boolean needsWorkOnBuildFailure;
 
     private boolean checkProbeMergeStatus;
 
@@ -93,7 +95,9 @@ public StashBuildTrigger(
             String ciBuildPhrases,
             boolean deletePreviousBuildFinishComments,
             String targetBranchesToBuild,
-            boolean cancelOutdatedJobsEnabled
+            boolean cancelOutdatedJobsEnabled,
+            boolean approveOnBuildSuccessful,
+            boolean needsWorkOnBuildFailure
     ) throws ANTLRException {
         super(cron);
         this.projectPath = projectPath;
@@ -113,6 +117,8 @@ public StashBuildTrigger(
         this.onlyBuildOnComment = onlyBuildOnComment;
         this.deletePreviousBuildFinishComments = deletePreviousBuildFinishComments;
         this.targetBranchesToBuild = targetBranchesToBuild;
+        this.approveOnBuildSuccessful = approveOnBuildSuccessful;
+        this.needsWorkOnBuildFailure = needsWorkOnBuildFailure;
     }
 
     @DataBoundSetter
@@ -198,6 +204,14 @@ public boolean isCancelOutdatedJobsEnabled() {
         return cancelOutdatedJobsEnabled;
     }
 
+    public boolean isApproveOnBuildSuccessful() {
+        return approveOnBuildSuccessful;
+    }
+
+     public boolean isNeedsWorkOnBuildFailure() {
+        return needsWorkOnBuildFailure;
+    }
+
     @Override
     public void start(AbstractProject<?, ?> project, boolean newInstance) {
         try {

src/main/java/stashpullrequestbuilder/stashpullrequestbuilder/StashBuilds.java

@@ -77,6 +77,16 @@ public void onCompleted(AbstractBuild build, TaskListener listener) {
                 cause.getDestinationCommitHash(), result, buildUrl,
                 build.getNumber(), additionalComment, duration);
 
+        // Mark PR as Approved or Needs Work
+        StashMarkStatus status = new StashMarkStatus();
+        status.handleStatus(
+                trigger.isApproveOnBuildSuccessful(),
+                trigger.isNeedsWorkOnBuildFailure(),
+                cause.getPullRequestId(),
+                build.getResult(),
+                repository
+        );
+
         //Merge PR
         StashBuildTrigger trig = StashBuildTrigger.getTrigger(build.getProject());
         if(trig.getMergeOnSuccess() && build.getResult() == Result.SUCCESS) {

src/main/java/stashpullrequestbuilder/stashpullrequestbuilder/StashMarkStatus.java

@@ -0,0 +1,18 @@
+package stashpullrequestbuilder.stashpullrequestbuilder;
+
+import hudson.model.Result;
+import hudson.model.Run;
+
+public class StashMarkStatus {
+
+     public void handleStatus(Boolean approveOnBuildSuccessful, Boolean needsWorkOnBuildFailure, String pullRequestId,
+        Result result, StashRepository repository) {
+        if(approveOnBuildSuccessful && result == Result.SUCCESS) {
+            repository.markStatus(pullRequestId, "APPROVED");
+        }
+
+        if(needsWorkOnBuildFailure && result == Result.FAILURE) {
+            repository.markStatus(pullRequestId, "NEEDS_WORK");
+        }
+    }
+}

src/main/java/stashpullrequestbuilder/stashpullrequestbuilder/StashRepository.java

@@ -204,6 +204,10 @@ public boolean mergePullRequest(String pullRequestId, String version)
         return this.client.mergePullRequest(pullRequestId, version);
     }
 
+    public void markStatus(String pullRequestId, String status) {
+        this.client.markStatus(pullRequestId, status);
+    }
+
     private Boolean isPullRequestMergable(StashPullRequestResponseValue pullRequest) {
         if (trigger.isCheckMergeable() || trigger.isCheckNotConflicted() || trigger.isCheckProbeMergeStatus()) {
             /* Request PR status from Stash, and consult our configuration

src/main/java/stashpullrequestbuilder/stashpullrequestbuilder/stash/StashApiClient.java

@@ -11,6 +11,7 @@
 import org.apache.commons.httpclient.methods.DeleteMethod;
 import org.apache.commons.httpclient.methods.GetMethod;
 import org.apache.commons.httpclient.methods.PostMethod;
+import org.apache.commons.httpclient.methods.PutMethod;
 import org.apache.commons.httpclient.methods.StringRequestEntity;
 import org.apache.commons.httpclient.params.HttpConnectionParams;
 import org.apache.commons.httpclient.params.HttpParams;
@@ -64,11 +65,13 @@ public class StashApiClient {
     private String project;
     private String repositoryName;
     private Credentials credentials;
+    private String username;
 
 
     public StashApiClient(String stashHost, String username, String password, String project, String repositoryName, boolean ignoreSsl) {
         this.credentials = new UsernamePasswordCredentials(username, password);
         this.project = project;
+	this.username = username;
         this.repositoryName = repositoryName;
         this.apiBaseUrl = stashHost.replaceAll("/$", "") + "/rest/api/1.0/projects/";
         if (ignoreSsl) {
@@ -128,6 +131,17 @@ public void deletePullRequestComment(String pullRequestId, String commentId) {
         deleteRequest(path);
     }
 
+    public void markStatus(String pullRequestId, String status) {
+        String path = pullRequestPath(pullRequestId) + "/participants/" + username;
+
+        try {
+            putRequest(path, status);
+        } catch (UnsupportedEncodingException e) {
+            e.printStackTrace();
+        } catch (IOException e) {
+            logger.log(Level.SEVERE, "Failed to mark Stash PR status " + path + " " + e);
+        }
+    }
 
     public StashPullRequestComment postPullRequestComment(String pullRequestId, String comment) {
         String path = pullRequestPath(pullRequestId) + "/comments";
@@ -414,6 +428,94 @@ public Callable<String> init(HttpClient client, PostMethod httppost) {
         return response;
     }
 
+    private String putRequest(String path, String status) throws UnsupportedEncodingException {
+        logger.log(Level.FINEST, "PR-PUT-REQUEST:" + path + " with: " + status);
+        HttpClient client = getHttpClient();
+	client.getState().setCredentials(AuthScope.ANY, credentials);
+
+        PutMethod httpput = new PutMethod(path);
+        //http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html; section 14.10.
+        //tells the server that we want it to close the connection when it has sent the response.
+        //address large amount of close_wait sockets client and fin sockets server side
+	httpput.setRequestHeader("Connection", "close");
+        httpput.setRequestHeader("X-Atlassian-Token", "no-check"); //xsrf
+
+         if (status != null) {
+            ObjectNode node = mapper.getNodeFactory().objectNode();
+            node.put("status", status);
+            StringRequestEntity requestEntity = null;
+            try {
+                requestEntity = new StringRequestEntity(
+                        mapper.writeValueAsString(node),
+			"application/json",
+                        "UTF-8");
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            httpput.setRequestEntity(requestEntity);
+        }
+
+         String response = "";
+        FutureTask<String> httpTask = null;
+        Thread thread;
+
+         try {
+            //Run the http request in a future task so we have the opportunity
+            //to cancel it if it gets hung up; which is possible if stuck at
+            //socket native layer.  see issue JENKINS-30558
+            httpTask = new FutureTask<String>(new Callable<String>() {
+
+                private HttpClient client;
+                private PutMethod httpput;
+
+                @Override
+                public String call() throws Exception {
+
+                    String response = "";
+                    int responseCode = HttpStatus.SC_INTERNAL_SERVER_ERROR;
+		    responseCode = client.executeMethod(httpput);
+                    if (!validResponseCode(responseCode)) {
+                        logger.log(Level.SEVERE, "Failing to get response from Stash PR PUT" + httpput.getURI().getPath());
+                        throw new RuntimeException("Didn't get a 200 response from Stash PR PUT! Response; '" +
+                                responseCode + "' with message; " + response);
+                    }
+                    InputStream responseBodyAsStream = httpput.getResponseBodyAsStream();
+                    StringWriter stringWriter = new StringWriter();
+                    IOUtils.copy(responseBodyAsStream, stringWriter, "UTF-8");
+                    response = stringWriter.toString();
+                    logger.log(Level.FINEST, "API Request Response: " + response);
+
+                    return response;
+
+                 }
+
+                 public Callable<String> init(HttpClient client, PutMethod httpput) {
+                    this.client = client;
+                    this.httpput = httpput;
+                    return this;
+                }
+
+             }.init(client, httpput));
+            thread = new Thread(httpTask);
+            thread.start();
+            response = httpTask.get((long) StashApiClient.HTTP_REQUEST_TIMEOUT_SECONDS, TimeUnit.SECONDS);
+
+         } catch (TimeoutException e) {
+            e.printStackTrace();
+            httpput.abort();
+            throw new RuntimeException(e);
+        } catch (Exception e) {
+            e.printStackTrace();
+            throw new RuntimeException(e);
+        } finally {
+            httpput.releaseConnection();
+        }
+
+         logger.log(Level.FINEST, "PR-PUT-RESPONSE:" + response);
+
+         return response;
+    }
+
     private boolean validResponseCode(int responseCode) {
         return responseCode == HttpStatus.SC_OK ||
                 responseCode == HttpStatus.SC_ACCEPTED ||

src/main/resources/stashpullrequestbuilder/stashpullrequestbuilder/StashBuildTrigger/config.jelly

@@ -52,5 +52,11 @@
     <f:entry title="Phrase to request a (re-)build" field="ciBuildPhrases">
       <f:textbox default="test this please"/>
     </f:entry>
+    <f:entry title="Approve PR on build success" field="approveOnBuildSuccessful">
+      <f:checkbox default="false"/>
+    </f:entry>
+    <f:entry title="Mark PR with Needs Work on build failure" field="needsWorkOnBuildFailure">
+      <f:checkbox default="false"/>
+    </f:entry>
   </f:advanced>
 </j:jelly>

src/test/java/stashpullrequestbuilder/stashpullrequestbuilder/stash/StashMarkStatusTest.java

@@ -0,0 +1,55 @@
+package stashpullrequestbuilder.stashpullrequestbuilder;
+
+import hudson.model.Result;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import static org.mockito.Mockito.*;
+
+public class StashMarkStatusTest {
+
+    private StashRepository repository;
+
+    @Before
+    public void setUp() throws Exception {
+        repository = mock(StashRepository.class);
+    }
+
+    @Test
+    public void handleStatus_shouldMarkStatusApprovedOnSuccessfulBuild() throws Exception {
+        StashMarkStatus status = new StashMarkStatus();
+
+        status.handleStatus(true, false, "", Result.SUCCESS, repository);
+
+        verify(repository).markStatus("", "APPROVED");
+    }
+
+    @Test
+    public void handleStatus_shouldMarkStatusNeedsWorkOnFailedBuild() throws Exception {
+        StashMarkStatus status = new StashMarkStatus();
+
+        status.handleStatus(false, true, "", Result.FAILURE, repository);
+
+        verify(repository).markStatus("", "NEEDS_WORK");
+    }
+
+    @Test
+    public void handleStatus_shouldNotMarkStatusApprovedWhenDisabled() throws Exception {
+        StashMarkStatus status = new StashMarkStatus();
+
+        status.handleStatus(false, false, "", Result.SUCCESS, repository);
+
+        verify(repository, never()).markStatus("", "APPROVED");
+    }
+
+    @Test
+    public void handleStatus_shouldNotMarkStatusNeedsWorkWhenDisabled() throws Exception {
+        StashMarkStatus status = new StashMarkStatus();
+
+        status.handleStatus(false, false, "", Result.FAILURE, repository);
+
+        verify(repository, never()).markStatus("", "NEEDS_WORK");
+    }
+
+}