private synchronized void setWatchRoots(
      List<String> recursive, List<String> flat, boolean restart) {
    if (myProcessHandler == null || myProcessHandler.isProcessTerminated()) return;

    if (ApplicationManager.getApplication().isDisposeInProgress()) {
      recursive = flat = Collections.emptyList();
    }

    if (!restart && myRecursiveWatchRoots.equals(recursive) && myFlatWatchRoots.equals(flat)) {
      return;
    }

    mySettingRoots.incrementAndGet();
    myMapping = emptyList();
    myRecursiveWatchRoots = recursive;
    myFlatWatchRoots = flat;

    try {
      writeLine(ROOTS_COMMAND);
      for (String path : recursive) {
        writeLine(path);
      }
      for (String path : flat) {
        writeLine("|" + path);
      }
      writeLine("#");
    } catch (IOException e) {
      LOG.warn(e);
    }
  }
    @Override
    public InputStream sendXmlRpc(byte[] request) throws IOException {
      // Create a trust manager that does not validate certificate for this connection
      TrustManager[] trustAllCerts = new TrustManager[] {new PyPITrustManager()};

      try {
        SSLContext sslContext = SSLContext.getInstance("TLS");
        sslContext.init(null, trustAllCerts, new SecureRandom());

        final HttpConfigurable settings = HttpConfigurable.getInstance();
        con = settings.openConnection(PYPI_LIST_URL);
        if (con instanceof HttpsURLConnection) {
          ((HttpsURLConnection) con).setSSLSocketFactory(sslContext.getSocketFactory());
        }
        con.setDoInput(true);
        con.setDoOutput(true);
        con.setUseCaches(false);
        con.setAllowUserInteraction(false);
        con.setRequestProperty("Content-Length", Integer.toString(request.length));
        con.setRequestProperty("Content-Type", "text/xml");
        if (auth != null) {
          con.setRequestProperty("Authorization", "Basic " + auth);
        }
        OutputStream out = con.getOutputStream();
        out.write(request);
        out.flush();
        out.close();
        return con.getInputStream();
      } catch (NoSuchAlgorithmException e) {
        LOG.warn(e.getMessage());
      } catch (KeyManagementException e) {
        LOG.warn(e.getMessage());
      }
      return super.sendXmlRpc(request);
    }
  @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 deleteInstance(@NotNull final VmwareCloudInstance instance) {
   if (instance.getErrorInfo() == null) {
     LOG.info("Will delete instance " + instance.getName());
     final VmwareInstance vmInstance;
     try {
       vmInstance = myApiConnector.getInstanceDetails(instance.getName());
       myAsyncTaskExecutor.executeAsync(
           vmInstance.deleteInstance(),
           new ImageStatusTaskWrapper(instance) {
             @Override
             public void onSuccess() {
               removeInstance(instance.getName());
             }
           });
     } catch (VmwareCheckedCloudException e) {
       LOG.warn("An exception during deleting instance " + instance.getName(), e);
       instance.updateErrors(TypedCloudErrorInfo.fromException(e));
     }
   } else {
     LOG.warn(
         String.format(
             "Won't delete instance %s with error: %s (%s)",
             instance.getName(),
             instance.getErrorInfo().getMessage(),
             instance.getErrorInfo().getDetailedMessage()));
   }
 }
  public Process createProcess() throws ExecutionException {
    if (LOG.isDebugEnabled()) {
      LOG.debug("Executing [" + getCommandLineString() + "]");
    }

    List<String> commands;
    try {
      checkWorkingDirectory();

      if (StringUtil.isEmptyOrSpaces(myExePath)) {
        throw new ExecutionException(
            IdeBundle.message("run.configuration.error.executable.not.specified"));
      }

      commands = CommandLineUtil.toCommandLine(myExePath, myProgramParams.getList());
    } catch (ExecutionException e) {
      LOG.warn(e);
      throw e;
    }

    try {
      ProcessBuilder builder = new ProcessBuilder(commands);
      setupEnvironment(builder.environment());
      builder.directory(myWorkDirectory);
      builder.redirectErrorStream(myRedirectErrorStream);
      return builder.start();
    } catch (IOException e) {
      LOG.warn(e);
      throw new ProcessNotCreatedException(e.getMessage(), e, this);
    }
  }
  @CalledInAwt
  private void reopenWithTool(@NotNull MergeTool tool) {
    if (myConflictResolved) {
      LOG.warn("Can't reopen with " + tool + " - conflict already resolved");
      return;
    }

    if (!tool.canShow(myContext, myRequest)) {
      LOG.warn("Can't reopen with " + tool + " - " + myRequest);
      return;
    }

    MergeTool.MergeViewer newViewer;
    try {
      newViewer = tool.createComponent(myContext, myRequest);
    } catch (Throwable e) {
      LOG.error(e);
      return;
    }

    boolean wasFocused = isFocused();

    destroyViewer();
    myViewer = newViewer;
    updateBottomActions();
    rebuildSouthPanel();
    initViewer();

    if (wasFocused) requestFocusInternal();
  }
  public static Set<String> getPackageNames(final String url) throws IOException {
    final TreeSet<String> names = new TreeSet<String>();
    final HTMLEditorKit.ParserCallback callback =
        new HTMLEditorKit.ParserCallback() {
          HTML.Tag myTag;

          @Override
          public void handleStartTag(HTML.Tag tag, MutableAttributeSet set, int i) {
            myTag = tag;
          }

          public void handleText(char[] data, int pos) {
            if (myTag != null && "a".equals(myTag.toString())) {
              names.add(String.valueOf(data));
            }
          }
        };

    try {
      final URL repositoryUrl = new URL(url);
      final InputStream is = repositoryUrl.openStream();
      final Reader reader = new InputStreamReader(is);
      try {
        new ParserDelegator().parse(reader, callback, true);
      } catch (IOException e) {
        LOG.warn(e);
      } finally {
        reader.close();
      }
    } catch (MalformedURLException e) {
      LOG.warn(e);
    }

    return names;
  }
 @Nullable
 private static JsonElement request(
     @NotNull String host,
     @Nullable String login,
     @Nullable String password,
     @NotNull String path,
     @Nullable String requestBody,
     boolean post) {
   HttpMethod method = null;
   try {
     method = doREST(host, login, password, path, requestBody, post);
     String resp = method.getResponseBodyAsString();
     if (method.getStatusCode() != 200) {
       String message =
           String.format(
               "Request not successful. Status-Code: %s, Message: %s.",
               method.getStatusCode(), method.getStatusText());
       LOG.warn(message);
       throw new HttpStatusException(method.getStatusCode(), method.getStatusText(), message);
     }
     if (resp == null) {
       String message = String.format("Unexpectedly empty response: %s.", resp);
       LOG.warn(message);
       throw new RuntimeException(message);
     }
     return parseResponse(resp);
   } catch (IOException e) {
     LOG.warn(String.format("Request failed: %s", e.getMessage()), e);
     throw Throwables.propagate(e);
   } finally {
     if (method != null) {
       method.releaseConnection();
     }
   }
 }
 public static SQLRefReference getAnnoRefIdFromMethodCallExpressionElement(PsiElement psiElement) {
   if (psiElement instanceof PsiMethodCallExpression) {
     final PsiReferenceExpression methodExpression =
         ((PsiMethodCallExpression) psiElement).getMethodExpression();
     if (methodExpression != null
         && methodExpression.getQualifierExpression() != null
         && methodExpression.getQualifierExpression().getType() != null) {
       final PsiType type = methodExpression.getQualifierExpression().getType();
       final PsiClassReferenceType classReferenceType = (PsiClassReferenceType) type;
       if (type instanceof PsiClassReferenceType && classReferenceType.getReference() != null) {
         final Project project = psiElement.getProject();
         if (AnnoRefConfigSettings.getInstance(project)
             .getAnnoRefState()
             .ANNOREF_UTIL_CLASS_FQN
             .equals(classReferenceType.getReference().getQualifiedName())) {
           if (((PsiCall) psiElement).getArgumentList().getExpressions().length == 1) {
             final PsiExpression psiExpression =
                 ((PsiCall) psiElement).getArgumentList().getExpressions()[0];
             final String refId = String.valueOf(((PsiLiteral) psiExpression).getValue());
             final SQLRefReference refReference =
                 ServiceManager.getService(project, SQLRefRepository.class)
                     .getSQLRefReferenceForID(refId);
             return refReference;
           } else {
             throw new IllegalArgumentException(
                 String.format(
                     "Argument %s for parameter of %s.%s must not be null",
                     new Object[] {
                       "0",
                       classReferenceType.getReference().getQualifiedName(),
                       methodExpression.getQualifiedName()
                     }));
           }
         } else {
           log.warn(
               "getAnnoRefIdFromMethodCallExpressionElement(): PsiElement ClassReferenceType FQA="
                   + classReferenceType.getReference().getQualifiedName()
                   + " different"
                   + " from ANNOREF_UTIL_CLASS_FQN="
                   + AnnoRefConfigSettings.getInstance(project)
                       .getAnnoRefState()
                       .ANNOREF_UTIL_CLASS_FQN);
         }
       } else {
         log.warn(
             "getAnnoRefIdFromMethodCallExpressionElement(): PsiElement ReferenceType="
                 + classReferenceType);
       }
     } else {
       log.warn(
           "getAnnoRefIdFromMethodCallExpressionElement(): PsiElement is of type="
               + psiElement.getClass());
     }
   }
   return null;
 }
  /**
   * Returns a cloud debugger connection given a user email to indicate the credentials to use. The
   * function may return null if the user is not logged in.
   */
  @Nullable
  private static Debugger getClient(final @Nullable String userEmail, final int timeout) {
    if (Strings.isNullOrEmpty(userEmail)) {
      LOG.warn("unexpected null email in controller initialize.");
      return null;
    }
    final String hashkey = userEmail + timeout;
    Debugger cloudDebuggerClient = myDebuggerClientsFromUserEmail.get(hashkey);

    if (cloudDebuggerClient == null) {
      try {
        final CredentialedUser user = GoogleLogin.getInstance().getAllUsers().get(userEmail);
        final Credential credential = (user != null ? user.getCredential() : null);
        if (credential != null) {
          user.getGoogleLoginState()
              .addLoginListener(
                  new LoginListener() {
                    @Override
                    public void statusChanged(boolean login) {
                      // aggressively remove the cached item on any status change.
                      myDebuggerClientsFromUserEmail.remove(hashkey);
                    }
                  });
          HttpRequestInitializer initializer =
              new HttpRequestInitializer() {
                @Override
                public void initialize(HttpRequest httpRequest) throws IOException {
                  httpRequest.setConnectTimeout(timeout);
                  httpRequest.setReadTimeout(timeout);
                  credential.initialize(httpRequest);
                }
              };

          HttpTransport httpTransport = GoogleNetHttpTransport.newTrustedTransport();
          cloudDebuggerClient =
              new Builder(httpTransport, JSON_FACTORY, initializer)
                  .setRootUrl(ROOT_URL)
                  .setApplicationName(GoogleLoginUtils.getCurrentPlatformName())
                  .build()
                  .debugger();
        }
      } catch (IOException ex) {
        LOG.warn("Error connecting to Cloud Debugger API", ex);
      } catch (GeneralSecurityException ex) {
        LOG.warn("Error connecting to Cloud Debugger API", ex);
      }

      if (cloudDebuggerClient != null) {
        myDebuggerClientsFromUserEmail.put(hashkey, cloudDebuggerClient);
      }
    }
    return cloudDebuggerClient;
  }
 private boolean isGhcMod5_4(String exePath) {
   String versionStr = getVersion(exePath, "version");
   if (versionStr == null) {
     LOG.warn("Could not retrieve ghc-mod version from " + exePath);
     return false;
   }
   Pair<Integer, Integer> version = parseGhcModVersion(versionStr);
   if (version == null) {
     LOG.warn("Could not parse ghc-mod version from string: " + versionStr);
     return false;
   }
   return version.first > 5 || (version.first == 5 && version.second >= 4);
 }
 private static void checkForUpdates() {
   PropertiesComponent propertiesComponent = PropertiesComponent.getInstance();
   long lastUpdate = propertiesComponent.getOrInitLong(KEY, 0);
   if (lastUpdate == 0 || System.currentTimeMillis() - lastUpdate > TimeUnit.DAYS.toMillis(1)) {
     ApplicationManager.getApplication()
         .executeOnPooledThread(
             () -> {
               try {
                 String buildNumber = ApplicationInfo.getInstance().getBuild().asString();
                 IdeaPluginDescriptor plugin = getPlugin();
                 String pluginVersion = plugin.getVersion();
                 String pluginId = plugin.getPluginId().getIdString();
                 String os =
                     URLEncoder.encode(
                         SystemInfo.OS_NAME + " " + SystemInfo.OS_VERSION, CharsetToolkit.UTF8);
                 String uid = PermanentInstallationID.get();
                 String url =
                     "https://plugins.jetbrains.com/plugins/list"
                         + "?pluginId="
                         + pluginId
                         + "&build="
                         + buildNumber
                         + "&pluginVersion="
                         + pluginVersion
                         + "&os="
                         + os
                         + "&uuid="
                         + uid;
                 PropertiesComponent.getInstance()
                     .setValue(KEY, String.valueOf(System.currentTimeMillis()));
                 HttpRequests.request(url)
                     .connect(
                         request -> {
                           try {
                             JDOMUtil.load(request.getReader());
                             LOG.info(
                                 (request.isSuccessful() ? "Successful" : "Unsuccessful")
                                     + " update: "
                                     + url);
                           } catch (JDOMException e) {
                             LOG.warn(e);
                           }
                           return null;
                         });
               } catch (UnknownHostException ignored) {
               } catch (IOException e) {
                 LOG.warn(e);
               }
             });
   }
 }
  protected void runOverEditor(
      @NotNull final Project project,
      @NotNull final Editor editor,
      @NotNull final PsiFile psiFile) {
    final Document document = editor.getDocument();
    if (!ReadonlyStatusHandler.ensureDocumentWritable(project, document)) return;

    final Runnable runnable =
        () -> {
          final int caretOffset = editor.getCaretModel().getOffset();
          final int lineLength = getRightMargin(project);

          DartAnalysisServerService.getInstance().updateFilesContent();
          DartAnalysisServerService.FormatResult formatResult =
              DartAnalysisServerService.getInstance()
                  .edit_format(psiFile.getVirtualFile(), caretOffset, 0, lineLength);

          if (formatResult == null) {
            showHintLater(editor, DartBundle.message("dart.style.hint.failed"), true);
            LOG.warn("Unexpected response from edit_format, formatResult is null");
            return;
          }

          final List<SourceEdit> edits = formatResult.getEdits();
          if (edits == null || edits.size() == 0) {
            showHintLater(editor, DartBundle.message("dart.style.hint.already.good"), false);
          } else if (edits.size() == 1) {
            final String replacement =
                StringUtil.convertLineSeparators(edits.get(0).getReplacement());
            document.replaceString(0, document.getTextLength(), replacement);
            final int offset =
                DartAnalysisServerService.getInstance()
                    .getConvertedOffset(psiFile.getVirtualFile(), formatResult.getOffset());
            editor.getCaretModel().moveToOffset(offset);
            showHintLater(editor, DartBundle.message("dart.style.hint.success"), false);
          } else {
            showHintLater(editor, DartBundle.message("dart.style.hint.failed"), true);
            LOG.warn(
                "Unexpected response from edit_format, formatResult.getEdits().size() = "
                    + edits.size());
          }
        };

    ApplicationManager.getApplication()
        .runWriteAction(
            () ->
                CommandProcessor.getInstance()
                    .executeCommand(
                        project, runnable, DartBundle.message("dart.style.action.name"), null));
  }
