bundles/org.eclipse.equinox.p2.touchpoint.natives/src/org/eclipse/equinox/internal/p2/touchpoint/natives/BackupFiles.java - equinox/rt.equinox.p2 - Git at Google

 /*******************************************************************************
  * Copyright (c) 2007 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
  *
  * Contributors:
  *     IBM Corporation - initial API and implementation
  *******************************************************************************/
 package org.eclipse.equinox.internal.p2.touchpoint.natives;

 import java.io.*;
 import java.net.URL;
 import java.util.*;
 import java.util.zip.*;
 import org.eclipse.core.runtime.IProgressMonitor;
 import org.eclipse.core.runtime.SubProgressMonitor;
 import org.eclipse.equinox.internal.p2.core.helpers.FileUtils;
 import org.eclipse.osgi.util.NLS;

 public class BackupFiles {

 	private static final String ZIP_SUFFIX = ".zip"; //$NON-NLS-1$
 	private static final String PROPERTIES_SUFFIX = ".properties"; //$NON-NLS-1$

 	private final File backupDir;
 	private boolean doBackup;

 	/**
 	 * Save or restore backups of files in backupDir
 	 */
 	public BackupFiles(File backupDir) {
 		this.doBackup = true;
 		this.backupDir = backupDir;
 		this.backupDir.mkdirs();
 	}

 	//    /**
 	//     * If doBackup is set to false, files are deleted on uninstall, instead of restored.
 	//     */
 	//    public void setDoBackup(boolean doBackup) {
 	//        this.doBackup = doBackup;
 	//    }

 	/**
 	 * Restore all backups made in this dir.
 	 */
 	public void restore(IProgressMonitor monitor) throws IOException {
 		// find backup properties files, do in reverse order
 		List propsFiles = new LinkedList();
 		for (int i = 0;; i += 1) {
 			File propsFile = getBackupProperties(i);
 			if (!propsFile.exists()) {
 				break;
 			}
 			propsFiles.add(0, propsFile);
 		}
 		IProgressMonitor[] pm = Util.splitProgressMonitor(monitor, propsFiles.size());
 		int j = 0;
 		for (Iterator i = propsFiles.iterator(); i.hasNext();) {
 			File propsFile = (File) i.next();
 			restoreFilesFromBackup(propsFile, pm[j++]);
 		}
 		if (!this.backupDir.delete()) {
 			//not empty?  log a warning?
 		} else {
 			// delete the parent if empty
 			this.backupDir.getParentFile().delete();
 		}
 		monitor.done();
 	}

 	/**
 	 * Find files under outputDir that will be overwritten in unzipURL
 	 * and save under backupDir, and delete.
 	 * Include properties file to indicate files to delete or restore on rolled back.
 	 * The progress monitor is used only to display sub-tasks; we don't update it otherwise.
 	 */
 	public void backupFilesInZip(String identifier, URL zipURL, File outputDir, IProgressMonitor monitor) throws IOException {
 		BackupProperties backupProps = new BackupProperties(identifier, outputDir);
 		ZipOutputStream zos = null;
 		String prevDir = null;
 		try {
 			ZipInputStream in = new ZipInputStream(zipURL.openStream());
 			ZipEntry ze;
 			while ((ze = in.getNextEntry()) != null) {
 				String name = ze.getName();
 				int i = name.lastIndexOf('/');
 				if (i != -1) {
 					String dir = name.substring(0, i);
 					if (this.doBackup && !dir.equals(prevDir)) {
 						monitor.subTask(name.substring(0, i));
 						prevDir = dir;
 					}
 				}
 				if (!ze.isDirectory()) {
 					File origFile = new File(outputDir, name);
 					if (this.doBackup && origFile.exists()) {
 						if (zos == null) {
 							File zipFile = backupProps.getArchive();
 							zos = new ZipOutputStream(new FileOutputStream(zipFile));
 						}
 						ZipEntry zipEntry = new ZipEntry(name);
 						zipEntry.setTime(origFile.lastModified());
 						zos.putNextEntry(zipEntry);
 						FileUtils.copyStream(new FileInputStream(origFile), true, zos, false);
 						zos.closeEntry();
 					} else {
 						backupProps.addFileToDelete(name);
 					}
 					origFile.delete();
 				}
 				in.closeEntry();
 			}
 			in.close();
 		} finally {
 			backupProps.store();
 			if (zos != null) {
 				zos.close();
 			}
 		}
 	}

 	private void restoreFilesFromBackup(File propsFile, IProgressMonitor monitor) throws IOException {
 		BackupProperties backupProps = new BackupProperties(propsFile);
 		monitor.beginTask(NLS.bind(Messages.restoring, propsFile.toString()), 3);
 		monitor.subTask(""); //$NON-NLS-1$
 		for (Iterator i = backupProps.getFilesToDelete().iterator(); i.hasNext();) {
 			String name = (String) i.next();
 			File full = new File(backupProps.getRootDir(), name);
 			full.delete();
 		}
 		monitor.worked(1);
 		File zipFile = backupProps.getArchive();
 		if (zipFile.exists()) { // only exists if files were saved
 			SubProgressMonitor sub = new SubProgressMonitor(monitor, 1, SubProgressMonitor.PREPEND_MAIN_LABEL_TO_SUBTASK);
 			FileUtils.unzipFile(zipFile, backupProps.getRootDir(), "", sub); //$NON-NLS-1$
 			zipFile.delete();
 		} else {
 			monitor.worked(1);
 		}
 		for (Iterator i = backupProps.getDirsToDelete().iterator(); i.hasNext();) {
 			String name = (String) i.next();
 			File full = new File(backupProps.getRootDir(), name);
 			FileUtils.deleteEmptyDirs(full);
 		}
 		propsFile.delete();
 		monitor.worked(1);
 		monitor.done();
 	}

 	// Backup files are just 0.properties, 1.properties, etc.
 	// Get the next unused one.
 	File getBackupProperties() {
 		for (int i = 0;; i += 1) {
 			File result = getBackupProperties(i);
 			if (!result.exists())
 				return result;
 		}
 	}

 	private File getBackupProperties(int i) {
 		return new File(BackupFiles.this.backupDir, Integer.toString(i) + PROPERTIES_SUFFIX);
 	}

 	private class BackupProperties extends Properties {
 		private static final long serialVersionUID = 2268313492348533029L;
 		private static final char FILE_KIND = 'f';
 		private static final char DIR_KIND = 'd';
 		private static final String ROOT_DIR = "rootDir"; //$NON-NLS-1$
 		private static final String ARTIFACT_KEY = "artifactKey"; //$NON-NLS-1$
 		//		private static final String ARTIFACT_USER = "artifactUser"; //$NON-NLS-1$

 		private int n = 0; // number of properties
 		private File file; // file to store properties in
 		private List keys = new LinkedList(); // keys, in order they were added or read
 		private final File rootDir; // root of where files are going
 		private Set dirsToCreate = new TreeSet(); // set of dirs we will create

 		// create properties based on file we are backing up to
 		public BackupProperties(String identifier, File rootDir) {
 			this.file = BackupFiles.this.getBackupProperties();
 			this.rootDir = rootDir;
 			setProperty(ROOT_DIR, rootDir.getPath().replace('\\', '/'));
 			setProperty(ARTIFACT_KEY, (identifier != null ? identifier : rootDir.getAbsolutePath()));
 			//			setProperty(ARTIFACT_USER, artifact.toUserString());
 			// make sure rootDir is deleted if appropriate
 			addDir("./"); //$NON-NLS-1$
 		}

 		// create backup properties from a previously saved BackupProperties
 		public BackupProperties(File file) throws IOException {
 			this.file = file;
 			FileInputStream stream = new FileInputStream(file);
 			try {
 				load(stream);
 			} finally {
 				stream.close();
 			}
 			this.rootDir = new File(getProperty(ROOT_DIR));
 		}

 		//		public String getArtifactKey() {
 		//			return getProperty(ARTIFACT_KEY);
 		//		}

 		//		public String getArtifactUserString() {
 		//			String result = getProperty(ARTIFACT_USER);
 		//			if (result != null) {
 		//				return result;
 		//			} else {
 		//				// return something if the key wasn't saved
 		//				result = getArtifactKey();
 		//				result = result.replaceFirst(",native,", ","); //$NON-NLS-1$ //$NON-NLS-2$
 		//				return result.replace(',', ' ').trim();
 		//			}
 		//		}

 		public File getRootDir() {
 			return this.rootDir;
 		}

 		// We are backing up files for this artifact.
 		// Create a backup zip based on the artifact key (as a hint).
 		public File getArchive() {
 			String path = this.file.getPath();
 			if (path.endsWith(PROPERTIES_SUFFIX)) {
 				path = path.substring(0, path.length() - PROPERTIES_SUFFIX.length());
 			}
 			return new File(path + ZIP_SUFFIX);
 		}

 		public List getFilesToDelete() {
 			return getMatchingProperties(FILE_KIND);
 		}

 		public List getDirsToDelete() {
 			return getMatchingProperties(DIR_KIND);
 		}

 		private List getMatchingProperties(char c) {
 			List result = new LinkedList();
 			for (Enumeration e = propertyNames(); e.hasMoreElements();) {
 				String key = (String) e.nextElement();
 				if (key.equals(BackupProperties.ROOT_DIR)) {
 					continue;
 				}
 				if (key.charAt(0) == c) {
 					result.add(getProperty(key));
 				}
 			}
 			return result;
 		}

 		public void addFileToDelete(String name) {
 			add(FILE_KIND, name);
 			addDir(name);
 		}

 		public void store() throws IOException {
 			// add the directories -- at end because we want them all in order
 			for (Iterator i = this.dirsToCreate.iterator(); i.hasNext();) {
 				String name = (String) i.next();
 				add(DIR_KIND, name);
 			}
 			FileOutputStream stream = new FileOutputStream(this.file);
 			try {
 				store(stream, /*header*/null);
 			} finally {
 				stream.close();
 			}
 		}

 		public Object put(Object key, Object value) {
 			if (!(key instanceof String))
 				throw new AssertionError("expected String: " + key); //$NON-NLS-1$
 			if (!(value instanceof String))
 				throw new AssertionError("expected String: " + value); //$NON-NLS-1$
 			this.keys.add(key);
 			return super.put(key, value);
 		}

 		// return keys in the order they were added
 		public synchronized Enumeration keys() {
 			final Iterator iterator = this.keys.iterator();
 			return new Enumeration() {
 				public boolean hasMoreElements() {
 					return iterator.hasNext();
 				}

 				public Object nextElement() {
 					return iterator.next();
 				}
 			};
 		}

 		private void add(char kind, String name) {
 			StringBuffer key = new StringBuffer(4);
 			key.append(kind).append(n++);
 			setProperty(key.toString(), name.replace('\\', '/'));
 		}

 		// if we're going to create this dir, remember that so we delete it
 		private void addDir(String name) {
 			int slash = name.lastIndexOf('/');
 			if (slash == -1)
 				return; // no dir
 			String dirName = name.substring(0, slash);
 			if (this.dirsToCreate.contains(dirName))
 				return; // already have it
 			if (new File(this.rootDir, dirName).exists())
 				return; // already exists
 			this.dirsToCreate.add(dirName);
 		}

 	}

 }
	/*******************************************************************************
	* Copyright (c) 2007 IBM Corporation and others.
	* All rights reserved. This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License v1.0
	* which accompanies this distribution, and is available at
	* http://www.eclipse.org/legal/epl-v10.html
	*
	* Contributors:
	* IBM Corporation - initial API and implementation
	*******************************************************************************/
	package org.eclipse.equinox.internal.p2.touchpoint.natives;

	import java.io.*;
	import java.net.URL;
	import java.util.*;
	import java.util.zip.*;
	import org.eclipse.core.runtime.IProgressMonitor;
	import org.eclipse.core.runtime.SubProgressMonitor;
	import org.eclipse.equinox.internal.p2.core.helpers.FileUtils;
	import org.eclipse.osgi.util.NLS;

	public class BackupFiles {

	private static final String ZIP_SUFFIX = ".zip"; //$NON-NLS-1$
	private static final String PROPERTIES_SUFFIX = ".properties"; //$NON-NLS-1$

	private final File backupDir;
	private boolean doBackup;

	/**
	* Save or restore backups of files in backupDir
	*/
	public BackupFiles(File backupDir) {
	this.doBackup = true;
	this.backupDir = backupDir;
	this.backupDir.mkdirs();
	}

	// /**
	// * If doBackup is set to false, files are deleted on uninstall, instead of restored.
	// */
	// public void setDoBackup(boolean doBackup) {
	// this.doBackup = doBackup;
	// }

	/**
	* Restore all backups made in this dir.
	*/
	public void restore(IProgressMonitor monitor) throws IOException {
	// find backup properties files, do in reverse order
	List propsFiles = new LinkedList();
	for (int i = 0;; i += 1) {
	File propsFile = getBackupProperties(i);
	if (!propsFile.exists()) {
	break;
	}
	propsFiles.add(0, propsFile);
	}
	IProgressMonitor[] pm = Util.splitProgressMonitor(monitor, propsFiles.size());
	int j = 0;
	for (Iterator i = propsFiles.iterator(); i.hasNext();) {
	File propsFile = (File) i.next();
	restoreFilesFromBackup(propsFile, pm[j++]);
	}
	if (!this.backupDir.delete()) {
	//not empty? log a warning?
	} else {
	// delete the parent if empty
	this.backupDir.getParentFile().delete();
	}
	monitor.done();
	}

	/**
	* Find files under outputDir that will be overwritten in unzipURL
	* and save under backupDir, and delete.
	* Include properties file to indicate files to delete or restore on rolled back.
	* The progress monitor is used only to display sub-tasks; we don't update it otherwise.
	*/
	public void backupFilesInZip(String identifier, URL zipURL, File outputDir, IProgressMonitor monitor) throws IOException {
	BackupProperties backupProps = new BackupProperties(identifier, outputDir);
	ZipOutputStream zos = null;
	String prevDir = null;
	try {
	ZipInputStream in = new ZipInputStream(zipURL.openStream());
	ZipEntry ze;
	while ((ze = in.getNextEntry()) != null) {
	String name = ze.getName();
	int i = name.lastIndexOf('/');
	if (i != -1) {
	String dir = name.substring(0, i);
	if (this.doBackup && !dir.equals(prevDir)) {
	monitor.subTask(name.substring(0, i));
	prevDir = dir;
	}
	}
	if (!ze.isDirectory()) {
	File origFile = new File(outputDir, name);
	if (this.doBackup && origFile.exists()) {
	if (zos == null) {
	File zipFile = backupProps.getArchive();
	zos = new ZipOutputStream(new FileOutputStream(zipFile));
	}
	ZipEntry zipEntry = new ZipEntry(name);
	zipEntry.setTime(origFile.lastModified());
	zos.putNextEntry(zipEntry);
	FileUtils.copyStream(new FileInputStream(origFile), true, zos, false);
	zos.closeEntry();
	} else {
	backupProps.addFileToDelete(name);
	}
	origFile.delete();
	}
	in.closeEntry();
	}
	in.close();
	} finally {
	backupProps.store();
	if (zos != null) {
	zos.close();
	}
	}
	}

	private void restoreFilesFromBackup(File propsFile, IProgressMonitor monitor) throws IOException {
	BackupProperties backupProps = new BackupProperties(propsFile);
	monitor.beginTask(NLS.bind(Messages.restoring, propsFile.toString()), 3);
	monitor.subTask(""); //$NON-NLS-1$
	for (Iterator i = backupProps.getFilesToDelete().iterator(); i.hasNext();) {
	String name = (String) i.next();
	File full = new File(backupProps.getRootDir(), name);
	full.delete();
	}
	monitor.worked(1);
	File zipFile = backupProps.getArchive();
	if (zipFile.exists()) { // only exists if files were saved
	SubProgressMonitor sub = new SubProgressMonitor(monitor, 1, SubProgressMonitor.PREPEND_MAIN_LABEL_TO_SUBTASK);
	FileUtils.unzipFile(zipFile, backupProps.getRootDir(), "", sub); //$NON-NLS-1$
	zipFile.delete();
	} else {
	monitor.worked(1);
	}
	for (Iterator i = backupProps.getDirsToDelete().iterator(); i.hasNext();) {
	String name = (String) i.next();
	File full = new File(backupProps.getRootDir(), name);
	FileUtils.deleteEmptyDirs(full);
	}
	propsFile.delete();
	monitor.worked(1);
	monitor.done();
	}

	// Backup files are just 0.properties, 1.properties, etc.
	// Get the next unused one.
	File getBackupProperties() {
	for (int i = 0;; i += 1) {
	File result = getBackupProperties(i);
	if (!result.exists())
	return result;
	}
	}

	private File getBackupProperties(int i) {
	return new File(BackupFiles.this.backupDir, Integer.toString(i) + PROPERTIES_SUFFIX);
	}

	private class BackupProperties extends Properties {
	private static final long serialVersionUID = 2268313492348533029L;
	private static final char FILE_KIND = 'f';
	private static final char DIR_KIND = 'd';
	private static final String ROOT_DIR = "rootDir"; //$NON-NLS-1$
	private static final String ARTIFACT_KEY = "artifactKey"; //$NON-NLS-1$
	// private static final String ARTIFACT_USER = "artifactUser"; //$NON-NLS-1$

	private int n = 0; // number of properties
	private File file; // file to store properties in
	private List keys = new LinkedList(); // keys, in order they were added or read
	private final File rootDir; // root of where files are going
	private Set dirsToCreate = new TreeSet(); // set of dirs we will create

	// create properties based on file we are backing up to
	public BackupProperties(String identifier, File rootDir) {
	this.file = BackupFiles.this.getBackupProperties();
	this.rootDir = rootDir;
	setProperty(ROOT_DIR, rootDir.getPath().replace('\\', '/'));
	setProperty(ARTIFACT_KEY, (identifier != null ? identifier : rootDir.getAbsolutePath()));
	// setProperty(ARTIFACT_USER, artifact.toUserString());
	// make sure rootDir is deleted if appropriate
	addDir("./"); //$NON-NLS-1$
	}

	// create backup properties from a previously saved BackupProperties
	public BackupProperties(File file) throws IOException {
	this.file = file;
	FileInputStream stream = new FileInputStream(file);
	try {
	load(stream);
	} finally {
	stream.close();
	}
	this.rootDir = new File(getProperty(ROOT_DIR));
	}

	// public String getArtifactKey() {
	// return getProperty(ARTIFACT_KEY);
	// }

	// public String getArtifactUserString() {
	// String result = getProperty(ARTIFACT_USER);
	// if (result != null) {
	// return result;
	// } else {
	// // return something if the key wasn't saved
	// result = getArtifactKey();
	// result = result.replaceFirst(",native,", ","); //$NON-NLS-1$ //$NON-NLS-2$
	// return result.replace(',', ' ').trim();
	// }
	// }

	public File getRootDir() {
	return this.rootDir;
	}

	// We are backing up files for this artifact.
	// Create a backup zip based on the artifact key (as a hint).
	public File getArchive() {
	String path = this.file.getPath();
	if (path.endsWith(PROPERTIES_SUFFIX)) {
	path = path.substring(0, path.length() - PROPERTIES_SUFFIX.length());
	}
	return new File(path + ZIP_SUFFIX);
	}

	public List getFilesToDelete() {
	return getMatchingProperties(FILE_KIND);
	}

	public List getDirsToDelete() {
	return getMatchingProperties(DIR_KIND);
	}

	private List getMatchingProperties(char c) {
	List result = new LinkedList();
	for (Enumeration e = propertyNames(); e.hasMoreElements();) {
	String key = (String) e.nextElement();
	if (key.equals(BackupProperties.ROOT_DIR)) {
	continue;
	}
	if (key.charAt(0) == c) {
	result.add(getProperty(key));
	}
	}
	return result;
	}

	public void addFileToDelete(String name) {
	add(FILE_KIND, name);
	addDir(name);
	}

	public void store() throws IOException {
	// add the directories -- at end because we want them all in order
	for (Iterator i = this.dirsToCreate.iterator(); i.hasNext();) {
	String name = (String) i.next();
	add(DIR_KIND, name);
	}
	FileOutputStream stream = new FileOutputStream(this.file);
	try {
	store(stream, /header/null);
	} finally {
	stream.close();
	}
	}

	public Object put(Object key, Object value) {
	if (!(key instanceof String))
	throw new AssertionError("expected String: " + key); //$NON-NLS-1$
	if (!(value instanceof String))
	throw new AssertionError("expected String: " + value); //$NON-NLS-1$
	this.keys.add(key);
	return super.put(key, value);
	}

	// return keys in the order they were added
	public synchronized Enumeration keys() {
	final Iterator iterator = this.keys.iterator();
	return new Enumeration() {
	public boolean hasMoreElements() {
	return iterator.hasNext();
	}

	public Object nextElement() {
	return iterator.next();
	}
	};
	}

	private void add(char kind, String name) {
	StringBuffer key = new StringBuffer(4);
	key.append(kind).append(n++);
	setProperty(key.toString(), name.replace('\\', '/'));
	}

	// if we're going to create this dir, remember that so we delete it
	private void addDir(String name) {
	int slash = name.lastIndexOf('/');
	if (slash == -1)
	return; // no dir
	String dirName = name.substring(0, slash);
	if (this.dirsToCreate.contains(dirName))
	return; // already have it
	if (new File(this.rootDir, dirName).exists())
	return; // already exists
	this.dirsToCreate.add(dirName);
	}

	}

	}