private static void rollbackUnderProgress(
     @NotNull final Project project,
     @NotNull final VirtualFile virtualFile,
     @NotNull final Label labelToRevert) {
   ProgressManager.getInstance()
       .runProcessWithProgressSynchronously(
           () -> {
             try {
               labelToRevert.revert(project, virtualFile);
               VcsNotifier.getInstance(project)
                   .notifyImportantWarning(
                       "Apply Patch Aborted",
                       "All files changed during apply patch action were rolled back");
             } catch (LocalHistoryException e) {
               VcsNotifier.getInstance(project)
                   .notifyImportantWarning(
                       "Rollback Failed",
                       String.format(
                           "Try using local history dialog for %s and perform revert manually.",
                           virtualFile.getName()));
             }
           },
           "Rollback Applied Changes...",
           true,
           project);
 }
  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();
  }
 @Override
 protected void notifyUnresolvedRemain() {
   VcsNotifier.getInstance(myProject)
       .notifyImportantWarning(
           "Local changes were restored with conflicts",
           "Your uncommitted changes were saved to <a href='saver'>stash</a>.<br/>"
               + "Unstash is not complete, you have unresolved merges in your working tree<br/>"
               + "<a href='resolve'>Resolve</a> conflicts and drop the stash.",
           new NotificationListener() {
             @Override
             public void hyperlinkUpdate(
                 @NotNull Notification notification, @NotNull HyperlinkEvent event) {
               if (event.getEventType() == HyperlinkEvent.EventType.ACTIVATED) {
                 if (event.getDescription().equals("saver")) {
                   // we don't use #showSavedChanges to specify unmerged root first
                   GitUnstashDialog.showUnstashDialog(
                       myProject,
                       new ArrayList<VirtualFile>(myStashedRoots),
                       myStashedRoots.iterator().next());
                 } else if (event.getDescription().equals("resolve")) {
                   mergeNoProceed();
                 }
               }
             }
           });
 }
  @NotNull
  public static <CommitInfo> List<CommitInfo> getCommitRecords(
      @NotNull Project project,
      @Nullable HgCommandResult result,
      @NotNull Function<String, CommitInfo> converter,
      boolean silent) {
    final List<CommitInfo> revisions = new LinkedList<CommitInfo>();
    if (result == null) {
      return revisions;
    }

    List<String> errors = result.getErrorLines();
    if (errors != null && !errors.isEmpty()) {
      if (result.getExitValue() != 0) {
        if (silent) {
          LOG.warn(errors.toString());
        } else {
          VcsNotifier.getInstance(project)
              .notifyError(
                  HgVcsMessages.message("hg4idea.error.log.command.execution"), errors.toString());
        }
        return Collections.emptyList();
      }
      LOG.warn(errors.toString());
    }
    String output = result.getRawOutput();
    List<String> changeSets = StringUtil.split(output, HgChangesetUtil.CHANGESET_SEPARATOR);
    return ContainerUtil.mapNotNull(changeSets, converter);
  }
 private void notifySuccessfulDeletion(
     @NotNull String remoteBranchName, @NotNull Collection<String> localBranches) {
   String message = "";
   if (!localBranches.isEmpty()) {
     message =
         "Also deleted local "
             + StringUtil.pluralize("branch", localBranches.size())
             + ": "
             + StringUtil.join(localBranches, ", ");
   }
   VcsNotifier.getInstance(myProject)
       .notifySuccess("Deleted remote branch " + remoteBranchName, message);
 }
 private void notifyException(VcsException e) {
   LOG.info("mergeFiles ", e);
   final String description =
       "Couldn't check the working tree for unmerged files because of an error.";
   VcsNotifier.getInstance(myProject)
       .notifyError(
           myParams.myErrorNotificationTitle,
           description
               + myParams.myErrorNotificationAdditionalDescription
               + "<br/>"
               + e.getLocalizedMessage(),
           new ResolveNotificationListener());
 }
 private void notifySuccess(final Project project, final String title, final String message) {
   VcsNotifier.getInstance(project)
       .notifyImportantInfo(
           title,
           message,
           new NotificationListener() {
             @Override
             public void hyperlinkUpdate(
                 @NotNull final Notification n, @NotNull final HyperlinkEvent e) {
               BrowserUtil.browse(e.getURL());
             }
           });
 }
 public void notifyLocalChangesAreNotRestored() {
   if (wereChangesSaved()) {
     LOG.info("Update is incomplete, changes are not restored");
     VcsNotifier.getInstance(myProject)
         .notifyImportantWarning(
             "Local changes were not restored",
             "Before update your uncommitted changes were saved to <a href='saver'>"
                 + getSaverName()
                 + "</a>.<br/>"
                 + "Update is not complete, you have unresolved merges in your working tree<br/>"
                 + "Resolve conflicts, complete update and restore changes manually.",
             new ShowSavedChangesNotificationListener());
   }
 }
