Java FetchResult类代码示例

import org.eclipse.jgit.transport.FetchResult; //导入依赖的package包/类
private List<TrackingRefUpdate> fetch(Repository repository) throws Exception {
       logger.info("Fetching changes of repository {}", repository.getDirectory().toString());
       try (Git git = new Git(repository)) {
   		FetchResult result = git.fetch().call();
   		
   		Collection<TrackingRefUpdate> updates = result.getTrackingRefUpdates();
   		List<TrackingRefUpdate> remoteRefsChanges = new ArrayList<TrackingRefUpdate>();
   		for (TrackingRefUpdate update : updates) {
   			String refName = update.getLocalName();
   			if (refName.startsWith(REMOTE_REFS_PREFIX)) {
   				ObjectId newObjectId = update.getNewObjectId();
   				logger.info("{} is now at {}", refName, newObjectId.getName());
   				remoteRefsChanges.add(update);
   			}
   		}
   		if (updates.isEmpty()) {
   			logger.info("Nothing changed");
   		}
   		return remoteRefsChanges;
       }
}
 

import org.eclipse.jgit.transport.FetchResult; //导入依赖的package包/类
@Override
public String fetch(String localBranchName, String remoteBranchName) {
    
    RefSpec spec = new RefSpec().setSourceDestination(localBranchName, remoteBranchName);
    FetchCommand command = _git.fetch();
    command.setRefSpecs(spec);
    FetchResult result = null;
    try {
        result = command.call();
    } catch (Throwable e) {
        throw new RuntimeException(String.format(
                "Failed to fetch from [%s] to [%s]",
                remoteBranchName,
                localBranchName), e);
    }
    
    return result.getMessages();
}
 

import org.eclipse.jgit.transport.FetchResult; //导入依赖的package包/类
@Test
public void shouldSetTransportConfigCallbackOnCloneAndFetch() throws Exception {
	Git mockGit = mock(Git.class);
	FetchCommand fetchCommand = mock(FetchCommand.class);
	when(mockGit.fetch()).thenReturn(fetchCommand);
	when(fetchCommand.call()).thenReturn(mock(FetchResult.class));

	CloneCommand mockCloneCommand = mock(CloneCommand.class);
	when(mockCloneCommand.setURI(anyString())).thenReturn(mockCloneCommand);
	when(mockCloneCommand.setDirectory(any(File.class))).thenReturn(mockCloneCommand);

	TransportConfigCallback configCallback = mock(TransportConfigCallback.class);
	JGitEnvironmentRepository envRepository = new JGitEnvironmentRepository(this.environment);
	envRepository.setGitFactory(new MockGitFactory(mockGit, mockCloneCommand));
	envRepository.setUri("http://somegitserver/somegitrepo");
	envRepository.setTransportConfigCallback(configCallback);
	envRepository.setCloneOnStart(true);

	envRepository.afterPropertiesSet();
	verify(mockCloneCommand, times(1)).setTransportConfigCallback(configCallback);

	envRepository.fetch(mockGit, "master");
	verify(fetchCommand, times(1)).setTransportConfigCallback(configCallback);
}
 

import org.eclipse.jgit.transport.FetchResult; //导入依赖的package包/类
/**
 * Fetch updates from the remote repository. If refSpecs is unspecifed, remote heads, tags, and notes are retrieved.
 * 
 * @param credentialsProvider
 * @param repository
 * @param refSpecs
 * @return FetchResult
 * @throws Exception
 */
public static FetchResult fetchRepository(CredentialsProvider credentialsProvider, Repository repository, RefSpec... refSpecs) throws Exception {
	try (Git git = new Git(repository)) {
		FetchCommand fetch = git.fetch();
		List<RefSpec> specs = new ArrayList<RefSpec>();
		if (refSpecs == null || refSpecs.length == 0) {
			specs.add(new RefSpec("+refs/heads/*:refs/remotes/origin/*"));
			specs.add(new RefSpec("+refs/tags/*:refs/tags/*"));
			specs.add(new RefSpec("+refs/notes/*:refs/notes/*"));
		} else {
			specs.addAll(Arrays.asList(refSpecs));
		}
		if (credentialsProvider != null) {
			fetch.setCredentialsProvider(credentialsProvider);
		}
		fetch.setRefSpecs(specs);
		FetchResult fetchRes = fetch.call();
		return fetchRes;
	}
}
 

