public <T extends TaskRepository> void setRepositories(List<T> repositories) {
Set<TaskRepository> set = new HashSet<TaskRepository>(myRepositories);
set.removeAll(repositories);
myBadRepositories.removeAll(set); // remove all changed reps
myIssueCache.clear();
myRepositories.clear();
myRepositories.addAll(repositories);
reps:
for (T repository : repositories) {
if (repository.isShared() && repository.getUrl() != null) {
List<TaskProjectConfiguration.SharedServer> servers = getProjectConfiguration().servers;
TaskRepositoryType type = repository.getRepositoryType();
for (TaskProjectConfiguration.SharedServer server : servers) {
if (repository.getUrl().equals(server.url) && type.getName().equals(server.type)) {
continue reps;
}
}
TaskProjectConfiguration.SharedServer server = new TaskProjectConfiguration.SharedServer();
server.type = type.getName();
server.url = repository.getUrl();
servers.add(server);
}
}
}
private Change[] getLeadSelection() {
final Set<Change> changes = new LinkedHashSet<Change>();
final TreePath[] paths = getSelectionPaths();
if (paths == null) return new Change[0];
for (TreePath path : paths) {
ChangesBrowserNode node = (ChangesBrowserNode) path.getLastPathComponent();
if (node instanceof ChangesBrowserChangeNode) {
changes.add(((ChangesBrowserChangeNode) node).getUserObject());
}
}
return changes.toArray(new Change[changes.size()]);
}
public Collection<AbstractVcs> getAffectedVcses() {
final ProjectLevelVcsManager vcsManager = ProjectLevelVcsManager.getInstance(myProject);
final Set<AbstractVcs> vcses =
new HashSet<AbstractVcs>(Arrays.asList(vcsManager.getAllActiveVcss()));
final Set<AbstractVcs> result = new HashSet<AbstractVcs>();
for (Change change : myBrowser.myAllChanges) {
if (vcses.isEmpty()) break;
final AbstractVcs vcs = ChangesUtil.getVcsForChange(change, myBrowser.myProject);
if (vcs != null) {
result.add(vcs);
vcses.remove(vcs);
}
}
return result;
}
private List<FilePath> getSelectedFilePaths(final Object tag) {
Set<FilePath> files = new HashSet<FilePath>();
final TreePath[] paths = getSelectionPaths();
if (paths != null) {
for (TreePath path : paths) {
if (path.getPathCount() > 1) {
ChangesBrowserNode firstNode = (ChangesBrowserNode) path.getPathComponent(1);
if (tag == null || firstNode.getUserObject() == tag) {
ChangesBrowserNode<?> node = (ChangesBrowserNode) path.getLastPathComponent();
files.addAll(node.getAllFilePathsUnder());
}
}
}
}
return new ArrayList<FilePath>(files);
}
@NotNull
private ChangeList[] getSelectedChangeLists() {
Set<ChangeList> lists = new HashSet<ChangeList>();
final TreePath[] paths = getSelectionPaths();
if (paths == null) return new ChangeList[0];
for (TreePath path : paths) {
ChangesBrowserNode node = (ChangesBrowserNode) path.getLastPathComponent();
final Object userObject = node.getUserObject();
if (userObject instanceof ChangeList) {
lists.add((ChangeList) userObject);
}
}
return lists.toArray(new ChangeList[lists.size()]);
}
@Nullable
private List<Task> getIssuesFromRepositories(
@Nullable String request,
int max,
long since,
boolean forceRequest,
@NotNull final ProgressIndicator cancelled) {
List<Task> issues = null;
for (final TaskRepository repository : getAllRepositories()) {
if (!repository.isConfigured() || (!forceRequest && myBadRepositories.contains(repository))) {
continue;
}
try {
Task[] tasks = repository.getIssues(request, max, since, cancelled);
myBadRepositories.remove(repository);
if (issues == null) issues = new ArrayList<Task>(tasks.length);
if (!repository.isSupported(TaskRepository.NATIVE_SEARCH) && request != null) {
List<Task> filteredTasks =
TaskSearchSupport.filterTasks(request, ContainerUtil.list(tasks));
ContainerUtil.addAll(issues, filteredTasks);
} else {
ContainerUtil.addAll(issues, tasks);
}
} catch (ProcessCanceledException ignored) {
// OK
} catch (Exception e) {
String reason = "";
// Fix to IDEA-111810
if (e.getClass() == Exception.class) {
// probably contains some message meaningful to end-user
reason = e.getMessage();
}
//noinspection InstanceofCatchParameter
if (e instanceof SocketTimeoutException) {
LOG.warn("Socket timeout from " + repository);
} else {
LOG.warn("Cannot connect to " + repository, e);
}
myBadRepositories.add(repository);
if (forceRequest) {
notifyAboutConnectionFailure(repository, reason);
}
}
}
return issues;
}
private List<LocallyDeletedChange> getSelectedLocallyDeletedChanges() {
Set<LocallyDeletedChange> files = new HashSet<LocallyDeletedChange>();
final TreePath[] paths = getSelectionPaths();
if (paths != null) {
for (TreePath path : paths) {
if (path.getPathCount() > 1) {
ChangesBrowserNode firstNode = (ChangesBrowserNode) path.getPathComponent(1);
if (firstNode.getUserObject() == TreeModelBuilder.LOCALLY_DELETED_NODE) {
ChangesBrowserNode<?> node = (ChangesBrowserNode) path.getLastPathComponent();
final List<LocallyDeletedChange> objectsUnder =
node.getAllObjectsUnder(LocallyDeletedChange.class);
files.addAll(objectsUnder);
}
}
}
}
return new ArrayList<LocallyDeletedChange>(files);
}
@Nullable
private Intersection checkIntersection(
@Nullable final List<CommittedChangeList> lists, List<LocalChangeList> localChangeLists) {
if (lists == null || lists.isEmpty()) {
return null;
}
final Set<FilePath> mergePaths = new HashSet<FilePath>();
for (CommittedChangeList list : lists) {
final SvnChangeList svnList = (SvnChangeList) list;
final List<String> paths = new ArrayList<String>(svnList.getAddedPaths());
paths.addAll(svnList.getChangedPaths());
paths.addAll(svnList.getDeletedPaths());
for (String path : paths) {
final File localPath = getLocalPath(path);
if (localPath != null) {
mergePaths.add(new FilePathImpl(localPath, false));
}
}
}
final Intersection intersection = new Intersection();
for (LocalChangeList localChangeList : localChangeLists) {
final Collection<Change> localChanges = localChangeList.getChanges();
for (Change localChange : localChanges) {
final FilePath before =
localChange.getBeforeRevision() == null
? null
: localChange.getBeforeRevision().getFile();
final FilePath after =
localChange.getAfterRevision() == null
? null
: localChange.getAfterRevision().getFile();
if ((before != null && mergePaths.contains(before))
|| (after != null && mergePaths.contains(after))) {
intersection.add(localChangeList.getName(), localChangeList.getComment(), localChange);
}
}
}
return intersection;
}
private void baseRevisionsOfDvcsIntoContext(
List<Change> textChanges, CommitContext commitContext) {
ProjectLevelVcsManager vcsManager = ProjectLevelVcsManager.getInstance(myProject);
if (vcsManager.dvcsUsedInProject()
&& VcsConfiguration.getInstance(myProject).INCLUDE_TEXT_INTO_SHELF) {
final Set<Change> big = SelectFilesToAddTextsToPatchPanel.getBig(textChanges);
final ArrayList<FilePath> toKeep = new ArrayList<FilePath>();
for (Change change : textChanges) {
if (change.getBeforeRevision() == null || change.getAfterRevision() == null) continue;
if (big.contains(change)) continue;
FilePath filePath = ChangesUtil.getFilePath(change);
final AbstractVcs vcs = vcsManager.getVcsFor(filePath);
if (vcs != null && VcsType.distibuted.equals(vcs.getType())) {
toKeep.add(filePath);
}
}
commitContext.putUserData(BaseRevisionTextPatchEP.ourPutBaseRevisionTextKey, true);
commitContext.putUserData(BaseRevisionTextPatchEP.ourBaseRevisionPaths, toKeep);
}
}
@NotNull
public Change[] getSelectedChanges() {
Set<Change> changes = new LinkedHashSet<Change>();
final TreePath[] paths = getSelectionPaths();
if (paths == null) {
return new Change[0];
}
for (TreePath path : paths) {
ChangesBrowserNode<?> node = (ChangesBrowserNode) path.getLastPathComponent();
changes.addAll(node.getAllChangesUnder());
}
if (changes.isEmpty()) {
final List<VirtualFile> selectedModifiedWithoutEditing = getSelectedModifiedWithoutEditing();
if (selectedModifiedWithoutEditing != null && !selectedModifiedWithoutEditing.isEmpty()) {
for (VirtualFile file : selectedModifiedWithoutEditing) {
AbstractVcs vcs = ProjectLevelVcsManager.getInstance(myProject).getVcsFor(file);
if (vcs == null) continue;
final VcsCurrentRevisionProxy before =
VcsCurrentRevisionProxy.create(file, myProject, vcs.getKeyInstanceMethod());
if (before != null) {
ContentRevision afterRevision = new CurrentContentRevision(new FilePathImpl(file));
changes.add(new Change(before, afterRevision, FileStatus.HIJACKED));
}
}
}
}
return changes.toArray(new Change[changes.size()]);
}
private Collection<FilePath> chooseBinaryFiles(List<Change> converted, Set<FilePath> paths) {
String singleMessage = "";
if (paths.size() == 1) {
final Change change = converted.get(0);
final FileStatus status = change.getFileStatus();
final FilePath path = ChangesUtil.getFilePath(change);
final String stringPath = TreeConflictRefreshablePanel.filePath(path);
if (FileStatus.DELETED.equals(status)) {
singleMessage = "Delete binary file " + stringPath + " (according to theirs changes)?";
} else if (FileStatus.ADDED.equals(status)) {
singleMessage = "Create binary file " + stringPath + " (according to theirs changes)?";
} else {
singleMessage =
"Apply changes to binary file " + stringPath + " (according to theirs changes)?";
}
}
return AbstractVcsHelper.getInstance(myVcs.getProject())
.selectFilePathsToProcess(
new ArrayList<FilePath>(paths),
TreeConflictRefreshablePanel.TITLE,
"Select binary files to patch",
TreeConflictRefreshablePanel.TITLE,
singleMessage,
new VcsShowConfirmationOption() {
@Override
public Value getValue() {
return null;
}
@Override
public void setValue(Value value) {}
@Override
public boolean isPersistent() {
return false;
}
});
}
public List<VcsException> commit(
@NotNull List<Change> changes,
@NotNull String message,
@NotNull NullableFunction<Object, Object> parametersHolder,
Set<String> feedback) {
List<VcsException> exceptions = new ArrayList<VcsException>();
Map<VirtualFile, Collection<Change>> sortedChanges = sortChangesByGitRoot(changes, exceptions);
log.assertTrue(
!sortedChanges.isEmpty(), "Trying to commit an empty list of changes: " + changes);
for (Map.Entry<VirtualFile, Collection<Change>> entry : sortedChanges.entrySet()) {
final VirtualFile root = entry.getKey();
try {
File messageFile = createMessageFile(root, message);
try {
final Set<FilePath> added = new HashSet<FilePath>();
final Set<FilePath> removed = new HashSet<FilePath>();
for (Change change : entry.getValue()) {
switch (change.getType()) {
case NEW:
case MODIFICATION:
added.add(change.getAfterRevision().getFile());
break;
case DELETED:
removed.add(change.getBeforeRevision().getFile());
break;
case MOVED:
FilePath afterPath = change.getAfterRevision().getFile();
FilePath beforePath = change.getBeforeRevision().getFile();
added.add(afterPath);
if (!GitFileUtils.shouldIgnoreCaseChange(
afterPath.getPath(), beforePath.getPath())) {
removed.add(beforePath);
}
break;
default:
throw new IllegalStateException("Unknown change type: " + change.getType());
}
}
try {
try {
Set<FilePath> files = new HashSet<FilePath>();
files.addAll(added);
files.addAll(removed);
commit(
myProject,
root,
files,
messageFile,
myNextCommitAuthor,
myNextCommitAmend,
myNextCommitAuthorDate);
} catch (VcsException ex) {
PartialOperation partialOperation = isMergeCommit(ex);
if (partialOperation == PartialOperation.NONE) {
throw ex;
}
if (!mergeCommit(
myProject,
root,
added,
removed,
messageFile,
myNextCommitAuthor,
exceptions,
partialOperation)) {
throw ex;
}
}
} finally {
if (!messageFile.delete()) {
log.warn("Failed to remove temporary file: " + messageFile);
}
}
} catch (VcsException e) {
exceptions.add(e);
}
} catch (IOException ex) {
//noinspection ThrowableInstanceNeverThrown
exceptions.add(new VcsException("Creation of commit message file failed", ex));
}
}
if (myNextCommitIsPushed != null
&& myNextCommitIsPushed.booleanValue()
&& exceptions.isEmpty()) {
// push
UIUtil.invokeLaterIfNeeded(
new Runnable() {
public void run() {
GitPusher.showPushDialogAndPerformPush(
myProject, ServiceManager.getService(myProject, GitPlatformFacade.class));
}
});
}
return exceptions;
}
@Override
public boolean testConnection(final TaskRepository repository) {
TestConnectionTask task =
new TestConnectionTask("Test connection") {
public void run(@NotNull ProgressIndicator indicator) {
indicator.setText("Connecting to " + repository.getUrl() + "...");
indicator.setFraction(0);
indicator.setIndeterminate(true);
try {
myConnection = repository.createCancellableConnection();
if (myConnection != null) {
Future<Exception> future =
ApplicationManager.getApplication().executeOnPooledThread(myConnection);
while (true) {
try {
myException = future.get(100, TimeUnit.MILLISECONDS);
return;
} catch (TimeoutException ignore) {
try {
indicator.checkCanceled();
} catch (ProcessCanceledException e) {
myException = e;
myConnection.cancel();
return;
}
} catch (Exception e) {
myException = e;
return;
}
}
} else {
try {
repository.testConnection();
} catch (Exception e) {
LOG.info(e);
myException = e;
}
}
} catch (Exception e) {
myException = e;
}
}
};
ProgressManager.getInstance().run(task);
Exception e = task.myException;
if (e == null) {
myBadRepositories.remove(repository);
Messages.showMessageDialog(
myProject, "Connection is successful", "Connection", Messages.getInformationIcon());
} else if (!(e instanceof ProcessCanceledException)) {
String message = e.getMessage();
if (e instanceof UnknownHostException) {
message = "Unknown host: " + message;
}
if (message == null) {
LOG.error(e);
message = "Unknown error";
}
Messages.showErrorDialog(myProject, StringUtil.capitalize(message), "Error");
}
return e == null;
}
@CalledInAwt
public static ApplyPatchStatus executePatchGroup(
final Collection<PatchApplier> group, final LocalChangeList localChangeList) {
if (group.isEmpty()) return ApplyPatchStatus.SUCCESS; // ?
final Project project = group.iterator().next().myProject;
ApplyPatchStatus result = ApplyPatchStatus.SUCCESS;
for (PatchApplier patchApplier : group) {
result = ApplyPatchStatus.and(result, patchApplier.nonWriteActionPreCheck());
}
final Label beforeLabel = LocalHistory.getInstance().putSystemLabel(project, "Before patch");
final TriggerAdditionOrDeletion trigger = new TriggerAdditionOrDeletion(project);
final Ref<ApplyPatchStatus> refStatus = new Ref<>(result);
try {
CommandProcessor.getInstance()
.executeCommand(
project,
new Runnable() {
@Override
public void run() {
for (PatchApplier applier : group) {
refStatus.set(ApplyPatchStatus.and(refStatus.get(), applier.createFiles()));
applier.addSkippedItems(trigger);
}
trigger.prepare();
if (refStatus.get() == ApplyPatchStatus.SUCCESS) {
// all pre-check results are valuable only if not successful; actual status we
// can receive after executeWritable
refStatus.set(null);
}
for (PatchApplier applier : group) {
refStatus.set(ApplyPatchStatus.and(refStatus.get(), applier.executeWritable()));
if (refStatus.get() == ApplyPatchStatus.ABORT) break;
}
}
},
VcsBundle.message("patch.apply.command"),
null);
} finally {
VcsFileListenerContextHelper.getInstance(project).clearContext();
LocalHistory.getInstance().putSystemLabel(project, "After patch");
}
result = refStatus.get();
result = result == null ? ApplyPatchStatus.FAILURE : result;
trigger.processIt();
final Set<FilePath> directlyAffected = new HashSet<>();
final Set<VirtualFile> indirectlyAffected = new HashSet<>();
for (PatchApplier applier : group) {
directlyAffected.addAll(applier.getDirectlyAffected());
indirectlyAffected.addAll(applier.getIndirectlyAffected());
}
directlyAffected.addAll(trigger.getAffected());
final Consumer<Collection<FilePath>> mover =
localChangeList == null ? null : createMover(project, localChangeList);
refreshPassedFilesAndMoveToChangelist(project, directlyAffected, indirectlyAffected, mover);
if (result == ApplyPatchStatus.FAILURE) {
suggestRollback(project, group, beforeLabel);
} else if (result == ApplyPatchStatus.ABORT) {
rollbackUnderProgress(project, project.getBaseDir(), beforeLabel);
}
showApplyStatus(project, result);
return result;
}
