Java Revision类代码示例

import hudson.plugins.git.Revision; //导入依赖的package包/类
@Override
public Revision decorateRevisionToBuild(GitSCM scm, Run<?, ?> build, GitClient git, TaskListener listener, Revision marked, Revision rev) throws IOException, InterruptedException, GitException {
    listener.getLogger().println("Merging " + targetBranch.getName() + " commit " + targetBranch.getRevision().getHash() + " into merge-request head commit " + rev.getSha1String());
    checkout(scm, build, git, listener, rev);
    try {
        git.setAuthor("Jenkins", /* could parse out of JenkinsLocationConfiguration.get().getAdminAddress() but seems overkill */"[email protected]");
        git.setCommitter("Jenkins", "[email protected]");
        MergeCommand cmd = git.merge().setRevisionToMerge(ObjectId.fromString(targetBranch.getRevision().getHash()));
        for (GitSCMExtension ext : scm.getExtensions()) {
            // By default we do a regular merge, allowing it to fast-forward.
            ext.decorateMergeCommand(scm, build, git, listener, cmd);
        }
        cmd.execute();
    } catch (GitException e) {
        // Try to revert merge conflict markers.
        checkout(scm, build, git, listener, rev);
        throw e;
    }
    build.addAction(new MergeRecord(targetBranch.getRefSpec().destinationRef(targetBranch.getName()), targetBranch.getRevision().getHash())); // does not seem to be used, but just in case
    ObjectId mergeRev = git.revParse(Constants.HEAD);
    listener.getLogger().println("Merge succeeded, producing " + mergeRev.name());
    return new Revision(mergeRev, rev.getBranches()); // note that this ensures Build.revision != Build.marked
}
 

import hudson.plugins.git.Revision; //导入依赖的package包/类
/**
 * Get failing build revision if this is a deflake build, otherwise use the default build chooser
 */
@Override
public Collection<Revision> getCandidateRevisions(boolean isPollCall, String singleBranch,
    GitClient git,
    TaskListener listener, BuildData buildData,
    BuildChooserContext context)
    throws GitException, IOException, InterruptedException {

  AbstractBuild build = context.actOnBuild(new GetBuild());
  // Not sure why it cannot be inferred and we have to put cast here
  DeflakeCause cause = (DeflakeCause) build.getCause(DeflakeCause.class);

  if (cause != null) {
    BuildData gitBuildData = gitSCM.getBuildData(cause.getUpstreamRun(), true);
    Revision revision = gitBuildData.getLastBuiltRevision();
    if (revision != null) {
      return Collections.singletonList(revision);
    }
  }

  // If it is not a deflake run, then use the default git checkout strategy
  defaultBuildChooser.gitSCM = this.gitSCM;
  return defaultBuildChooser
      .getCandidateRevisions(isPollCall, singleBranch, git, listener, buildData, context);
}
 

import hudson.plugins.git.Revision; //导入依赖的package包/类
/**
 * Construct a SingleTestFlakyStatsWithRevision object with {@link SingleTestFlakyStats} and
 * build information.
 *
 * @param stats Embedded {@link SingleTestFlakyStats} object
 * @param build The {@link hudson.model.AbstractBuild} object to get SCM information from.
 */
public SingleTestFlakyStatsWithRevision(SingleTestFlakyStats stats, AbstractBuild build) {
  this.stats = stats;
  revision = Integer.toString(build.getNumber());

  SCM scm = build.getProject().getScm();
  if (scm != null && scm instanceof GitSCM) {
    GitSCM gitSCM = (GitSCM) scm;
    BuildData buildData = gitSCM.getBuildData(build);
    if (buildData != null) {
      Revision gitRevision = buildData.getLastBuiltRevision();
      if (gitRevision != null) {
        revision = gitRevision.getSha1String();
      }
    }
  }
}
 