Example #14
0
  private void mergeWithDefaultConfiguration() {
    final ArrayList<Configuration> cfgList = new ArrayList<Configuration>();
    for (LanguageInjectionSupport support : InjectorUtils.getActiveInjectionSupports()) {
      final String config = support.getDefaultConfigUrl();
      final URL url = config == null ? null : support.getClass().getResource(config);
      if (url != null) {
        try {
          cfgList.add(load(url.openStream()));
        } catch (Exception e) {
          LOG.warn(e);
        }
      }
    }
    final THashSet<Object> visited = new THashSet<Object>();
    for (IdeaPluginDescriptor pluginDescriptor : PluginManager.getPlugins()) {
      if (pluginDescriptor instanceof IdeaPluginDescriptorImpl
          && !((IdeaPluginDescriptorImpl) pluginDescriptor).isEnabled()) continue;
      final ClassLoader loader = pluginDescriptor.getPluginClassLoader();
      if (!visited.add(loader)) continue;
      if (loader instanceof PluginClassLoader && ((PluginClassLoader) loader).getUrls().isEmpty())
        continue;
      try {
        final Enumeration<URL> enumeration = loader.getResources("META-INF/languageInjections.xml");
        if (enumeration == null) continue;
        while (enumeration.hasMoreElements()) {
          URL url = enumeration.nextElement();
          if (!visited.add(url.getFile())) continue; // for DEBUG mode
          try {
            cfgList.add(load(url.openStream()));
          } catch (Exception e) {
            LOG.warn(e);
          }
        }
      } catch (Exception e) {
        LOG.warn(e);
      }
    }

    final ArrayList<BaseInjection> originalInjections = new ArrayList<BaseInjection>();
    final ArrayList<BaseInjection> newInjections = new ArrayList<BaseInjection>();
    myDefaultInjections = new ArrayList<BaseInjection>();
    for (String supportId : InjectorUtils.getActiveInjectionSupportIds()) {
      for (Configuration cfg : cfgList) {
        final List<BaseInjection> imported = cfg.getInjections(supportId);
        myDefaultInjections.addAll(imported);
        importInjections(getInjections(supportId), imported, originalInjections, newInjections);
      }
    }
    replaceInjections(newInjections, originalInjections);
  }
  @Override
  public void importData(
      @NotNull Collection<DataNode<LibraryDependencyData>> toImport,
      @NotNull Project project,
      boolean synchronous) {
    if (toImport.isEmpty()) {
      return;
    }

    Map<DataNode<ModuleData>, List<DataNode<LibraryDependencyData>>> byModule =
        ExternalSystemApiUtil.groupBy(toImport, MODULE);
    for (Map.Entry<DataNode<ModuleData>, List<DataNode<LibraryDependencyData>>> entry :
        byModule.entrySet()) {
      Module module = myProjectStructureHelper.findIdeModule(entry.getKey().getData(), project);
      if (module == null) {
        myModuleManager.importData(Collections.singleton(entry.getKey()), project, true);
        module = myProjectStructureHelper.findIdeModule(entry.getKey().getData(), project);
        if (module == null) {
          LOG.warn(
              String.format(
                  "Can't import library dependencies %s. Reason: target module (%s) is not found at the ide and can't be imported",
                  entry.getValue(), entry.getKey()));
          continue;
        }
      }
      importData(entry.getValue(), module, synchronous);
    }
  }
  @NotNull
  public static <K, V> Map<K, List<V>> groupBy(
      @NotNull Collection<V> nodes, @NotNull NullableFunction<V, K> grouper) {
    Map<K, List<V>> result = ContainerUtilRt.newHashMap();
    for (V data : nodes) {
      K key = grouper.fun(data);
      if (key == null) {
        LOG.warn(
            String.format(
                "Skipping entry '%s' during grouping. Reason: it's not possible to build a grouping key with grouping strategy '%s'. "
                    + "Given entries: %s",
                data, grouper.getClass(), nodes));
        continue;
      }
      List<V> grouped = result.get(key);
      if (grouped == null) {
        result.put(key, grouped = ContainerUtilRt.newArrayList());
      }
      grouped.add(data);
    }

    if (!result.isEmpty() && result.keySet().iterator().next() instanceof Comparable) {
      List<K> ordered = ContainerUtilRt.newArrayList(result.keySet());
      Collections.sort(ordered, COMPARABLE_GLUE);
      Map<K, List<V>> orderedResult = ContainerUtilRt.newLinkedHashMap();
      for (K k : ordered) {
        orderedResult.put(k, result.get(k));
      }
      return orderedResult;
    }
    return result;
  }
  /**
   * Gets the profile picture that corresponds to the {@code userInfo} and sets it on the provided
   * {@code pictureCallback}.
   *
   * @param userInfo the class to be parsed
   * @param pictureCallback the user image will be set on this callback
   */
  public static void provideUserPicture(
      Userinfoplus userInfo, final IUserPropertyCallback pictureCallback) {
    // set the size of the image before it is served
    String urlString = userInfo.getPicture() + "?sz=" + DEFAULT_PICTURE_SIZE;
    URL url = null;
    try {
      url = new URL(urlString);
    } catch (MalformedURLException ex) {
      LOG.warn(String.format("The picture URL: %s,  is not a valid URL string.", urlString), ex);
      return;
    }

    final URL newUrl = url;

    ApplicationManager.getApplication()
        .executeOnPooledThread(
            new Runnable() {
              @Override
              public void run() {
                Image image = Toolkit.getDefaultToolkit().getImage(newUrl);
                Toolkit.getDefaultToolkit().prepareImage(image, -1, -1, null);
                pictureCallback.setProperty(image);
              }
            });
  }
