package org.eclipse.update.internal.core;
/*
 * (c) Copyright IBM Corp. 2000, 2001.
 * All Rights Reserved.
 */

import org.eclipse.swt.widgets.Shell;
import org.eclipse.webdav.http.client.Response;
import java.util.jar.*;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.internal.boot.LaunchInfo;
import org.eclipse.update.internal.ui.*;
import org.eclipse.core.internal.boot.update.*;
import java.io.*;
import java.net.*;
import java.util.*;

/**
 * This class represents an operation such as "copy" or "unzip".
 * Attributes are id, status (pending/complete), action,
 * source, target.  Children are messages.
 */

public class UMSessionManagerOperation extends UMSessionManagerEntry {
		
	protected ArrayList         _alMessages     = new ArrayList();
	protected ILogEntryProperty _propertyAction = null;
	protected ILogEntryProperty _propertyID     = null;
	protected ILogEntryProperty _propertySource = null;
	protected ILogEntryProperty _propertyTarget = null;
/**
 * UpdateManagerOperation constructor comment.
 */
public UMSessionManagerOperation( ILogEntry logEntry ) {
	super( logEntry );

	// Action
	//-------
	_propertyAction = _logEntry.getProperty(UpdateManagerConstants.STRING_ACTION);

	if (_propertyAction == null) {
		_propertyAction = new LogEntryProperty(logEntry, UpdateManagerConstants.STRING_ACTION, UpdateManagerConstants.STRING_EMPTY );
		logEntry.addProperty( _propertyAction );
	}

	// Id
	//---
	_propertyID = _logEntry.getProperty(UpdateManagerConstants.STRING_ID);

	if (_propertyID == null) {
		_propertyID = new LogEntryProperty(logEntry, UpdateManagerConstants.STRING_ID, UpdateManagerConstants.STRING_EMPTY );
		logEntry.addProperty( _propertyID );
	}

	// Source
	//-------
	_propertySource = _logEntry.getProperty(UpdateManagerConstants.STRING_SOURCE);

	if (_propertySource == null) {
		_propertySource = new LogEntryProperty(logEntry, UpdateManagerConstants.STRING_SOURCE, UpdateManagerConstants.STRING_EMPTY );
		logEntry.addProperty( _propertySource );
	}

	// Target
	//-------
	_propertyTarget = _logEntry.getProperty(UpdateManagerConstants.STRING_TARGET);

	if (_propertyTarget == null) {
		_propertyTarget = new LogEntryProperty(logEntry, UpdateManagerConstants.STRING_TARGET, UpdateManagerConstants.STRING_EMPTY );
		logEntry.addProperty( _propertyTarget);
	}
}
/**
 * @param logEntry org.eclipse.update.internal.core.LogEntry
 */
public void buildTreeFromLog(ILogEntry logEntry) {
	
	super.buildTreeFromLog( logEntry );
	
	// Action
	//-------
	ILogEntryProperty property = _logEntry.getProperty(UpdateManagerConstants.STRING_ACTION);

	if (property != null) {
		_propertyAction = property;
	}
	

	// Id
	//---
	property = _logEntry.getProperty(UpdateManagerConstants.STRING_ID);

	if (property != null) {
		_propertyID = property;
	}

	// Source
	//-------
	property = _logEntry.getProperty(UpdateManagerConstants.STRING_SOURCE);

	if (property != null) {
		_propertySource = property;
	}

	// Target
	//-------
	property = _logEntry.getProperty(UpdateManagerConstants.STRING_TARGET);

	if (property != null) {
		_propertyTarget = property;
	}


	ILogEntry[] entries = logEntry.getChildEntries();

	// Messages
	//---------
	int iIndex = 0;
	UMSessionManagerMessage message = null;
	
	for( int i = 0; i < entries.length; ++i) {
		if (entries[i] != null && entries[i].getName().equals(UpdateManagerConstants.STRING_MESSAGE) == true) {
			message = new UMSessionManagerMessage( entries[i] );			
	        _alMessages.add( message );

	        message.buildTreeFromLog( entries[i] );
		}
	}
}
/**
 * Copies all data from input stream to output stream.
 * @param inputStream java.io.InputStream
 * @param outputStream java.io.OutputStream
 */
public String copyStream(InputStream streamInput, OutputStream streamOutput, long lContentLength, String strTaskName, IProgressMonitor progressMonitor, boolean bSubtask) {

	String strErrorMessage = null;

	// Allocate buffer
	//---------------- 
	byte[] byteArray = null;

	if (streamInput != null && streamOutput != null) {
		byteArray = new byte[64000];
	}

	if (byteArray != null) {

		// Copy
		//-----
		if (progressMonitor != null) {
			if (bSubtask == false) {
				if (lContentLength > 0 && lContentLength < Integer.MAX_VALUE)
					progressMonitor.beginTask(UpdateManagerStrings.getString("S_Copy") + ": " +strTaskName, (int) lContentLength);
				else
					progressMonitor.beginTask(UpdateManagerStrings.getString("S_Copy") + ": "  + strTaskName, IProgressMonitor.UNKNOWN);
			}
			else {
				progressMonitor.subTask(UpdateManagerStrings.getString("S_Copy") + ": "  + strTaskName);
			}
		}

		int iBytesReceived = 0;

		do {
			// Read
			//-----
			try {
				iBytesReceived = streamInput.read(byteArray);
			}
			catch (Exception ex) {
				iBytesReceived = 0;
				strErrorMessage = UpdateManagerStrings.getString("S_Error_reading_from_input_stream") + ": " + ex.getMessage();
			}

			// Write
			//------
			if (iBytesReceived > 0) {
				try {
					streamOutput.write(byteArray, 0, iBytesReceived);

					if (progressMonitor != null && bSubtask == false)
						progressMonitor.worked(iBytesReceived);
				}
				catch (IOException ex) {
					iBytesReceived = 0;
					strErrorMessage = UpdateManagerStrings.getString("S_Error_writing_to_output_stream") + ": " + ex.getMessage();
				}
			}
		}
		while (iBytesReceived > 0);

		if (progressMonitor != null && bSubtask == false) {
			progressMonitor.done();
		}
	}

	return strErrorMessage;
}
/**
 *
 * @return org.eclipse.update.internal.core.UMSessionManagerMessage
 * @param actionType java.lang.String
 */
public UMSessionManagerMessage createMessage() {

	// Create a new log entry
	//-----------------------
	ILogEntry logEntryChild = new LogEntry( _logEntry, UpdateManagerConstants.STRING_MESSAGE );
	_logEntry.addChildEntry( logEntryChild );

	// Create the operation object
	//----------------------------
	UMSessionManagerMessage message = new UMSessionManagerMessage( logEntryChild );
	
	message.buildTreeFromLog( logEntryChild );
	
	_alMessages.add( message );
	
	return message;
}
/**
 *
 * 
 */
public boolean doCopy(IProgressMonitor progressMonitor) {

	String strErrorMessage = null;

	// Input URL
	//----------
	URL urlInput = null;

	try {
		urlInput = new URL(getSource());
	}
	catch (MalformedURLException ex) {
		strErrorMessage = createMessageString(UpdateManagerStrings.getString("S_Source_URL_is_malformed"), ex);
	}

	URL urlOutput = null;

	// Output URL
	//-----------
	try {
		urlOutput = new URL(getTarget());
	}
	catch (MalformedURLException ex) {
		strErrorMessage = createMessageString(UpdateManagerStrings.getString("S_Target_URL_is_malformed"), ex);
	}

	// Input
	//-------
	InputStream streamInput = null;

	long lContentLength = 0;

	if (urlInput != null && urlOutput != null) {

		// Input stream
		//-------------
		try {
			URLHandler.Response response = (URLHandler.Response)URLHandler.open(urlInput);
			lContentLength = response.getContentLength();
			if( response.getResponseCode() == HttpURLConnection.HTTP_OK )
				streamInput = response.getInputStream();
		}
		catch (IOException ex) {
			strErrorMessage = createMessageString(UpdateManagerStrings.getString("S_Unable_to_obtain_source_input_stream"), ex);
		}

	}

	// Output
	//-------
	OutputStream streamOutput = null;

	if (streamInput != null) {

		// Output connection
		//------------------
		URLConnection urlConnectionOutput = null;
		
		try {
			urlConnectionOutput = urlOutput.openConnection();
			urlConnectionOutput.setDoOutput(true);
		}
		catch (IOException ex) {
			strErrorMessage = createMessageString( UpdateManagerStrings.getString("S_Unable_to_connect"), ex );
		}

		// Output stream
		//--------------
		if (urlConnectionOutput != null) {
			try {
				streamOutput = urlConnectionOutput.getOutputStream();
			}
			catch (IOException ex) {
				strErrorMessage = createMessageString( UpdateManagerStrings.getString("S_Unable_to_obtain_target_output_stream"), ex );
			}
		}

		// Attempt to create a file output stream
		// This is used when protocol is file: or valoader:
		// thus our local writes are all file I/O currently
		//-------------------------------------------------
		if (streamOutput == null) {
	        try
	        {
		 		streamOutput = getFileOutputStream(urlOutput);
	        }
	        catch( IOException ex){
				strErrorMessage = createMessageString( UpdateManagerStrings.getString("S_Unable_to_create_file"), ex );
			}
		}
	}

	if( streamInput != null && streamOutput != null )
	{
	    strErrorMessage = copyStream( streamInput, streamOutput, lContentLength, urlInput.toExternalForm(), progressMonitor, false );
	}    

	// Close input stream
	//-------------------
	if (streamInput != null) {
		try {
			streamInput.close();
		}
		catch (IOException ex) {
		}
	}

	// Close output stream
	//--------------------
	if (streamOutput != null) {
		try {
			streamOutput.flush();
			streamOutput.close();
		}
		catch (IOException ex) {
			strErrorMessage = createMessageString( UpdateManagerStrings.getString("S_Error_closing_output_stream"), ex );
		}
	}
	
	// Increment the number of attempts
	//---------------------------------
	incrementAttemptCount();

	// Error return
	//-------------
	if (strErrorMessage != null) {
		UMSessionManagerMessage message = createMessage();
		message.setText(strErrorMessage);
		setStatus(UpdateManagerConstants.STATUS_FAILED);
		return false;
	}

	// Successful return
	//------------------
	setStatus(UpdateManagerConstants.STATUS_SUCCEEDED);

	return true;
}
/**
 *
 * 
 */
public boolean doUnzip(IProgressMonitor progressMonitor) {

	String strErrorMessage = null;
	int rc = UpdateManagerConstants.UNDEFINED_CONTENTS;

	// Input URL
	//----------
	URL urlInput = null;
	try {
		urlInput = new URL(getSource());
	}
	catch (MalformedURLException ex) {
		strErrorMessage = createMessageString(UpdateManagerStrings.getString("S_Source_URL_is_malformed"), ex);
	}

	// Output URL
	//-----------
	URL urlOutput = null;
	try {
		urlOutput = new URL(getTarget());
	}
	catch (MalformedURLException ex) {
		strErrorMessage = createMessageString(UpdateManagerStrings.getString("S_Target_URL_is_malformed"), ex);
	}

	// For unzipping plugins or component/configuration jar, 
	// set up the list of directories to look for, also call
	// LaunchInfo.installPending
	//-----------------------------------------------------
	Vector dirNames = new Vector();
	Vector dirNamesInstalled = new Vector();// keep track of plugins/fragments unzipped
	Vector dirNamesUnexpected = new Vector();	// keep track of unexpected plugins/fragments dir
	ArrayList productVIDs = new ArrayList();
	ArrayList componentVIDs = new ArrayList();
	ArrayList pluginVIDs = new ArrayList();
	ArrayList fragmentVIDs = new ArrayList();

	if (getAction() == UpdateManagerConstants.OPERATION_UNZIP_PLUGINS ) {
		IComponentDescriptor comp = null;
		if (getData() instanceof IComponentEntryDescriptor) {
			comp = ((IComponentEntryDescriptor) getData()).getComponentDescriptor();
		} else {
			comp = (IComponentDescriptor) getData();
		}
		if (comp != null) {
			IPluginEntryDescriptor[] plugins = comp.getPluginEntries();
			for (int i=0; i<plugins.length; i++) {
				dirNames.addElement( UMEclipseTree.PLUGINS_DIR + "/" + plugins[i].getDirName());
				pluginVIDs.add(new LaunchInfo.VersionedIdentifier(plugins[i].getUniqueIdentifier(), plugins[i].getVersionStr()));
			}
			IFragmentEntryDescriptor[] fragments = comp.getFragmentEntries();
			for (int i=0; i<fragments.length; i++) {
				dirNames.addElement( UMEclipseTree.FRAGMENTS_DIR + "/" + fragments[i].getDirName());	
				fragmentVIDs.add(new LaunchInfo.VersionedIdentifier(plugins[i].getUniqueIdentifier(), plugins[i].getVersionStr()));
			}
		} else {
			strErrorMessage = UpdateManagerStrings.getString("S_Error_in_registry");
		}
	} else if (getAction() == UpdateManagerConstants.OPERATION_UNZIP_INSTALL) {
		rc = UpdateManagerConstants.INSTALL_XML_MISSING;
		if (getData() instanceof IProductDescriptor) {
			IProductDescriptor desc = (IProductDescriptor) getData();
			dirNames.addElement(UMEclipseTree.INSTALL_DIR + "/" + UMEclipseTree.PRODUCTS_DIR + "/" + desc.getDirName());
			productVIDs.add(new LaunchInfo.VersionedIdentifier(desc.getUniqueIdentifier(), desc.getVersionStr()));
		} else { 
			IComponentDescriptor desc = null;
			if (getData() instanceof IComponentEntryDescriptor) {
				desc = ((IComponentEntryDescriptor) getData()).getComponentDescriptor();
			} else {
				desc = (IComponentDescriptor) getData();
			}
			dirNames.addElement(UMEclipseTree.INSTALL_DIR + "/" + UMEclipseTree.COMPONENTS_DIR + "/" + desc.getDirName());
			componentVIDs.add(new LaunchInfo.VersionedIdentifier(desc.getUniqueIdentifier(), desc.getVersionStr()));
		}
	}
	if (!LaunchInfo.getCurrent().installPending(productVIDs, componentVIDs, pluginVIDs, fragmentVIDs)) {
		strErrorMessage = UpdateManagerStrings.getString("S_Error_occurred_during_installation_setup");
	}
	
	
	// Create a file specification from the input URL
	//-----------------------------------------------
	String strFilespec = UMEclipseTree.getFileInPlatformString(urlInput);

	JarFile jarFile = null;

	try {
		jarFile = new JarFile(strFilespec);
	}
	catch (IOException ex) {
		strErrorMessage = createMessageString(UpdateManagerStrings.getString("S_Unable_to_open_Jar_file"), ex);
	}

	if ((jarFile != null) && (strErrorMessage == null)) {

		JarEntry entry = null;
		InputStream streamInputEntry = null;

		int iCount = jarFile.size();
		
		// Set up progress monitor
		// Compute the filename without the path information
		//--------------------------------------------------
		String strFilename = strFilespec;
		int iIndex = strFilespec.lastIndexOf(File.separatorChar);
		
		if (iIndex >= 0 && iIndex < strFilespec.length() - 1) {
			strFilename = strFilespec.substring(iIndex + 1);
		}

		if (progressMonitor != null) {
			progressMonitor.beginTask(UpdateManagerStrings.getString("S_Install") + ": " + strFilename, iCount);
		}


		// Do each jar file entry
		//-----------------------
		Enumeration enum = jarFile.entries();
		while (enum.hasMoreElements() == true) {
			entry = (JarEntry) enum.nextElement();
			String entryName = entry.getName();
			
			if (getAction() == UpdateManagerConstants.OPERATION_UNZIP_PLUGINS ) {
				// Unzip plugins and fragments.  Skip entries not under plugins/  or fragments/ trees
				//-----------------------------------------------------------------------------------
				if ((!entryName.startsWith(UMEclipseTree.PLUGINS_DIR) &&
					!entryName.startsWith(UMEclipseTree.FRAGMENTS_DIR)) 
					|| entryName.endsWith("/")) {
					if (progressMonitor != null) progressMonitor.worked(1);
					continue;
				}
				String prefix = entryName;
				int second_slash = entryName.indexOf("/", (entryName.indexOf("/")+1));
				if (second_slash > 0) 
					prefix = entryName.substring(0,second_slash);
				int match = dirNames.indexOf(prefix);
				if (match < 0) {   // not a valid plugin
					if (!dirNamesUnexpected.contains(prefix))
						dirNamesUnexpected.addElement(prefix);
					continue;
				}
				// got an entry with matching directory 
				// keep track of which ones they are
				if (!dirNamesInstalled.contains(prefix))
					dirNamesInstalled.addElement(prefix);
			} else if (getAction() == UpdateManagerConstants.OPERATION_UNZIP_INSTALL) {
				// Skip over entries that don't start with the right dir naming convention (id_version)
				//-------------------------------------------------------------------------------------
				if (!entryName.startsWith((String)dirNames.firstElement()) || entryName.endsWith("/")) {
					if (progressMonitor != null) progressMonitor.worked(1);
					continue;
				}
				// got an entry - as long as we have install.xml we're happy
				if (entryName.equals((String)dirNames.firstElement()+"/"+IManifestAttributes.INSTALL_MANIFEST))
					rc = UpdateManagerConstants.OK;
			} else if (getAction() == UpdateManagerConstants.OPERATION_UNZIP_BINDIR) {
				// Unzip the bin directory, if it exists
				//--------------------------------------
				if (!entryName.startsWith(UMEclipseTree.BIN_DIR) || entryName.endsWith("/")) {
					if (progressMonitor != null) progressMonitor.worked(1);
					continue;
				}
				// got bin dir
				rc = UpdateManagerConstants.OK;
			}
			try {
				streamInputEntry = jarFile.getInputStream(entry);
			}
			catch (IOException ex) {
				streamInputEntry = null;
				strErrorMessage = createMessageString(UpdateManagerStrings.getString("S_Unable_to_open_jar_entry_input_stream"), ex);
				break;
			}
			catch (SecurityException ex) {
				streamInputEntry = null;
				strErrorMessage = createMessageString(UpdateManagerStrings.getString("S_Encountered_jar_entry_security_exception"), ex);
				break;
			}


			// Create an output URL
			//---------------------
			URL urlOutputFile = null;

			if (streamInputEntry != null) {
				try {
					// Ensure file separator between target directory, and source file path
					//---------------------------------------------------------------------
					StringBuffer strbTarget = new StringBuffer(getTarget());
					if (getTarget().endsWith("/") == false) {
						strbTarget.append('/');
					}
					strbTarget.append(entryName);
					urlOutputFile = new URL(strbTarget.toString());
					File fTarget = new File(UMEclipseTree.getFileInPlatformString(urlOutputFile));
					if (fTarget.exists() &&
						(getAction() != UpdateManagerConstants.OPERATION_UNZIP_BINDIR)) {		
						// we will not override existing files, except in bin/
						if (progressMonitor != null) progressMonitor.worked(1);
						continue;
					}
				}
				catch (MalformedURLException ex) {
					strErrorMessage = createMessageString(UpdateManagerStrings.getString("S_Unable_to_create_jar_entry_URL"), ex);
					break;
				}
			}


			// Create a file output stream
			//----------------------------
			OutputStream streamOutputFile = null;

			if (urlOutputFile != null) {
				try {
					streamOutputFile = getFileOutputStream(urlOutputFile);
				}
				catch (IOException ex) {
					strErrorMessage = createMessageString(UpdateManagerStrings.getString("S_Unable_to_create_output_file_for_Jar_entry") + ": " + urlOutputFile.toExternalForm(), ex);
					break;
				}
			}

			// Copy from input to output stream
			//---------------------------------
			if (streamInputEntry != null && streamOutputFile != null) {

	            // Do not alter progress monitor
	            //------------------------------
				strErrorMessage = copyStream(streamInputEntry, streamOutputFile, 0, entryName, null, true );
				if (strErrorMessage != null) {
					break;
				}
			}
			try {
				if (streamInputEntry != null) 	streamInputEntry.close();
				if (streamOutputFile != null) 	streamOutputFile.close();
			} catch (java.io.IOException ex) {
				// unchecked
			}
			if (progressMonitor != null) progressMonitor.worked(1);
		}	// while
//		strErrorMessage = "Error Injected!";
		try {
			jarFile.close();
		} catch (java.io.IOException ex) {
			// unchecked
		}		
	}	// if jarFile is not null

	// tally up what's unzipped and what's not
	//---------------------------------
	if (strErrorMessage == null) {
		if (getAction() == UpdateManagerConstants.OPERATION_UNZIP_PLUGINS ) {
			if (dirNamesUnexpected.size() > 0) {
				rc = UpdateManagerConstants.UNDEFINED_CONTENTS;
				strErrorMessage = UpdateManagerStrings.getString("S_Undefined_contents_found_in_Jar");
			}
			else if (!dirNamesInstalled.containsAll(dirNames)) {
				rc = UpdateManagerConstants.MISSING_CONTENTS;
				strErrorMessage = UpdateManagerStrings.getString("S_Unable_to_find_defined_contents_in_Jar");
			} 
		} else if (getAction() == UpdateManagerConstants.OPERATION_UNZIP_INSTALL) {
			if (rc != UpdateManagerConstants.OK)
				strErrorMessage = UpdateManagerStrings.getString("S_Unable_to_find_install_manifest_file_in_Jar");
		}
	}		
	
	// Call LaunchInfo.installConfirmed if all clean
	// Otherwise, call after we've cleaned up (undo*)
	//-----------------------------------------------
	if (strErrorMessage == null) {
		if (!LaunchInfo.getCurrent().installConfirmed(productVIDs, componentVIDs, pluginVIDs, fragmentVIDs)) {
			strErrorMessage = UpdateManagerStrings.getString("S_Error_occurred_during_installation_completion");
		}
	}
	
	if (progressMonitor != null) progressMonitor.done();

	// Increment the number of attempts
	//---------------------------------
	incrementAttemptCount();

	// Error return
	//-------------
	if (strErrorMessage != null) {
		UMSessionManagerMessage message = createMessage();
		message.setText(strErrorMessage);
		setStatus(UpdateManagerConstants.STATUS_FAILED);
		return false;
	}

	// Successful return
	//------------------
	setStatus(UpdateManagerConstants.STATUS_SUCCEEDED);

	return true;
}
/**
 *
 * 
 */
public boolean doVerify(IProgressMonitor progressMonitor) {

	String strErrorMessage = null;

	// Input URL
	//----------
	URL urlInput = null;

	try {
		urlInput = new URL(getSource());
	}
	catch (MalformedURLException ex) {
		strErrorMessage = createMessageString(UpdateManagerStrings.getString("S_Source_URL_is_malformed"), ex);
	}

	IInstallable installable = (IInstallable) getData();

	String strName = installable.getLabel();
	String strId = null;
	String strProviderName = null;

	if (installable instanceof IProductDescriptor) {
		strId = ((IProductDescriptor) installable).getUniqueIdentifier();
		strProviderName = ((IProductDescriptor) installable).getProviderName();
	}
	else if (installable instanceof IComponentDescriptor) {
		strId = ((IComponentDescriptor) installable).getUniqueIdentifier();
		strProviderName = ((IComponentDescriptor) installable).getProviderName();
	}
	else if (installable instanceof IComponentEntryDescriptor) {
		strId = ((IComponentEntryDescriptor) installable).getUniqueIdentifier();
	}
	else if (installable instanceof IPluginEntryDescriptor) {
		strId = ((IPluginEntryDescriptor) installable).getUniqueIdentifier();
	}
	else if (installable instanceof IFragmentEntryDescriptor) {
		strId = ((IFragmentEntryDescriptor) installable).getUniqueIdentifier();
	}

	JarVerificationService verifier = UpdateManager.getCurrentInstance().getJarVerifier();

	JarVerificationResult result = verifier.okToInstall(new File(urlInput.getFile()), strId, strName, strProviderName, progressMonitor);

	if (result.getResultCode() == JarVerificationResult.CANCEL_INSTALL) {
		Exception ex = result.getResultException();
		strErrorMessage = createMessageString(UpdateManagerStrings.getString("S_Installation_cancelled_by_user"), ex);
	}

	// Increment the number of attempts
	//---------------------------------
	incrementAttemptCount();

	// Error return
	//-------------
	if (strErrorMessage != null) {
		UMSessionManagerMessage message = createMessage();
		message.setText(strErrorMessage);
		setStatus(UpdateManagerConstants.STATUS_FAILED);
		return false;
	}

	// Successful return
	//------------------
	setStatus(UpdateManagerConstants.STATUS_SUCCEEDED);

	return true;
}
/**
 * Execute copy from source URL to target URL.
 */
public boolean execute(IProgressMonitor progressMonitor) {

	if (getAction() == UpdateManagerConstants.OPERATION_UNZIP_INSTALL ||
		getAction() == UpdateManagerConstants.OPERATION_UNZIP_PLUGINS ||
		getAction() == UpdateManagerConstants.OPERATION_UNZIP_BINDIR) {
		return doUnzip(progressMonitor);
	}
	
	else if (getAction() == UpdateManagerConstants.OPERATION_COPY) {
		return doCopy(progressMonitor);
	}
	else if (getAction() == UpdateManagerConstants.OPERATION_VERIFY_JAR) {
		return doVerify(progressMonitor);
	}
	return false;
}
/**
 * Execute any pending or failed updates.
 */
public boolean executeUndo(IProgressMonitor progressMonitor) {

	// Undo all successful and failed operations
	//------------------------------------------
	if (getStatus().equals(UpdateManagerConstants.STATUS_PENDING) == false) {
		if (getAction() == UpdateManagerConstants.OPERATION_UNZIP_INSTALL ||
			getAction() == UpdateManagerConstants.OPERATION_UNZIP_PLUGINS) {
			return undoUnzip(progressMonitor);
		}
		else if (getAction() == UpdateManagerConstants.OPERATION_COPY) {
			return undoCopy(progressMonitor);
		}
		else if (getAction() == UpdateManagerConstants.OPERATION_VERIFY_JAR){
			return undoVerify(progressMonitor);
		}
	}

	return true;
}
/**
 * 
 * @return java.lang.String
 */
public String getAction() {
	
	return _propertyAction.getValue();
}
/**
 * Creates a file output stream from the URL.
 * @param url java.net.URL
 */
private FileOutputStream getFileOutputStream(URL url) throws IOException {

	// Convert the URL to a string
	//----------------------------
	String strFilespec = UMEclipseTree.getFileInPlatformString(url);


	// Create directory structure
	//---------------------------
	int iIndex = strFilespec.lastIndexOf(File.separator);
	if (iIndex >= 0) {
		String strPath = strFilespec.substring(0, iIndex+1);

		File fileDirectory = new File(strPath);
		if (fileDirectory.exists() == false) {
			fileDirectory.mkdirs();
		}
	}

	// Open / create the file
	//-----------------------
	File file = new File(strFilespec);
	boolean bExists = file.exists();

	if (bExists == false) {
		bExists = file.createNewFile();
	}

	// Create the output stream
	//-------------------------
	return new FileOutputStream(file);
}
/**
 * @return java.lang.String
 */
public String getId() {
	
	return _propertyID.getValue();
}
/**
 *
 * @return java.lang.String
 */
public String getSource() {
	
	return _propertySource.getValue();
}
/**
 * @param strb java.lang.StringBuffer
 * @param iIndentation int
 */
public void getStatusString(java.lang.StringBuffer strb, int iIndentation) {

	if (getStatus().equals(UpdateManagerConstants.STATUS_SUCCEEDED) == true) {
		return;
	}
	else if (getStatus().equals(UpdateManagerConstants.STATUS_PENDING) == true) {
		return;
	}

	else {
		if (getAction().equals(UpdateManagerConstants.OPERATION_COPY) == true) {
			indent(strb, iIndentation);
			strb.append(UpdateManagerStrings.getString("S_Copy") + ": " + getSource());
		}
		else if (getAction().equals(UpdateManagerConstants.OPERATION_UNZIP_INSTALL) ||
				getAction().equals(UpdateManagerConstants.OPERATION_UNZIP_PLUGINS) == true) {
			indent(strb, iIndentation);
			strb.append(UpdateManagerStrings.getString("S_Install") + ": " + getSource());
		}

		// Obtain messages
		//----------------
		for (int i = 0; i < _alMessages.size(); ++i) {
			indent(strb, iIndentation + 2);
			strb.append(((UMSessionManagerMessage) _alMessages.get(i)).getText());
		}
	}
}
/**
 *
 * @return java.lang.String
 */
public String getTarget() {
	
	return _propertyTarget.getValue();
}
/**
 *
 * @param actionType java.lang.String
 */
public void setAction(String strAction) {
	_propertyAction.setValue( strAction != null ? strAction : UpdateManagerConstants.STRING_EMPTY );
}
/**
 *
 */
public void setId( String strID ) {
	_propertyID.setValue( strID != null ? strID : UpdateManagerConstants.STRING_EMPTY );
}
/**
 *
 */
public void setSource( String strSource ) {
	_propertySource.setValue( strSource != null ? strSource : UpdateManagerConstants.STRING_EMPTY );
}
/**
 *
 */
public void setTarget( String strTarget ) {
	_propertyTarget.setValue( strTarget != null ? strTarget : UpdateManagerConstants.STRING_EMPTY );
}
/**
 *
 * 
 */
public boolean undoCopy(IProgressMonitor progressMonitor) {

	String strErrorMessage = null;

	// Output URL
	//-----------
	URL urlOutput = null;

	try {
		urlOutput = new URL(getTarget());
	}
	catch (MalformedURLException ex) {
		strErrorMessage = createMessageString(UpdateManagerStrings.getString("S_Target_URL_is_malformed"), ex);
	}

	if (urlOutput != null) {

		// Convert the URL to a string
		//----------------------------
		String strFilespec = UMEclipseTree.getFileInPlatformString(urlOutput);

		// Delete the file
		//----------------
		File file = new File(strFilespec);
		if (file.exists() == true) {
			if (file.delete() == false) {
				strErrorMessage = UpdateManagerStrings.getString("S_Unable_to_delete_file") + ": " + strFilespec;
			}
		}
	}

	// Reset the number of attempts
	//-----------------------------
	resetAttemptCount();

	// Error return
	//-------------
	if (strErrorMessage != null) {
		if (getStatus().equals(UpdateManagerConstants.STATUS_SUCCEEDED) == true)
			setStatus(UpdateManagerConstants.STATUS_SUCCEEDED_UNDO_FAILED);
		else
			setStatus(UpdateManagerConstants.STATUS_FAILED_UNDO_FAILED);

		return false;
	}

	// Successful return
	//------------------
	if (getStatus().equals(UpdateManagerConstants.STATUS_SUCCEEDED) == true)
		setStatus(UpdateManagerConstants.STATUS_SUCCEEDED_UNDO_SUCCEEDED);
	else
		setStatus(UpdateManagerConstants.STATUS_FAILED_UNDO_SUCCEEDED);

	return true;
}
/**
 *
 * 
 */
public boolean undoUnzip(IProgressMonitor progressMonitor) {

	String strErrorMessage = null;

	// Input URL
	//----------
	URL urlInput = null;
	try {
		urlInput = new URL(getSource());
	}
	catch (MalformedURLException ex) {
		strErrorMessage = createMessageString(UpdateManagerStrings.getString("S_Source_URL_is_malformed"), ex);
	}

	// Output URL
	//-----------
	URL urlOutput = null;
	try {
		urlOutput = new URL(getTarget());
	}
	catch (MalformedURLException ex) {
		strErrorMessage = createMessageString(UpdateManagerStrings.getString("S_Target_URL_is_malformed"), ex);
	}

	// For plugins or component/configuration jar, 
	// set up the list of directories to look for
	// This section contains subtle differences from doUnzip()
	//--------------------------------------------------------
	Vector dirNames = new Vector();
	ArrayList productVIDs = new ArrayList();
	ArrayList componentVIDs = new ArrayList();
	ArrayList pluginVIDs = new ArrayList();
	ArrayList fragmentVIDs = new ArrayList();
	if (getAction() == UpdateManagerConstants.OPERATION_UNZIP_PLUGINS ) {
		IComponentDescriptor comp = null;
		if (getData() instanceof IComponentEntryDescriptor) {
			comp = ((IComponentEntryDescriptor) getData()).getComponentDescriptor();
		} else {
			comp = (IComponentDescriptor) getData();
		}
		if (comp != null) {
			IPluginEntryDescriptor[] plugins = comp.getPluginEntries();
			for (int i=0; i<plugins.length; i++) {
				dirNames.addElement( UMEclipseTree.PLUGINS_DIR + "/" + plugins[i].getDirName());
				pluginVIDs.add(new LaunchInfo.VersionedIdentifier(plugins[i].getUniqueIdentifier(), plugins[i].getVersionStr()));
			}
			IFragmentEntryDescriptor[] fragments = comp.getFragmentEntries();
			for (int i=0; i<fragments.length; i++) {
				dirNames.addElement( UMEclipseTree.FRAGMENTS_DIR + "/" + fragments[i].getDirName());	
				fragmentVIDs.add(new LaunchInfo.VersionedIdentifier(plugins[i].getUniqueIdentifier(), plugins[i].getVersionStr()));
			}
		} else {
			strErrorMessage = UpdateManagerStrings.getString("S_Error_in_registry");
		}
	} else if (getAction() == UpdateManagerConstants.OPERATION_UNZIP_INSTALL) {
		// rc = UpdateManagerConstants.INSTALL_XML_MISSING;
		if (getData() instanceof IProductDescriptor) {
			IProductDescriptor desc = (IProductDescriptor) getData();
			dirNames.addElement(UMEclipseTree.INSTALL_DIR + "/" + UMEclipseTree.PRODUCTS_DIR + "/" + desc.getDirName() + "/");
			productVIDs.add(new LaunchInfo.VersionedIdentifier(desc.getUniqueIdentifier(), desc.getVersionStr()));
		} else { 
			IComponentDescriptor desc = (IComponentDescriptor) getData();
			dirNames.addElement(UMEclipseTree.INSTALL_DIR + "/" + UMEclipseTree.COMPONENTS_DIR + "/" + desc.getDirName() + "/");
			componentVIDs.add(new LaunchInfo.VersionedIdentifier(desc.getUniqueIdentifier(), desc.getVersionStr()));
		}
	}

		
	// Create a file specification from the input URL
	//-----------------------------------------------
	String strFilespec = UMEclipseTree.getFileInPlatformString(urlInput);

	JarFile jarFile = null;
	
	try {
		jarFile = new JarFile(strFilespec);
	}
	catch (IOException ex) {
		strErrorMessage = createMessageString(UpdateManagerStrings.getString("S_Unable_to_open_Jar_file"), ex);
	}

	if (jarFile != null) {

		JarEntry entry = null;

		int iCount = jarFile.size();

		// Set up progress monitor
		// Compute the filename without the path information
		//--------------------------------------------------
		String strFilename = strFilespec;
		int iIndex = strFilespec.lastIndexOf(File.separatorChar);
		
		if (iIndex >= 0 && iIndex < strFilespec.length() - 1) {
			strFilename = strFilespec.substring(iIndex + 1);
		}
		
		if (progressMonitor != null) progressMonitor.beginTask(UpdateManagerStrings.getString("S_Undo") + ": " + strFilename, iCount);

		// Do each jar file entry
		//-----------------------
		Enumeration enum = jarFile.entries();

		while (enum.hasMoreElements() == true) {
			entry = (JarEntry) enum.nextElement();
			String entryName = entry.getName();
			
			if (getAction().equals(UpdateManagerConstants.OPERATION_UNZIP_PLUGINS)) {
				// Remove the plugins and fragments.  Skip entries not under plugins/ or fragments/ trees
				//----------------------------------------------------------------------------------------
				if ((!entryName.startsWith(UMEclipseTree.PLUGINS_DIR)) &&
					(!entryName.startsWith(UMEclipseTree.FRAGMENTS_DIR))) {
					if (progressMonitor != null) progressMonitor.worked(1);
					continue;
				}												
				if ((entryName.equals(UMEclipseTree.PLUGINS_DIR + "/")) ||
					(entryName.equals(UMEclipseTree.FRAGMENTS_DIR + "/"))) {
					if (progressMonitor != null) progressMonitor.worked(1);
					continue;
				}
				// Don't bother cleaning up the entries not matching the expected list
				// They weren't unzipped in the first place
				//--------------------------------------------------------------------
				String prefix = entryName;
				int second_slash = entryName.indexOf("/", (entryName.indexOf("/")+1));
				if (second_slash > 0) 
					prefix = entryName.substring(0,second_slash);
				int match = dirNames.indexOf(prefix);
				if (match < 0) {   // not a valid plugin
					continue;
				}
			} else if (getAction().equals(UpdateManagerConstants.OPERATION_UNZIP_INSTALL)) {
				// Remove the component/product items.  Skip over entries that don't match the dirname
				//------------------------------------------------------------------------------------
				if (!entryName.startsWith((String)dirNames.firstElement())) {
					if (progressMonitor != null) progressMonitor.worked(1);
					continue;
				}
			} else if (getAction().equals(UpdateManagerConstants.OPERATION_UNZIP_BINDIR)) {
				// No-op.   The bin directory contents cannot be undone
				//-----------------------------------------------------
				break;
			}

			if (urlOutput != null) {
				// Build pathname to actual install location
				//------------------------------------------
				strFilespec = urlOutput.getFile() + "/" + entryName;
				strFilespec = strFilespec.replace('/',File.separatorChar);
				int k = strFilespec.indexOf(UMEclipseTree.DEVICE_SEPARATOR);
				if (k != -1 && strFilespec.startsWith(File.separator)) {
					strFilespec = strFilespec.substring(1);
				}

				// Delete the file or directory
				//-----------------------------
				File file = new File(strFilespec);
				if (file.exists() == true) {
					if (file.isDirectory())
						UpdateManager.cleanupDirectory(file);
					if (file.delete() == false) {
						strErrorMessage = UpdateManagerStrings.getString("S_Unable_to_delete_file") + ": " + strFilespec;
					}
				}
			}
		if (progressMonitor != null) progressMonitor.worked(1);		
		} // while

		try {
			jarFile.close();
		} catch (java.io.IOException ex) {
			// unchecked
		}
	} // if jarFile is not null

	// Call LaunchInfo.installConfirmed if all clean
	//-----------------------------------------------
	if (strErrorMessage == null) {
		if (!LaunchInfo.getCurrent().installConfirmed(productVIDs, componentVIDs, pluginVIDs, fragmentVIDs)) {
			strErrorMessage = UpdateManagerStrings.getString("S_Error_occurred_during_installation_completion");
		}
	}
	
	if (progressMonitor != null) progressMonitor.done();
	
	// Reset the number of attempts
	//-----------------------------
	resetAttemptCount();

	// Error return
	//-------------
	if (strErrorMessage != null) {
		if (getStatus().equals(UpdateManagerConstants.STATUS_SUCCEEDED) == true)
			setStatus(UpdateManagerConstants.STATUS_SUCCEEDED_UNDO_FAILED);
		else
			setStatus(UpdateManagerConstants.STATUS_FAILED_UNDO_FAILED);

		return false;
	}

	// Successful return
	//------------------
	if (getStatus().equals(UpdateManagerConstants.STATUS_SUCCEEDED) == true)
		setStatus(UpdateManagerConstants.STATUS_SUCCEEDED_UNDO_SUCCEEDED);
	else
		setStatus(UpdateManagerConstants.STATUS_FAILED_UNDO_SUCCEEDED);

	return true;
}
/**
 *
 * 
 */
public boolean undoVerify(IProgressMonitor progressMonitor) {
	
	resetAttemptCount();
	
	if (getStatus().equals(UpdateManagerConstants.STATUS_SUCCEEDED) == true)
		setStatus(UpdateManagerConstants.STATUS_SUCCEEDED_UNDO_SUCCEEDED);
	else
		setStatus(UpdateManagerConstants.STATUS_FAILED_UNDO_SUCCEEDED);

	return true;
}
}