import hudson.plugins.git.Revision; //导入依赖的package包/类
private static String getBuildRevision(Run<?, ?> build) {
    GitLabWebHookCause cause = build.getCause(GitLabWebHookCause.class);
    if (cause != null) {
        return cause.getData().getLastCommit();
    }

    BuildData action = build.getAction(BuildData.class);
    if (action == null) {
        throw new IllegalStateException("No (git-plugin) BuildData associated to current build");
    }
    Revision lastBuiltRevision = action.getLastBuiltRevision();

    if (lastBuiltRevision == null) {
        throw new IllegalStateException("Last build has no associated commit");
    }

    return action.getLastBuild(lastBuiltRevision.getSha1()).getMarked().getSha1String();
}
 

import hudson.plugins.git.Revision; //导入依赖的package包/类
private BuildData createBuildData(String sha) {
  
  BuildData buildData = mock(BuildData.class);
  Revision revision = mock(Revision.class);
  when(revision.getSha1String()).thenReturn(sha);
  when(buildData.getLastBuiltRevision()).thenReturn(revision);

  Build gitBuild = mock(Build.class);
  when(gitBuild.getMarked()).thenReturn(revision);
  when(buildData.getLastBuild(any(ObjectId.class))).thenReturn(gitBuild);
  when(gitBuild.getRevision()).thenReturn(revision);
  when(gitBuild.isFor(sha)).thenReturn(true);
  buildData.lastBuild = gitBuild;

  return buildData;
}
 

import hudson.plugins.git.Revision; //导入依赖的package包/类
@Override
public void integrateAsGitPluginExt(GitSCM scm, Run<?, ?> build, GitClient git, TaskListener listener, Revision marked, Revision rev, GitBridge gitbridge) throws NothingToDoException, IntegrationFailedException, IOException, InterruptedException {


    String expandedRepoName;
    try {
        expandedRepoName = gitbridge.getExpandedRepository(build.getEnvironment(listener));
    } catch (IOException | InterruptedException ex) {
        expandedRepoName = gitbridge.getRepoName();
    }

    if (!PretestedIntegrationGitUtils.isRelevant(rev, expandedRepoName)) {
        throw new NothingToDoException("No revision matches configuration in 'Integration repository'");
    }

    Branch triggerBranch = rev.getBranches().iterator().next();
    String expandedIntegrationBranch = gitbridge.getExpandedIntegrationBranch(build.getEnvironment(listener));
    doTheIntegration((Run) build, listener, gitbridge, triggerBranch.getSHA1(), git, expandedIntegrationBranch, triggerBranch);
}
 

import hudson.plugins.git.Revision; //导入依赖的package包/类
private void checkout(GitSCM scm, Run<?, ?> build, GitClient git, TaskListener listener, Revision rev) throws InterruptedException, IOException, GitException {
    CheckoutCommand checkoutCommand = git.checkout().ref(rev.getSha1String());
    for (GitSCMExtension ext : scm.getExtensions()) {
        ext.decorateCheckoutCommand(scm, build, git, listener, checkoutCommand);
    }
    checkoutCommand.execute();
}
 

import hudson.plugins.git.Revision; //导入依赖的package包/类
private String getGitSourceCommit() {
    // depend on git plugin
    for (BuildData data : getJenkinsBuild().getActions(BuildData.class)) {
        Revision revision = data.getLastBuiltRevision();
        if (revision != null) {
            return revision.getSha1String();
        }
    }

    return null;
}
 

