/** * Tests reading a 3.0.2 install with a mix of classic and OSGi plug-ins. * * @throws Exception */ public void testClassicPlugins() throws Exception { // extract the 3.0.2 skeleton IPath location = extractClassicPlugins(); // the new way ITargetDefinition definition = getNewTarget(); ITargetLocation container = getTargetService().newDirectoryLocation(location.toOSString()); definition.setTargetLocations(new ITargetLocation[] {container}); Set urls = getAllBundleURLs(definition); assertTrue("Must be bundles", urls.size() > 0); Preferences store = PDECore.getDefault().getPluginPreferences(); boolean restore = store.getBoolean(ICoreConstants.TARGET_PLATFORM_REALIZATION); try { store.setValue(ICoreConstants.TARGET_PLATFORM_REALIZATION, false); // the old way URL[] pluginPaths = PluginPathFinder.getPluginPaths(location.toOSString()); for (int i = 0; i < pluginPaths.length; i++) { URL url = pluginPaths[i]; if (!urls.contains(url)) { System.err.println(url.toString()); } } assertEquals("Wrong number of bundles", pluginPaths.length, urls.size()); } finally { store.setValue(ICoreConstants.TARGET_PLATFORM_REALIZATION, restore); } }
/** * Tests identification of source bundles in a 3.0.2 install. * * @throws Exception */ public void testClassicSourcePlugins() throws Exception { // extract the 3.0.2 skeleton IPath location = extractClassicPlugins(); // the new way ITargetDefinition definition = getNewTarget(); ITargetLocation container = getTargetService().newDirectoryLocation(location.toOSString()); definition.setTargetLocations(new ITargetLocation[] {container}); definition.resolve(null); TargetBundle[] bundles = definition.getBundles(); List source = new ArrayList(); for (int i = 0; i < bundles.length; i++) { TargetBundle sb = bundles[i]; if (sb.isSourceBundle()) { source.add(sb); } } assertEquals("Wrong number of source bundles", 4, source.size()); Set names = new HashSet(); for (int i = 0; i < source.size(); i++) { names.add(((TargetBundle) source.get(i)).getBundleInfo().getSymbolicName()); } String[] expected = new String[] { "org.eclipse.platform.source", "org.eclipse.jdt.source", "org.eclipse.pde.source", "org.eclipse.platform.source.win32.win32.x86" }; for (int i = 0; i < expected.length; i++) { assertTrue("Missing source for " + expected[i], names.contains(expected[i])); } }
protected boolean checkForClassFileChanges( IResourceDelta binaryDelta, ClasspathMultiDirectory md, int segmentCount) throws CoreException { IResource resource = binaryDelta.getResource(); // remember that if inclusion & exclusion patterns change then a full build is done boolean isExcluded = (md.exclusionPatterns != null || md.inclusionPatterns != null) && Util.isExcluded(resource, md.inclusionPatterns, md.exclusionPatterns); switch (resource.getType()) { case IResource.FOLDER: if (isExcluded && md.inclusionPatterns == null) return true; // no need to go further with this delta since its children cannot be // included IResourceDelta[] children = binaryDelta.getAffectedChildren(); for (int i = 0, l = children.length; i < l; i++) if (!checkForClassFileChanges(children[i], md, segmentCount)) return false; return true; case IResource.FILE: if (!isExcluded && org.eclipse.jdt.internal.compiler.util.Util.isClassFileName(resource.getName())) { // perform full build if a managed class file has been changed IPath typePath = resource.getFullPath().removeFirstSegments(segmentCount).removeFileExtension(); if (this.newState.isKnownType(typePath.toString())) { if (JavaBuilder.DEBUG) System.out.println( "MUST DO FULL BUILD. Found change to class file " + typePath); // $NON-NLS-1$ return false; } return true; } } return true; }
/** * Tests a JDT source feature bundle container contains the appropriate bundles * * @throws Exception */ public void testSourceFeatureBundleContainer() throws Exception { // extract the feature IPath location = extractModifiedFeatures(); ITargetDefinition definition = getNewTarget(); ITargetLocation container = getTargetService() .newFeatureLocation(location.toOSString(), "org.eclipse.jdt.source", null); container.resolve(definition, null); TargetBundle[] bundles = container.getBundles(); List expected = new ArrayList(); expected.add("org.eclipse.jdt.source"); expected.add("org.eclipse.jdt.launching.source"); // There are two versions of junit available, each with source expected.add("org.junit.source"); expected.add("org.junit.source"); if (Platform.getOS().equals(Platform.OS_MACOSX)) { expected.add("org.eclipse.jdt.launching.macosx.source"); } assertEquals("Wrong number of bundles", expected.size(), bundles.length); for (int i = 0; i < bundles.length; i++) { if (bundles[i].getBundleInfo().getSymbolicName().equals("org.eclipse.jdt.doc.isv")) { assertFalse("Should not be a source bundle", bundles[i].isSourceBundle()); } else { assertTrue(expected.remove(bundles[i].getBundleInfo().getSymbolicName())); assertTrue("Should be a source bundle", bundles[i].isSourceBundle()); } } assertTrue("Wrong bundles in JDT feature", expected.isEmpty()); }
protected void finishedWith( String sourceLocator, CompilationResult result, char[] mainTypeName, ArrayList definedTypeNames, ArrayList duplicateTypeNames) { char[][] previousTypeNames = this.newState.getDefinedTypeNamesFor(sourceLocator); if (previousTypeNames == null) previousTypeNames = new char[][] {mainTypeName}; IPath packagePath = null; next: for (int i = 0, l = previousTypeNames.length; i < l; i++) { char[] previous = previousTypeNames[i]; for (int j = 0, m = definedTypeNames.size(); j < m; j++) if (CharOperation.equals(previous, (char[]) definedTypeNames.get(j))) continue next; SourceFile sourceFile = (SourceFile) result.getCompilationUnit(); if (packagePath == null) { int count = sourceFile.sourceLocation.sourceFolder.getFullPath().segmentCount(); packagePath = sourceFile.resource.getFullPath().removeFirstSegments(count).removeLastSegments(1); } if (this.secondaryTypesToRemove == null) this.secondaryTypesToRemove = new SimpleLookupTable(); ArrayList types = (ArrayList) this.secondaryTypesToRemove.get(sourceFile.sourceLocation.binaryFolder); if (types == null) types = new ArrayList(definedTypeNames.size()); types.add(packagePath.append(new String(previous))); this.secondaryTypesToRemove.put(sourceFile.sourceLocation.binaryFolder, types); } super.finishedWith(sourceLocator, result, mainTypeName, definedTypeNames, duplicateTypeNames); }
/** * Returns the file path where the given resolved bundle can be found. Used to group bundles by * file path in the tree. * * @param bundle bundle to lookup parent path for * @return path of parent directory, if unknown it will be a path object containing "Unknown" */ private IPath getParentPath(IResolvedBundle bundle) { URI location = bundle.getBundleInfo().getLocation(); if (location == null) { return new Path(Messages.TargetContentsGroup_8); } IPath path = new Path(URIUtil.toUnencodedString(location)); path = path.removeLastSegments(1); return path; }
/** * Returns the existing WebProject corresponding to the provided path, or <code>null</code> if no * such project exists. * * @param path path in the form /file/{workspaceId}/{projectName}/[filePath] * @return the web project, or <code>null</code> */ public static ProjectInfo projectFromPath(IPath path) { if (path == null || path.segmentCount() < 3) return null; String workspaceId = path.segment(1); String projectName = path.segment(2); try { return OrionConfiguration.getMetaStore().readProject(workspaceId, projectName); } catch (CoreException e) { return null; } }
protected long computeModificationStamp(IResource resource) { long modificationStamp = resource.getModificationStamp(); IPath path = resource.getLocation(); if (path == null) { return modificationStamp; } modificationStamp = path.toFile().lastModified(); return modificationStamp; }
/** * Tests a JDT feature bundle container contains the appropriate bundles for a specific OS. * * @throws Exception */ public void testMacOSFeatureBundleContainer() throws Exception { // extract the feature IPath location = extractModifiedFeatures(); ITargetDefinition definition = getNewTarget(); definition.setOS(Platform.OS_MACOSX); ITargetLocation container = getTargetService().newFeatureLocation(location.toOSString(), "org.eclipse.jdt", null); container.resolve(definition, null); TargetBundle[] bundles = container.getBundles(); List expected = new ArrayList(); expected.add("org.eclipse.jdt"); expected.add("org.eclipse.jdt.launching"); // 2 versions of JUnit expected.add("org.junit"); expected.add("org.junit"); expected.add("org.junit4"); expected.add("org.eclipse.jdt.launching.macosx"); assertEquals("Wrong number of bundles in JDT feature", expected.size(), bundles.length); for (int i = 0; i < bundles.length; i++) { String symbolicName = bundles[i].getBundleInfo().getSymbolicName(); expected.remove(symbolicName); if (symbolicName.equals("org.eclipse.jdt.launching.macosx")) { // the bundle should be missing unless on Mac IStatus status = bundles[i].getStatus(); if (Platform.getOS().equals(Platform.OS_MACOSX)) { assertTrue("Mac bundle should be present", status.isOK()); } else { assertFalse("Mac bundle should be missing", status.isOK()); assertEquals( "Mac bundle should be mssing", TargetBundle.STATUS_PLUGIN_DOES_NOT_EXIST, status.getCode()); } } } Iterator iterator = expected.iterator(); while (iterator.hasNext()) { String name = (String) iterator.next(); System.err.println("Missing: " + name); } assertTrue("Wrong bundles in JDT feature", expected.isEmpty()); // should be no source bundles for (int i = 0; i < bundles.length; i++) { TargetBundle bundle = bundles[i]; assertFalse("Should be no source bundles", bundle.isSourceBundle()); } }
/** * Tests reading a 3.0 style plug-in that has a MANIFEST file that is not a bundle manifest. * * @throws Exception */ public void testClassicPluginsWithNonBundleManifest() throws Exception { // extract the plug-in IPath location = extractClassicNonBundleManifestPlugins(); // the new way ITargetDefinition definition = getNewTarget(); ITargetLocation container = getTargetService().newDirectoryLocation(location.toOSString()); definition.setTargetLocations(new ITargetLocation[] {container}); definition.resolve(null); TargetBundle[] bundles = definition.getAllBundles(); assertEquals("Wrong number of bundles", 1, bundles.length); assertEquals( "Wrong bundle", "org.eclipse.core.variables", bundles[0].getBundleInfo().getSymbolicName()); }
/** * Returns the location of the JDT feature in the running host as a path in the local file system. * * @return path to JDT feature */ protected IPath getJdtFeatureLocation() { IPath path = new Path(TargetPlatform.getDefaultLocation()); path = path.append("features"); File dir = path.toFile(); assertTrue("Missing features directory", dir.exists() && !dir.isFile()); String[] files = dir.list(); String location = null; for (int i = 0; i < files.length; i++) { if (files[i].startsWith("org.eclipse.jdt_")) { location = path.append(files[i]).toOSString(); break; } } assertNotNull("Missing JDT feature", location); return new Path(location); }
/** * Returns the existing git repositories for the given file path, following the given traversal * rule. * * @param path expected format /file/{Workspace}/{projectName}[/{path}] * @return a map of all git repositories found, or <code>null</code> if the provided path format * doesn't match the expected format. * @throws CoreException */ public static Map<IPath, File> getGitDirs(IPath path, Traverse traverse) throws CoreException { IPath p = path.removeFirstSegments(1); // remove /file IFileStore fileStore = NewFileServlet.getFileStore(null, p); if (fileStore == null) return null; Map<IPath, File> result = new HashMap<IPath, File>(); File file = fileStore.toLocalFile(EFS.NONE, null); // jgit can only handle a local file if (file == null) return result; switch (traverse) { case CURRENT: if (RepositoryCache.FileKey.isGitRepository(file, FS.DETECTED)) { result.put(new Path(""), file); // $NON-NLS-1$ } else if (RepositoryCache.FileKey.isGitRepository( new File(file, Constants.DOT_GIT), FS.DETECTED)) { result.put(new Path(""), new File(file, Constants.DOT_GIT)); // $NON-NLS-1$ } break; case GO_UP: getGitDirsInParents(file, result); break; case GO_DOWN: getGitDirsInChildren(file, p, result); break; } return result; }
/** * Tests setting the target platform to the stored JDT feature test data * * @throws Exception */ public void testSetTargetPlatformToJdtFeature() throws Exception { try { // extract the feature IPath location = extractModifiedFeatures(); // org.eclipse.jdt_3.6.0.v20100105-0800-7z8VFR9FMTb52_pOyKHhoek1 ITargetDefinition target = getNewTarget(); ITargetLocation container = getTargetService() .newFeatureLocation( location.toOSString(), "org.eclipse.jdt", "3.6.0.v20100105-0800-7z8VFR9FMTb52_pOyKHhoek1"); target.setTargetLocations(new ITargetLocation[] {container}); setTargetPlatform(target); List expected = new ArrayList(); expected.add("org.eclipse.jdt"); expected.add("org.eclipse.jdt.launching"); // 2 versions of JUnit expected.add("org.junit"); expected.add("org.junit"); expected.add("org.junit4"); if (Platform.getOS().equals(Platform.OS_MACOSX)) { expected.add("org.eclipse.jdt.launching.macosx"); } // current platform IPluginModelBase[] models = TargetPlatformHelper.getPDEState().getTargetModels(); assertEquals("Wrong number of bundles in JDT feature", expected.size(), models.length); for (int i = 0; i < models.length; i++) { expected.remove(models[i].getPluginBase().getId()); assertTrue(models[i].isEnabled()); } Iterator iterator = expected.iterator(); while (iterator.hasNext()) { String name = (String) iterator.next(); System.err.println("Missing: " + name); } assertTrue("Wrong bundles in target platform", expected.isEmpty()); } finally { resetTargetPlatform(); } }
protected void removeClassFile(IPath typePath, IContainer outputFolder) throws CoreException { if (typePath.lastSegment().indexOf('$') == -1) { // is not a nested type this.newState.removeQualifiedTypeName(typePath.toString()); // add dependents even when the type thinks it does not exist to be on the safe side if (JavaBuilder.DEBUG) System.out.println("Found removed type " + typePath); // $NON-NLS-1$ addDependentsOf( typePath, true); // when member types are removed, their enclosing type is structurally changed } IFile classFile = outputFolder.getFile(typePath.addFileExtension(SuffixConstants.EXTENSION_class)); if (classFile.exists()) { if (JavaBuilder.DEBUG) System.out.println("Deleting class file of removed type " + typePath); // $NON-NLS-1$ classFile.delete(IResource.FORCE, null); } }
/** * Completes a move after a file transfer. Returns <code>true</code> if the move was successful, * and <code>false</code> otherwise. In case of failure, this method handles setting an * appropriate response. */ private boolean completeMove(HttpServletRequest req, HttpServletResponse resp) throws ServletException { IPath destPath = new Path(getPath()).append(getFileName()); try { IFileStore source = EFS.getStore(new File(getStorageDirectory(), FILE_DATA).toURI()); IFileStore destination = NewFileServlet.getFileStore(destPath); source.move(destination, EFS.OVERWRITE, null); } catch (CoreException e) { String msg = NLS.bind("Failed to complete file transfer on {0}", destPath.toString()); statusHandler.handleRequest( req, resp, new ServerStatus(IStatus.ERROR, HttpServletResponse.SC_INTERNAL_SERVER_ERROR, msg, e)); return false; } return true; }
/** * Removes path information from the given string containing one or more comma separated osgi * bundles. Replaces escaped '\:' with ':'. Removes, reference, platform and file prefixes. * Removes any other path information converting the location or the last segment to a bundle id. * * @param osgiBundles list of bundles to strip path information from (commma separated) * @return list of bundles with path information stripped */ public static String stripPathInformation(String osgiBundles) { StringBuffer result = new StringBuffer(); StringTokenizer tokenizer = new StringTokenizer(osgiBundles, ","); // $NON-NLS-1$ while (tokenizer.hasMoreElements()) { String token = tokenizer.nextToken(); token = token.replaceAll("\\\\:|/:", ":"); // $NON-NLS-1$ //$NON-NLS-2$ // read up until the first @, if there int atIndex = token.indexOf('@'); String bundle = atIndex > 0 ? token.substring(0, atIndex) : token; bundle = bundle.trim(); // strip [reference:][platform:][file:] prefixes if any if (bundle.startsWith(REFERENCE_PREFIX) && bundle.length() > REFERENCE_PREFIX.length()) bundle = bundle.substring(REFERENCE_PREFIX.length()); if (bundle.startsWith(PLATFORM_PREFIX) && bundle.length() > PLATFORM_PREFIX.length()) bundle = bundle.substring(PLATFORM_PREFIX.length()); if (bundle.startsWith(FILE_URL_PREFIX) && bundle.length() > FILE_URL_PREFIX.length()) bundle = bundle.substring(FILE_URL_PREFIX.length()); // if the path is relative, the last segment is the bundle symbolic name // Otherwise, we need to retrieve the bundle symbolic name ourselves IPath path = new Path(bundle); String id = null; if (path.isAbsolute()) { id = getSymbolicName(bundle); } if (id == null) { id = path.lastSegment(); } if (id != null) { int underscoreIndex = id.indexOf('_'); if (underscoreIndex >= 0) { id = id.substring(0, underscoreIndex); } if (id.endsWith(JAR_EXTENSION)) { id = id.substring(0, id.length() - 4); } } if (result.length() > 0) result.append(","); // $NON-NLS-1$ result.append(id != null ? id : bundle); if (atIndex > -1) result.append(token.substring(atIndex).trim()); } return result.toString(); }
boolean filterExtraResource(IResource resource) { if (this.extraResourceFileFilters != null) { char[] name = resource.getName().toCharArray(); for (int i = 0, l = this.extraResourceFileFilters.length; i < l; i++) if (CharOperation.match(this.extraResourceFileFilters[i], name, true)) return true; } if (this.extraResourceFolderFilters != null) { IPath path = resource.getProjectRelativePath(); String pathName = path.toString(); int count = path.segmentCount(); if (resource.getType() == IResource.FILE) count--; for (int i = 0, l = this.extraResourceFolderFilters.length; i < l; i++) if (pathName.indexOf(this.extraResourceFolderFilters[i]) != -1) for (int j = 0; j < count; j++) if (this.extraResourceFolderFilters[i].equals(path.segment(j))) return true; } return false; }
public boolean include(Object object) { if (object instanceof IResource) { IResource resource = (IResource) object; IPath path = IResource.FILE == resource.getType() ? resource.getFullPath() : resource.getFullPath().addTrailingSeparator(); object = path.toPortableString(); } for (Iterator iter = filters.iterator(); iter.hasNext(); ) { Filter filter = (Filter) iter.next(); if (filter.matches(object)) { return filter.inclusive(); } } return default_; }
private void loadCommentTemplates() { IPath pluginStateLocation = CVSUIPlugin.getPlugin().getStateLocation().append(COMMENT_TEMPLATES_FILE); File file = pluginStateLocation.toFile(); if (!file.exists()) return; try { BufferedInputStream is = new BufferedInputStream(new FileInputStream(file)); try { readCommentTemplates(is); } finally { is.close(); } } catch (IOException e) { CVSUIPlugin.log(IStatus.ERROR, CVSUIMessages.RepositoryManager_ioException, e); } catch (TeamException e) { CVSUIPlugin.log(e); } }
protected void deleteGeneratedFiles(IFile[] deletedGeneratedFiles) { // delete generated files and recompile any affected source files try { for (int j = deletedGeneratedFiles.length; --j >= 0; ) { IFile deletedFile = deletedGeneratedFiles[j]; if (deletedFile.exists()) continue; // only delete .class files for source files that were actually deleted SourceFile sourceFile = findSourceFile(deletedFile, false); String typeLocator = sourceFile.typeLocator(); int mdSegmentCount = sourceFile.sourceLocation.sourceFolder.getFullPath().segmentCount(); IPath typePath = sourceFile .resource .getFullPath() .removeFirstSegments(mdSegmentCount) .removeFileExtension(); addDependentsOf(typePath, true); // add dependents of the source file since its now deleted this.previousSourceFiles = null; // existing source files did not see it as deleted since they were compiled before // it was char[][] definedTypeNames = this.newState.getDefinedTypeNamesFor(typeLocator); if (definedTypeNames == null) { // defined a single type matching typePath removeClassFile(typePath, sourceFile.sourceLocation.binaryFolder); } else { if (definedTypeNames.length > 0) { // skip it if it failed to successfully define a type IPath packagePath = typePath.removeLastSegments(1); for (int d = 0, l = definedTypeNames.length; d < l; d++) removeClassFile( packagePath.append(new String(definedTypeNames[d])), sourceFile.sourceLocation.binaryFolder); } } this.newState.removeLocator(typeLocator); } } catch (CoreException e) { // must continue with compile loop so just log the CoreException Util.log( e, "JavaBuilder logging CompilationParticipant's CoreException to help debugging"); //$NON-NLS-1$ } }
/* Return the list of projects for which it requires a resource delta. This builder's project * is implicitly included and need not be specified. Builders must re-specify the list * of interesting projects every time they are run as this is not carried forward * beyond the next build. Missing projects should be specified but will be ignored until * they are added to the workspace. */ private IProject[] getRequiredProjects(boolean includeBinaryPrerequisites) { if (this.javaProject == null || this.workspaceRoot == null) return new IProject[0]; ArrayList projects = new ArrayList(); ExternalFoldersManager externalFoldersManager = JavaModelManager.getExternalManager(); try { IClasspathEntry[] entries = this.javaProject.getExpandedClasspath(); for (int i = 0, l = entries.length; i < l; i++) { IClasspathEntry entry = entries[i]; IPath path = entry.getPath(); IProject p = null; switch (entry.getEntryKind()) { case IClasspathEntry.CPE_PROJECT: p = this.workspaceRoot.getProject( path.lastSegment()); // missing projects are considered too if (((ClasspathEntry) entry).isOptional() && !JavaProject.hasJavaNature(p)) // except if entry is optional p = null; break; case IClasspathEntry.CPE_LIBRARY: if (includeBinaryPrerequisites && path.segmentCount() > 0) { // some binary resources on the class path can come from projects that are not // included in the project references IResource resource = this.workspaceRoot.findMember(path.segment(0)); if (resource instanceof IProject) { p = (IProject) resource; } else { resource = externalFoldersManager.getFolder(path); if (resource != null) p = resource.getProject(); } } } if (p != null && !projects.contains(p)) projects.add(p); } } catch (JavaModelException e) { return new IProject[0]; } IProject[] result = new IProject[projects.size()]; projects.toArray(result); return result; }
/** * Tests that a target definition equivalent to the default target platform contains the same * bundles as the default target platform (this is an explicit location with no target weaving), * when created with a variable referencing ${eclipse_home} * * @throws Exception */ public void testEclipseHomeTargetPlatform() throws Exception { // the new way ITargetDefinition definition = getNewTarget(); ITargetLocation container = getTargetService().newProfileLocation("${eclipse_home}", null); definition.setTargetLocations(new ITargetLocation[] {container}); Set urls = getAllBundleURLs(definition); // the old way IPath location = new Path(TargetPlatform.getDefaultLocation()); URL[] pluginPaths = P2Utils.readBundlesTxt( location.toOSString(), location.append("configuration").toFile().toURL()); // pluginPaths will be null (and NPE) when self-hosting and the target platform is not a real // installation assertEquals("Should have same number of bundles", pluginPaths.length, urls.size()); for (int i = 0; i < pluginPaths.length; i++) { URL url = pluginPaths[i]; assertTrue("Missing plug-in " + url.toString(), urls.contains(url)); } }
private void createParents(IProject fragmentProject, IPath parent) throws CoreException { String[] segments = parent.segments(); String path = new String(); for (int i = 0; i < segments.length; i++) { path += SLASH + segments[i]; IFolder folder = fragmentProject.getFolder(path); if (!folder.exists()) { folder.create(true, true, getProgressMonitor()); } } }
/* * Instruct the build manager that this project is involved in a cycle and * needs to propagate structural changes to the other projects in the cycle. */ void mustPropagateStructuralChanges() { LinkedHashSet cycleParticipants = new LinkedHashSet(3); this.javaProject.updateCycleParticipants( new ArrayList(), cycleParticipants, this.workspaceRoot, new HashSet(3), null); IPath currentPath = this.javaProject.getPath(); Iterator i = cycleParticipants.iterator(); while (i.hasNext()) { IPath participantPath = (IPath) i.next(); if (participantPath != currentPath) { IProject project = this.workspaceRoot.getProject(participantPath.segment(0)); if (hasBeenBuilt(project)) { if (DEBUG) System.out.println( "JavaBuilder: Requesting another build iteration since cycle participant " + project.getName() // $NON-NLS-1$ + " has not yet seen some structural changes"); //$NON-NLS-1$ needRebuild(); return; } } } }
private void loadState() { IPath pluginStateLocation = CVSUIPlugin.getPlugin().getStateLocation().append(REPOSITORIES_VIEW_FILE); File file = pluginStateLocation.toFile(); if (file.exists()) { try { BufferedInputStream is = new BufferedInputStream(new FileInputStream(file)); try { readState(is); } finally { is.close(); } } catch (IOException e) { CVSUIPlugin.log(IStatus.ERROR, CVSUIMessages.RepositoryManager_ioException, e); } catch (TeamException e) { CVSUIPlugin.log(e); } } else { IPath oldPluginStateLocation = CVSUIPlugin.getPlugin().getStateLocation().append(STATE_FILE); file = oldPluginStateLocation.toFile(); if (file.exists()) { try { DataInputStream dis = new DataInputStream(new FileInputStream(file)); try { readOldState(dis); } finally { dis.close(); } saveState(); file.delete(); } catch (IOException e) { CVSUIPlugin.log(IStatus.ERROR, CVSUIMessages.RepositoryManager_ioException, e); } catch (TeamException e) { CVSUIPlugin.log(e); } } } }
protected void saveState() throws TeamException { IPath pluginStateLocation = CVSUIPlugin.getPlugin().getStateLocation(); File tempFile = pluginStateLocation.append(REPOSITORIES_VIEW_FILE + ".tmp").toFile(); // $NON-NLS-1$ File stateFile = pluginStateLocation.append(REPOSITORIES_VIEW_FILE).toFile(); try { XMLWriter writer = new XMLWriter(new BufferedOutputStream(new FileOutputStream(tempFile))); try { writeState(writer); } finally { writer.close(); } if (stateFile.exists()) { stateFile.delete(); } boolean renamed = tempFile.renameTo(stateFile); if (!renamed) { throw new TeamException( new Status( IStatus.ERROR, CVSUIPlugin.ID, TeamException.UNABLE, NLS.bind( CVSUIMessages.RepositoryManager_rename, new String[] {tempFile.getAbsolutePath()}), null)); } } catch (IOException e) { throw new TeamException( new Status( IStatus.ERROR, CVSUIPlugin.ID, TeamException.UNABLE, NLS.bind( CVSUIMessages.RepositoryManager_save, new String[] {stateFile.getAbsolutePath()}), e)); } }
/** * Unzips the transferred file. Returns <code>true</code> if the unzip was successful, and <code> * false</code> otherwise. In case of failure, this method handles setting an appropriate * response. */ private boolean completeUnzip(HttpServletRequest req, HttpServletResponse resp) throws ServletException { IPath destPath = new Path(getPath()); try { ZipFile source = new ZipFile(new File(getStorageDirectory(), FILE_DATA)); IFileStore destinationRoot = NewFileServlet.getFileStore(destPath); Enumeration<? extends ZipEntry> entries = source.entries(); while (entries.hasMoreElements()) { ZipEntry entry = entries.nextElement(); IFileStore destination = destinationRoot.getChild(entry.getName()); if (entry.isDirectory()) destination.mkdir(EFS.NONE, null); else { destination.getParent().mkdir(EFS.NONE, null); IOUtilities.pipe( source.getInputStream(entry), destination.openOutputStream(EFS.NONE, null), false, true); } } source.close(); } catch (ZipException e) { // zip exception implies client sent us invalid input String msg = NLS.bind("Failed to complete file transfer on {0}", destPath.toString()); statusHandler.handleRequest( req, resp, new ServerStatus(IStatus.ERROR, HttpServletResponse.SC_BAD_REQUEST, msg, e)); return false; } catch (Exception e) { // other failures should be considered server errors String msg = NLS.bind("Failed to complete file transfer on {0}", destPath.toString()); statusHandler.handleRequest( req, resp, new ServerStatus(IStatus.ERROR, HttpServletResponse.SC_INTERNAL_SERVER_ERROR, msg, e)); return false; } return true; }
protected void doIncludeVersions(NameVersionDescriptor[] descriptions) throws Exception { String bsn = MULTI_VERSION_LOW_DESCRIPTION.getId(); IPath extras = extractMultiVersionPlugins(); ITargetDefinition target = getNewTarget(); ITargetLocation container = getTargetService().newDirectoryLocation(extras.toOSString()); target.setTargetLocations(new ITargetLocation[] {container}); target.setIncluded(descriptions); try { getTargetService().saveTargetDefinition(target); setTargetPlatform(target); IPluginModelBase[] models = PluginRegistry.getExternalModels(); Set enabled = new HashSet(); for (int i = 0; i < models.length; i++) { IPluginModelBase pm = models[i]; if (pm.getBundleDescription().getSymbolicName().equals(bsn)) { NameVersionDescriptor desc = new NameVersionDescriptor( pm.getPluginBase().getId(), pm.getPluginBase().getVersion()); if (pm.isEnabled()) { enabled.add(desc); } } } if (descriptions == null) { } else { assertEquals("Wrong number of enabled bundles", descriptions.length, enabled.size()); for (int i = 0; i < descriptions.length; i++) { assertTrue("Missing bundle", enabled.contains(descriptions[i])); } } } finally { getTargetService().deleteTarget(target.getHandle()); resetTargetPlatform(); } }
public static String getRelativePath(IPath filePath, IPath pathToGitRoot) { StringBuilder sb = new StringBuilder(); String file = null; if (!filePath.hasTrailingSeparator()) { file = filePath.lastSegment(); filePath = filePath.removeLastSegments(1); } for (int i = 0; i < pathToGitRoot.segments().length; i++) { if (pathToGitRoot.segments()[i].equals("..")) sb.append( filePath.segment(filePath.segments().length - pathToGitRoot.segments().length + i)) .append("/"); // else TODO } if (file != null) sb.append(file); return sb.toString(); }
/** Recursively walks down a directory tree and collects the paths of all git repositories. */ private static void getGitDirsInChildren(File localFile, IPath path, Map<IPath, File> gitDirs) throws CoreException { if (localFile.exists() && localFile.isDirectory()) { if (RepositoryCache.FileKey.isGitRepository(localFile, FS.DETECTED)) { gitDirs.put(path.addTrailingSeparator(), localFile); return; } else if (RepositoryCache.FileKey.isGitRepository( new File(localFile, Constants.DOT_GIT), FS.DETECTED)) { gitDirs.put(path.addTrailingSeparator(), new File(localFile, Constants.DOT_GIT)); return; } File[] folders = localFile.listFiles( new FileFilter() { public boolean accept(File file) { return file.isDirectory() && !file.getName().equals(Constants.DOT_GIT); } }); for (File folder : folders) { getGitDirsInChildren(folder, path.append(folder.getName()), gitDirs); } return; } }