Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package ca.carleton.gcrc.couch.command.impl;
  
  import java.io.File;
  import java.util.HashSet;
  import java.util.List;
  import java.util.Set;
  import java.util.Vector;
 
 public class UpgradeProcess {
 
 	public UpgradeReport computeUpgrade(File newFilesFile targetDirFileSetManifest installedManifestthrows Exception {
 		UpgradeReport report =  new UpgradeReport();
 		report.setInstalledFileSetManifest(installedManifest);
 		
 		FileSetManifest upgradedManifest = FileSetManifest.fromDirectory(newFiles);
 		report.setUpgradeFileSetManifest(upgradedManifest);
 
 		DigestComputerSha1 digestComputer = new DigestComputerSha1();
 		
 		// Detect added and upgraded files
 		Set<StringrelevantPaths = new HashSet<String>();
 		for(FileManifest upgraded : upgradedManifest.getAllFileManifest()){
 			String path = upgraded.getRelativePath();
 			relevantPaths.add(path);
 
 			FileManifest installed = installedManifest.getFileManifest(path);
 			ifnull == installed ) {
 				// New file
 				report.addAddedPath(path);
 			} else iffalse == upgraded.equals(installed) ) {
 				// Upgraded file
 				report.addUpgradedPath(path);
 			}
 		}
 		
 		// Detect deleted files
 		for(FileManifest installed : installedManifest.getAllFileManifest()){
 			String path = installed.getRelativePath();
 
 			FileManifest upgraded = upgradedManifest.getFileManifest(path);
 			ifnull == upgraded ) {
 				// Deleted file
 				relevantPaths.add(path);
 				report.addDeletedPath(path);
 			}
 		}
 		
 		// Construct a relevant manifest of what is found on disk
 		FileSetManifest diskManifest = new FileSetManifest();
 		report.setDiskFileSetManifest(diskManifest);
 		for(String path : relevantPaths){
 			File targetFile = new File(targetDir,path);
 			
 			iftargetFile.exists() ) {
 				FileManifest fileManifest = new FileManifest();
 				fileManifest.setRelativePath(path);
 				iftargetFile.isDirectory() ){
 					fileManifest.setDirectory(true);
 				} else {
 					try {
 						String digest = digestComputer.computeDocumentDigest(targetFile);
 						fileManifest.setDigest(digest);
 					} catch(Exception e) {
 						throw new Exception("Error while computing digest on file: "+targetFile.getAbsolutePath(), e);
 					}
 				}
 				
 				diskManifest.addFileManifest(fileManifest);
 			}
 		}
 		
 		// Only files that were not changed can be deleted
 		for(String path : report.getDeletedPaths()){
 			FileManifest installed = installedManifest.getFileManifest(path);
 			FileManifest disk = diskManifest.getFileManifest(path);
 			
 			// If file is already deleted, then its OK
 			ifnull == disk ) {
 				// OK
 				report.addPathToAssumeUpgraded(path);
 				
 			} else ifinstalled.equals(disk) ) {
 				// This path can be deleted
 				ifinstalled.isDirectory() ) {
 					report.addDirectoryToBeDeleted(path);
 				} else {
 					report.addFileToBeDeleted(path);
 				}
 			} else {
 				// At this point, the element on disk is different
 				// then the element in the installed manifest
 				UpgradeCollision collision = new UpgradeCollision(
 						,path
 						,null
 						,installed
 						,disk
					);
				report.addCollision(collision);
			}
		}
		// Only files that are not present can be added, unless they
		// are exactly the same
		for(String path : report.getAddedPaths()){
			FileManifest upgraded = upgradedManifest.getFileManifest(path);
			FileManifest disk = diskManifest.getFileManifest(path);
			// Check if it exists on disk
			ifnull == disk ) {
				// Normal case: it is not located on disk
				// Add file or directory
				ifupgraded.isDirectory() ) {
else {
					report.addFileToBeAdded(path);
				}
else ifupgraded.equals(disk) ) {
				// What is found on disk is exactly the same
				// as what the upgrade would do. Therefore, simply
				// assume that the file was installed without performing
				// any operations on the element
else {
				// Collision
						,path
						,upgraded
						,null
						,disk
					);
				report.addCollision(collision);
			}
		}
		// Upgrade files that were not changed
		for(String path : report.getUpgradedPaths()){
			FileManifest installed = installedManifest.getFileManifest(path);
			FileManifest upgrade = upgradedManifest.getFileManifest(path);
			FileManifest disk = diskManifest.getFileManifest(path);
			// If file was deleted, then we do not need to upgrade
			// This is a special kind of collision since this is a file that was
			// deliberately removed from the atlas
			ifnull == disk ) {
						,path
						,upgrade
						,null
						,disk
					);
				report.addCollision(collision);
				// Assume the manifest of the upgrade for this file, because this is 
				// equivalent as if the user had installed the latest upgrade and then 
				// deleted the file