import hudson.plugins.git.Revision; //导入依赖的package包/类
private AbstractBuild mockBuild(String gitLabConnection, Result result, String... remoteUrls) {
    AbstractBuild build = mock(AbstractBuild.class);
    List<BuildData> buildDatas = new ArrayList<>();
    BuildData buildData = mock(BuildData.class);
    Revision revision = mock(Revision.class);
    when(revision.getSha1String()).thenReturn(SHA1);
    when(buildData.getLastBuiltRevision()).thenReturn(revision);
    when(buildData.getRemoteUrls()).thenReturn(new HashSet<>(Arrays.asList(remoteUrls)));
    Build gitBuild = mock(Build.class);
    when(gitBuild.getMarked()).thenReturn(revision);
    when(buildData.getLastBuild(any(ObjectId.class))).thenReturn(gitBuild);
    buildDatas.add(buildData);
    when(build.getActions(BuildData.class)).thenReturn(buildDatas);
    when(build.getAction(BuildData.class)).thenReturn(buildData);
    when(build.getResult()).thenReturn(result);
    when(build.getUrl()).thenReturn(BUILD_URL);
    AbstractProject<?, ?> project = mock(AbstractProject.class);
    when(project.getProperty(GitLabConnectionProperty.class)).thenReturn(new GitLabConnectionProperty(gitLabConnection));
    when(build.getProject()).thenReturn(project);
    EnvVars environment = mock(EnvVars.class);
    when(environment.expand(anyString())).thenAnswer(new Answer<String>() {
        @Override
        public String answer(InvocationOnMock invocation) throws Throwable {
            return (String) invocation.getArguments()[0];
        }
    });
    try {
        when(build.getEnvironment(any(TaskListener.class))).thenReturn(environment);
    } catch (IOException | InterruptedException e) {
        throw new RuntimeException(e);
    }
    return build;
}
 

import hudson.plugins.git.Revision; //导入依赖的package包/类
@Test
public void testShouldBeCommited() throws Exception {
    DummySCM scm = new DummySCM(null);
    FreeStyleBuild build = mock(FreeStyleBuild.class);
    when(build.getResult()).thenReturn(Result.SUCCESS);
    Launcher launcher = mock(Launcher.class);

    BuildData gitBuildData = mock(BuildData.class);
    Build lastBuild = mock(Build.class);
    Revision rev = mock(Revision.class);
    Branch gitBranchData = mock(Branch.class);

    gitBuildData.lastBuild = lastBuild;
    lastBuild.revision = rev;

    when(build.getAction(BuildData.class)).thenReturn(gitBuildData);

    List<Branch> branches = new ArrayList<>();
    branches.add(gitBranchData);
    when(gitBuildData.lastBuild.revision.getBranches()).thenReturn(branches);
    when(gitBranchData.getName()).thenReturn("origin/ready/f1");

    OutputStream out = new ByteArrayOutputStream();
    BuildListener listener = new StreamBuildListener(out);

    assertFalse(scm.isCommited());
    scm.handlePostBuild(build, launcher, listener);
    assertTrue(scm.isCommited());
}
 

import hudson.plugins.git.Revision; //导入依赖的package包/类
public void testSetupSubmoduleUrls() throws Exception {
    System.out.println("setupSubmoduleUrls");
    Revision rev = null;
    TaskListener listener = null;
    GitClient instance = gitClient;
    instance.setupSubmoduleUrls(rev, listener);
    fail("The test case is a prototype.");
}
 

import hudson.plugins.git.Revision; //导入依赖的package包/类
@Test
@Deprecated
public void testShowRevisionThrowsGitException() throws Exception {
    File trackedFile = commitTrackedFile();
    thrown.expect(GitException.class);
    git.showRevision(new Revision(gitClientCommit));
}
 

import hudson.plugins.git.Revision; //导入依赖的package包/类
@Test
@Deprecated
public void testShowRevisionTrackedFile() throws Exception {
    File trackedFile = commitTrackedFile();
    ObjectId head = git.getHeadRev(repo.getPath(), "master");
    List<String> revisions = git.showRevision(new Revision(head));
    assertEquals("commit " + head.name(), revisions.get(0));
}
 

