public static void loadDescriptors(
String pluginsPath,
List<IdeaPluginDescriptorImpl> result,
@Nullable StartupProgress progress,
int pluginsCount) {
final File pluginsHome = new File(pluginsPath);
final File[] files = pluginsHome.listFiles();
if (files != null) {
int i = result.size();
for (File file : files) {
final IdeaPluginDescriptorImpl descriptor = loadDescriptor(file, PLUGIN_XML);
if (descriptor == null) continue;
if (progress != null) {
progress.showProgress(
descriptor.getName(), PLUGINS_PROGRESS_MAX_VALUE * ((float) ++i / pluginsCount));
}
int oldIndex = result.indexOf(descriptor);
if (oldIndex >= 0) {
final IdeaPluginDescriptorImpl oldDescriptor = result.get(oldIndex);
if (StringUtil.compareVersionNumbers(oldDescriptor.getVersion(), descriptor.getVersion())
< 0) {
result.set(oldIndex, descriptor);
}
} else {
result.add(descriptor);
}
}
}
}
public ShelvedChangeList importFilePatches(
final String fileName, final List<FilePatch> patches, final PatchEP[] patchTransitExtensions)
throws IOException {
try {
final File patchPath = getPatchPath(fileName);
myFileProcessor.savePathFile(
new CompoundShelfFileProcessor.ContentProvider() {
public void writeContentTo(final Writer writer, CommitContext commitContext)
throws IOException {
UnifiedDiffWriter.write(
myProject, patches, writer, "\n", patchTransitExtensions, commitContext);
}
},
patchPath,
new CommitContext());
final ShelvedChangeList changeList =
new ShelvedChangeList(
patchPath.toString(),
fileName.replace('\n', ' '),
new SmartList<ShelvedBinaryFile>());
myShelvedChangeLists.add(changeList);
return changeList;
} finally {
notifyStateChanged();
}
}
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 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;
}
static int countPlugins(String pluginsPath) {
File configuredPluginsDir = new File(pluginsPath);
if (configuredPluginsDir.exists()) {
String[] list = configuredPluginsDir.list();
if (list != null) {
return list.length;
}
}
return 0;
}
public ShelvedChangeList shelveChanges(
final Collection<Change> changes, final String commitMessage, final boolean rollback)
throws IOException, VcsException {
final List<Change> textChanges = new ArrayList<Change>();
final List<ShelvedBinaryFile> binaryFiles = new ArrayList<ShelvedBinaryFile>();
for (Change change : changes) {
if (ChangesUtil.getFilePath(change).isDirectory()) {
continue;
}
if (change.getBeforeRevision() instanceof BinaryContentRevision
|| change.getAfterRevision() instanceof BinaryContentRevision) {
binaryFiles.add(shelveBinaryFile(change));
} else {
textChanges.add(change);
}
}
final ShelvedChangeList changeList;
try {
File patchPath = getPatchPath(commitMessage);
ProgressManager.checkCanceled();
final List<FilePatch> patches =
IdeaTextPatchBuilder.buildPatch(
myProject, textChanges, myProject.getBaseDir().getPresentableUrl(), false);
ProgressManager.checkCanceled();
CommitContext commitContext = new CommitContext();
baseRevisionsOfDvcsIntoContext(textChanges, commitContext);
myFileProcessor.savePathFile(
new CompoundShelfFileProcessor.ContentProvider() {
public void writeContentTo(final Writer writer, CommitContext commitContext)
throws IOException {
UnifiedDiffWriter.write(myProject, patches, writer, "\n", commitContext);
}
},
patchPath,
commitContext);
changeList =
new ShelvedChangeList(
patchPath.toString(), commitMessage.replace('\n', ' '), binaryFiles);
myShelvedChangeLists.add(changeList);
ProgressManager.checkCanceled();
if (rollback) {
new RollbackWorker(myProject, false)
.doRollback(changes, true, null, VcsBundle.message("shelve.changes.action"));
}
} finally {
notifyStateChanged();
}
return changeList;
}
private void deleteListImpl(final ShelvedChangeList changeList) {
File file = new File(changeList.PATH);
myFileProcessor.delete(file.getName());
for (ShelvedBinaryFile binaryFile : changeList.getBinaryFiles()) {
final String path = binaryFile.SHELVED_PATH;
if (path != null) {
File binFile = new File(path);
myFileProcessor.delete(binFile.getName());
}
}
}
private File getPatchPath(@NonNls final String commitMessage) {
File file = myFileProcessor.getBaseIODir();
if (!file.exists()) {
file.mkdirs();
}
return suggestPatchName(
myProject,
commitMessage.length() > PatchNameChecker.MAX
? (commitMessage.substring(0, PatchNameChecker.MAX))
: commitMessage,
file,
VcsConfiguration.PATCH);
}
@Nullable
static IdeaPluginDescriptorImpl loadDescriptorFromDir(final File file, @NonNls String fileName) {
IdeaPluginDescriptorImpl descriptor = null;
File descriptorFile = new File(file, META_INF + File.separator + fileName);
if (descriptorFile.exists()) {
descriptor = new IdeaPluginDescriptorImpl(file);
try {
descriptor.readExternal(descriptorFile.toURI().toURL());
} catch (Exception e) {
System.err.println("Cannot load: " + descriptorFile.getAbsolutePath());
e.printStackTrace();
}
}
return descriptor;
}
@Nullable
static IdeaPluginDescriptorImpl loadDescriptorFromJar(File file, @NonNls String fileName) {
try {
URI fileURL = file.toURI();
URL jarURL =
new URL(
"jar:"
+ StringUtil.replace(fileURL.toASCIIString(), "!", "%21")
+ "!/META-INF/"
+ fileName);
IdeaPluginDescriptorImpl descriptor = new IdeaPluginDescriptorImpl(file);
FileInputStream in = new FileInputStream(file);
ZipInputStream zipStream = new ZipInputStream(in);
try {
ZipEntry entry = zipStream.getNextEntry();
if (entry.getName().equals(JarMemoryLoader.SIZE_ENTRY)) {
entry = zipStream.getNextEntry();
if (entry.getName().equals("META-INF/" + fileName)) {
byte[] content = FileUtil.loadBytes(zipStream, (int) entry.getSize());
Document document = JDOMUtil.loadDocument(new ByteArrayInputStream(content));
descriptor.readExternal(document, jarURL);
return descriptor;
}
}
} finally {
zipStream.close();
in.close();
}
descriptor.readExternal(jarURL);
return descriptor;
} catch (XmlSerializationException e) {
getLogger().info("Cannot load " + file, e);
prepareLoadingPluginsErrorMessage(
"Plugin file " + file.getName() + " contains invalid plugin descriptor file.");
} catch (FileNotFoundException e) {
return null;
} catch (Exception e) {
getLogger().info("Cannot load " + file, e);
} catch (Throwable e) {
getLogger().info("Cannot load " + file, e);
}
return null;
}
public static void loadDisabledPlugins(
final String configPath, final Collection<String> disabledPlugins) {
final File file = new File(configPath, DISABLED_PLUGINS_FILENAME);
if (file.isFile()) {
try {
BufferedReader reader = new BufferedReader(new FileReader(file));
try {
String id;
while ((id = reader.readLine()) != null) {
disabledPlugins.add(id.trim());
}
} finally {
reader.close();
}
} catch (IOException ignored) {
}
}
}
@Nullable
static ClassLoader createPluginClassLoader(
@NotNull File[] classPath,
@NotNull ClassLoader[] parentLoaders,
@NotNull IdeaPluginDescriptor pluginDescriptor) {
if (pluginDescriptor.getUseIdeaClassLoader()) {
try {
final ClassLoader loader = PluginManagerCore.class.getClassLoader();
final Method addUrlMethod = getAddUrlMethod(loader);
for (File aClassPath : classPath) {
final File file = aClassPath.getCanonicalFile();
addUrlMethod.invoke(loader, file.toURI().toURL());
}
return loader;
} catch (NoSuchMethodException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
}
PluginId pluginId = pluginDescriptor.getPluginId();
File pluginRoot = pluginDescriptor.getPath();
// if (classPath.length == 0) return null;
if (isUnitTestMode()) return null;
try {
final List<URL> urls = new ArrayList<URL>(classPath.length);
for (File aClassPath : classPath) {
final File file =
aClassPath
.getCanonicalFile(); // it is critical not to have "." and ".." in classpath
// elements
urls.add(file.toURI().toURL());
}
return new PluginClassLoader(
urls, parentLoaders, pluginId, pluginDescriptor.getVersion(), pluginRoot);
} catch (MalformedURLException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
return null;
}
private ShelvedBinaryFile shelveBinaryFile(final Change change) throws IOException {
final ContentRevision beforeRevision = change.getBeforeRevision();
final ContentRevision afterRevision = change.getAfterRevision();
File beforeFile = beforeRevision == null ? null : beforeRevision.getFile().getIOFile();
File afterFile = afterRevision == null ? null : afterRevision.getFile().getIOFile();
String shelvedPath = null;
if (afterFile != null) {
String shelvedName = FileUtil.getNameWithoutExtension(afterFile.getName());
String shelvedExt = FileUtil.getExtension(afterFile.getName());
File shelvedFile =
FileUtil.findSequentNonexistentFile(
myFileProcessor.getBaseIODir(), shelvedName, shelvedExt);
myFileProcessor.saveFile(afterRevision.getFile().getIOFile(), shelvedFile);
shelvedPath = shelvedFile.getPath();
}
String beforePath = ChangesUtil.getProjectRelativePath(myProject, beforeFile);
String afterPath = ChangesUtil.getProjectRelativePath(myProject, afterFile);
return new ShelvedBinaryFile(beforePath, afterPath, shelvedPath);
}
public static File suggestPatchName(
Project project, final String commitMessage, final File file, String extension) {
@NonNls String defaultPath = PathUtil.suggestFileName(commitMessage);
if (defaultPath.length() == 0) {
defaultPath = "unnamed";
}
if (defaultPath.length() > (PatchNameChecker.MAX - 10)) {
defaultPath = defaultPath.substring(0, PatchNameChecker.MAX - 10);
}
while (true) {
final File nonexistentFile =
FileUtil.findSequentNonexistentFile(
file,
defaultPath,
extension == null
? VcsConfiguration.getInstance(project).getPatchFileExtension()
: extension);
if (nonexistentFile.getName().length() >= PatchNameChecker.MAX) {
defaultPath = defaultPath.substring(0, defaultPath.length() - 1);
continue;
}
return nonexistentFile;
}
}
public static void savePluginsList(Collection<String> ids, boolean append, File plugins)
throws IOException {
if (!plugins.isFile()) {
FileUtil.ensureCanCreateFile(plugins);
}
PrintWriter printWriter = new PrintWriter(new BufferedWriter(new FileWriter(plugins, append)));
try {
for (String id : ids) {
printWriter.println(id);
}
printWriter.flush();
} finally {
printWriter.close();
}
}
public static void dumpFullHistory(
final Project project, VirtualFile root, final String outFilePath) throws VcsException {
if (!GitUtil.isGitRoot(new File(root.getPath())))
throw new VcsException("Path " + root.getPath() + " is not git repository root");
final GitLineHandler h = new GitLineHandler(project, root, GitCommand.LOG);
// GitSimpleHandler h = new GitSimpleHandler(project, root, GitCommand.LOG);
GitLogParser parser =
new GitLogParser(project, GitLogParser.NameStatus.STATUS, HASH, COMMIT_TIME);
h.setNoSSH(true);
h.setSilent(true);
h.addParameters(
"--all",
"--pretty=format:%H%x20%ct%x0A",
"--date-order",
"--reverse",
"--encoding=UTF-8",
"--full-history",
"--sparse");
h.endOptions();
// for file sort
final Long[] minTs = new Long[1];
minTs[0] = Long.MAX_VALUE;
final Long[] maxTs = new Long[1];
minTs[0] = 0L;
final OutputStream[] stream = new OutputStream[1];
try {
stream[0] = new BufferedOutputStream(new FileOutputStream(outFilePath, false));
final Semaphore semaphore = new Semaphore();
final VcsException[] ioExceptions = new VcsException[1];
h.addLineListener(
new GitLineHandlerListener() {
@Override
public void onLineAvailable(String line, Key outputType) {
if (line.length() == 0) return;
try {
GitCommitsSequentialIndex.parseRecord(line);
stream[0].write((line + '\n').getBytes("UTF-8"));
} catch (IOException e) {
ioExceptions[0] = new VcsException(e);
h.cancel();
semaphore.up();
} catch (ProcessCanceledException e) {
h.cancel();
semaphore.up();
} catch (VcsException e) {
ioExceptions[0] = e;
h.cancel();
semaphore.up();
}
}
@Override
public void processTerminated(int exitCode) {
semaphore.up();
}
@Override
public void startFailed(Throwable exception) {
semaphore.up();
}
});
semaphore.down();
h.start();
semaphore.waitFor();
if (ioExceptions[0] != null) {
throw ioExceptions[0];
}
} catch (FileNotFoundException e) {
throw new VcsException(e);
} finally {
try {
if (stream[0] != null) {
stream[0].close();
}
} catch (IOException e) {
throw new VcsException(e);
}
}
/*String result = h.run();
if (result.length() > 0) {
throw new VcsException(result);
}*/
File file = new File(outFilePath);
if (!file.exists() || file.length() == 0)
throw new VcsException("Short repository history not loaded");
}
@SuppressWarnings({"HardCodedStringLiteral"})
@Nullable
public static IdeaPluginDescriptorImpl loadDescriptor(
final File file, @NonNls final String fileName) {
IdeaPluginDescriptorImpl descriptor = null;
if (file.isDirectory()) {
descriptor = loadDescriptorFromDir(file, fileName);
if (descriptor == null) {
File libDir = new File(file, "lib");
if (!libDir.isDirectory()) {
return null;
}
final File[] files = libDir.listFiles();
if (files == null || files.length == 0) {
return null;
}
Arrays.sort(
files,
new Comparator<File>() {
@Override
public int compare(File o1, File o2) {
if (o2.getName().startsWith(file.getName())) return Integer.MAX_VALUE;
if (o1.getName().startsWith(file.getName())) return -Integer.MAX_VALUE;
if (o2.getName().startsWith("resources")) return -Integer.MAX_VALUE;
if (o1.getName().startsWith("resources")) return Integer.MAX_VALUE;
return 0;
}
});
for (final File f : files) {
if (FileUtil.isJarOrZip(f)) {
descriptor = loadDescriptorFromJar(f, fileName);
if (descriptor != null) {
descriptor.setPath(file);
break;
}
// getLogger().warn("Cannot load descriptor from " + f.getName() + "");
} else if (f.isDirectory()) {
IdeaPluginDescriptorImpl descriptor1 = loadDescriptorFromDir(f, fileName);
if (descriptor1 != null) {
if (descriptor != null) {
getLogger()
.info("Cannot load " + file + " because two or more plugin.xml's detected");
return null;
}
descriptor = descriptor1;
descriptor.setPath(file);
}
}
}
}
} else if (StringUtil.endsWithIgnoreCase(file.getName(), ".jar") && file.exists()) {
descriptor = loadDescriptorFromJar(file, fileName);
}
if (descriptor != null && !descriptor.getOptionalConfigs().isEmpty()) {
final Map<PluginId, IdeaPluginDescriptorImpl> descriptors =
new HashMap<PluginId, IdeaPluginDescriptorImpl>(descriptor.getOptionalConfigs().size());
for (Map.Entry<PluginId, String> entry : descriptor.getOptionalConfigs().entrySet()) {
String optionalDescriptorName = entry.getValue();
assert !Comparing.equal(fileName, optionalDescriptorName)
: "recursive dependency: " + fileName;
IdeaPluginDescriptorImpl optionalDescriptor = loadDescriptor(file, optionalDescriptorName);
if (optionalDescriptor == null && !FileUtil.isJarOrZip(file)) {
for (URL url : getClassLoaderUrls()) {
if ("file".equals(url.getProtocol())) {
optionalDescriptor =
loadDescriptor(new File(decodeUrl(url.getFile())), optionalDescriptorName);
if (optionalDescriptor != null) {
break;
}
}
}
}
if (optionalDescriptor != null) {
descriptors.put(entry.getKey(), optionalDescriptor);
} else {
getLogger().info("Cannot find optional descriptor " + optionalDescriptorName);
}
}
descriptor.setOptionalDescriptors(descriptors);
}
return descriptor;
}