Example #18
0
  @Override
  protected boolean isComponentSuitable(@Nullable Map<String, String> options) {
    if (!super.isComponentSuitable(options)) {
      return false;
    }
    if (options == null || options.isEmpty()) {
      return true;
    }

    for (String optionName : options.keySet()) {
      if ("workspace".equals(optionName)) {
        continue;
      }

      // we cannot filter using module options because at this moment module file data could be not
      // loaded
      String message =
          "Don't specify "
              + optionName
              + " in the component registration, transform component to service and implement your logic in your getInstance() method";
      if (ApplicationManager.getApplication().isUnitTestMode()) {
        LOG.error(message);
      } else {
        LOG.warn(message);
      }
    }

    return true;
  }
  @NotNull
  @Override
  public LightClassConstructionContext getContextForClassOrObject(
      @NotNull JetClassOrObject classOrObject) {
    ResolveSessionForBodies session =
        KotlinCacheService.getInstance(classOrObject.getProject())
            .getLazyResolveSession(classOrObject);

    if (classOrObject.isLocal()) {
      BindingContext bindingContext = session.resolveToElement(classOrObject, BodyResolveMode.FULL);
      ClassDescriptor descriptor = bindingContext.get(BindingContext.CLASS, classOrObject);

      if (descriptor == null) {
        LOG.warn(
            "No class descriptor in context for class: "
                + PsiUtilPackage.getElementTextWithContext(classOrObject));
        return new LightClassConstructionContext(bindingContext, session.getModuleDescriptor());
      }

      ForceResolveUtil.forceResolveAllContents(descriptor);

      return new LightClassConstructionContext(bindingContext, session.getModuleDescriptor());
    }

    ForceResolveUtil.forceResolveAllContents(session.getClassDescriptor(classOrObject));
    return new LightClassConstructionContext(
        session.getBindingContext(), session.getModuleDescriptor());
  }