import org.eclipse.jgit.transport.FetchResult; //导入依赖的package包/类
@Given("^I clone repository \"([^\"]*)\"$")
public void iCloneRepository(String name) throws Throwable {
    workFolder = Files.createTempDir();
    RepositoryModel repositoryModel = repositoriesApi.getRepository(name)
        .getRepositoryModel();

    repositoryName = name;
    git = Git.init().setBare(false).setDirectory(workFolder).call();

    RemoteAddCommand addCommand = git.remoteAdd();
    addCommand.setName(REMOTE_ORIGIN);
    addCommand.setUri(new URIish(repositoryModel.getUrl() + ".git"));
    addCommand.call();

    FetchResult fetchResult = git.fetch().setRemote(REMOTE_ORIGIN).call();

    if (!fetchResult.getAdvertisedRefs().isEmpty()) {
        git.pull().setRemote(REMOTE_ORIGIN).setRemoteBranchName(MASTER_BRANCH_NAME).call();
    }

}
 

import org.eclipse.jgit.transport.FetchResult; //导入依赖的package包/类
/**
 * Fetch updates from the remote repository. If refSpecs is unspecifed,
 * remote heads, tags, and notes are retrieved.
 * 
 * @param credentialsProvider
 * @param repository
 * @param refSpecs
 * @return FetchResult
 * @throws Exception
 */
public static FetchResult fetchRepository(CredentialsProvider credentialsProvider,
		Repository repository, RefSpec... refSpecs) throws Exception {
	Git git = new Git(repository);
	FetchCommand fetch = git.fetch();
	List<RefSpec> specs = new ArrayList<RefSpec>();
	if (refSpecs == null || refSpecs.length == 0) {
		specs.add(new RefSpec("+refs/heads/*:refs/remotes/origin/*"));
		specs.add(new RefSpec("+refs/tags/*:refs/tags/*"));
		specs.add(new RefSpec("+refs/notes/*:refs/notes/*"));
	} else {
		specs.addAll(Arrays.asList(refSpecs));
	}
	if (credentialsProvider != null) {
		fetch.setCredentialsProvider(credentialsProvider);
	}
	fetch.setRefSpecs(specs);
	FetchResult fetchRes = fetch.call();
	return fetchRes;
}
 

import org.eclipse.jgit.transport.FetchResult; //导入依赖的package包/类
@Override
public void doExecute() {
        try {
                PullCommand pullCommand = git.pull().setRebase(rebase);

                if (getProgressMonitor() != null) {
                        pullCommand.setProgressMonitor(getProgressMonitor());
                }

                setupCredentials(pullCommand);
                PullResult pullResult = pullCommand.call();

                if (!pullResult.isSuccessful()) {
                        FetchResult fetchResult = pullResult.getFetchResult();
                        GitTaskUtils.validateTrackingRefUpdates(MESSAGE_PULLED_FAILED, fetchResult.getTrackingRefUpdates());
                        MergeStatus mergeStatus = pullResult.getMergeResult().getMergeStatus();

                        if (!mergeStatus.isSuccessful()) {
                                throw new BuildException(String.format(MESSAGE_PULLED_FAILED_WITH_STATUS, mergeStatus.name()));
                        }
                }
        }
        catch (Exception e) {
                throw new GitBuildException(String.format(MESSAGE_PULLED_FAILED_WITH_URI, getUri()), e);
        }
}
 