else ifinstalled.equals(disk) ) {
				// User has not changed what was installed
				// Check if type is changed during upgrade
				ifupgrade.isDirectory() != disk.isDirectory() ) {
					ifdisk.isDirectory() ) {
						report.addFileToBeAdded(path);
else {
						// Disk is file, upgrade is directory
						report.addFileToBeDeleted(path);
					}
else {
					// Type was not changed. Therefore, this is a file that
					// needs upgrading
					report.addFileToBeUpgraded(path);
				}
else ifupgrade.equals(disk) ) {
				// The user has modified the disk version, but it is the same as
				// what is found in the upgrade. Therefore, no changes to the element
				// is required. Just assume that the upgrade was installed.
else {
				// What is found on disk is not the same as what was found
				// in the install manifest. Furthermore, the upgrade is different
				// than what is found on disk. Therefore, this is a collision.
						,path
						,upgrade
						,installed
						,disk
					);
				report.addCollision(collision);
			}
		}
		return report;
	}
	public void performUpgrade(
		,UpgradeOperations operations
throws Exception {
		try {
			FileSetManifest resultingInstalledManifest = 
			// Assumed upgrades
			{
				for(String path : report.getPathsToAssumeUpgraded()){
					ifnull == upgrade ) {
						resultingInstalledManifest.removeFileManifest(path);
else {
						resultingInstalledManifest.addFileManifest(upgrade);
					}
				}
				operations.saveInstalledManifest(resultingInstalledManifest);
			}
			// Delete files
			for(String path : report.getFilesToBeDeleted()){
				operations.deleteFile(path);
				// After each file removal, update installed manifest to reflect
				// current state in case process is aborted
				resultingInstalledManifest.removeFileManifest(path);
				operations.saveInstalledManifest(resultingInstalledManifest);
			}
			// Delete directories
			{
				// Delete longest paths first. This ensures that sub-dirs
				// are removed before a parent
				List<StringorderedPaths = new Vector<String>(report.getDirectoriesToBeDeleted());
				Collections.sort(orderedPathsnew Comparator<String>(){
					public int compare(String s0String s1) {
						return s1.length() - s0.length();
					}
				});
				for(String path : orderedPaths){
					operations.deleteDirectory(path);
					// After each directory removal, update installed manifest to reflect
					// current state in case process is aborted
					resultingInstalledManifest.removeFileManifest(path);
					operations.saveInstalledManifest(resultingInstalledManifest);
				}
			}
			// Add directories
			{
				// Add shortest paths first. This ensures that sub-dirs
				// are added after a parent
				List<StringorderedPaths = new Vector<String>(report.getDirectoriesToBeAdded());
				Collections.sort(orderedPathsnew Comparator<String>(){
					public int compare(String s0String s1) {
						return s0.length() - s1.length();
					}
				});
				for(String path : orderedPaths){
					operations.addDirectory(path);
					// After each directory creation, update installed manifest to reflect
					// current state in case process is aborted
					resultingInstalledManifest.addFileManifest(upgrade);
					operations.saveInstalledManifest(resultingInstalledManifest);
				}
			}
			// Add files
			for(String path : report.getFilesToBeAdded()){
				operations.copyFile(path);
				// After each file copy, update installed manifest to reflect
				// current state in case process is aborted
				resultingInstalledManifest.addFileManifest(upgrade);
				operations.saveInstalledManifest(resultingInstalledManifest);
			}
			// Upgrade files
			for(String path : report.getFilesToBeUpgraded()){
				operations.copyFile(path);
				// After each file copy, update installed manifest to reflect
				// current state in case process is aborted
				resultingInstalledManifest.addFileManifest(upgrade);
				operations.saveInstalledManifest(resultingInstalledManifest);
			}
			// Save collisions
			for(UpgradeCollision collision : report.getCollisions()){
				operations.handleCollision(collision);
			}
catch(Exception e) {
			throw new Exception("Error while performing upgrade",e);
		}
	}
New to GrepCode? Check out our FAQ X