Example #20
0
 /**
  * Given the list of paths converts them to the list of {@link Change Changes} found in the {@link
  * ChangeListManager}, i.e. this works only for local changes. </br> Paths can be absolute or
  * relative to the repository. If a path is not found in the local changes, it is ignored, but the
  * fact is logged.
  */
 @NotNull
 public static List<Change> findLocalChangesForPaths(
     @NotNull Project project,
     @NotNull VirtualFile root,
     @NotNull Collection<String> affectedPaths,
     boolean relativePaths) {
   ChangeListManagerEx changeListManager =
       (ChangeListManagerEx) ChangeListManager.getInstance(project);
   List<Change> affectedChanges = new ArrayList<Change>();
   for (String path : affectedPaths) {
     String absolutePath = relativePaths ? toAbsolute(root, path) : path;
     VirtualFile file = findRefreshFileOrLog(absolutePath);
     if (file != null) {
       Change change = changeListManager.getChange(file);
       if (change != null) {
         affectedChanges.add(change);
       } else {
         String message = "Change is not found for " + file.getPath();
         if (changeListManager.isInUpdate()) {
           message += " because ChangeListManager is being updated.";
         }
         LOG.warn(message);
       }
     }
   }
   return affectedChanges;
 }
  static {
    System.setProperty("svnkit.log.native.calls", "true");

    final SvnKitDebugLogger logger =
        new SvnKitDebugLogger(
            Boolean.getBoolean(LOG_PARAMETER_NAME), Boolean.getBoolean(TRACE_NATIVE_CALLS), LOG);
    SVNDebugLog.setDefaultLog(logger);

    SVNJNAUtil.setJNAEnabled(true);
    SvnHttpAuthMethodsDefaultChecker.check();

    SVNAdminAreaFactory.setSelector(new SvnKitAdminAreaFactorySelector());

    DAVRepositoryFactory.setup();
    SVNRepositoryFactoryImpl.setup();
    FSRepositoryFactory.setup();

    // non-optimized writing is fast enough on Linux/MacOS, and somewhat more reliable
    if (SystemInfo.isWindows) {
      SVNAdminArea14.setOptimizedWritingEnabled(true);
    }

    if (!SVNJNAUtil.isJNAPresent()) {
      LOG.warn("JNA is not found by svnkit library");
    }

    ourExplicitlySetSslProtocols = System.getProperty(SVNKIT_HTTP_SSL_PROTOCOLS);
  }
  private void checkFsSanity() {
    try {
      String path = myProject.getProjectFilePath();
      if (path == null || FileUtil.isAncestor(PathManager.getConfigPath(), path, true)) {
        return;
      }

      boolean actual = FileUtil.isFileSystemCaseSensitive(path);
      LOG.info(path + " case-sensitivity: " + actual);
      if (actual != SystemInfo.isFileSystemCaseSensitive) {
        int prefix =
            SystemInfo.isFileSystemCaseSensitive ? 1 : 0; // IDE=true -> FS=false -> prefix='in'
        String title = ApplicationBundle.message("fs.case.sensitivity.mismatch.title");
        String text = ApplicationBundle.message("fs.case.sensitivity.mismatch.message", prefix);
        Notifications.Bus.notify(
            new Notification(
                Notifications.SYSTEM_MESSAGES_GROUP_ID,
                title,
                text,
                NotificationType.WARNING,
                NotificationListener.URL_OPENING_LISTENER),
            myProject);
      }
    } catch (FileNotFoundException e) {
      LOG.warn(e);
    }
  }
  @Override
  public void compileAndRun(
      @NotNull final Runnable startRunnable,
      @NotNull final ExecutionEnvironment environment,
      @Nullable final RunProfileState state,
      @Nullable final Runnable onCancelRunnable) {
    long id = environment.getExecutionId();
    if (id == 0) {
      id = environment.assignNewExecutionId();
    }

    RunProfile profile = environment.getRunProfile();
    if (!(profile instanceof RunConfiguration)) {
      startRunnable.run();
      return;
    }

    final RunConfiguration runConfiguration = (RunConfiguration) profile;
    final List<BeforeRunTask> beforeRunTasks =
        RunManagerEx.getInstanceEx(myProject).getBeforeRunTasks(runConfiguration);
    if (beforeRunTasks.isEmpty()) {
      startRunnable.run();
    } else {
      DataContext context = environment.getDataContext();
      final DataContext projectContext =
          context != null ? context : SimpleDataContext.getProjectContext(myProject);
      final long finalId = id;
      final Long executionSessionId = new Long(id);
      ApplicationManager.getApplication()
          .executeOnPooledThread(
              () -> {
                for (BeforeRunTask task : beforeRunTasks) {
                  if (myProject.isDisposed()) {
                    return;
                  }
                  @SuppressWarnings("unchecked")
                  BeforeRunTaskProvider<BeforeRunTask> provider =
                      BeforeRunTaskProvider.getProvider(myProject, task.getProviderId());
                  if (provider == null) {
                    LOG.warn(
                        "Cannot find BeforeRunTaskProvider for id='" + task.getProviderId() + "'");
                    continue;
                  }
                  ExecutionEnvironment taskEnvironment =
                      new ExecutionEnvironmentBuilder(environment).contentToReuse(null).build();
                  taskEnvironment.setExecutionId(finalId);
                  EXECUTION_SESSION_ID_KEY.set(taskEnvironment, executionSessionId);
                  if (!provider.executeTask(
                      projectContext, runConfiguration, taskEnvironment, task)) {
                    if (onCancelRunnable != null) {
                      SwingUtilities.invokeLater(onCancelRunnable);
                    }
                    return;
                  }
                }

                doRun(environment, startRunnable);
              });
    }
  }
  private List<VFileEvent> getEvents(String msg, @Nullable Runnable action) {
    LOG.debug("** waiting for " + msg);
    myAccept = true;

    if (action != null) {
      action.run();
    }

    int timeout = myTimeout;
    try {
      synchronized (myWaiter) {
        //noinspection WaitNotInLoop
        myWaiter.wait(timeout);
      }
    } catch (InterruptedException e) {
      LOG.warn(e);
    }

    LOG.debug("** waited for " + timeout);
    myFileSystem.refresh(false);

    ArrayList<VFileEvent> result;
    synchronized (myEvents) {
      result = new ArrayList<VFileEvent>(myEvents);
      myEvents.clear();
    }
    LOG.debug("** events: " + result.size());
    return result;
  }
  /**
   * Callback function for when GDB has responded to our expression evaluation request.
   *
   * @param event The event.
   * @param callback The callback passed to evaluate().
   */
  private void onGdbExpressionReady(GdbEvent event, XEvaluationCallback callback) {
    if (event instanceof GdbErrorEvent) {
      callback.errorOccurred(((GdbErrorEvent) event).message);
      return;
    }
    if (!(event instanceof GdbVariableObjects)) {
      callback.errorOccurred("Unexpected data received from GDB");
      m_log.warn("Unexpected event " + event + " received from expression request");
      return;
    }

    GdbVariableObjects variableObjects = (GdbVariableObjects) event;
    if (variableObjects.objects.isEmpty()) {
      callback.errorOccurred("Failed to evaluate expression");
      return;
    }

    GdbVariableObject variableObject = variableObjects.objects.get(0);
    if (variableObject.value == null) {
      callback.errorOccurred("Failed to evaluate expression");
      return;
    }

    callback.evaluated(new GdbValue(m_gdb, variableObject));
  }
 /**
  * TODO this is non-optimal and even incorrect, since such diff shows the difference between
  * committed changes For each of the given repositories looks to the diff between current branch
  * and the given branch and converts it to the list of local changes.
  */
 @NotNull
 Map<GitRepository, List<Change>> collectLocalChangesConflictingWithBranch(
     @NotNull Collection<GitRepository> repositories,
     @NotNull String currentBranch,
     @NotNull String otherBranch) {
   Map<GitRepository, List<Change>> changes = new HashMap<GitRepository, List<Change>>();
   for (GitRepository repository : repositories) {
     try {
       Collection<String> diff =
           GitUtil.getPathsDiffBetweenRefs(myGit, repository, currentBranch, otherBranch);
       List<Change> changesInRepo = convertPathsToChanges(repository, diff, false);
       if (!changesInRepo.isEmpty()) {
         changes.put(repository, changesInRepo);
       }
     } catch (VcsException e) {
       // ignoring the exception: this is not fatal if we won't collect such a diff from other
       // repositories.
       // At worst, use will get double dialog proposing the smart checkout.
       LOG.warn(
           String.format(
               "Couldn't collect diff between %s and %s in %s",
               currentBranch, otherBranch, repository.getRoot()),
           e);
     }
   }
   return changes;
 }
  @Override
  public void initialize(
      @NotNull ManagingFS managingFS, @NotNull FileWatcherNotificationSink notificationSink) {
    myManagingFS = managingFS;
    myNotificationSink = notificationSink;

    boolean disabled = Boolean.parseBoolean(System.getProperty(PROPERTY_WATCHER_DISABLED));
    myExecutable = getExecutable();

    if (disabled) {
      LOG.info("Native file watcher is disabled");
    } else if (myExecutable == null) {
      LOG.info("Native file watcher is not supported on this platform");
    } else if (!myExecutable.exists()) {
      notifyOnFailure(ApplicationBundle.message("watcher.exe.not.found"), null);
    } else if (!myExecutable.canExecute()) {
      notifyOnFailure(
          ApplicationBundle.message("watcher.exe.not.exe", myExecutable),
          new NotificationListener() {
            @Override
            public void hyperlinkUpdate(
                @NotNull Notification notification, @NotNull HyperlinkEvent event) {
              ShowFilePathAction.openFile(myExecutable);
            }
          });
    } else {
      try {
        startupProcess(false);
        LOG.info("Native file watcher is operational.");
      } catch (IOException e) {
        LOG.warn(e.getMessage());
        notifyOnFailure(ApplicationBundle.message("watcher.failed.to.start"), null);
      }
    }
  }
  @NotNull
  private static List<RepoPackage> getPackagesFromAdditionalRepository(@NotNull String url)
      throws IOException {
    final List<RepoPackage> result = new ArrayList<>();
    final boolean simpleIndex = url.endsWith("simple/");
    final List<String> packagesList = parsePyPIListFromWeb(url, simpleIndex);

    for (String pyPackage : packagesList) {
      if (simpleIndex) {
        final Pair<String, String> nameVersion =
            splitNameVersion(StringUtil.trimTrailing(pyPackage, '/'));
        result.add(new RepoPackage(nameVersion.getFirst(), url, nameVersion.getSecond()));
      } else {
        try {
          final Pattern repositoryPattern = Pattern.compile(url + "([^/]*)/([^/]*)$");
          final Matcher matcher = repositoryPattern.matcher(URLDecoder.decode(pyPackage, "UTF-8"));
          if (matcher.find()) {
            final String packageName = matcher.group(1);
            final String packageVersion = matcher.group(2);
            if (!packageName.contains(" ")) {
              result.add(new RepoPackage(packageName, url, packageVersion));
            }
          }
        } catch (UnsupportedEncodingException e) {
          LOG.warn(e.getMessage());
        }
      }
    }
    return result;
  }
 public static void setReadOnlyAttribute(@NotNull String path, boolean readOnlyFlag) {
   final boolean writableFlag = !readOnlyFlag;
   final File file = new File(path);
   if (!file.setWritable(writableFlag) && file.canWrite() != writableFlag) {
     LOG.warn("Can't set writable attribute of '" + path + "' to " + readOnlyFlag);
   }
 }
  @Override
  protected void save(@NotNull Collection<VirtualFile> rootsToSave) throws VcsException {
    LOG.info("saving " + rootsToSave);

    for (VirtualFile root : rootsToSave) {
      final String message = GitHandlerUtil.formatOperationName("Stashing changes from", root);
      LOG.info(message);
      final String oldProgressTitle = myProgressIndicator.getText();
      myProgressIndicator.setText(message);
      GitRepository repository = myRepositoryManager.getRepositoryForRoot(root);
      if (repository == null) {
        LOG.error("Repository is null for root " + root);
      } else {
        GitCommandResult result = myGit.stashSave(repository, myStashMessage);
        if (result.success() && somethingWasStashed(result)) {
          myStashedRoots.add(root);
        } else {
          String error =
              "stash " + repository.getRoot() + ": " + result.getErrorOutputAsJoinedString();
          if (!result.success()) {
            throw new VcsException(error);
          } else {
            LOG.warn(error);
          }
        }
      }
      myProgressIndicator.setText(oldProgressTitle);
    }
  }