import org.eclipse.jgit.transport.FetchResult; //导入依赖的package包/类
private List<TrackingRefUpdate> fetch(Repository repository) throws Exception {
	try (Git git = new Git(repository)) {
		FetchResult result = git.fetch().call();
		
		Collection<TrackingRefUpdate> updates = result.getTrackingRefUpdates();
		List<TrackingRefUpdate> remoteRefsChanges = new ArrayList<TrackingRefUpdate>();
		for (TrackingRefUpdate update : updates) {
			String refName = update.getLocalName();
			if (refName.startsWith(REMOTE_REFS_PREFIX)) {
				remoteRefsChanges.add(update);
			}
		}
		return remoteRefsChanges;
	}
}
 

import org.eclipse.jgit.transport.FetchResult; //导入依赖的package包/类
/**
 * Fetches all content from the given remote. Note: this command will also prune deleted references
 * @param git the git repository
 * @param remoteName the name of the remote or the uri of the remote
 * @return result of the fetch
 * @throws GitAPIException
 */
public static FetchResult fetch(Git git, String remoteName) throws GitAPIException {
    return git.fetch()
            .setRemote(remoteName)
            .setCheckFetchedObjects(true)
            .setRemoveDeletedRefs(true)
            .call();
}
 

import org.eclipse.jgit.transport.FetchResult; //导入依赖的package包/类
public static TestRepository<InMemoryRepository> cloneProject(Project.NameKey project, String uri)
    throws Exception {
  DfsRepositoryDescription desc = new DfsRepositoryDescription("clone of " + project.get());

  FS fs = FS.detect();

  // Avoid leaking user state into our tests.
  fs.setUserHome(null);

  InMemoryRepository dest =
      new InMemoryRepository.Builder()
          .setRepositoryDescription(desc)
          // SshTransport depends on a real FS to read ~/.ssh/config, but
          // InMemoryRepository by default uses a null FS.
          // TODO(dborowitz): Remove when we no longer depend on SSH.
          .setFS(fs)
          .build();
  Config cfg = dest.getConfig();
  cfg.setString("remote", "origin", "url", uri);
  cfg.setString("remote", "origin", "fetch", "+refs/heads/*:refs/remotes/origin/*");
  TestRepository<InMemoryRepository> testRepo = newTestRepository(dest);
  FetchResult result = testRepo.git().fetch().setRemote("origin").call();
  String originMaster = "refs/remotes/origin/master";
  if (result.getTrackingRefUpdate(originMaster) != null) {
    testRepo.reset(originMaster);
  }
  return testRepo;
}
 

import org.eclipse.jgit.transport.FetchResult; //导入依赖的package包/类
private boolean onCommandGitFetch(Caller caller, String workspaceName, Git git, String remote) {
    GitExecutor<FetchResult> executor = new GitExecutor<FetchResult>(caller, workspaceName, new GitFetchHandler());
    FetchCommand command = git.fetch()
            .setRemote(remote != null ? remote : "origin")
            .setProgressMonitor(executor)
            .setTagOpt(TagOpt.FETCH_TAGS)
            .setCredentialsProvider(executor);
    executor.setCommand(command);
    plugin.getServer().getScheduler().runTaskAsynchronously(plugin,executor);
    return true;
}
 

import org.eclipse.jgit.transport.FetchResult; //导入依赖的package包/类
private AnyObjectId commitToMergeFor(FetchResult fetchRes, String remoteBranchName, boolean remote) {
    // we check the updates to see which of the updated branches
    // corresponds
    // to the remote branch name
    AnyObjectId commitToMerge;
    if (remote) {
        Ref r = null;
        if (fetchRes != null) {
            r = fetchRes.getAdvertisedRef(remoteBranchName);
            if (r == null)
                r = fetchRes.getAdvertisedRef(R_HEADS + remoteBranchName);
        }
        if (r == null)
            throw new JGitInternalException(MessageFormat.format(JGitText
                    .get().couldNotGetAdvertisedRef, remoteBranchName));
        else
            commitToMerge = r.getObjectId();
    } else {
        try {
            commitToMerge = repo.resolve(remoteBranchName);
            if (commitToMerge == null)
                throw exceptionMessage(R.string.ref_not_resolved, remoteBranchName);
        } catch (IOException e) {
            throw new JGitInternalException(
                    JGitText.get().exceptionCaughtDuringExecutionOfPullCommand,
                    e);
        }
    }
    return commitToMerge;
}
 