import hudson.plugins.git.Revision; //导入依赖的package包/类
public static String fromPull(BuildData buildData, Optional<String> organization) {
    Set<String> remoteUrls = buildData.getRemoteUrls();

    checkArgument(!remoteUrls.isEmpty(), "buildData does not contain any remote URLs");

    Revision lastBuiltRevision = buildData.getLastBuiltRevision();
    Collection<hudson.plugins.git.Branch> scmBranches = lastBuiltRevision.getBranches();

    checkArgument(!scmBranches.isEmpty(), "buildData last revision does not contain any branches");

    String firstRemoteUrl = remoteUrls.iterator().next();
    Repository repository = new Repository(firstRemoteUrl);

    hudson.plugins.git.Branch firstScmBranch = scmBranches.iterator().next();
    Branch branch = new Branch(firstScmBranch);

    return generateRemoteImageName(organization, repository, branch);
}
 

import hudson.plugins.git.Revision; //导入依赖的package包/类
private AbstractBuild mockBuildWithLibrary(String gitLabConnection, Result result, String... remoteUrls) {
    AbstractBuild build = mock(AbstractBuild.class);
    List<BuildData> buildDatas = new ArrayList<>();
    BuildData buildData = mock(BuildData.class);
    SCMRevisionAction scmRevisionAction = mock(SCMRevisionAction.class);
    AbstractGitSCMSource.SCMRevisionImpl revisionImpl = mock(AbstractGitSCMSource.SCMRevisionImpl.class);
    
    when(build.getAction(SCMRevisionAction.class)).thenReturn(scmRevisionAction);
    when(scmRevisionAction.getRevision()).thenReturn(revisionImpl);
    when(revisionImpl.getHash()).thenReturn(SHA1);
    
    Revision revision = mock(Revision.class);
    when(revision.getSha1String()).thenReturn(SHA1);
    when(buildData.getLastBuiltRevision()).thenReturn(revision);
    when(buildData.getRemoteUrls()).thenReturn(new HashSet<>(Arrays.asList(remoteUrls)));

    Build gitBuild = mock(Build.class);

    when(gitBuild.getMarked()).thenReturn(revision);
    when(gitBuild.getSHA1()).thenReturn(ObjectId.fromString(SHA1));
    when(buildData.getLastBuild(any(ObjectId.class))).thenReturn(gitBuild);
    Map<String, Build> buildsByBranchName = new HashMap<>();
    buildsByBranchName.put("develop", gitBuild);
    when(buildData.getBuildsByBranchName()).thenReturn(buildsByBranchName);
    buildDatas.add(buildData);
    
    //Second build data (@librabry)
    BuildData buildDataLib = mock(BuildData.class);
    Revision revisionLib = mock(Revision.class);
    when(revisionLib.getSha1String()).thenReturn("SHALIB");
    when(buildDataLib.getLastBuiltRevision()).thenReturn(revisionLib);
    Build gitBuildLib = mock(Build.class);
    when(gitBuildLib.getMarked()).thenReturn(revisionLib);
    when(buildDataLib.getLastBuild(any(ObjectId.class))).thenReturn(gitBuildLib);
    buildDatas.add(buildDataLib);
    
    when(build.getActions(BuildData.class)).thenReturn(buildDatas);
    when(build.getResult()).thenReturn(result);
    when(build.getUrl()).thenReturn(BUILD_URL);

    AbstractProject<?, ?> project = mock(AbstractProject.class);
    when(project.getProperty(GitLabConnectionProperty.class)).thenReturn(new GitLabConnectionProperty(gitLabConnection));
    when(build.getProject()).thenReturn(project);
    EnvVars environment = mock(EnvVars.class);
    when(environment.expand(anyString())).thenAnswer(new Answer<String>() {
        @Override
        public String answer(InvocationOnMock invocation) throws Throwable {
            return (String) invocation.getArguments()[0];
        }
    });
    try {
        when(build.getEnvironment(any(TaskListener.class))).thenReturn(environment);
    } catch (IOException | InterruptedException e) {
        throw new RuntimeException(e);
    }
    return build;
}