Version 0.1.00.1.0

7 files changed, 886 insertions, 0 deletions

diff --git a/src/main/java/org/jenkinsci/plugins/bbprb/BitbucketAdditionalParameterEnvironmentContributor.java b/src/main/java/org/jenkinsci/plugins/bbprb/BitbucketAdditionalParameterEnvironmentContributor.java
new file mode 100644
index 0000000..2e9d8bc
--- /dev/null
+++ b/src/main/java/org/jenkinsci/plugins/bbprb/BitbucketAdditionalParameterEnvironmentContributor.java
@@ -0,0 +1,39 @@
+package org.jenkinsci.plugins.bbprb;
+
+import hudson.EnvVars;
+import hudson.Extension;
+import hudson.model.*;
+
+import java.io.IOException;
+
+@Extension
+public class BitbucketAdditionalParameterEnvironmentContributor
+    extends EnvironmentContributor {
+  @Override
+  public void buildEnvironmentFor(Run run, EnvVars envVars,
+                                  TaskListener taskListener)
+      throws IOException, InterruptedException {
+
+    BitbucketCause cause = (BitbucketCause)run.getCause(BitbucketCause.class);
+    if (cause == null) {
+      return;
+    }
+
+    putEnvVar(envVars, "destinationRepository",
+              cause.getDestinationRepository());
+    putEnvVar(envVars, "pullRequestAuthor", cause.getPullRequestAuthor());
+    putEnvVar(envVars, "pullRequestId", cause.getPullRequestId());
+    putEnvVar(envVars, "pullRequestTitle", cause.getPullRequestTitle());
+    putEnvVar(envVars, "sourceBranch", cause.getSourceBranch());
+    putEnvVar(envVars, "sourceRepository", cause.getSourceRepository());
+    putEnvVar(envVars, "targetBranch", cause.getTargetBranch());
+  }
+
+  private static void putEnvVar(EnvVars envs, String name, String value) {
+    envs.put(name, getString(value, ""));
+  }
+
+  private static String getString(String actual, String d) {
+    return actual == null ? d : actual;
+  }
+}
diff --git a/src/main/java/org/jenkinsci/plugins/bbprb/BitbucketBuildListener.java b/src/main/java/org/jenkinsci/plugins/bbprb/BitbucketBuildListener.java
new file mode 100644
index 0000000..efcc13a
--- /dev/null
+++ b/src/main/java/org/jenkinsci/plugins/bbprb/BitbucketBuildListener.java
@@ -0,0 +1,69 @@
+package org.jenkinsci.plugins.bbprb;
+
+import hudson.Extension;
+import hudson.model.AbstractBuild;
+import hudson.model.Job;
+import hudson.model.TaskListener;
+import hudson.model.listeners.RunListener;
+import hudson.triggers.Trigger;
+import java.io.IOException;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import hudson.model.Result;
+
+import org.jenkinsci.plugins.bbprb.bitbucket.BuildState;
+
+@Extension
+public class BitbucketBuildListener extends RunListener<AbstractBuild<?, ?>> {
+
+  @Override
+  public void onStarted(AbstractBuild<?, ?> build, TaskListener listener) {
+    BitbucketCause cause = build.getCause(BitbucketCause.class);
+    if (cause == null) {
+      return;
+    }
+
+    BitbucketBuildTrigger trigger = extractTrigger(build);
+    if (trigger == null) {
+      return;
+    }
+
+    LOGGER.log(Level.FINE, "Started by BitbucketBuildTrigger");
+    trigger.setPRState(cause, BuildState.INPROGRESS, build.getUrl());
+    try {
+      build.setDescription(
+          build.getCause(BitbucketCause.class).getShortDescription());
+    } catch (IOException e) {
+      LOGGER.log(Level.WARNING, "Could not set build description: {0}",
+                 e.getMessage());
+    }
+  }
+
+  @Override
+  public void onCompleted(AbstractBuild<?, ?> build, TaskListener listener) {
+    BitbucketBuildTrigger trigger = extractTrigger(build);
+    if (trigger != null) {
+      LOGGER.log(Level.FINE, "Completed after BitbucketBuildTrigger");
+      Result result = build.getResult();
+      BuildState state = (result == Result.SUCCESS) ? BuildState.SUCCESSFUL
+                                                    : BuildState.FAILED;
+      BitbucketCause cause = build.getCause(BitbucketCause.class);
+      trigger.setPRState(cause, state, build.getUrl());
+    }
+  }
+
+  private static BitbucketBuildTrigger
+  extractTrigger(AbstractBuild<?, ?> build) {
+    BitbucketBuildTrigger trigger =
+        build.getProject().getTrigger(BitbucketBuildTrigger.class);
+
+    if ((trigger != null) && (trigger instanceof BitbucketBuildTrigger)) {
+      return trigger;
+    } else {
+      return null;
+    }
+  }
+
+  private static final Logger LOGGER =
+      Logger.getLogger(BitbucketBuildListener.class.getName());
+}
diff --git a/src/main/java/org/jenkinsci/plugins/bbprb/BitbucketBuildTrigger.java b/src/main/java/org/jenkinsci/plugins/bbprb/BitbucketBuildTrigger.java
new file mode 100644
index 0000000..b0c6ece
--- /dev/null
+++ b/src/main/java/org/jenkinsci/plugins/bbprb/BitbucketBuildTrigger.java
@@ -0,0 +1,303 @@
+package org.jenkinsci.plugins.bbprb;
+
+import antlr.ANTLRException;
+import com.cloudbees.plugins.credentials.common.StandardListBoxModel;
+import com.cloudbees.plugins.credentials.common.StandardUsernamePasswordCredentials;
+import com.cloudbees.plugins.credentials.common.UsernamePasswordCredentials;
+import com.cloudbees.plugins.credentials.CredentialsMatchers;
+import com.cloudbees.plugins.credentials.CredentialsProvider;
+import com.cloudbees.plugins.credentials.domains.URIRequirementBuilder;
+import hudson.Extension;
+import hudson.model.AbstractProject;
+import hudson.model.Cause;
+import hudson.model.Executor;
+import hudson.model.Item;
+import hudson.model.ParameterDefinition;
+import hudson.model.ParametersAction;
+import hudson.model.ParametersDefinitionProperty;
+import hudson.model.ParameterValue;
+import hudson.model.queue.QueueTaskFuture;
+import hudson.model.Queue;
+import hudson.model.Result;
+import hudson.model.Run;
+import hudson.plugins.git.RevisionParameterAction;
+import hudson.security.ACL;
+import hudson.triggers.Trigger;
+import hudson.triggers.TriggerDescriptor;
+import hudson.util.ListBoxModel;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import java.util.Map;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import jenkins.model.Jenkins;
+import jenkins.model.ParameterizedJobMixIn;
+import net.sf.json.JSONObject;
+import org.acegisecurity.context.SecurityContext;
+import org.acegisecurity.context.SecurityContextHolder;
+import org.apache.commons.lang.StringUtils;
+import org.jenkinsci.Symbol;
+import org.kohsuke.stapler.DataBoundConstructor;
+import org.kohsuke.stapler.StaplerRequest;
+import static com.cloudbees.plugins.credentials.CredentialsMatchers.instanceOf;
+
+import org.jenkinsci.plugins.bbprb.bitbucket.ApiClient;
+import org.jenkinsci.plugins.bbprb.bitbucket.BuildState;
+
+public class BitbucketBuildTrigger extends Trigger<AbstractProject<?, ?>> {
+  private final String ciKey;
+  private final String ciName;
+  private final String credentialsId;
+  private final String destinationRepository;
+  private final boolean cancelOutdatedJobs;
+  private final boolean checkDestinationCommit;
+
+  // XXX: This is for Jelly.
+  // https://wiki.jenkins.io/display/JENKINS/Basic+guide+to+Jelly+usage+in+Jenkins
+  public String getCiKey() {
+    return this.ciKey;
+  }
+  public String getCiName() {
+    return this.ciName;
+  }
+  public String getCredentialsId() {
+    return this.credentialsId;
+  }
+  public String getDestinationRepository() {
+    return this.destinationRepository;
+  }
+  public boolean getCancelOutdatedJobs() {
+    return this.cancelOutdatedJobs;
+  }
+  public boolean getCheckDestinationCommit() {
+    return this.checkDestinationCommit;
+  }
+
+  private transient ApiClient apiClient;
+
+  public static final BitbucketBuildTriggerDescriptor descriptor =
+      new BitbucketBuildTriggerDescriptor();
+
+  @DataBoundConstructor
+  public BitbucketBuildTrigger(String credentialsId,
+                               String destinationRepository, String ciKey,
+                               String ciName, boolean checkDestinationCommit,
+                               boolean cancelOutdatedJobs)
+      throws ANTLRException {
+    super();
+    this.apiClient = null;
+    this.cancelOutdatedJobs = cancelOutdatedJobs;
+    this.checkDestinationCommit = checkDestinationCommit;
+    this.ciKey = ciKey;
+    this.ciName = ciName;
+    this.credentialsId = credentialsId;
+    this.destinationRepository = destinationRepository;
+  }
+
+  @Override
+  public void start(AbstractProject<?, ?> project, boolean newInstance) {
+    logger.log(Level.FINE, "Started for `{0}`", project.getFullName());
+
+    super.start(project, newInstance);
+
+    if (credentialsId != null && !credentialsId.isEmpty()) {
+      logger.log(Level.FINE, "Looking up credentials `{0}`",
+                 this.credentialsId);
+      List<UsernamePasswordCredentials> all =
+          CredentialsProvider.lookupCredentials(
+              UsernamePasswordCredentials.class, (Item)null, ACL.SYSTEM,
+              URIRequirementBuilder.fromUri("https://bitbucket.org").build());
+      UsernamePasswordCredentials creds = CredentialsMatchers.firstOrNull(
+          all, CredentialsMatchers.withId(this.credentialsId));
+      if (creds != null) {
+        logger.log(Level.INFO, "Creating Bitbucket API client");
+        this.apiClient = new ApiClient(
+            creds.getUsername(), creds.getPassword().getPlainText(),
+            this.destinationRepository, this.ciKey, this.ciName);
+      } else {
+        logger.log(Level.SEVERE, "Credentials `{0}` not found",
+                   this.credentialsId);
+      }
+    } else {
+      logger.log(Level.WARNING, "Missing Bitbucket API credentials");
+    }
+  }
+
+  public void setPRState(BitbucketCause cause, BuildState state, String path) {
+    if (this.apiClient != null) {
+      logger.log(Level.INFO, "Setting status of PR #{0} to {1} for {2}",
+                 new Object[] {cause.getPullRequestId(), state,
+                               cause.getDestinationRepository()});
+      this.apiClient.setBuildStatus(cause.getSourceCommitHash(), state,
+                                    getInstance().getRootUrl() + path, null,
+                                    this.job.getFullName());
+    } else {
+      logger.log(Level.INFO,
+                 "Will not set Bitbucket PR build status (not configured)");
+    }
+  }
+
+  private void startJob(BitbucketCause cause) {
+    if (this.cancelOutdatedJobs) {
+      SecurityContext orig = ACL.impersonate(ACL.SYSTEM);
+      cancelPreviousJobsInQueueThatMatch(cause);
+      abortRunningJobsThatMatch(cause);
+      SecurityContextHolder.setContext(orig);
+    }
+
+    setPRState(cause, BuildState.INPROGRESS, this.job.getUrl());
+
+    this.job.scheduleBuild2(
+        0, cause, new ParametersAction(this.getDefaultParameters()),
+        new RevisionParameterAction(cause.getSourceCommitHash()));
+  }
+
+  private void
+  cancelPreviousJobsInQueueThatMatch(@Nonnull BitbucketCause cause) {
+    logger.log(Level.FINE, "Looking for queued jobs that match PR #{0}",
+               cause.getPullRequestId());
+    Queue queue = getInstance().getQueue();
+
+    for (Queue.Item item : queue.getItems()) {
+      if (hasCauseFromTheSamePullRequest(item.getCauses(), cause)) {
+        logger.fine("Canceling item in queue: " + item);
+        queue.cancel(item);
+      }
+    }
+  }
+
+  private Jenkins getInstance() {
+    final Jenkins instance = Jenkins.getInstance();
+    if (instance == null) {
+      throw new IllegalStateException("Jenkins instance is NULL!");
+    }
+    return instance;
+  }
+
+  private void
+  abortRunningJobsThatMatch(@Nonnull BitbucketCause bitbucketCause) {
+    logger.log(Level.FINE, "Looking for running jobs that match PR #{0}",
+               bitbucketCause.getPullRequestId());
+    for (Object o : job.getBuilds()) {
+      if (o instanceof Run) {
+        Run build = (Run)o;
+        if (build.isBuilding() &&
+            hasCauseFromTheSamePullRequest(build.getCauses(), bitbucketCause)) {
+          logger.fine("Aborting build: " + build + " since PR is outdated");
+          setBuildDescription(build);
+          final Executor executor = build.getExecutor();
+          if (executor == null) {
+            throw new IllegalStateException("Executor can't be NULL");
+          }
+          executor.interrupt(Result.ABORTED);
+        }
+      }
+    }
+  }
+
+  private void setBuildDescription(final Run build) {
+    try {
+      build.setDescription(
+          "Aborting build by `Bitbucket Pullrequest Builder Plugin`: " + build +
+          " since PR is outdated");
+    } catch (IOException e) {
+      logger.warning("Could not set build description: " + e.getMessage());
+    }
+  }
+
+  private boolean
+  hasCauseFromTheSamePullRequest(@Nullable List<Cause> causes,
+                                 @Nullable BitbucketCause pullRequestCause) {
+    if (causes != null && pullRequestCause != null) {
+      for (Cause cause : causes) {
+        if (cause instanceof BitbucketCause) {
+          BitbucketCause sc = (BitbucketCause)cause;
+          if (StringUtils.equals(sc.getPullRequestId(),
+                                 pullRequestCause.getPullRequestId()) &&
+              StringUtils.equals(sc.getSourceRepository(),
+                                 pullRequestCause.getSourceRepository())) {
+            return true;
+          }
+        }
+      }
+    }
+    return false;
+  }
+
+  private ArrayList<ParameterValue> getDefaultParameters() {
+    Map<String, ParameterValue> values = new HashMap<String, ParameterValue>();
+    ParametersDefinitionProperty definitionProperty =
+        this.job.getProperty(ParametersDefinitionProperty.class);
+
+    if (definitionProperty != null) {
+      for (ParameterDefinition definition :
+           definitionProperty.getParameterDefinitions()) {
+        values.put(definition.getName(), definition.getDefaultParameterValue());
+      }
+    }
+    return new ArrayList<ParameterValue>(values.values());
+  }
+
+  public void handlePR(JSONObject pr) {
+    JSONObject src = pr.getJSONObject("source");
+    JSONObject dst = pr.getJSONObject("destination");
+    String dstRepository =
+        dst.getJSONObject("repository").getString("full_name");
+    BitbucketCause cause = new BitbucketCause(
+        src.getJSONObject("branch").getString("name"),
+        dst.getJSONObject("branch").getString("name"),
+        src.getJSONObject("repository").getString("full_name"),
+        pr.getString("id"), // FIXME: it is integer
+        dstRepository, pr.getString("title"),
+        src.getJSONObject("commit").getString("hash"),
+        dst.getJSONObject("commit").getString("hash"),
+        pr.getJSONObject("author").getString("username"));
+    if (!dstRepository.equals(this.destinationRepository)) {
+      logger.log(Level.FINE,
+                 "Job `{0}`: repository `{1}` does not match `{2}`. Skipping.",
+                 new Object[] {this.job.getFullName(), dstRepository,
+                               this.destinationRepository});
+      return;
+    }
+    startJob(cause);
+  }
+
+  @Extension
+  @Symbol("bbprb")
+  public static final class BitbucketBuildTriggerDescriptor
+      extends TriggerDescriptor {
+    public BitbucketBuildTriggerDescriptor() {
+      load();
+    }
+
+    @Override
+    public boolean isApplicable(Item item) {
+      return item instanceof AbstractProject;
+    }
+
+    @Override
+    public String getDisplayName() {
+      return "Bitbucket Pull Requests Builder";
+    }
+
+    @Override
+    public boolean configure(StaplerRequest req, JSONObject json)
+        throws FormException {
+      save();
+      return super.configure(req, json);
+    }
+
+    public ListBoxModel doFillCredentialsIdItems() {
+      return new StandardListBoxModel().withEmptySelection().withMatching(
+          instanceOf(UsernamePasswordCredentials.class),
+          CredentialsProvider.lookupCredentials(
+              StandardUsernamePasswordCredentials.class));
+    }
+  }
+  private static final Logger logger =
+      Logger.getLogger(BitbucketBuildTrigger.class.getName());
+}
diff --git a/src/main/java/org/jenkinsci/plugins/bbprb/BitbucketCause.java b/src/main/java/org/jenkinsci/plugins/bbprb/BitbucketCause.java
new file mode 100644
index 0000000..a4a20a6
--- /dev/null
+++ b/src/main/java/org/jenkinsci/plugins/bbprb/BitbucketCause.java
@@ -0,0 +1,80 @@
+package org.jenkinsci.plugins.bbprb;
+
+import hudson.model.Cause;
+
+/**
+ * Created by nishio
+ */
+public class BitbucketCause extends Cause {
+  private final String sourceBranch;
+  private final String targetBranch;
+  private final String sourceRepository;
+  private final String pullRequestId;
+  private final String destinationRepository;
+  private final String pullRequestTitle;
+  private final String sourceCommitHash;
+  private final String destinationCommitHash;
+  private final String pullRequestAuthor;
+  public static final String BITBUCKET_URL = "https://bitbucket.org/";
+
+  public BitbucketCause(String sourceBranch, String targetBranch,
+                        String sourceRepository, String pullRequestId,
+                        String destinationRepository, String pullRequestTitle,
+                        String sourceCommitHash, String destinationCommitHash,
+                        String pullRequestAuthor) {
+    this.sourceBranch = sourceBranch;
+    this.targetBranch = targetBranch;
+    this.sourceRepository = sourceRepository;
+    this.pullRequestId = pullRequestId;
+    this.destinationRepository = destinationRepository;
+    this.pullRequestTitle = pullRequestTitle;
+    this.sourceCommitHash = sourceCommitHash;
+    this.destinationCommitHash = destinationCommitHash;
+    this.pullRequestAuthor = pullRequestAuthor;
+  }
+
+  public String getSourceBranch() {
+    return sourceBranch;
+  }
+  public String getTargetBranch() {
+    return targetBranch;
+  }
+
+  public String getSourceRepository() {
+    return sourceRepository;
+  }
+
+  public String getPullRequestId() {
+    return pullRequestId;
+  }
+
+  public String getDestinationRepository() {
+    return destinationRepository;
+  }
+
+  public String getPullRequestTitle() {
+    return pullRequestTitle;
+  }
+
+  public String getSourceCommitHash() {
+    return sourceCommitHash;
+  }
+
+  public String getDestinationCommitHash() {
+    return destinationCommitHash;
+  }
+
+  @Override
+  public String getShortDescription() {
+    String description =
+        "<a href=\"" + BITBUCKET_URL + this.getDestinationRepository();
+    description += "/pull-request/" + this.getPullRequestId();
+    description += "\">#" + this.getPullRequestId() + " " +
+                   this.getPullRequestTitle() + "</a>";
+    return description;
+  }
+
+  public String getPullRequestAuthor() {
+    return this.pullRequestAuthor;
+  }
+}
diff --git a/src/main/java/org/jenkinsci/plugins/bbprb/BitbucketHookReceiver.java b/src/main/java/org/jenkinsci/plugins/bbprb/BitbucketHookReceiver.java
new file mode 100644
index 0000000..18b2688
--- /dev/null
+++ b/src/main/java/org/jenkinsci/plugins/bbprb/BitbucketHookReceiver.java
@@ -0,0 +1,140 @@
+package org.jenkinsci.plugins.bbprb;
+
+import hudson.Extension;
+import hudson.model.UnprotectedRootAction;
+import hudson.security.ACL;
+import hudson.triggers.Trigger;
+import hudson.triggers.TriggerDescriptor;
+import java.io.IOException;
+import java.net.URLDecoder;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import jenkins.model.Jenkins;
+import jenkins.model.ParameterizedJobMixIn.ParameterizedJob;
+import net.sf.json.JSONException;
+import net.sf.json.JSONObject;
+import org.acegisecurity.context.SecurityContext;
+import org.acegisecurity.context.SecurityContextHolder;
+import org.apache.commons.io.IOUtils;
+import org.kohsuke.stapler.StaplerRequest;
+import org.kohsuke.stapler.StaplerResponse;
+
+@Extension
+public class BitbucketHookReceiver implements UnprotectedRootAction {
+
+  private static final String BITBUCKET_HOOK_URL = "bbprb-hook";
+  private static final String BITBUCKET_UA = "Bitbucket-Webhooks/2.0";
+
+  public void doIndex(StaplerRequest req, StaplerResponse resp)
+      throws IOException {
+
+    String userAgent = req.getHeader("user-agent");
+    if (!BITBUCKET_UA.equals(userAgent)) {
+      LOGGER.log(Level.WARNING, "Bad user agent: `{0}`, expected `{1}`",
+                 new Object[] {userAgent, BITBUCKET_UA});
+      resp.setStatus(StaplerResponse.SC_BAD_REQUEST);
+      return;
+    }
+
+    String uri = req.getRequestURI();
+    if (!uri.contains("/" + BITBUCKET_HOOK_URL + "/")) {
+      LOGGER.log(Level.WARNING,
+                 "BitBucket hook URI does not contain `/{0}/`: `{1}`",
+                 new Object[] {BITBUCKET_HOOK_URL, uri});
+      resp.setStatus(StaplerResponse.SC_NOT_FOUND);
+      return;
+    }
+
+    String event = req.getHeader("x-event-key");
+    if (event == null) {
+      LOGGER.log(Level.WARNING, "Missing the `x-event-key` header");
+      resp.setStatus(StaplerResponse.SC_BAD_REQUEST);
+      return;
+    }
+
+    String body = IOUtils.toString(req.getInputStream());
+    if (body.isEmpty()) {
+      LOGGER.log(Level.WARNING, "Received empty request body");
+      resp.setStatus(StaplerResponse.SC_BAD_REQUEST);
+      return;
+    }
+
+    String contentType = req.getContentType();
+    if (contentType != null &&
+        contentType.startsWith("application/x-www-form-urlencoded")) {
+      body = URLDecoder.decode(body, "UTF-8");
+    }
+    if (body.startsWith("payload=")) {
+      body = body.substring(8);
+    }
+
+    LOGGER.log(Level.FINE,
+               "Received commit hook notification, key: `{0}`, body: `{1}`",
+               new Object[] {event, body});
+
+    try {
+      JSONObject payload = JSONObject.fromObject(body);
+      if (event.startsWith("pullrequest:")) {
+        JSONObject pr = payload.getJSONObject("pullrequest");
+        String state = pr.getString("state");
+        if (!"OPEN".equals(state)) {
+          LOGGER.log(
+              Level.INFO, "Ignoring closed PR ({0}): #{1} {2}",
+              new Object[] {state, pr.getInt("id"), pr.getString("title")});
+          return;
+        }
+        for (BitbucketBuildTrigger trigger : getBitbucketTriggers()) {
+          trigger.handlePR(pr);
+        }
+        return;
+      }
+    } catch (JSONException e) {
+      LOGGER.log(Level.WARNING, e.getMessage());
+      resp.setStatus(StaplerResponse.SC_BAD_REQUEST);
+      return;
+    }
+  }
+
+  private static List<BitbucketBuildTrigger> getBitbucketTriggers() {
+    List<BitbucketBuildTrigger> bbtriggers = new ArrayList<>();
+
+    SecurityContext orig = ACL.impersonate(ACL.SYSTEM);
+    List<ParameterizedJob> jobs =
+        Jenkins.getInstance().getAllItems(ParameterizedJob.class);
+    SecurityContextHolder.setContext(orig);
+
+    for (ParameterizedJob job : jobs) {
+      String jobName = job.getFullName();
+      LOGGER.log(Level.FINER, "Found job: `{0}`", jobName);
+
+      Map<TriggerDescriptor, Trigger<?>> triggers = job.getTriggers();
+
+      for (Trigger<?> trigger : triggers.values()) {
+        if (trigger instanceof BitbucketBuildTrigger) {
+          LOGGER.log(Level.FINE, "Will consider job: `{0}`", jobName);
+          bbtriggers.add((BitbucketBuildTrigger)trigger);
+        }
+      }
+    }
+
+    return bbtriggers;
+  }
+
+  private static final Logger LOGGER =
+      Logger.getLogger(BitbucketHookReceiver.class.getName());
+
+  public String getIconFileName() {
+    return null;
+  }
+
+  public String getDisplayName() {
+    return null;
+  }
+
+  public String getUrlName() {
+    return BITBUCKET_HOOK_URL;
+  }
+}
diff --git a/src/main/java/org/jenkinsci/plugins/bbprb/bitbucket/ApiClient.java b/src/main/java/org/jenkinsci/plugins/bbprb/bitbucket/ApiClient.java
new file mode 100644
index 0000000..80ae3aa
--- /dev/null
+++ b/src/main/java/org/jenkinsci/plugins/bbprb/bitbucket/ApiClient.java
@@ -0,0 +1,246 @@
+package org.jenkinsci.plugins.bbprb.bitbucket;
+
+import org.apache.commons.httpclient.*;
+import org.apache.commons.httpclient.auth.AuthScope;
+import org.apache.commons.httpclient.methods.GetMethod;
+import org.apache.commons.httpclient.methods.PostMethod;
+import org.apache.commons.httpclient.methods.DeleteMethod;
+import org.apache.commons.httpclient.params.HttpClientParams;
+import org.codehaus.jackson.map.ObjectMapper;
+import org.codehaus.jackson.map.type.TypeFactory;
+import org.codehaus.jackson.type.JavaType;
+import org.codehaus.jackson.type.TypeReference;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import jenkins.model.Jenkins;
+import hudson.ProxyConfiguration;
+
+import java.io.UnsupportedEncodingException;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import org.apache.commons.codec.binary.Hex;
+import org.apache.commons.httpclient.methods.PutMethod;
+import org.apache.commons.httpclient.util.EncodingUtil;
+
+/**
+ * Created by nishio
+ */
+public class ApiClient {
+  private static final Logger logger =
+      Logger.getLogger(ApiClient.class.getName());
+  private static final String V1_API_BASE_URL =
+      "https://bitbucket.org/api/1.0/repositories/";
+  private static final String V2_API_BASE_URL =
+      "https://bitbucket.org/api/2.0/repositories/";
+  private static final String COMPUTED_KEY_FORMAT = "%s-%s";
+  private String repository;
+  private Credentials credentials;
+  private String key;
+  private String name;
+  private HttpClientFactory factory;
+
+  public static final byte MAX_KEY_SIZE_BB_API = 40;
+
+  public static class HttpClientFactory {
+    public static final HttpClientFactory INSTANCE = new HttpClientFactory();
+    private static final int DEFAULT_TIMEOUT = 60000;
+
+    public HttpClient getInstanceHttpClient() {
+      HttpClient client = new HttpClient();
+
+      HttpClientParams params = client.getParams();
+      params.setConnectionManagerTimeout(DEFAULT_TIMEOUT);
+      params.setSoTimeout(DEFAULT_TIMEOUT);
+
+      if (Jenkins.getInstance() == null)
+        return client;
+
+      ProxyConfiguration proxy = getInstance().proxy;
+      if (proxy == null)
+        return client;
+
+      logger.log(Level.FINE, "Jenkins proxy: {0}:{1}",
+                 new Object[] {proxy.name, proxy.port});
+      client.getHostConfiguration().setProxy(proxy.name, proxy.port);
+      String username = proxy.getUserName();
+      String password = proxy.getPassword();
+
+      // Consider it to be passed if username specified. Sufficient?
+      if (username != null && !"".equals(username.trim())) {
+        logger.log(Level.FINE, "Using proxy authentication (user={0})",
+                   username);
+        client.getState().setProxyCredentials(
+            AuthScope.ANY, new UsernamePasswordCredentials(username, password));
+      }
+
+      return client;
+    }
+
+    private Jenkins getInstance() {
+      final Jenkins instance = Jenkins.getInstance();
+      if (instance == null) {
+        throw new IllegalStateException("Jenkins instance is NULL!");
+      }
+      return instance;
+    }
+  }
+
+  public <T extends HttpClientFactory> ApiClient(String username,
+                                                 String password,
+                                                 String repository, String key,
+                                                 String name) {
+    this.credentials = new UsernamePasswordCredentials(username, password);
+    this.repository = repository;
+    this.key = key;
+    this.name = name;
+    this.factory = HttpClientFactory.INSTANCE;
+  }
+
+  public String getName() {
+    return this.name;
+  }
+
+  private static MessageDigest SHA1 = null;
+
+  /**
+   * Retrun
+   * @param keyExPart
+   * @return key parameter for call BitBucket API
+   */
+  private String computeAPIKey(String keyExPart) {
+    String computedKey =
+        String.format(COMPUTED_KEY_FORMAT, this.key, keyExPart);
+
+    if (computedKey.length() > MAX_KEY_SIZE_BB_API) {
+      try {
+        if (SHA1 == null)
+          SHA1 = MessageDigest.getInstance("SHA1");
+        return new String(
+            Hex.encodeHex(SHA1.digest(computedKey.getBytes("UTF-8"))));
+      } catch (NoSuchAlgorithmException e) {
+        logger.log(Level.WARNING, "Failed to create hash provider", e);
+      } catch (UnsupportedEncodingException e) {
+        logger.log(Level.WARNING, "Failed to create hash provider", e);
+      }
+    }
+    return (computedKey.length() <= MAX_KEY_SIZE_BB_API)
+        ? computedKey
+        : computedKey.substring(0, MAX_KEY_SIZE_BB_API);
+  }
+
+  public String buildStatusKey(String bsKey) {
+    return this.computeAPIKey(bsKey);
+  }
+
+  public boolean hasBuildStatus(String revision, String keyEx) {
+    String url = v2("/commit/" + revision + "/statuses/build/" +
+                    this.computeAPIKey(keyEx));
+    String reqBody = get(url);
+    return reqBody != null && reqBody.contains("\"state\"");
+  }
+
+  public void setBuildStatus(String revision, BuildState state, String buildUrl,
+                             String comment, String keyEx) {
+    String url = v2("/commit/" + revision + "/statuses/build");
+    String computedKey = this.computeAPIKey(keyEx);
+    NameValuePair[] data = new NameValuePair[] {
+        new NameValuePair("description", comment),
+        new NameValuePair("key", computedKey),
+        new NameValuePair("name", this.name),
+        new NameValuePair("state", state.toString()),
+        new NameValuePair("url", buildUrl),
+    };
+    logger.log(Level.FINE,
+               "POST state {0} to {1} with key {2} with response {3}",
+               new Object[] {state, url, computedKey, post(url, data)});
+  }
+
+  public void deletePullRequestApproval(String pullRequestId) {
+    delete(v2("/pullrequests/" + pullRequestId + "/approve"));
+  }
+
+  public void deletePullRequestComment(String pullRequestId, String commentId) {
+    delete(v1("/pullrequests/" + pullRequestId + "/comments/" + commentId));
+  }
+
+  public void updatePullRequestComment(String pullRequestId, String content,
+                                       String commentId) {
+    NameValuePair[] data = new NameValuePair[] {
+        new NameValuePair("content", content),
+    };
+    put(v1("/pullrequests/" + pullRequestId + "/comments/" + commentId), data);
+  }
+
+  private HttpClient getHttpClient() {
+    return this.factory.getInstanceHttpClient();
+  }
+
+  private String v1(String path) {
+    return V1_API_BASE_URL + this.repository + path;
+  }
+
+  private String v2(String path) {
+    return V2_API_BASE_URL + this.repository + path;
+  }
+
+  private String get(String path) {
+    return send(new GetMethod(path));
+  }
+
+  private String post(String path, NameValuePair[] data) {
+    PostMethod req = new PostMethod(path);
+    req.setRequestBody(data);
+    req.getParams().setContentCharset("utf-8");
+    return send(req);
+  }
+
+  private void delete(String path) {
+    send(new DeleteMethod(path));
+  }
+
+  private void put(String path, NameValuePair[] data) {
+    PutMethod req = new PutMethod(path);
+    req.setRequestBody(EncodingUtil.formUrlEncode(data, "utf-8"));
+    req.getParams().setContentCharset("utf-8");
+    send(req);
+  }
+
+  private String send(HttpMethodBase req) {
+    HttpClient client = getHttpClient();
+    client.getState().setCredentials(AuthScope.ANY, credentials);
+    client.getParams().setAuthenticationPreemptive(true);
+    try {
+      int statusCode = client.executeMethod(req);
+      if (statusCode != HttpStatus.SC_OK) {
+        logger.log(Level.WARNING, "Response status: " + req.getStatusLine() +
+                                      " URI: " + req.getURI());
+      } else {
+        return req.getResponseBodyAsString();
+      }
+    } catch (HttpException e) {
+      logger.log(Level.WARNING, "Failed to send request.", e);
+    } catch (IOException e) {
+      logger.log(Level.WARNING, "Failed to send request.", e);
+    } finally {
+      req.releaseConnection();
+    }
+    return null;
+  }
+
+  private <R> R parse(String response, Class<R> cls) throws IOException {
+    return new ObjectMapper().readValue(response, cls);
+  }
+  private <R> R parse(String response, JavaType type) throws IOException {
+    return new ObjectMapper().readValue(response, type);
+  }
+  private <R> R parse(String response, TypeReference<R> ref)
+      throws IOException {
+    return new ObjectMapper().readValue(response, ref);
+  }
+}
diff --git a/src/main/java/org/jenkinsci/plugins/bbprb/bitbucket/BuildState.java b/src/main/java/org/jenkinsci/plugins/bbprb/bitbucket/BuildState.java
new file mode 100644
index 0000000..8fe1cdd
--- /dev/null
+++ b/src/main/java/org/jenkinsci/plugins/bbprb/bitbucket/BuildState.java
@@ -0,0 +1,9 @@
+package org.jenkinsci.plugins.bbprb.bitbucket;
+
+/**
+ * Valid build states for a pull request
+ *
+ * @see
+ * "https://confluence.atlassian.com/bitbucket/buildstatus-resource-779295267.html"
+ */
+public enum BuildState { FAILED, INPROGRESS, SUCCESSFUL }