* Progress cancellation is ignored while writting the cache to disk. This * is to ensure cache to disk consistency. *
* * @param monitor the progress monitor, may be null * @exception CVSException with a status with codeCOMMITTING_SYNC_INFO_FAILED
* if all the CVS sync information could not be written to disk.
*/
public void endBatching(ISchedulingRule rule, IProgressMonitor monitor) throws CVSException {
resourceLock.release(rule, monitor);
}
/* (non-Javadoc)
*
* Callback which is invoked when the batching resource lock is released
* or when a flush is requested (see beginBatching(IResource)).
*
* @see org.eclipse.team.internal.ccvs.core.syncinfo.ReentrantLock.IRunnableOnExit#run(org.eclipse.team.internal.ccvs.core.syncinfo.ReentrantLock.ThreadInfo, org.eclipse.core.runtime.IProgressMonitor)
*/
public void flush(final ThreadInfo info, IProgressMonitor monitor) throws CVSException {
if (info != null && !info.isEmpty()) {
try {
beginOperation();
ResourcesPlugin.getWorkspace().run(new IWorkspaceRunnable() {
public void run(IProgressMonitor pm) throws CoreException {
IStatus status = commitCache(info, pm);
if (!status.isOK()) {
throw new CVSException(status);
}
}
}, null, 0 /* no flags */, monitor);
} catch (CoreException e) {
throw CVSException.wrapException(e);
} finally {
endOperation();
}
}
}
/*
* Begin an access to the internal data structures of the synchronizer
*/
private void beginOperation() {
lock.acquire();
}
/*
* End an access to the internal data structures of the synchronizer
*/
private void endOperation() {
lock.release();
}
/**
* Flush the sync information from the in-memory cache to disk and purge
* the entries from the cache.
* * Recursively flushes the sync information for all resources * below the root to disk and purges the entries from memory * so that the next time it is accessed it will be retrieved from disk. * May flush more sync information than strictly needed, but never less. *
* * @param root the root of the subtree to purge * @param deep purge sync from child folders * @param monitor the progress monitor, may be null */ public void flush(IContainer root, boolean deep, IProgressMonitor monitor) throws CVSException { monitor = Policy.monitorFor(monitor); monitor.beginTask(null, 10); ISchedulingRule rule = null; try { rule = beginBatching(root, Policy.subMonitorFor(monitor, 1)); try { beginOperation(); try { // Flush changes to disk resourceLock.flush(Policy.subMonitorFor(monitor, 8)); } finally { // Purge the in-memory cache sessionPropertyCache.purgeCache(root, deep); } } finally { endOperation(); } } finally { if (rule != null) endBatching(rule, Policy.subMonitorFor(monitor, 1)); monitor.done(); } } public void deconfigure(final IProject project, IProgressMonitor monitor) throws CVSException { monitor = Policy.monitorFor(monitor); monitor.beginTask(null, 100); ISchedulingRule rule = null; try { rule = beginBatching(project, Policy.subMonitorFor(monitor, 10)); // Flush flush(project, true /* deep */, Policy.subMonitorFor(monitor, 80)); // forget about pruned folders however the top level pruned folder will have resource sync (e.g. // a line in the Entry file). As a result the folder is managed but is not a CVS folder. synchronizerCache.purgeCache(project, true); } finally { if (rule != null) endBatching(rule, Policy.subMonitorFor(monitor, 10)); monitor.done(); } } /** * Called to notify the synchronizer that meta files have changed on disk, outside * of the workbench. The cache will be flushed for this folder and it's immediate * children and appropriate state change events are broadcasts to state change * listeners. */ public void ignoreFilesChanged(IContainer[] roots) throws CVSException { for (int i = 0; i < roots.length; i++) { IContainer container = roots[i]; ISchedulingRule rule = null; try { Set changed = new HashSet(); rule = beginBatching(container, null); try { beginOperation(); changed.addAll(Arrays.asList( sessionPropertyCache.purgeCache(container, false /*don't flush children*/))); } finally { endOperation(); } if (!changed.isEmpty()) { ResourceStateChangeListeners.getListener().resourceSyncInfoChanged( (IResource[]) changed.toArray(new IResource[changed.size()])); } } finally { if (rule != null) endBatching(rule, null); } } } public void syncFilesChangedExternally(IContainer[] changedMetaFiles, IFile[] externalDeletions) throws CVSException { List changed = new ArrayList(); for (int i = 0; i < changedMetaFiles.length; i++) { IContainer container = changedMetaFiles[i]; if (!isWithinActiveOperationScope(container)) { changed.addAll(Arrays.asList( sessionPropertyCache.purgeCache(container, false /*don't flush children*/))); } } for (int i = 0; i < externalDeletions.length; i++) { IFile file = externalDeletions[i]; if (!isWithinActiveOperationScope(file)) { sessionPropertyCache.purgeCache(file.getParent(), false /*don't flush children*/); changed.add(file); } } if (!changed.isEmpty()) { ResourceStateChangeListeners.getListener().externalSyncInfoChange( (IResource[]) changed.toArray(new IResource[changed.size()])); } } /* * The resource is about to be deleted by the move delete hook. * In all cases (except when the resource doesn't exist), this method * will indicate that the dirty state of the parent needs to be recomputed. * For managed resources, it will move the cached sync info from the session * property cache into the sycnrhonizer cache, purging the session cache. * @param resource the resource about to be deleted. ** Note taht this method is not recursive. Hence, for managed resources * * @returns whether children need to be prepared * @throws CVSException */ /* private */ boolean prepareForDeletion(IResource resource) throws CVSException { if (!resource.exists()) return false; ISchedulingRule rule = null; try { rule = beginBatching(resource, null); try { beginOperation(); // Flush the dirty info for the resource and it's ancestors. // Although we could be smarter, we need to do this because the // deletion may fail. adjustDirtyStateRecursively(resource, RECOMPUTE_INDICATOR); if (resource.getType() == IResource.FILE) { byte[] syncBytes = getSyncBytes(resource); if (syncBytes != null) { if (ResourceSyncInfo.isAddition(syncBytes)) { deleteResourceSync(resource); } else { syncBytes = convertToDeletion(syncBytes); synchronizerCache.setCachedSyncBytes(resource, syncBytes, true); } sessionPropertyCache.purgeResourceSyncCache(resource); resourceChanged(resource); } return false; } else { IContainer container = (IContainer)resource; if (container.getType() == IResource.PROJECT) { synchronizerCache.flush((IProject)container); return false; } else { // Move the folder sync info into phantom space FolderSyncInfo info = getFolderSync(container); if (info == null) return false; synchronizerCache.setCachedFolderSync(container, info, true); folderChanged(container); // move the resource sync as well byte[] syncBytes = getSyncBytes(resource); synchronizerCache.setCachedSyncBytes(resource, syncBytes, true); sessionPropertyCache.purgeResourceSyncCache(container); sessionPropertyCache.purgeCache(container, false); return true; } } } finally { endOperation(); } } finally { if (rule != null) endBatching(rule, null); } } /** * The resource has been deleted. Make sure any cached state is cleared. * This is needed because the move/delete hook is not invoked in all situations * (e.g. external deletion). * * @param resource * @throws CVSException */ protected void handleDeleted(IResource resource) throws CVSException { if (resource.exists()) return; try { beginOperation(); adjustDirtyStateRecursively(resource, RECOMPUTE_INDICATOR); } finally { endOperation(); } } /** * Prepare for the deletion of the target resource from within * the move/delete hook. The method is invoked by both the * deleteFile/Folder methods and for the source resource * of moveFile/Folder. This method will move the cached sync info * into the phantom (ISynchronizer) cache so that outgoing deletions * and known remote folders are preserved. * * @param resource * @param monitor * @throws CVSException */ public void prepareForDeletion(IResource resource, IProgressMonitor monitor) throws CVSException { // Move sync info to phantom space for the resource and all it's children monitor = Policy.monitorFor(monitor); try { beginOperation(); monitor.beginTask(null, 100); try { resource.accept(new IResourceVisitor() { public boolean visit(IResource innerResource) throws CoreException { try { return prepareForDeletion(innerResource); } catch (CVSException e) { CVSProviderPlugin.log(e); throw new CoreException(e.getStatus()); } } }); } catch (CoreException e) { throw CVSException.wrapException(e); } } finally { endOperation(); monitor.done(); } } /** * If not already cached, loads and caches the resource sync for the children of the container. * Folder must exist and must not be the workspace root. * * @param container the container */ private void cacheResourceSyncForChildren(IContainer container, boolean canModifyWorkspace) throws CVSException { // don't try to load if the information is already cached if (! getSyncInfoCacheFor(container).isResourceSyncInfoCached(container)) { // load the sync info from disk byte[][] infos; // do not load the sync info for resources that are linked if (isLinkedResource(container)) { infos = null; } else { infos = SyncFileWriter.readAllResourceSync(container); } if (infos != null) { for (int i = 0; i < infos.length; i++) { byte[] syncBytes = infos[i]; IPath name = new Path(getName(syncBytes)); IResource resource; if (isFolder(syncBytes)) { resource = container.getFolder(name); } else { resource = container.getFile(name); } getSyncInfoCacheFor(resource).setCachedSyncBytes(resource, syncBytes, canModifyWorkspace); } } getSyncInfoCacheFor(container).setResourceSyncInfoCached(container); } } /** * If not already cached, loads and caches the folder sync for the * container. Folder must exist and must not be the workspace root. * * @param container the container */ private void cacheFolderSync(IContainer container) throws CVSException { // don't try to load if the information is already cached if (! getSyncInfoCacheFor(container).isFolderSyncInfoCached(container)) { // load the sync info from disk FolderSyncInfo info; // do not load the sync info for resources that are linked if (isLinkedResource(container)) { info = null; } else { info = SyncFileWriter.readFolderSync(container); } getSyncInfoCacheFor(container).setCachedFolderSync(container, info, false); } } private boolean isLinkedResource(IResource resource) { return CVSWorkspaceRoot.isLinkedResource(resource); } /** * Load the sync info for the given resource from disk * @param resource * @return byte[] */ private byte[] getSyncBytesFromDisk(IResource resource) throws CVSException { byte[][] infos = SyncFileWriter.readAllResourceSync(resource.getParent()); if (infos == null) return null; for (int i = 0; i < infos.length; i++) { byte[] syncBytes = infos[i]; if (resource.getName().equals(getName(syncBytes))) { return syncBytes; } } return null; } /** * Commits the cache after a series of operations. * * Will return STATUS_OK unless there were problems writting sync * information to disk. If an error occurs a multistatus is returned * with the list of reasons for the failures. Failures are recovered, * and all changed resources are given a chance to be written to disk. * * @param monitor the progress monitor, may be null */ /* internal use only */ IStatus commitCache(ThreadInfo threadInfo, IProgressMonitor monitor) { if (threadInfo.isEmpty()) { return SyncInfoCache.STATUS_OK; } List errors = new ArrayList(); try { /*** prepare operation ***/ // find parents of changed resources IResource[] changedResources = threadInfo.getChangedResources(); IContainer[] changedFolders = threadInfo.getChangedFolders(); Set dirtyParents = new HashSet(); for (int i = 0; i < changedResources.length; i++) { IResource resource = changedResources[i]; IContainer folder = resource.getParent(); dirtyParents.add(folder); } monitor = Policy.monitorFor(monitor); int numDirty = dirtyParents.size(); int numResources = changedFolders.length + numDirty; monitor.beginTask(null, numResources); if(monitor.isCanceled()) { monitor.subTask(Policy.bind("EclipseSynchronizer.UpdatingSyncEndOperationCancelled")); //$NON-NLS-1$ } else { monitor.subTask(Policy.bind("EclipseSynchronizer.UpdatingSyncEndOperation")); //$NON-NLS-1$ } /*** write sync info to disk ***/ // folder sync info changes for (int i = 0; i < changedFolders.length; i++) { IContainer folder = changedFolders[i]; if (folder.exists() && folder.getType() != IResource.ROOT) { try { FolderSyncInfo info = sessionPropertyCache.getCachedFolderSync(folder); // Do not write the folder sync for linked resources if (info == null) { // deleted folder sync info since we loaded it // (but don't overwrite the sync info for linked folders if (!isLinkedResource(folder)) SyncFileWriter.deleteFolderSync(folder); dirtyParents.remove(folder); } else { // modified or created new folder sync info since we loaded it SyncFileWriter.writeFolderSync(folder, info); } } catch(CVSException e) { try { sessionPropertyCache.purgeCache(folder, true /* deep */); } catch(CVSException pe) { errors.add(pe.getStatus()); } errors.add(e.getStatus()); } } monitor.worked(1); } // update progress for parents we will skip because they were deleted monitor.worked(numDirty - dirtyParents.size()); // resource sync info changes for (Iterator it = dirtyParents.iterator(); it.hasNext();) { IContainer folder = (IContainer) it.next(); if (folder.exists() && folder.getType() != IResource.ROOT) { // write sync info for all children in one go try { List infos = new ArrayList(); IResource[] children = folder.members(true); for (int i = 0; i < children.length; i++) { IResource resource = children[i]; byte[] syncBytes = getSyncBytes(resource); if (syncBytes != null) { infos.add(syncBytes); } } // do not overwrite the sync info for linked resources if (infos.size() > 0 || !isLinkedResource(folder)) SyncFileWriter.writeAllResourceSync(folder, (byte[][]) infos.toArray(new byte[infos.size()][])); } catch(CVSException e) { try { sessionPropertyCache.purgeCache(folder, false /* depth 1 */); } catch(CVSException pe) { errors.add(pe.getStatus()); } errors.add(e.getStatus()); } catch (CoreException e) { try { sessionPropertyCache.purgeCache(folder, false /* depth 1 */); } catch(CVSException pe) { errors.add(pe.getStatus()); } errors.add(e.getStatus()); } } monitor.worked(1); } /*** broadcast events ***/ monitor.subTask(Policy.bind("EclipseSynchronizer.NotifyingListeners")); //$NON-NLS-1$ Set allChanges = new HashSet(); allChanges.addAll(Arrays.asList(changedResources)); allChanges.addAll(Arrays.asList(changedFolders)); allChanges.addAll(dirtyParents); IResource[] resources = (IResource[]) allChanges.toArray( new IResource[allChanges.size()]); broadcastResourceStateChanges(resources); if ( ! errors.isEmpty()) { MultiStatus status = new MultiStatus(CVSProviderPlugin.ID, CVSStatus.COMMITTING_SYNC_INFO_FAILED, Policy.bind("EclipseSynchronizer.ErrorCommitting"), //$NON-NLS-1$ null); for (int i = 0; i < errors.size(); i++) { status.merge((IStatus)errors.get(i)); } return status; } return SyncInfoCache.STATUS_OK; } finally { monitor.done(); } } /** * Broadcasts the resource state changes for the given resources to CVS Provider Plugin */ void broadcastResourceStateChanges(IResource[] resources) { if (resources.length > 0) { ResourceStateChangeListeners.getListener().resourceSyncInfoChanged(resources); } } /** * Returns the resource sync info for the resource; null if none. * Parent must exist and must not be the workspace root. * The resource sync info for the children of the parent container MUST ALREADY BE CACHED. * * @param resource the resource * @return the resource sync info for the resource, or null * @see #cacheResourceSyncForChildren */ private byte[] getCachedSyncBytes(IResource resource) throws CVSException { return getSyncInfoCacheFor(resource).getCachedSyncBytes(resource); } /** * Returns the resource sync info for the resource; null if none. * Parent must exist and must not be the workspace root. * The resource sync info for the children of the parent container MUST ALREADY BE CACHED. * * @param resource the resource * @return the resource sync info for the resource, or null * @see #cacheResourceSyncForChildren */ private void setCachedSyncBytes(IResource resource, byte[] syncBytes) throws CVSException { getSyncInfoCacheFor(resource).setCachedSyncBytes(resource, syncBytes, true); resourceChanged(resource); } /** * Sets the resource sync info for the resource; if null, deletes it. Parent * must exist and must not be the workspace root. The resource sync info for * the children of the parent container MUST ALREADY BE CACHED. * * @param resource the resource * @param info the new resource sync info * @see #cacheResourceSyncForChildren */ private void setCachedResourceSync(IResource resource, ResourceSyncInfo info) throws CVSException { //todo byte[] syncBytes = null; if (info != null) syncBytes = info.getBytes(); getSyncInfoCacheFor(resource).setCachedSyncBytes(resource, syncBytes, true); } /** * If not already cached, loads and caches the folder ignores sync for the container. * Folder must exist and must not be the workspace root. * * @param container the container * @return the folder ignore patterns, or an empty array if none */ private FileNameMatcher cacheFolderIgnores(IContainer container) throws CVSException { return sessionPropertyCache.cacheFolderIgnores(container); } /** * Sets the array of folder ignore patterns for the container, must not be null. * Folder must exist and must not be the workspace root. * * @param container the container * @param ignores the array of ignore patterns */ private void setCachedFolderIgnores(IContainer container, String[] ignores) throws CVSException { sessionPropertyCache.setCachedFolderIgnores(container, ignores); } /* * Recursively adds to the possibleIgnores list all children of the given * folder that can be ignored. This method may only be invoked when a * schedling rule for the given foldr is held and when the CVs sync lock is * held. * * @param folder the folder to be searched * @param possibleIgnores the list of IResources that can be ignored */ private void accumulateNonManagedChildren(IContainer folder, List possibleIgnores) throws CVSException { try { cacheResourceSyncForChildren(folder, true /* can modify workspace */); IResource[] children = folder.members(); List folders = new ArrayList(); // deal with all files first and then folders to be otimized for caching scheme for (int i = 0; i < children.length; i++) { IResource child = children[i]; if(getCachedSyncBytes(child)==null) { possibleIgnores.add(child); } if(child.getType()!=IResource.FILE) { folders.add(child); } } for (Iterator iter = folders.iterator(); iter.hasNext();) { IContainer child = (IContainer) iter.next(); accumulateNonManagedChildren(child, possibleIgnores); } } catch(CoreException e) { throw CVSException.wrapException(e); } } /** * Add the entry to the CVS/Notify file. We are not initially concerned with efficiency * since edit/unedit are typically issued on a small set of files. * * XXX If there was a previous notify entry for the resource, it is replaced. This is * probably not the proper behavior (see EclipseFile). * * A value of null for info indicates that any entry for the given * resource is to be removed from the Notify file. * * @param resource * @param info */ public void setNotifyInfo(IResource resource, NotifyInfo info) throws CVSException { NotifyInfo[] infos = SyncFileWriter.readAllNotifyInfo(resource.getParent()); if (infos == null) { // if the file is empty and we are removing an entry, just return; if (info == null) return; infos = new NotifyInfo[] { info }; } else { Map infoMap = new HashMap(); for (int i = 0; i < infos.length; i++) { NotifyInfo notifyInfo = infos[i]; infoMap.put(notifyInfo.getName(), notifyInfo); } if (info == null) { // if the info is null, remove the entry infoMap.remove(resource.getName()); } else { // add the new entry to the list infoMap.put(info.getName(), info); } NotifyInfo[] newInfos = new NotifyInfo[infoMap.size()]; int i = 0; for (Iterator iter = infoMap.values().iterator(); iter.hasNext();) { newInfos[i++] = (NotifyInfo) iter.next(); } infos = newInfos; } SyncFileWriter.writeAllNotifyInfo(resource.getParent(), infos); } /** * Method getNotifyInfo. * @param resource * @return NotifyInfo */ public NotifyInfo getNotifyInfo(IResource resource) throws CVSException { NotifyInfo[] infos = SyncFileWriter.readAllNotifyInfo(resource.getParent()); if (infos == null) return null; for (int i = 0; i < infos.length; i++) { NotifyInfo notifyInfo = infos[i]; if (notifyInfo.getName().equals(resource.getName())) { return notifyInfo; } } return null; } /** * Method deleteNotifyInfo. * @param resource */ public void deleteNotifyInfo(IResource resource) throws CVSException { NotifyInfo[] infos = SyncFileWriter.readAllNotifyInfo(resource.getParent()); if (infos == null) return; Map infoMap = new HashMap(); for (int i = 0; i < infos.length; i++) { NotifyInfo notifyInfo = infos[i]; infoMap.put(notifyInfo.getName(), notifyInfo); } infoMap.remove(resource.getName()); NotifyInfo[] newInfos = new NotifyInfo[infoMap.size()]; int i = 0; for (Iterator iter = infoMap.values().iterator(); iter.hasNext();) { newInfos[i++] = (NotifyInfo) iter.next(); } SyncFileWriter.writeAllNotifyInfo(resource.getParent(), newInfos); } /** * Add the entry to the CVS/Baserev file. We are not initially concerned * with efficiency since edit/unedit are typically issued on a small set of * files. * * XXX If there was a previous notify entry for the resource, it is replaced. This is * probably not the proper behavior (see EclipseFile). * * @param resource * @param info */ public void setBaserevInfo(IResource resource, BaserevInfo info) throws CVSException { BaserevInfo[] infos = SyncFileWriter.readAllBaserevInfo(resource.getParent()); if (infos == null) { infos = new BaserevInfo[] { info }; } else { Map infoMap = new HashMap(); for (int i = 0; i < infos.length; i++) { infoMap.put(infos[i].getName(), infos[i]); } infoMap.put(info.getName(), info); BaserevInfo[] newInfos = new BaserevInfo[infoMap.size()]; int i = 0; for (Iterator iter = infoMap.values().iterator(); iter.hasNext();) { newInfos[i++] = (BaserevInfo) iter.next(); } infos = newInfos; } SyncFileWriter.writeAllBaserevInfo(resource.getParent(), infos); } /** * Method getBaserevInfo. * @param resource * @return BaserevInfo */ public BaserevInfo getBaserevInfo(IResource resource) throws CVSException { BaserevInfo[] infos = SyncFileWriter.readAllBaserevInfo(resource.getParent()); if (infos == null) return null; for (int i = 0; i < infos.length; i++) { BaserevInfo info = infos[i]; if (info.getName().equals(resource.getName())) { return info; } } return null; } /** * Method deleteNotifyInfo. * @param resource */ public void deleteBaserevInfo(IResource resource) throws CVSException { BaserevInfo[] infos = SyncFileWriter.readAllBaserevInfo(resource.getParent()); if (infos == null) return; Map infoMap = new HashMap(); for (int i = 0; i < infos.length; i++) { infoMap.put(infos[i].getName(), infos[i]); } infoMap.remove(resource.getName()); BaserevInfo[] newInfos = new BaserevInfo[infoMap.size()]; int i = 0; for (Iterator iter = infoMap.values().iterator(); iter.hasNext();) { newInfos[i++] = (BaserevInfo) iter.next(); } SyncFileWriter.writeAllBaserevInfo(resource.getParent(), newInfos); } public void copyFileToBaseDirectory(final IFile file, IProgressMonitor monitor) throws CVSException { monitor = Policy.monitorFor(monitor); monitor.beginTask(null, 100); ISchedulingRule rule = null; try { rule = beginBatching(file, Policy.subMonitorFor(monitor, 10)); ResourceSyncInfo info = getResourceSync(file); // The file must exist remotely and locally if (info == null || info.isAdded() || info.isDeleted()) return; SyncFileWriter.writeFileToBaseDirectory(file, Policy.subMonitorFor(monitor, 80)); resourceChanged(file); } finally { if (rule != null) endBatching(rule, Policy.subMonitorFor(monitor, 10)); monitor.done(); } } public void restoreFileFromBaseDirectory(final IFile file, IProgressMonitor monitor) throws CVSException { monitor = Policy.monitorFor(monitor); monitor.beginTask(null, 100); ISchedulingRule rule = null; try { rule = beginBatching(file, Policy.subMonitorFor(monitor, 10)); ResourceSyncInfo info = getResourceSync(file); // The file must exist remotely if (info == null || info.isAdded()) return; SyncFileWriter.restoreFileFromBaseDirectory(file, Policy.subMonitorFor(monitor, 80)); resourceChanged(file); } finally { if (rule != null) endBatching(rule, Policy.subMonitorFor(monitor, 10)); monitor.done(); } } public void deleteFileFromBaseDirectory(final IFile file, IProgressMonitor monitor) throws CVSException { ResourceSyncInfo info = getResourceSync(file); // The file must exist remotely if (info == null || info.isAdded()) return; SyncFileWriter.deleteFileFromBaseDirectory(file, monitor); } /** * Method isSyncInfoLoaded returns true if all the sync info for the * provided resources is loaded into the internal cache. * * @param resources * @param i * @return boolean */ public boolean isSyncInfoLoaded(IResource[] resources, int depth) throws CVSException { // get the folders involved IContainer[] folders = getParentFolders(resources, depth); // for all folders that have a CVS folder, ensure the sync info is cached for (int i = 0; i < folders.length; i++) { IContainer parent = folders[i]; if (!getSyncInfoCacheFor(parent).isSyncInfoLoaded(parent)) { return false; } } return true; } /** * Method ensureSyncInfoLoaded loads all the relevent sync info into the cache. * This method can only be invoked when the workspace is open for modification. * in other words it cannot be invoked from inside a POST_CHANGE delta listener. * @param resources * @param i * @return Object */ public void ensureSyncInfoLoaded(IResource[] resources, int depth) throws CVSException { // get the folders involved IContainer[] folders = getParentFolders(resources, depth); // Cache the sync info for all the folders for (int i = 0; i < folders.length; i++) { IContainer parent = folders[i]; ISchedulingRule rule = null; try { rule = beginBatching(parent, null); try { beginOperation(); cacheResourceSyncForChildren(parent, true /* can modify workspace */); cacheFolderSync(parent); cacheFolderIgnores(parent); } finally { endOperation(); } } finally { if (rule != null) endBatching(rule, null); } } } /* * Collect the projects and parent folders of the resources since * thats were the sync info is kept. */ private IContainer[] getParentFolders(IResource[] resources, int depth) throws CVSException { final Set folders = new HashSet(); for (int i = 0; i < resources.length; i++) { IResource resource = resources[i]; folders.add(resource.getProject()); if (resource.getType() != IResource.PROJECT) { folders.add(resource.getParent()); } // use the depth to gather child folders when appropriate if (depth != IResource.DEPTH_ZERO) { try { resource.accept(new IResourceVisitor() { public boolean visit(IResource innerResource) throws CoreException { if (innerResource.getType() == IResource.FOLDER) folders.add(innerResource); // let the depth determine who we visit return true; } }, depth, false); } catch (CoreException e) { throw CVSException.wrapException(e); } } } return (IContainer[]) folders.toArray(new IContainer[folders.size()]); } /** * Perform sync info batching within the context of the given resource * scheduling rule while running the given ICVSRunnable. * @param runnable * @param monitor * @throws CVSException */ public void run(ISchedulingRule resourceRule, ICVSRunnable runnable, IProgressMonitor monitor) throws CVSException { monitor = Policy.monitorFor(monitor); monitor.beginTask(null, 100); ISchedulingRule rule = beginBatching(resourceRule, Policy.subMonitorFor(monitor, 10)); try { runnable.run(Policy.subMonitorFor(monitor, 80)); } finally { if (rule != null) endBatching(rule, Policy.subMonitorFor(monitor, 10)); monitor.done(); } } /** * This method is invoked from the IMoveDeleteHook to batch the resulting sync file * changes. */ public void run(ICVSRunnable runnable, IProgressMonitor monitor) throws CVSException { // Use the root resource as the rule. // Note: This will not lock the workspace due to behavior in ReentrantLock IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot(); run(root, runnable, monitor); } /** * Method isEdited returns true if a "cvs edit" was performed on the given * file and no commit or unedit has yet been performed. * @param iResource * @return boolean */ public boolean isEdited(IFile resource) throws CVSException { return SyncFileWriter.isEdited(resource); } private void adjustDirtyStateRecursively(IResource resource, String indicator) throws CVSException { if (resource.getType() == IResource.ROOT) return; try { beginOperation(); if (indicator == getDirtyIndicator(resource)) { return; } if (Policy.DEBUG_DIRTY_CACHING) { debug(resource, indicator, "adjusting dirty state"); //$NON-NLS-1$ } getSyncInfoCacheFor(resource).setDirtyIndicator(resource, indicator); IContainer parent = resource.getParent(); if(indicator == NOT_DIRTY_INDICATOR) { adjustDirtyStateRecursively(parent, RECOMPUTE_INDICATOR); } if(indicator == RECOMPUTE_INDICATOR) { adjustDirtyStateRecursively(parent, RECOMPUTE_INDICATOR); } if(indicator == IS_DIRTY_INDICATOR) { adjustDirtyStateRecursively(parent, indicator); } } finally { endOperation(); } } protected String getDirtyIndicator(IResource resource) throws CVSException { try { beginOperation(); return getSyncInfoCacheFor(resource).getDirtyIndicator(resource); } finally { endOperation(); } } /* * Mark the given resource as either modified or clean using a persistant * property. Do nothing if the modified state is already what we want. * Return true if the modification state was changed. */ protected void setDirtyIndicator(IResource resource, boolean modified) throws CVSException { String indicator = modified ? IS_DIRTY_INDICATOR : NOT_DIRTY_INDICATOR; // set the dirty indicator and adjust the parent accordingly adjustDirtyStateRecursively(resource, indicator); } /** * Method getName. * @param syncBytes */ private String getName(byte[] syncBytes) throws CVSException { return ResourceSyncInfo.getName(syncBytes); } /** * Method isFolder. * @param syncBytes * @return boolean */ private boolean isFolder(byte[] syncBytes) { return ResourceSyncInfo.isFolder(syncBytes); } /** * Method convertToDeletion. * @param syncBytes * @return byte[] */ private byte[] convertToDeletion(byte[] syncBytes) throws CVSException { return ResourceSyncInfo.convertToDeletion(syncBytes); } /** * Method createdByMove clears any session properties on the file so it * appears as an ADDED file. * * @param destination */ public void createdByMove(IFile file) throws CVSException { deleteResourceSync(file); } static public void debug(IResource resource, String indicator, String string) { String di = EclipseSynchronizer.IS_DIRTY_INDICATOR; if(indicator == EclipseSynchronizer.IS_DIRTY_INDICATOR) { di = "dirty"; //$NON-NLS-1$ } else if(indicator == EclipseSynchronizer.NOT_DIRTY_INDICATOR) { di = "clean"; //$NON-NLS-1$ } else { di = "needs recomputing"; //$NON-NLS-1$ } System.out.println("["+string + ":" + di + "] " + resource.getFullPath()); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ } static public void debug(IResource resource, boolean modified, String string) { debug(resource, modified ? IS_DIRTY_INDICATOR : NOT_DIRTY_INDICATOR, string); } /** * @param file * @return int */ public int getModificationState(IResource resource) throws CVSException { String indicator = getDirtyIndicator(resource); if (Policy.DEBUG_DIRTY_CACHING) { debug(resource, indicator, "getModificationState"); //$NON-NLS-1$ } if (indicator == null || indicator == RECOMPUTE_INDICATOR) { return ICVSFile.UNKNOWN; } else if (indicator == IS_DIRTY_INDICATOR) { return ICVSFile.DIRTY; } else if (indicator == NOT_DIRTY_INDICATOR) { return ICVSFile.CLEAN; } else { return ICVSFile.UNKNOWN; } } /** * Return whether the resource is within the scope of a currently active * CVS operation. * @param resource * @return */ public boolean isWithinActiveOperationScope(IResource resource) { return resourceLock.isWithinActiveOperationScope(resource); } public void setTimeStamp(IFile file, long time) throws CVSException { ISchedulingRule rule = null; try { rule = beginBatching(file, null); try { beginOperation(); try { file.setLocalTimeStamp(time); } catch (CoreException e) { throw CVSException.wrapException(e); } resourceChanged(file); } finally { endOperation(); } } finally { if (rule != null) endBatching(rule, null); } } /** * React to a resource that was just moved by the move/delete hook. * @param resource the resource that was moved (at its new location) */ public void postMove(IResource resource) throws CVSException { try { beginOperation(); if (resource.getType() == IResource.FILE) { // Purge any copied sync info so true sync info will // be obtained from the synchronizer cache sessionPropertyCache.purgeResourceSyncCache(resource); } else { IContainer container = (IContainer)resource; // Purge any copied sync info sessionPropertyCache.purgeCache(container, true /* deep */); // Dirty all resources so old sync info will be rewritten to disk try { container.accept(new IResourceVisitor() { public boolean visit(IResource resource) throws CoreException { if (getSyncBytes(resource) != null) { resourceChanged(resource); } if (resource.getType() != IResource.FILE) { if (getFolderSync((IContainer)resource) != null) { folderChanged((IContainer)resource); return true; } } return false; } }); } catch (CoreException e) { throw CVSException.wrapException(e); } // Flush the sync info to disk flush(container, true /* deep */, null); } } finally { endOperation(); } } /** * This method is to be invoked only from the move/delete hook. It's purpose * is to obtain the sync look in order to prevent other threads from accessing * sync info while the move/delete is taking place. * @param runnable * @param monitor * @throws CVSException */ public void performMoveDelete(ICVSRunnable runnable, IProgressMonitor monitor) throws CVSException { ISchedulingRule rule = null; try { monitor.beginTask(null, 100); rule = beginBatching(null, null); try { beginOperation(); runnable.run(Policy.subMonitorFor(monitor, 95)); } finally { endOperation(); } } finally { if (rule != null) endBatching(rule, Policy.subMonitorFor(monitor, 5)); monitor.done(); } } }