void saveRemainingPatches( final ShelvedChangeList changeList, final List<FilePatch> remainingPatches, final List<ShelvedBinaryFile> remainingBinaries, CommitContext commitContext) { final File newPath = getPatchPath(changeList.DESCRIPTION); try { FileUtil.copy(new File(changeList.PATH), newPath); } catch (IOException e) { // do not delete if cannot recycle return; } final ShelvedChangeList listCopy = new ShelvedChangeList( newPath.getAbsolutePath(), changeList.DESCRIPTION, new ArrayList<ShelvedBinaryFile>(changeList.getBinaryFiles())); listCopy.DATE = (changeList.DATE == null) ? null : new Date(changeList.DATE.getTime()); writePatchesToFile(myProject, changeList.PATH, remainingPatches, commitContext); changeList.getBinaryFiles().retainAll(remainingBinaries); changeList.clearLoadedChanges(); recycleChangeList(listCopy, changeList); notifyStateChanged(); }
public static void rename(@NotNull File source, @NotNull File target) throws IOException { if (source.renameTo(target)) return; if (!source.exists()) return; copy(source, target); delete(source); }
private void copyFileOrDir(File src, File dst) throws IOException { if (src.isDirectory()) { FileUtil.copyDir(src, dst); } else { FileUtil.copy(src, dst); } }
public List<ShelvedChangeList> importChangeLists( final Collection<VirtualFile> files, final Consumer<VcsException> exceptionConsumer) { final List<ShelvedChangeList> result = new ArrayList<ShelvedChangeList>(files.size()); try { final FilesProgress filesProgress = new FilesProgress(files.size(), "Processing "); for (VirtualFile file : files) { filesProgress.updateIndicator(file); final String description = file.getNameWithoutExtension().replace('_', ' '); final File patchPath = getPatchPath(description); final ShelvedChangeList list = new ShelvedChangeList( patchPath.getPath(), description, new SmartList<ShelvedBinaryFile>(), file.getTimeStamp()); try { final List<TextFilePatch> patchesList = loadPatches(myProject, file.getPath(), new CommitContext()); if (!patchesList.isEmpty()) { FileUtil.copy(new File(file.getPath()), patchPath); // add only if ok to read patch myShelvedChangeLists.add(list); result.add(list); } } catch (IOException e) { exceptionConsumer.consume(new VcsException(e)); } catch (PatchSyntaxException e) { exceptionConsumer.consume(new VcsException(e)); } } } finally { notifyStateChanged(); } return result; }
public static void copyDir( @NotNull File fromDir, @NotNull File toDir, @Nullable final FileFilter filter) throws IOException { ensureExists(toDir); if (isAncestor(fromDir, toDir, true)) { LOG.error(fromDir.getAbsolutePath() + " is ancestor of " + toDir + ". Can't copy to itself."); return; } File[] files = fromDir.listFiles(); if (files == null) throw new IOException( CommonBundle.message("exception.directory.is.invalid", fromDir.getPath())); if (!fromDir.canRead()) throw new IOException( CommonBundle.message("exception.directory.is.not.readable", fromDir.getPath())); for (File file : files) { if (filter != null && !filter.accept(file)) { continue; } if (file.isDirectory()) { copyDir(file, new File(toDir, file.getName()), filter); } else { copy(file, new File(toDir, file.getName())); } } }
public static void extractEntry( ZipEntry entry, final InputStream inputStream, File outputDir, boolean overwrite) throws IOException { final boolean isDirectory = entry.isDirectory(); String entryName = entry.getName(); String relativeName = entryName.substring(JAVASCRIPT_GEN_DIR.length() + 1, entryName.length()); final File file = new File(outputDir, relativeName); if (file.exists() && !overwrite) return; FileUtil.createParentDirs(file); if (isDirectory) { file.mkdir(); } else { final BufferedInputStream is = new BufferedInputStream(inputStream); final BufferedOutputStream os = new BufferedOutputStream(new FileOutputStream(file)); try { FileUtil.copy(is, os); } finally { os.close(); is.close(); } } }
private static void copyFile(@NotNull final File from, @NotNull final File to) { if (from.exists()) { try { FileUtil.copy(from, to); } catch (IOException e) { LOG.warn("Failed to copy " + from.getName()); } } }
/** * Copies content of {@code fromDir} to {@code toDir}. It's equivalent to "cp -r fromDir/* toDir" * unix command. * * @param fromDir source directory * @param toDir destination directory * @throws IOException in case of any IO troubles */ public static void copyDirContent(@NotNull File fromDir, @NotNull File toDir) throws IOException { File[] children = ObjectUtils.notNull(fromDir.listFiles(), ArrayUtil.EMPTY_FILE_ARRAY); for (File child : children) { File target = new File(toDir, child.getName()); if (child.isFile()) { copy(child, target); } else { copyDir(child, target, true); } } }
public void testExtractDirectoryFromExcludedJar() throws IOException { String jarPath = createFile("dir/lib/j.jar"); FileUtil.copy(new File(getJUnitJarPath()), new File(jarPath)); JpsModule module = addModule("m"); String libDir = PathUtil.getParentPath(jarPath); module.getContentRootsList().addUrl(JpsPathUtil.pathToUrl(PathUtil.getParentPath(libDir))); module.getExcludeRootsList().addUrl(JpsPathUtil.pathToUrl(libDir)); final JpsArtifact a = addArtifact("a", root().extractedDir(jarPath, "/junit/textui/")); buildAll(); assertOutput(a, fs().file("ResultPrinter.class").file("TestRunner.class")); }
protected String copyToProject(String relativeSourcePath, String relativeTargetPath) { File source = findFindUnderProjectHome(relativeSourcePath); String fullTargetPath = getAbsolutePath(relativeTargetPath); File target = new File(fullTargetPath); try { if (source.isDirectory()) { FileUtil.copyDir(source, target); } else { FileUtil.copy(source, target); } } catch (IOException e) { throw new RuntimeException(e); } return fullTargetPath; }
public static File copyResourceFile( String sourceName, String copyName, Project project, Task task) throws IOException { StudyTaskManager taskManager = StudyTaskManager.getInstance(project); Course course = taskManager.getCourse(); int taskNum = task.getIndex() + 1; int lessonNum = task.getLesson().getIndex() + 1; assert course != null; String pathToResource = FileUtil.join( new File(course.getResourcePath()).getParent(), Lesson.LESSON_DIR + lessonNum, Task.TASK_DIR + taskNum); File resourceFile = new File(pathToResource, copyName); FileUtil.copy(new File(pathToResource, sourceName), resourceFile); return resourceFile; }
private static void writeRuntimeToJar(final JarOutputStream stream) throws IOException { final File unpackedRuntimePath = getUnpackedRuntimePath(); if (unpackedRuntimePath != null) { FileUtil.processFilesRecursively( unpackedRuntimePath, new Processor<File>() { @Override public boolean process(File file) { if (file.isDirectory()) return true; final String relativePath = FileUtil.getRelativePath(unpackedRuntimePath, file); try { stream.putNextEntry(new JarEntry(FileUtil.toSystemIndependentName(relativePath))); FileInputStream fis = new FileInputStream(file); try { FileUtil.copy(fis, stream); } finally { fis.close(); } } catch (IOException e) { throw new RuntimeException(e); } return true; } }); } else { File runtimeJarPath = getRuntimeJarPath(); if (runtimeJarPath != null) { JarInputStream jis = new JarInputStream(new FileInputStream(runtimeJarPath)); try { while (true) { JarEntry e = jis.getNextJarEntry(); if (e == null) { break; } if (FileUtil.getExtension(e.getName()).equals("class")) { stream.putNextEntry(e); FileUtil.copy(jis, stream); } } } finally { jis.close(); } } else { throw new CompileEnvironmentException("Couldn't find runtime library"); } } }
private static void performCopy( @NotNull File fromFile, @NotNull File toFile, final boolean syncTimestamp) throws IOException { final FileOutputStream fos; try { fos = openOutputStream(toFile); } catch (IOException e) { if (SystemInfo.isWindows && e.getMessage() != null && e.getMessage().contains("denied") && WinUACTemporaryFix.nativeCopy(fromFile, toFile, syncTimestamp)) { return; } throw e; } try { final FileInputStream fis = new FileInputStream(fromFile); try { copy(fis, fos); } finally { fis.close(); } } finally { fos.close(); } if (syncTimestamp) { final long timeStamp = fromFile.lastModified(); if (timeStamp < 0) { LOG.warn("Invalid timestamp " + timeStamp + " of '" + fromFile + "'"); } else if (!toFile.setLastModified(timeStamp)) { LOG.warn("Unable to set timestamp " + timeStamp + " to '" + toFile + "'"); } } if (SystemInfo.isUnix && fromFile.canExecute()) { FileSystemUtil.clonePermissions(fromFile.getPath(), toFile.getPath()); } }
@NotNull private File copyToMirror(@NotNull File original, @NotNull File mirror) { ProgressIndicator progress = ProgressManager.getInstance().getProgressIndicator(); if (progress != null) { progress.pushState(); progress.setText(VfsBundle.message("jar.copy.progress", original.getPath())); progress.setFraction(0); } try { FileUtil.copy(original, mirror); } catch (final IOException e) { reportIOErrorWithJars(original, mirror, e); return original; } if (progress != null) { progress.popState(); } return mirror; }
private static void ensureLogConfigExists(File workDirectory) { final File logConfig = new File(workDirectory, LOGGER_CONFIG); if (!logConfig.exists()) { FileUtil.createIfDoesntExist(logConfig); try { final InputStream in = Server.class.getResourceAsStream("/" + DEFAULT_LOGGER_CONFIG); if (in != null) { try { final FileOutputStream out = new FileOutputStream(logConfig); try { FileUtil.copy(in, out); } finally { out.close(); } } finally { in.close(); } } } catch (IOException e) { LOG.error(e); } } }
private static void copy( @NotNull File src, @NotNull File dest, ConfigImportSettings settings, File oldInstallationHome) throws IOException { src = src.getCanonicalFile(); dest = dest.getCanonicalFile(); if (!src.isDirectory()) { throw new IOException( ApplicationBundle.message( "config.import.invalid.directory.error", src.getAbsolutePath())); } if (!dest.isDirectory()) { throw new IOException( ApplicationBundle.message( "config.import.invalid.directory.error", dest.getAbsolutePath())); } if (FileUtil.filesEqual(src, dest)) { return; } FileUtil.ensureExists(dest); File[] childFiles = src.listFiles( new FilenameFilter() { @Override public boolean accept(@NotNull File dir, @NotNull String name) { // Don't copy plugins just imported. They're most probably incompatible with newer // idea version. return !StringUtil.startsWithChar(name, '.') && !name.equals(PLUGINS_PATH); } }); if (childFiles == null || childFiles.length == 0) { return; } for (File from : childFiles) { File to = new File(dest, from.getName()); if (from.isDirectory()) { FileUtil.copyDir(from, to, false); } else { FileUtil.copy(from, to); } } File plugins = new File(src, PLUGINS_PATH); if (!loadOldPlugins(plugins, dest) && SystemInfo.isMac) { File oldPluginsDir = getOldPath( oldInstallationHome, settings, PathManager.PROPERTY_PLUGINS_PATH, new Function<String, String>() { @Override public String fun(String pathSelector) { return PathManager.getDefaultPluginPathFor(pathSelector); } }); if (oldPluginsDir == null) { // e.g. installation home referred to config home. Try with default selector, same as config // name oldPluginsDir = new File(PathManager.getDefaultPluginPathFor(src.getName())); } loadOldPlugins(oldPluginsDir, dest); } }
@Nullable private Pair<String, String> moveToRealLocation( String tempOutputDir, String pathToClass, VirtualFile sourceFile, final List<File> filesToRefresh) { final Module module = myCompileContext.getModuleByFile(sourceFile); if (module == null) { final String message = "Cannot determine module for source file: " + sourceFile.getPresentableUrl() + ";\nCorresponding output file: " + pathToClass; LOG.info(message); myCompileContext.addMessage( CompilerMessageCategory.WARNING, message, sourceFile.getUrl(), -1, -1); // do not move: looks like source file has been invalidated, need recompilation return new Pair<String, String>(tempOutputDir, pathToClass); } final String realOutputDir; if (myCompileContext.isInTestSourceContent(sourceFile)) { realOutputDir = getTestsOutputDir(module); LOG.assertTrue(realOutputDir != null); } else { realOutputDir = getOutputDir(module); LOG.assertTrue(realOutputDir != null); } if (FileUtil.pathsEqual(tempOutputDir, realOutputDir)) { // no need to move filesToRefresh.add(new File(pathToClass)); return new Pair<String, String>(realOutputDir, pathToClass); } final String realPathToClass = realOutputDir + pathToClass.substring(tempOutputDir.length()); final File fromFile = new File(pathToClass); final File toFile = new File(realPathToClass); boolean success = fromFile.renameTo(toFile); if (!success) { // assuming cause of the fail: intermediate dirs do not exist FileUtil.createParentDirs(toFile); // retry after making non-existent dirs success = fromFile.renameTo(toFile); } if (!success) { // failed to move the file: e.g. because source and destination reside on // different mountpoints. try { FileUtil.copy(fromFile, toFile); FileUtil.delete(fromFile); success = true; } catch (IOException e) { LOG.info(e); success = false; } } if (success) { filesToRefresh.add(toFile); return new Pair<String, String>(realOutputDir, realPathToClass); } return null; }