Esempio n. 9
0
 /**
  * Checks Git version and updates the myVersion variable. In the case of exception or unsupported
  * version reports the problem. Note that unsupported version is also applied - some functionality
  * might not work (we warn about that), but no need to disable at all.
  */
 public void checkVersion() {
   final String executable = myAppSettings.getPathToGit();
   try {
     myVersion = GitVersion.identifyVersion(executable);
     if (!myVersion.isSupported()) {
       log.info("Unsupported Git version: " + myVersion);
       final String SETTINGS_LINK = "settings";
       final String UPDATE_LINK = "update";
       String message =
           String.format(
               "The <a href='"
                   + SETTINGS_LINK
                   + "'>configured</a> version of Git is not supported: %s.<br/> "
                   + "The minimal supported version is %s. Please <a href='"
                   + UPDATE_LINK
                   + "'>update</a>.",
               myVersion,
               GitVersion.MIN);
       VcsNotifier.getInstance(myProject)
           .notifyError(
               "Unsupported Git version",
               message,
               new NotificationListener.Adapter() {
                 @Override
                 protected void hyperlinkActivated(
                     @NotNull Notification notification, @NotNull HyperlinkEvent e) {
                   if (SETTINGS_LINK.equals(e.getDescription())) {
                     ShowSettingsUtil.getInstance()
                         .showSettingsDialog(myProject, getConfigurable().getDisplayName());
                   } else if (UPDATE_LINK.equals(e.getDescription())) {
                     BrowserUtil.browse("http://git-scm.com");
                   }
                 }
               });
     }
   } catch (Exception e) {
     if (getExecutableValidator()
         .checkExecutableAndNotifyIfNeeded()) { // check executable before notifying error
       final String reason = (e.getCause() != null ? e.getCause() : e).getMessage();
       String message = GitBundle.message("vcs.unable.to.run.git", executable, reason);
       if (!myProject.isDefault()) {
         showMessage(message, ConsoleViewContentType.SYSTEM_OUTPUT.getAttributes());
       }
       VcsBalloonProblemNotifier.showOverVersionControlView(myProject, message, MessageType.ERROR);
     }
   }
 }
  /**
   * Displays notification about {@code untracked files would be overwritten by checkout} error.
   * Clicking on the link in the notification opens a simple dialog with the list of these files.
   *
   * @param root
   * @param relativePaths
   * @param operation the name of the Git operation that caused the error: {@code rebase, merge,
   *     checkout}.
   * @param description the content of the notification or null if the deafult content is to be
   *     used.
   */
  public static void notifyUntrackedFilesOverwrittenBy(
      @NotNull final Project project,
      @NotNull final VirtualFile root,
      @NotNull Collection<String> relativePaths,
      @NotNull final String operation,
      @Nullable String description) {
    final String notificationTitle = StringUtil.capitalize(operation) + " failed";
    final String notificationDesc =
        description == null
            ? createUntrackedFilesOverwrittenDescription(operation, true)
            : description;

    final Collection<String> absolutePaths = GitUtil.toAbsolute(root, relativePaths);
    final List<VirtualFile> untrackedFiles =
        ContainerUtil.mapNotNull(
            absolutePaths,
            new Function<String, VirtualFile>() {
              @Override
              public VirtualFile fun(String absolutePath) {
                return GitUtil.findRefreshFileOrLog(absolutePath);
              }
            });

    VcsNotifier.getInstance(project)
        .notifyError(
            notificationTitle,
            notificationDesc,
            new NotificationListener() {
              @Override
              public void hyperlinkUpdate(
                  @NotNull Notification notification, @NotNull HyperlinkEvent event) {
                if (event.getEventType() == HyperlinkEvent.EventType.ACTIVATED) {
                  final String dialogDesc =
                      createUntrackedFilesOverwrittenDescription(operation, false);
                  String title = "Untracked Files Preventing " + StringUtil.capitalize(operation);
                  if (untrackedFiles.isEmpty()) {
                    GitUtil.showPathsInDialog(project, absolutePaths, title, dialogDesc);
                  } else {
                    DialogWrapper dialog;
                    dialog = new UntrackedFilesDialog(project, untrackedFiles, dialogDesc);
                    dialog.setTitle(title);
                    dialog.show();
                  }
                }
              }
            });
  }
  public void rescanAndNotifyIfNeeded() {
    Collection<VcsRootError> errors = scan();
    if (errors.isEmpty()) {
      synchronized (NOTIFICATION_LOCK) {
        expireNotification();
      }
      return;
    }

    Collection<VcsRootError> importantUnregisteredRoots = getImportantUnregisteredMappings(errors);
    Collection<VcsRootError> invalidRoots = getInvalidRoots(errors);

    List<String> unregRootPaths =
        ContainerUtil.map(importantUnregisteredRoots, PATH_FROM_ROOT_ERROR);
    if (invalidRoots.isEmpty()
        && (importantUnregisteredRoots.isEmpty()
            || myReportedUnregisteredRoots.containsAll(unregRootPaths))) {
      return;
    }
    myReportedUnregisteredRoots.addAll(unregRootPaths);

    String title = makeTitle(importantUnregisteredRoots, invalidRoots);
    String description = makeDescription(importantUnregisteredRoots, invalidRoots);

    synchronized (NOTIFICATION_LOCK) {
      expireNotification();
      NotificationListener listener =
          new MyNotificationListener(
              myProject, mySettings, myVcsManager, importantUnregisteredRoots);
      VcsNotifier notifier = VcsNotifier.getInstance(myProject);
      myNotification =
          invalidRoots.isEmpty()
              ? notifier.notifyMinorInfo(title, description, listener)
              : notifier.notifyError(title, description, listener);
    }
  }
 private void notifyWarning(String title, String content) {
   VcsNotifier.getInstance(myProject)
       .notifyImportantWarning(title, content, new ResolveNotificationListener());
 }
 private void notifyError(final Project project, final String title, final String message) {
   VcsNotifier.getInstance(project).notifyError(title, message);
 }