@NotNull
private Set<VcsRef> readBranches(@NotNull GitRepository repository) {
StopWatch sw = StopWatch.start("readBranches in " + repository.getRoot().getName());
VirtualFile root = repository.getRoot();
repository.update();
Collection<GitLocalBranch> localBranches = repository.getBranches().getLocalBranches();
Collection<GitRemoteBranch> remoteBranches = repository.getBranches().getRemoteBranches();
Set<VcsRef> refs = new THashSet<VcsRef>(localBranches.size() + remoteBranches.size());
for (GitLocalBranch localBranch : localBranches) {
refs.add(
myVcsObjectsFactory.createRef(
localBranch.getHash(), localBranch.getName(), GitRefManager.LOCAL_BRANCH, root));
}
for (GitRemoteBranch remoteBranch : remoteBranches) {
refs.add(
myVcsObjectsFactory.createRef(
remoteBranch.getHash(),
remoteBranch.getNameForLocalOperations(),
GitRefManager.REMOTE_BRANCH,
root));
}
String currentRevision = repository.getCurrentRevision();
if (currentRevision != null) { // null => fresh repository
refs.add(
myVcsObjectsFactory.createRef(
HashImpl.build(currentRevision), "HEAD", GitRefManager.HEAD, root));
}
sw.report();
return refs;
}
/**
* Checks if update is possible, saves local changes and updates all roots. In case of error shows
* notification and returns false. If update completes without errors, returns true.
*
* <p>Perform update on all roots. 0. Blocks reloading project on external change, saving/syncing
* on frame deactivation. 1. Checks if update is possible (rebase/merge in progress, no tracked
* branches...) and provides merge dialog to solve problems. 2. Finds updaters to use (merge or
* rebase). 3. Preserves local changes if needed (not needed for merge sometimes). 4. Updates via
* 'git pull' or equivalent. 5. Restores local changes if update completed or failed with error.
* If update is incomplete, i.e. some unmerged files remain, local changes are not restored.
*/
@NotNull
public GitUpdateResult update(final UpdateMethod updateMethod) {
LOG.info("update started|" + updateMethod);
String oldText = myProgressIndicator.getText();
myProgressIndicator.setText("Updating...");
for (GitRepository repository : myRepositories) {
repository.update();
}
// check if update is possible
if (checkRebaseInProgress()
|| isMergeInProgress()
|| areUnmergedFiles()
|| !checkTrackedBranchesConfigured()) {
return GitUpdateResult.NOT_READY;
}
if (!fetchAndNotify()) {
return GitUpdateResult.NOT_READY;
}
AccessToken token = DvcsUtil.workingTreeChangeStarted(myProject);
GitUpdateResult result;
try {
result = updateImpl(updateMethod);
} finally {
DvcsUtil.workingTreeChangeFinished(myProject, token);
}
myProgressIndicator.setText(oldText);
return result;
}
private boolean doDeleteRemote(
@NotNull String branchName, @NotNull Collection<GitRepository> repositories) {
Couple<String> pair = splitNameOfRemoteBranch(branchName);
String remoteName = pair.getFirst();
String branch = pair.getSecond();
GitCompoundResult result = new GitCompoundResult(myProject);
for (GitRepository repository : repositories) {
GitCommandResult res;
GitRemote remote = getRemoteByName(repository, remoteName);
if (remote == null) {
String error = "Couldn't find remote by name: " + remoteName;
LOG.error(error);
res = GitCommandResult.error(error);
} else {
res = pushDeletion(repository, remote, branch);
if (!res.success() && isAlreadyDeletedError(res.getErrorOutputAsJoinedString())) {
res = myGit.remotePrune(repository, remote);
}
}
result.append(repository, res);
repository.update();
}
if (!result.totalSuccess()) {
VcsNotifier.getInstance(myProject)
.notifyError(
"Failed to delete remote branch " + branchName,
result.getErrorOutputWithReposIndication());
}
return result.totalSuccess();
}
@Nullable
public static GithubCreatePullRequestWorker createPullRequestWorker(
@NotNull final Project project, @Nullable final VirtualFile file) {
Git git = ServiceManager.getService(Git.class);
GitRepository gitRepository = GithubUtil.getGitRepository(project, file);
if (gitRepository == null) {
GithubNotifications.showError(
project, CANNOT_CREATE_PULL_REQUEST, "Can't find git repository");
return null;
}
gitRepository.update();
Pair<GitRemote, String> remote = GithubUtil.findGithubRemote(gitRepository);
if (remote == null) {
GithubNotifications.showError(
project, CANNOT_CREATE_PULL_REQUEST, "Can't find GitHub remote");
return null;
}
String remoteName = remote.getFirst().getName();
String remoteUrl = remote.getSecond();
GithubFullPath path = GithubUrlUtil.getUserAndRepositoryFromRemoteUrl(remoteUrl);
if (path == null) {
GithubNotifications.showError(
project, CANNOT_CREATE_PULL_REQUEST, "Can't process remote: " + remoteUrl);
return null;
}
GitLocalBranch currentBranch = gitRepository.getCurrentBranch();
if (currentBranch == null) {
GithubNotifications.showError(project, CANNOT_CREATE_PULL_REQUEST, "No current branch");
return null;
}
GithubAuthData auth;
try {
auth =
GithubUtil.computeValueInModal(
project,
"Access to GitHub",
new ThrowableConvertor<ProgressIndicator, GithubAuthData, IOException>() {
@Override
public GithubAuthData convert(ProgressIndicator indicator) throws IOException {
return GithubUtil.getValidAuthDataFromConfig(project, indicator);
}
});
} catch (GithubAuthenticationCanceledException e) {
return null;
} catch (IOException e) {
GithubNotifications.showError(project, CANNOT_CREATE_PULL_REQUEST, e);
return null;
}
return new GithubCreatePullRequestWorker(
project, git, gitRepository, path, remoteName, remoteUrl, currentBranch.getName(), auth);
}
@Override
public CloudGitApplication deploy() throws ServerRuntimeException {
CloudGitApplication application = findOrCreateApplication();
GitRepository repository = findOrCreateRepository();
addOrResetGitRemote(application, repository);
add();
commit();
repository.update();
pushApplication(application);
return application;
}
protected void fetch() throws ServerRuntimeException {
final VirtualFile contentRoot = getContentRoot();
GitRepository repository = getRepository();
final GitLineHandler fetchHandler =
new GitLineHandler(getProject(), contentRoot, GitCommand.FETCH);
fetchHandler.setSilent(false);
fetchHandler.addParameters(getRemoteName());
fetchHandler.addLineListener(createGitLineHandlerListener());
performRemoteGitTask(fetchHandler, CloudBundle.getText("fetching.application", getCloudName()));
repository.update();
}
/**
* Invokes 'git fetch'.
*
* @return true if fetch was successful, false in the case of error.
*/
public GitFetchResult fetch(@NotNull GitRepository repository) {
// TODO need to have a fair compound result here
GitFetchResult fetchResult = GitFetchResult.success();
if (myFetchAll) {
fetchResult = fetchAll(repository, fetchResult);
} else {
return fetchCurrentRemote(repository);
}
repository.update();
return fetchResult;
}
@Override
public void actionPerformed(@NotNull AnActionEvent event) {
final Project project = event.getProject();
if (project == null) {
return;
}
final Set<VirtualFile> conflictedFiles =
new TreeSet<VirtualFile>(
new Comparator<VirtualFile>() {
@Override
public int compare(@NotNull VirtualFile f1, @NotNull VirtualFile f2) {
return f1.getPresentableUrl().compareTo(f2.getPresentableUrl());
}
});
for (Change change : ChangeListManager.getInstance(project).getAllChanges()) {
if (change.getFileStatus() != FileStatus.MERGED_WITH_CONFLICTS) {
continue;
}
final ContentRevision before = change.getBeforeRevision();
final ContentRevision after = change.getAfterRevision();
if (before != null) {
final VirtualFile file = before.getFile().getVirtualFile();
if (file != null) {
conflictedFiles.add(file);
}
}
if (after != null) {
final VirtualFile file = after.getFile().getVirtualFile();
if (file != null) {
conflictedFiles.add(file);
}
}
}
AbstractVcsHelper.getInstance(project)
.showMergeDialog(
new ArrayList<VirtualFile>(conflictedFiles),
GitVcs.getInstance(project).getMergeProvider());
for (VirtualFile conflictedFile : conflictedFiles) {
final GitRepository repo =
GitRepositoryManager.getInstance(project).getRepositoryForFile(conflictedFile);
if (repo != null) {
repo.update(GitRepository.TrackedTopic.ALL_CURRENT);
}
}
}
@NotNull
@Override
public Collection<VcsRef> readAllRefs(@NotNull VirtualFile root) throws VcsException {
if (!isRepositoryReady(root)) {
return Collections.emptyList();
}
GitRepository repository = getRepository(root);
repository.update();
Collection<GitLocalBranch> localBranches = repository.getBranches().getLocalBranches();
Collection<GitRemoteBranch> remoteBranches = repository.getBranches().getRemoteBranches();
Collection<VcsRef> refs = new ArrayList<VcsRef>(localBranches.size() + remoteBranches.size());
for (GitLocalBranch localBranch : localBranches) {
refs.add(
myVcsObjectsFactory.createRef(
HashImpl.build(localBranch.getHash()),
localBranch.getName(),
GitRefManager.LOCAL_BRANCH,
root));
}
for (GitRemoteBranch remoteBranch : remoteBranches) {
refs.add(
myVcsObjectsFactory.createRef(
HashImpl.build(remoteBranch.getHash()),
remoteBranch.getNameForLocalOperations(),
GitRefManager.REMOTE_BRANCH,
root));
}
String currentRevision = repository.getCurrentRevision();
if (currentRevision != null) { // null => fresh repository
refs.add(
myVcsObjectsFactory.createRef(
HashImpl.build(currentRevision), "HEAD", GitRefManager.HEAD, root));
}
refs.addAll(readTags(root));
return refs;
}
@Override
public void consume(GitRepository.TrackedTopic trackedTopic) {
myRepository.update(trackedTopic);
}