import org.eclipse.jgit.transport.FetchResult; //导入依赖的package包/类
public FetchResult fetch(String remote, Collection<RefSpec> toFetch) {
    Log.d(TAG, "About to run fetch : " + remote);

    for (Map.Entry<String,Ref> entry : git.getRepository().getAllRefs().entrySet()) {
        Log.d(TAG, entry.getKey()+" = "+entry.getValue());
    }
    FetchResult fetchResult = null;
    try {
        fetchResult = git.fetch()
                .setRemote(remote)
                .setRefSpecs(toFetch == null ? Collections.<RefSpec>emptyList() : newArrayList(toFetch))
                .setProgressMonitor(messagingProgressMonitor)
                .setTransportConfigCallback(transportConfigCallback)
                .setCredentialsProvider(credentialsProvider)
                .call();
    } catch (GitAPIException e) {
        throw exceptionWithFriendlyMessageFor(e);
    }
    Log.d(TAG, "Fetch complete with : " + fetchResult+" messages="+fetchResult.getMessages());
    for (Ref ref : fetchResult.getAdvertisedRefs()) {
        Log.d(TAG, "AdvertisedRef : " + ref.getName()+" objectId="+ref.getObjectId());
    }
    for (TrackingRefUpdate update : fetchResult.getTrackingRefUpdates()) {
        Log.d(TAG, "TrackingRefUpdate : " + update.getLocalName() + " old=" + update.getOldObjectId() + " new=" + update.getNewObjectId());
    }
    repoUpdateBroadcaster.broadcastUpdate();
    return fetchResult;
}
 

import org.eclipse.jgit.transport.FetchResult; //导入依赖的package包/类
protected void synchronize() {
	//
	// Grab our working repository
	//
	Path repoPath = ((XacmlAdminUI)getUI()).getUserGitPath();
	try {
		final Git git = Git.open(repoPath.toFile());
		
		PullResult result = git.pull().call();
		FetchResult fetch = result.getFetchResult();
		MergeResult merge = result.getMergeResult();
		RebaseResult rebase = result.getRebaseResult();
		if (result.isSuccessful()) {
			//
			// TODO add more notification
			//
			this.textAreaResults.setValue("Successful!");
		} else {
			//
			// TODO
			//
			this.textAreaResults.setValue("Failed.");
		}
	} catch (IOException | GitAPIException e) {
		e.printStackTrace();
	}
	this.buttonSynchronize.setCaption("Ok");
}
 

import org.eclipse.jgit.transport.FetchResult; //导入依赖的package包/类
@Override
public Context doApply(Context context) throws Throwable {
    final Repository repository = new FileRepositoryBuilder()
        .setGitDir(context.getProjectPath())
            // scan environment GIT_* variables
        .readEnvironment()
        .findGitDir()
        .setMustExist(true)
        .build();
    context.setRepository(repository);

    logger.info("Fetching '{}' repository at path: '{}'", context.getName(), context.getProjectPath());

    Git git = new Git(repository);

    FetchResult fetchResult = git.fetch()
        .setProgressMonitor(new LoggingProgressMonitor(logger))
        .call();

    Collection<Ref> refs = FluentIterable
        .from(fetchResult.getTrackingRefUpdates())
        .filter(Predicates.not(new Predicate<TrackingRefUpdate>() {
            @Override
            public boolean apply(TrackingRefUpdate input) {
                return NO_CHANGE.equals(input.getResult());
            }
        }))
        .transform(new TrackingRefUpdateToRef(repository))
        .toList();

    context.setRefs(refs);
    logger.info("Found {} refs to process.", refs.size());
    return context;
}