private static void doInitializeDdmlib(@NotNull String adbPath) { synchronized (myDdmsLock) { if (!myDdmLibInitialized) { myDdmLibInitialized = true; DdmPreferences.setLogLevel(Log.LogLevel.INFO.getStringValue()); DdmPreferences.setTimeOut(AndroidUtils.TIMEOUT); AndroidDebugBridge.init(AndroidEnableAdbServiceAction.isAdbServiceEnabled()); LOG.info("DDMLib initialized"); final AndroidDebugBridge bridge = AndroidDebugBridge.createBridge(adbPath, true); waitUntilConnect(bridge); if (!bridge.isConnected()) { LOG.info("Failed to connect debug bridge"); } } else { final AndroidDebugBridge bridge = AndroidDebugBridge.getBridge(); final boolean forceRestart = myAdbCrashed || (bridge != null && !bridge.isConnected()); if (forceRestart) { LOG.info("Restart debug bridge: " + (myAdbCrashed ? "crashed" : "disconnected")); } final AndroidDebugBridge newBridge = AndroidDebugBridge.createBridge(adbPath, forceRestart); waitUntilConnect(newBridge); if (!newBridge.isConnected()) { LOG.info("Failed to connect debug bridge after restart"); } } } }
private void processOrphanModules() { if (myProject.isDisposed()) return; if (ExternalSystemDebugEnvironment.DEBUG_ORPHAN_MODULES_PROCESSING) { LOG.info( String.format( "Checking for orphan modules. External paths returned by external system: '%s'", myExternalModulePaths)); } PlatformFacade platformFacade = ServiceManager.getService(PlatformFacade.class); List<Module> orphanIdeModules = ContainerUtilRt.newArrayList(); String externalSystemIdAsString = myExternalSystemId.toString(); for (Module module : platformFacade.getModules(myProject)) { String s = module.getOptionValue(ExternalSystemConstants.EXTERNAL_SYSTEM_ID_KEY); String p = module.getOptionValue(ExternalSystemConstants.LINKED_PROJECT_PATH_KEY); if (ExternalSystemDebugEnvironment.DEBUG_ORPHAN_MODULES_PROCESSING) { LOG.info( String.format( "IDE module: EXTERNAL_SYSTEM_ID_KEY - '%s', LINKED_PROJECT_PATH_KEY - '%s'.", s, p)); } if (externalSystemIdAsString.equals(s) && !myExternalModulePaths.contains(p)) { orphanIdeModules.add(module); if (ExternalSystemDebugEnvironment.DEBUG_ORPHAN_MODULES_PROCESSING) { LOG.info( String.format( "External paths doesn't contain IDE module LINKED_PROJECT_PATH_KEY anymore => add to orphan IDE modules.")); } } } if (!orphanIdeModules.isEmpty()) { ruleOrphanModules(orphanIdeModules, myProject, myExternalSystemId); } }
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.info(e); throw e; } try { return startProcess(commands); } catch (IOException e) { LOG.info(e); throw new ProcessNotCreatedException(e.getMessage(), e, this); } }
public static boolean isJsonSchema( @NotNull JsonSchemaExportedDefinitions definitions, @NotNull VirtualFile key, @NotNull final String string, Consumer<String> errorConsumer) throws IOException { final JsonSchemaReader reader = new JsonSchemaReader(key); java.io.StringReader stringReader = new java.io.StringReader(string); try { reader.read(stringReader, null); } catch (Exception e) { LOG.info(e); errorConsumer.consume(e.getMessage()); return false; } // have two stages so that just syntax errors do not clear cache stringReader = new java.io.StringReader(string); try { reader.read(stringReader, definitions); } catch (Exception e) { LOG.info(e); errorConsumer.consume(e.getMessage()); throw e; } return true; }
@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); } } }
@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); } }
@Nullable private static RepositoryInfo getDetailedRepoInfo( @NotNull String url, @NotNull String login, @NotNull String password, @NotNull String owner, @NotNull String name) { try { final String request = "/repos/" + owner + "/" + name; JsonElement jsonObject = GithubApiUtil.getRequest(url, login, password, request); if (jsonObject == null) { LOG.info( String.format( "Information about repository is unavailable. Owner: %s, Name: %s", owner, name)); return null; } return parseSingleRepositoryInfo(jsonObject.getAsJsonObject()); } catch (IOException e) { LOG.info( String.format( "Exception was thrown when trying to retrieve information about repository. Owner: %s, Name: %s", owner, name)); return null; } }
/** * Returns true if the root was loaded with conflict. False is returned in all other cases: in the * case of success and in case of some other error. */ private boolean loadRoot(final VirtualFile root) { LOG.info("loadRoot " + root); myProgressIndicator.setText(GitHandlerUtil.formatOperationName("Unstashing changes to", root)); GitRepository repository = myRepositoryManager.getRepositoryForRoot(root); if (repository == null) { LOG.error("Repository is null for root " + root); return false; } GitSimpleEventDetector conflictDetector = new GitSimpleEventDetector(GitSimpleEventDetector.Event.MERGE_CONFLICT_ON_UNSTASH); GitCommandResult result = myGit.stashPop(repository, conflictDetector); VfsUtil.markDirtyAndRefresh(false, true, false, root); if (result.success()) { return false; } else if (conflictDetector.hasHappened()) { return true; } else { LOG.info("unstash failed " + result.getErrorOutputAsJoinedString()); GitUIUtil.notifyImportantError( myProject, "Couldn't unstash", "<br/>" + result.getErrorOutputAsHtmlString()); return false; } }
private GitUpdateResult handleRebaseFailure( GitLineHandler pullHandler, GitRebaseProblemDetector rebaseConflictDetector, final GitMessageWithFilesDetector untrackedWouldBeOverwrittenDetector) { if (rebaseConflictDetector.isMergeConflict()) { LOG.info("handleRebaseFailure merge conflict"); final boolean allMerged = new MyConflictResolver(myProject, myGit, myRoot, myRebaser).merge(); return allMerged ? GitUpdateResult.SUCCESS_WITH_RESOLVED_CONFLICTS : GitUpdateResult.INCOMPLETE; } else if (untrackedWouldBeOverwrittenDetector.wasMessageDetected()) { LOG.info("handleRebaseFailure: untracked files would be overwritten by checkout"); UntrackedFilesNotifier.notifyUntrackedFilesOverwrittenBy( myProject, ServiceManager.getService(myProject, GitPlatformFacade.class), untrackedWouldBeOverwrittenDetector.getFiles(), "rebase", null); return GitUpdateResult.ERROR; } else { LOG.info("handleRebaseFailure error " + pullHandler.errors()); GitUIUtil.notifyImportantError( myProject, "Rebase error", GitUIUtil.stringifyErrors(pullHandler.errors())); return GitUpdateResult.ERROR; } }
private void performShutdown() { if (myShutDown.compareAndSet(false, true)) { LOG.info("VFS dispose started"); FSRecords.dispose(); LOG.info("VFS dispose completed"); } }
private ChangeListWorker(final ChangeListWorker worker) { myProject = worker.myProject; myMap = new LinkedHashMap<String, LocalChangeList>(); myIdx = new ChangeListsIndexes(worker.myIdx); myLocallyDeleted = worker.myLocallyDeleted.copy(); mySwitchedHolder = worker.mySwitchedHolder.copy(); myDelta = worker.myDelta; myListsToDisappear = new LinkedList<String>(worker.myListsToDisappear); LocalChangeList defaultList = null; for (LocalChangeList changeList : worker.myMap.values()) { final LocalChangeList copy = changeList.copy(); final String changeListName = copy.getName(); myMap.put(changeListName, copy); if (copy.isDefault()) { defaultList = copy; } } if (defaultList == null) { LOG.info("default list not found when copy"); defaultList = myMap.get(worker.getDefaultListName()); } if (defaultList == null) { LOG.info("default list not found when copy in original object too"); if (!myMap.isEmpty()) { defaultList = myMap.values().iterator().next(); } else { // can be when there's no vcs configured /// LOG.error("no changelists at all"); } } myDefault = defaultList; }
private void showVFInfo(VirtualFile virtualFile) { logger.info("showVFInfo(): XML"); logger.info("virtualFile: isValid= " + virtualFile.isValid()); logger.info("virtualFile: isSymLink=" + virtualFile.isSymLink()); logger.info("virtualFile: url= " + virtualFile.getUrl()); logger.info("virtualFile: fileType= " + virtualFile.getFileType()); }
private boolean merge(boolean mergeDialogInvokedFromNotification) { try { final Collection<VirtualFile> initiallyUnmergedFiles = getUnmergedFiles(myRoots); if (initiallyUnmergedFiles.isEmpty()) { LOG.info("merge: no unmerged files"); return mergeDialogInvokedFromNotification ? true : proceedIfNothingToMerge(); } else { showMergeDialog(initiallyUnmergedFiles); final Collection<VirtualFile> unmergedFilesAfterResolve = getUnmergedFiles(myRoots); if (unmergedFilesAfterResolve.isEmpty()) { LOG.info("merge no more unmerged files"); return mergeDialogInvokedFromNotification ? true : proceedAfterAllMerged(); } else { LOG.info("mergeFiles unmerged files remain: " + unmergedFilesAfterResolve); if (mergeDialogInvokedFromNotification) { notifyUnresolvedRemainAfterNotification(); } else { notifyUnresolvedRemain(); } } } } catch (VcsException e) { if (myVcs.getExecutableValidator().checkExecutableAndNotifyIfNeeded()) { notifyException(e); } } return false; }
/** * Check if rebase is in progress, propose to resolve conflicts. * * @return true if rebase is in progress, which means that update can't continue. */ private boolean checkRebaseInProgress() { LOG.info("checkRebaseInProgress: checking if there is an unfinished rebase process..."); final GitRebaser rebaser = new GitRebaser(myProject, myGit, myProgressIndicator); final Collection<VirtualFile> rebasingRoots = rebaser.getRebasingRoots(); if (rebasingRoots.isEmpty()) { return false; } LOG.info("checkRebaseInProgress: roots with unfinished rebase: " + rebasingRoots); GitConflictResolver.Params params = new GitConflictResolver.Params(); params.setErrorNotificationTitle("Can't update"); params.setMergeDescription( "You have unfinished rebase process. These conflicts must be resolved before update."); params.setErrorNotificationAdditionalDescription( "Then you may <b>continue rebase</b>. <br/> You also may <b>abort rebase</b> to restore the original branch and stop rebasing."); params.setReverse(true); return !new GitConflictResolver(myProject, myGit, rebasingRoots, params) { @Override protected boolean proceedIfNothingToMerge() { return rebaser.continueRebase(rebasingRoots); } @Override protected boolean proceedAfterAllMerged() { return rebaser.continueRebase(rebasingRoots); } }.merge(); }
/** * Tries to execute {@code git merge --ff-only}. * * @return true, if everything is successful; false for any error (to let a usual "fair" update * deal with it). */ public boolean fastForwardMerge() { LOG.info("Trying fast-forward merge for " + myRoot); GitRepository repository = GitUtil.getRepositoryManager(myProject).getRepositoryForRoot(myRoot); if (repository == null) { LOG.error("Repository is null for " + myRoot); return false; } try { markStart(myRoot); } catch (VcsException e) { LOG.info("Couldn't mark start for repository " + myRoot, e); return false; } GitCommandResult result = myGit.merge(repository, getRemoteBranchToMerge(), Collections.singletonList("--ff-only")); try { markEnd(myRoot); } catch (VcsException e) { // this is not critical, and update has already happened, // so we just notify the user about problems with collecting the updated changes. LOG.info("Couldn't mark end for repository " + myRoot, e); Notificator.getInstance(myProject) .notifyWeakWarning( "Couldn't collect the updated files info", String.format( "Update of %s was successful, but we couldn't collect the updated changes because of an error", myRoot), null); } return result.success(); }
private void checkProjectRoots() { LocalFileSystem fs = LocalFileSystem.getInstance(); if (!(fs instanceof LocalFileSystemImpl)) return; FileWatcher watcher = ((LocalFileSystemImpl) fs).getFileWatcher(); if (!watcher.isOperational()) return; Collection<String> manualWatchRoots = watcher.getManualWatchRoots(); if (manualWatchRoots.isEmpty()) return; VirtualFile[] roots = ProjectRootManager.getInstance(myProject).getContentRoots(); if (roots.length == 0) return; List<String> nonWatched = new SmartList<String>(); for (VirtualFile root : roots) { if (!(root.getFileSystem() instanceof LocalFileSystem)) continue; String rootPath = root.getPath(); for (String manualWatchRoot : manualWatchRoots) { if (FileUtil.isAncestor(manualWatchRoot, rootPath, false)) { nonWatched.add(rootPath); } } } if (!nonWatched.isEmpty()) { String message = ApplicationBundle.message("watcher.non.watchable.project"); watcher.notifyOnFailure(message, null); LOG.info("unwatched roots: " + nonWatched); LOG.info("manual watches: " + manualWatchRoots); } }
@Override public void contentsChanged(VirtualFileEvent event) { if (event.isFromSave()) return; final VirtualFile file = event.getFile(); final Document document = getCachedDocument(file); if (document == null) { myMultiCaster.fileWithNoDocumentChanged(file); return; } if (isBinaryWithDecompiler(file)) { myMultiCaster.fileWithNoDocumentChanged( file); // This will generate PSI event at FileManagerImpl } long documentStamp = document.getModificationStamp(); long oldFileStamp = event.getOldModificationStamp(); if (documentStamp != oldFileStamp) { LOG.info("reload from disk?"); LOG.info(" documentStamp:" + documentStamp); LOG.info(" oldFileStamp:" + oldFileStamp); if (file.isValid() && askReloadFromDisk(file, document)) { reloadFromDisk(document); } } else { reloadFromDisk(document); } }
public void initComponent() { log.info("Initializing WakaTime plugin v" + VERSION + " (https://wakatime.com/)"); // System.out.println("Initializing WakaTime plugin v" + VERSION + " (https://wakatime.com/)"); // Set runtime constants IDE_NAME = PlatformUtils.getPlatformPrefix(); IDE_VERSION = ApplicationInfo.getInstance().getFullVersion(); if (!Dependencies.isCLIInstalled()) { log.info("Downloading and installing wakatime-cli ..."); Dependencies.installCLI(); } else if (Dependencies.isCLIOld()) { log.info("Upgrading wakatime-cli ..."); Dependencies.upgradeCLI(); } if (Dependencies.isPythonInstalled()) { WakaTime.DEBUG = WakaTime.isDebugEnabled(); if (WakaTime.DEBUG) { log.setLevel(Level.DEBUG); log.debug("Logging level set to DEBUG"); } log.debug("Python location: " + Dependencies.getPythonLocation()); log.debug("CLI location: " + Dependencies.getCLILocation()); // prompt for apiKey if it does not already exist if (ApiKey.getApiKey().equals("")) { Project project = ProjectManager.getInstance().getDefaultProject(); ApiKey apiKey = new ApiKey(project); apiKey.promptForApiKey(); } log.debug("Api Key: " + ApiKey.getApiKey()); // add WakaTime item to File menu ActionManager am = ActionManager.getInstance(); PluginMenu action = new PluginMenu(); am.registerAction("WakaTimeApiKey", action); DefaultActionGroup fileMenu = (DefaultActionGroup) am.getAction("FileMenu"); fileMenu.addSeparator(); fileMenu.add(action); // Setup message listeners MessageBus bus = ApplicationManager.getApplication().getMessageBus(); connection = bus.connect(); connection.subscribe(AppTopics.FILE_DOCUMENT_SYNC, new CustomSaveListener()); EditorFactory.getInstance() .getEventMulticaster() .addDocumentListener(new CustomDocumentListener()); log.debug("Finished initializing WakaTime plugin"); } else { Messages.showErrorDialog( "WakaTime requires Python to be installed.\nYou can install it from https://www.python.org/downloads/\nAfter installing Python, restart your IDE.", "Error"); } }
private synchronized void performShutdown() { if (!myShutDown) { myShutDown = true; LOG.info("VFS dispose started"); FSRecords.dispose(); LOG.info("VFS dispose completed"); } }
private static void joinThread(final Future<?> threadFuture) { if (threadFuture != null) { try { threadFuture.get(); } catch (InterruptedException ignored) { LOG.info("Thread interrupted", ignored); } catch (ExecutionException ignored) { LOG.info("Thread interrupted", ignored); } } }
private void parseXmlForSql(VirtualFile xmlFile) { final AnnoRefSettings annoRefState = AnnoRefConfigSettings.getInstance(project).getAnnoRefState(); if (annoRefState.ENABLE_SQL_TO_MODEL_VALIDATION) { logger.info(AnnoRefBundle.message("annoRef.xml.parse.sql.validation.enabled")); final XmlBuilderDriver xmlBuilderDriver = new XmlBuilderDriver( AnnRefApplication.getPsiFileFromVirtualFile(xmlFile, project).getText()); xmlBuilderDriver.build(new AnnoRefXmlVisitor(project, xmlFile)); } logger.info(AnnoRefBundle.message("annoRef.xml.parse..sql.validation.disabled")); }
public Collection<String> getFilteredGlobalsCache() { try { return filteredGlobalsCache.get(1000, TimeUnit.MILLISECONDS); } catch (InterruptedException e) { LOG.info("exception creating globals cache", e); } catch (ExecutionException e) { LOG.info("exception creating globals cache", e); } catch (TimeoutException e) { LOG.info("The global cache is still processing"); } return new ArrayList<String>(); }
@Override public void log(final SVNLogType logType, final String message, final byte[] data) { if (shouldLog(logType)) { if (data != null) { try { myLog.info(message + "\n" + new String(data, "UTF-8")); } catch (UnsupportedEncodingException e) { myLog.info(message + "\n" + new String(data)); } } else { myLog.info(message); } } }
public static void updateDependencies( CompileContext context, List<File> toCompile, Map<ModuleBuildTarget, Collection<GroovycOutputParser.OutputItem>> successfullyCompiled, OutputConsumer outputConsumer, Builder builder) throws IOException { JavaBuilderUtil.registerFilesToCompile(context, toCompile); if (!successfullyCompiled.isEmpty()) { final Callbacks.Backend callback = JavaBuilderUtil.getDependenciesRegistrar(context); for (Map.Entry<ModuleBuildTarget, Collection<GroovycOutputParser.OutputItem>> entry : successfullyCompiled.entrySet()) { final ModuleBuildTarget target = entry.getKey(); final Collection<GroovycOutputParser.OutputItem> compiled = entry.getValue(); for (GroovycOutputParser.OutputItem item : compiled) { final String sourcePath = FileUtil.toSystemIndependentName(item.sourcePath); final String outputPath = FileUtil.toSystemIndependentName(item.outputPath); final File outputFile = new File(outputPath); final File srcFile = new File(sourcePath); try { final byte[] bytes = FileUtil.loadFileBytes(outputFile); if (Utils.IS_TEST_MODE || LOG.isDebugEnabled()) { LOG.info("registerCompiledClass " + outputFile + " from " + srcFile); } outputConsumer.registerCompiledClass( target, new CompiledClass( outputFile, srcFile, readClassName(bytes), new BinaryContent(bytes))); callback.associate(outputPath, sourcePath, new FailSafeClassReader(bytes)); } catch (Throwable e) { // need this to make sure that unexpected errors in, for example, ASM will not ruin the // compilation final String message = "Class dependency information may be incomplete! Error parsing generated class " + item.outputPath; LOG.info(message, e); context.processMessage( new CompilerMessage( builder.getPresentableName(), BuildMessage.Kind.WARNING, message + "\n" + CompilerMessage.getTextFromThrowable(e), sourcePath)); } JavaBuilderUtil.registerSuccessfullyCompiled(context, srcFile); } } } }
private void compact(final String path) { synchronized (myLock) { LOG.info( "Space waste in " + path + " is " + myDataTable.getWaste() + " bytes. Compacting now."); long start = System.currentTimeMillis(); try { File newDataFile = new File(path + ".storageData.backup"); FileUtil.delete(newDataFile); FileUtil.createIfDoesntExist(newDataFile); File oldDataFile = new File(path + DATA_EXTENSION); DataTable newDataTable = new DataTable(newDataFile, myPool); final int count = myRecordsTable.getRecordsCount(); for (int i = 1; i <= count; i++) { final long addr = myRecordsTable.getAddress(i); final int size = myRecordsTable.getSize(i); if (size > 0) { assert addr > 0; final int capacity = myCapacityAllocationPolicy.calculateCapacity(size); final long newaddr = newDataTable.allocateSpace(capacity); final byte[] bytes = new byte[size]; myDataTable.readBytes(addr, bytes); newDataTable.writeBytes(newaddr, bytes); myRecordsTable.setAddress(i, newaddr); myRecordsTable.setCapacity(i, capacity); } } myDataTable.dispose(); newDataTable.dispose(); if (!FileUtil.delete(oldDataFile)) { throw new IOException("Can't delete file: " + oldDataFile); } newDataFile.renameTo(oldDataFile); myDataTable = new DataTable(oldDataFile, myPool); } catch (IOException e) { LOG.info("Compact failed: " + e.getMessage()); } long timedelta = System.currentTimeMillis() - start; LOG.info("Done compacting in " + timedelta + "msec."); } }
/** * Check if merge is in progress, propose to resolve conflicts. * * @return true if merge is in progress, which means that update can't continue. */ private boolean isMergeInProgress() { LOG.info("isMergeInProgress: checking if there is an unfinished merge process..."); final Collection<VirtualFile> mergingRoots = myMerger.getMergingRoots(); if (mergingRoots.isEmpty()) { return false; } LOG.info("isMergeInProgress: roots with unfinished merge: " + mergingRoots); GitConflictResolver.Params params = new GitConflictResolver.Params(); params.setErrorNotificationTitle("Can't update"); params.setMergeDescription( "You have unfinished merge. These conflicts must be resolved before update."); return !new GitMergeCommittingConflictResolver( myProject, myGit, myMerger, mergingRoots, params, false) .merge(); }
private void recycleChangeList( final ShelvedChangeList listCopy, final ShelvedChangeList newList) { if (newList != null) { for (Iterator<ShelvedBinaryFile> shelvedChangeListIterator = listCopy.getBinaryFiles().iterator(); shelvedChangeListIterator.hasNext(); ) { final ShelvedBinaryFile binaryFile = shelvedChangeListIterator.next(); for (ShelvedBinaryFile newBinary : newList.getBinaryFiles()) { if (Comparing.equal(newBinary.BEFORE_PATH, binaryFile.BEFORE_PATH) && Comparing.equal(newBinary.AFTER_PATH, binaryFile.AFTER_PATH)) { shelvedChangeListIterator.remove(); } } } for (Iterator<ShelvedChange> iterator = listCopy.getChanges(myProject).iterator(); iterator.hasNext(); ) { final ShelvedChange change = iterator.next(); for (ShelvedChange newChange : newList.getChanges(myProject)) { if (Comparing.equal(change.getBeforePath(), newChange.getBeforePath()) && Comparing.equal(change.getAfterPath(), newChange.getAfterPath())) { iterator.remove(); } } } // needed only if partial unshelve try { final CommitContext commitContext = new CommitContext(); final List<FilePatch> patches = new ArrayList<FilePatch>(); for (ShelvedChange change : listCopy.getChanges(myProject)) { patches.add(change.loadFilePatch(myProject, commitContext)); } writePatchesToFile(myProject, listCopy.PATH, patches, commitContext); } catch (IOException e) { LOG.info(e); // left file as is } catch (PatchSyntaxException e) { LOG.info(e); // left file as is } } if ((!listCopy.getBinaryFiles().isEmpty()) || (!listCopy.getChanges(myProject).isEmpty())) { listCopy.setRecycled(true); myRecycledShelvedChangeLists.add(listCopy); notifyStateChanged(); } }
@Override public void run(@NotNull ProgressIndicator indicator) { try { SAXTransformerFactory transformerFactory = (SAXTransformerFactory) TransformerFactory.newInstance(); TransformerHandler handler = transformerFactory.newTransformerHandler(); handler.getTransformer().setOutputProperty(OutputKeys.INDENT, "yes"); handler .getTransformer() .setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "4"); final String configurationNameIncludedDate = PathUtil.suggestFileName(myConfiguration.getName()) + " - " + new SimpleDateFormat(HISTORY_DATE_FORMAT).format(new Date()); myOutputFile = new File( AbstractImportTestsAction.getTestHistoryRoot(myProject), configurationNameIncludedDate + ".xml"); FileUtilRt.createParentDirs(myOutputFile); handler.setResult(new StreamResult(new FileWriter(myOutputFile))); final SMTestProxy.SMRootTestProxy root = myRoot; final RunConfiguration configuration = myConfiguration; if (root != null && configuration != null) { TestResultsXmlFormatter.execute(root, configuration, myConsoleProperties, handler); } } catch (ProcessCanceledException e) { throw e; } catch (Exception e) { LOG.info("Export to history failed", e); } }
// relativePaths are guaranteed to fit into command line length limitations. @Override @NotNull public Collection<VirtualFile> untrackedFilesNoChunk( @NotNull Project project, @NotNull VirtualFile root, @Nullable List<String> relativePaths) throws VcsException { final Set<VirtualFile> untrackedFiles = new HashSet<VirtualFile>(); GitSimpleHandler h = new GitSimpleHandler(project, root, GitCommand.LS_FILES); h.setNoSSH(true); h.setSilent(true); h.addParameters("--exclude-standard", "--others", "-z"); h.endOptions(); if (relativePaths != null) { h.addParameters(relativePaths); } final String output = h.run(); if (StringUtil.isEmptyOrSpaces(output)) { return untrackedFiles; } for (String relPath : output.split("\u0000")) { VirtualFile f = root.findFileByRelativePath(relPath); if (f == null) { // files was created on disk, but VirtualFile hasn't yet been created, // when the GitChangeProvider has already been requested about changes. LOG.info(String.format("VirtualFile for path [%s] is null", relPath)); } else { untrackedFiles.add(f); } } return untrackedFiles; }
private static boolean waitComplete(ChannelFuture writeFuture, String failedMessage) { if (!writeFuture.awaitUninterruptibly(500) || !writeFuture.isSuccess()) { LOG.info("port check: " + failedMessage + ", " + writeFuture.isSuccess()); return false; } return true; }