1.5/plugins/org.eclipse.epf.library.xmi/src/org/eclipse/epf/library/xmi/XMILibraryUtil.java - epf/org.eclipse.epf.composer - Git at Google

 //------------------------------------------------------------------------------
 // Copyright (c) 2005, 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 implementation
 //------------------------------------------------------------------------------
 package org.eclipse.epf.library.xmi;

 import java.io.File;
 import java.util.HashMap;
 import java.util.Map;

 import org.eclipse.core.resources.IProject;
 import org.eclipse.core.resources.IProjectDescription;
 import org.eclipse.core.resources.IResource;
 import org.eclipse.core.resources.ResourcesPlugin;
 import org.eclipse.core.runtime.CoreException;
 import org.eclipse.core.runtime.IProgressMonitor;
 import org.eclipse.core.runtime.IStatus;
 import org.eclipse.core.runtime.Path;
 import org.eclipse.core.runtime.Platform;
 import org.eclipse.core.runtime.Status;
 import org.eclipse.epf.common.service.versioning.VersionUtil;
 import org.eclipse.epf.common.utils.StrUtil;
 import org.eclipse.epf.library.LibraryPlugin;
 import org.eclipse.epf.library.LibraryResources;
 import org.eclipse.epf.library.LibraryService;
 import org.eclipse.epf.library.LibraryServiceException;
 import org.eclipse.epf.library.util.ResourceUtil;
 import org.eclipse.epf.persistence.MultiFileResourceSetImpl;
 import org.eclipse.epf.persistence.MultiFileSaveUtil;
 import org.eclipse.epf.uma.MethodLibrary;
 import org.eclipse.osgi.util.NLS;

 /**
  * Helper utilities for accessing a XMI method library.
  *
  * @author Kelvin Low
  * @author Phong Nguyen Le
  * @since 1.0
  */
 public class XMILibraryUtil {

 	private static final String EMPTY_METHOD_LIBRARY_PATH_MSG = LibraryResources.emptyLibraryPathError_reason;

 	private static final String MISSING_LIBRARY_FILE_MSG = LibraryResources.missingLibraryFileError_reason;

 	private static final String COULD_NOT_LOCK_LIBRARY_MSG = LibraryResources.couldNotLockLibrary_reason;

 	public static final IStatus EMPTY_METHOD_LIBRARY_PATH_STATUS = new Status(
 			Status.ERROR, LibraryPlugin.getDefault().getId(), 1,
 			EMPTY_METHOD_LIBRARY_PATH_MSG, null);

 	public static final IStatus MISSING_LIBRARY_FILE_STATUS = new Status(
 			Status.ERROR, LibraryPlugin.getDefault().getId(), 1,
 			MISSING_LIBRARY_FILE_MSG, null);

 	public static final IStatus COULD_NOT_LOCK_LIBRARY_STATUS = new Status(
 			Status.ERROR, LibraryPlugin.getDefault().getId(), 1,
 			COULD_NOT_LOCK_LIBRARY_MSG, null);

 	static {
 		try {
 			// TODO: This call is needed to initialize the persistence layer
 			// to avoid a null pointer exception in
 			// PersistenceUtil.conversionRequired(). A better solution is
 			// needed.
 			new MultiFileResourceSetImpl();
 		} catch (Exception e) {
 			e.printStackTrace();
 		}
 	}

 	/**
 	 * Checks whether a method library exists on a given path.
 	 *
 	 * @param path
 	 *            an absolute path to a method library
 	 * @return <code>true</code> if the given path contains a valid method
 	 *         library
 	 */
 	public static boolean hasMethodLibrary(String path) {
 		if (path == null) {
 			throw new IllegalArgumentException();
 		}

 		File libraryDir = new File(path);
 		if (!libraryDir.exists()) {
 			return false;
 		}

 		File libraryFile = new File(libraryDir, XMILibraryManager.LIBRARY_XMI);
 		if (!libraryFile.exists()) {
 			return false;
 		}

 		return true;
 	}

 	/**
 	 * Returns the absolute path to a method library model (library.xmi) file.
 	 *
 	 * @param path
 	 *            an absolute path to a method library
 	 * @returnt an absolute path to a method library model file (if one exists)
 	 */
 	public static String getLibraryModelFile(String path) {
 		if (!StrUtil.isBlank(path)) {
 			String libPath = new File(path).getAbsolutePath();
 			String suffix = File.separator
 					+ MultiFileSaveUtil.DEFAULT_LIBRARY_MODEL_FILENAME;
 			if (libPath.endsWith(suffix)) {
 				return libPath;
 			} else {
 				return libPath + suffix;
 			}
 		}
 		return path;
 	}

 	/**
 	 * Validates a method library path.
 	 *
 	 * @param path
 	 *            an absolute path to a method library
 	 * @param validateModelFile
 	 *            if <code>true</code>, validate that the library.xmi file
 	 *            also exists.
 	 * @return <code>true</code> if the given path is a valid method library
 	 *         folder
 	 */
 	public static IStatus isValidLibrary(String path, boolean validateModelFile) {
 		if (path == null || path.trim().length() == 0) {
 			return EMPTY_METHOD_LIBRARY_PATH_STATUS;
 		}

 		if (validateModelFile) {
 			File libFile = new File(getLibraryModelFile(path));
 			if (!libFile.exists()) {
 				return MISSING_LIBRARY_FILE_STATUS;
 			}
 		}

 		File libPath = new File(path);
 		if (path.endsWith(MultiFileSaveUtil.DEFAULT_LIBRARY_MODEL_FILENAME)) {
 			libPath = libPath.getParentFile();
 		}

 		String libFullPath = libPath.getAbsolutePath();

 		if (libFullPath.startsWith("\\")) { //$NON-NLS-1$
 			// the first part must be a machine name, and you must specify a
 			// folder

 			boolean isValid = true;
 			String uncPath;
 			int index = libFullPath.indexOf(File.separatorChar, 2);
 			if (index < 0) {
 				isValid = false;
 			} else {
 				uncPath = libFullPath.substring(index + 1);
 				if (uncPath.length() == 0) {
 					// must specify a valid path
 					isValid = false;
 				} else {
 					// the top level path must be valid
 					index = libFullPath.indexOf(File.separatorChar, index + 1);
 					if (index < 0) {
 						uncPath = libFullPath;
 					} else {
 						uncPath = libFullPath.substring(0, index);
 					}

 					File f = new File(uncPath);
 					if (!f.exists()) {
 						isValid = false;
 					}
 				}
 			}

 			if (!isValid) {
 				// no new resource string, wait later
 				// return new Status(Status.ERROR,
 				// LibraryPlugin.getDefault().getId(), 1, "Invalid path", null);
 				return EMPTY_METHOD_LIBRARY_PATH_STATUS;
 			}
 		}

 		// Check for presence of a .project file.
 		IProjectDescription description = null;
 		try {
 			description = ResourcesPlugin
 					.getWorkspace()
 					.loadProjectDescription(
 							new Path(libFullPath + File.separator
 									+ IProjectDescription.DESCRIPTION_FILE_NAME));
 			if (description != null) {
 				return Status.OK_STATUS;
 			}
 		} catch (CoreException e) {
 		}

 		// If a .project file does not exists, use it to validate the path.
 		// only call validateProjectLocation if path is not on workspace
 		// for some reason, validateProjectLocation only works on paths not on
 		// the workspace
 		if (Platform.getLocation().isPrefixOf(new Path(libFullPath))) {
 			return Status.OK_STATUS;
 		}
 		IProject project = ResourceUtil.findProject(libFullPath);
 		if (project == null) {
 			project = ResourcesPlugin.getWorkspace().getRoot().getProject(
 					libPath.getName());
 		}

 		return ResourcesPlugin.getWorkspace().validateProjectLocation(project,
 				new Path(libFullPath));
 	}

 	/**
 	 * Validates a method library path.
 	 *
 	 * @param path
 	 *            an absolute path to a method library
 	 * @return <code>true</code> if the given path is a valid method library
 	 *         folder
 	 */
 	public static IStatus isValidLibrary(String path) {
 		return isValidLibrary(path, false);
 	}

 	/**
 	 * Checks whether a method library needs to be upgraded to a new format.
 	 *
 	 * @param path
 	 *            An absolute path to a method library
 	 * @return <code>true</code> if the method library needs to be upgraded
 	 */
 	public static boolean isMethodLibraryUpgradeRequired(String path,
 			VersionUtil.VersionCheckInfo info) {
 		return isMethodLibraryUpgradeRequired(path,
 				XMILibraryManager.LIBRARY_XMI, info);
 	}

 	public static boolean isMethodLibraryUpgradeRequired(String path,
 			String libXmi, VersionUtil.VersionCheckInfo info) {
 		return org.eclipse.epf.persistence.migration.MappingUtil
 				.conversionRequired(path + File.separator + libXmi, info);
 	}

 	/**
 	 * Creates a new XMI method library.
 	 *
 	 * @param name
 	 *            a name for the new method library
 	 * @param path
 	 *            an absolute path to a method library
 	 * @return a method library
 	 * @throw <code>LibraryServiceException</code> if an error occurs while
 	 *        performing the operation
 	 */
 	public static MethodLibrary createMethodLibrary(String name, String path)
 			throws LibraryServiceException {
 		Map<String, Object> args = new HashMap<String, Object>();
 		args.put(XMILibraryManager.ARG_LIBRARY_PATH, path);
 		return LibraryService.getInstance().createMethodLibrary(name,
 				XMILibraryManager.LIBRARY_TYPE, args);
 	}

 	/**
 	 * Opens an existing method library.
 	 *
 	 * @param path
 	 *            an absolute path to a method library
 	 * @return a method library
 	 * @throw <code>LibraryServiceException</code> if an error occurs while
 	 *        performing the operation
 	 */
 	public static MethodLibrary openMethodLibrary(String path)
 			throws LibraryServiceException {
 		Map<String, Object> args = new HashMap<String, Object>();
 		args.put(XMILibraryManager.ARG_LIBRARY_PATH, path);
 		return LibraryService.getInstance().openMethodLibrary(
 				XMILibraryManager.LIBRARY_TYPE, args);
 	}

 	/**
 	 * Opens the method library project associated with a method library.
 	 *
 	 * @param library
 	 *            a method library
 	 * @param monitor
 	 *            a progress monitor
 	 */
 	public static void openMethodLibraryProject(MethodLibrary library,
 			IProgressMonitor monitor) {
 		if (library != null && library.eResource() != null
 				&& library.eResource().getURI().isFile()) {
 			IProject project = ResourceUtil.findProject(library);
 			if (project != null && !project.isOpen()) {
 				try {
 					project.open(IResource.BACKGROUND_REFRESH, monitor);
 				} catch (CoreException e) {
 					XMILibraryPlugin.getDefault().getLogger().logError(e);
 				}
 			}
 		}
 	}

 	/**
 	 * Check if the directory given by specified path contains a plugin or
 	 * config spec export file.
 	 *
 	 * @param path
 	 *            an absolute path to a method library
 	 */
 	public static boolean containsPluginOrConfigSpecExportFile(String path) {
 		if (path == null || path.trim().length() == 0) {
 			return false;
 		}
 		path = new File(path).getAbsolutePath();
 		path += File.separator + XMILibraryManager.exportFile;
 		File exportFile = new File(path);
 		return exportFile.exists();
 	}

 	public static IStatus checkVersion(File file,
 			VersionUtil.VersionCheckInfo info) {
 		if (info != null && info.result > 0) {
 			String message;
 			if (info.toolID.equals(VersionUtil.getPrimaryToolID())) {
 				message = NLS.bind(LibraryResources.oldToolVersion_err_msg,
 						new Object[] { Platform.getProduct().getName(),
 								info.toolVersion, file });
 			} else {
 				message = NLS.bind(
 						LibraryResources.toolVersionMismatch_err_msg,
 						new Object[] { Platform.getProduct().getName() });
 			}
 			return new Status(IStatus.ERROR, XMILibraryPlugin.getDefault()
 					.getId(), 0, message, null);
 		}
 		return Status.OK_STATUS;
 	}
 }
	//------------------------------------------------------------------------------
	// Copyright (c) 2005, 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 implementation
	//------------------------------------------------------------------------------
	package org.eclipse.epf.library.xmi;

	import java.io.File;
	import java.util.HashMap;
	import java.util.Map;

	import org.eclipse.core.resources.IProject;
	import org.eclipse.core.resources.IProjectDescription;
	import org.eclipse.core.resources.IResource;
	import org.eclipse.core.resources.ResourcesPlugin;
	import org.eclipse.core.runtime.CoreException;
	import org.eclipse.core.runtime.IProgressMonitor;
	import org.eclipse.core.runtime.IStatus;
	import org.eclipse.core.runtime.Path;
	import org.eclipse.core.runtime.Platform;
	import org.eclipse.core.runtime.Status;
	import org.eclipse.epf.common.service.versioning.VersionUtil;
	import org.eclipse.epf.common.utils.StrUtil;
	import org.eclipse.epf.library.LibraryPlugin;
	import org.eclipse.epf.library.LibraryResources;
	import org.eclipse.epf.library.LibraryService;
	import org.eclipse.epf.library.LibraryServiceException;
	import org.eclipse.epf.library.util.ResourceUtil;
	import org.eclipse.epf.persistence.MultiFileResourceSetImpl;
	import org.eclipse.epf.persistence.MultiFileSaveUtil;
	import org.eclipse.epf.uma.MethodLibrary;
	import org.eclipse.osgi.util.NLS;

	/**
	* Helper utilities for accessing a XMI method library.
	*
	* @author Kelvin Low
	* @author Phong Nguyen Le
	* @since 1.0
	*/
	public class XMILibraryUtil {

	private static final String EMPTY_METHOD_LIBRARY_PATH_MSG = LibraryResources.emptyLibraryPathError_reason;

	private static final String MISSING_LIBRARY_FILE_MSG = LibraryResources.missingLibraryFileError_reason;

	private static final String COULD_NOT_LOCK_LIBRARY_MSG = LibraryResources.couldNotLockLibrary_reason;

	public static final IStatus EMPTY_METHOD_LIBRARY_PATH_STATUS = new Status(
	Status.ERROR, LibraryPlugin.getDefault().getId(), 1,
	EMPTY_METHOD_LIBRARY_PATH_MSG, null);

	public static final IStatus MISSING_LIBRARY_FILE_STATUS = new Status(
	Status.ERROR, LibraryPlugin.getDefault().getId(), 1,
	MISSING_LIBRARY_FILE_MSG, null);

	public static final IStatus COULD_NOT_LOCK_LIBRARY_STATUS = new Status(
	Status.ERROR, LibraryPlugin.getDefault().getId(), 1,
	COULD_NOT_LOCK_LIBRARY_MSG, null);

	static {
	try {
	// TODO: This call is needed to initialize the persistence layer
	// to avoid a null pointer exception in
	// PersistenceUtil.conversionRequired(). A better solution is
	// needed.
	new MultiFileResourceSetImpl();
	} catch (Exception e) {
	e.printStackTrace();
	}
	}

	/**
	* Checks whether a method library exists on a given path.
	*
	* @param path
	* an absolute path to a method library
	* @return <code>true</code> if the given path contains a valid method
	* library
	*/
	public static boolean hasMethodLibrary(String path) {
	if (path == null) {
	throw new IllegalArgumentException();
	}

	File libraryDir = new File(path);
	if (!libraryDir.exists()) {
	return false;
	}

	File libraryFile = new File(libraryDir, XMILibraryManager.LIBRARY_XMI);
	if (!libraryFile.exists()) {
	return false;
	}

	return true;
	}

	/**
	* Returns the absolute path to a method library model (library.xmi) file.
	*
	* @param path
	* an absolute path to a method library
	* @returnt an absolute path to a method library model file (if one exists)
	*/
	public static String getLibraryModelFile(String path) {
	if (!StrUtil.isBlank(path)) {
	String libPath = new File(path).getAbsolutePath();
	String suffix = File.separator
	+ MultiFileSaveUtil.DEFAULT_LIBRARY_MODEL_FILENAME;
	if (libPath.endsWith(suffix)) {
	return libPath;
	} else {
	return libPath + suffix;
	}
	}
	return path;
	}

	/**
	* Validates a method library path.
	*
	* @param path
	* an absolute path to a method library
	* @param validateModelFile
	* if <code>true</code>, validate that the library.xmi file
	* also exists.
	* @return <code>true</code> if the given path is a valid method library
	* folder
	*/
	public static IStatus isValidLibrary(String path, boolean validateModelFile) {
	if (path == null \|\| path.trim().length() == 0) {
	return EMPTY_METHOD_LIBRARY_PATH_STATUS;
	}

	if (validateModelFile) {
	File libFile = new File(getLibraryModelFile(path));
	if (!libFile.exists()) {
	return MISSING_LIBRARY_FILE_STATUS;
	}
	}

	File libPath = new File(path);
	if (path.endsWith(MultiFileSaveUtil.DEFAULT_LIBRARY_MODEL_FILENAME)) {
	libPath = libPath.getParentFile();
	}

	String libFullPath = libPath.getAbsolutePath();

	if (libFullPath.startsWith("\\")) { //$NON-NLS-1$
	// the first part must be a machine name, and you must specify a
	// folder

	boolean isValid = true;
	String uncPath;
	int index = libFullPath.indexOf(File.separatorChar, 2);
	if (index < 0) {
	isValid = false;
	} else {
	uncPath = libFullPath.substring(index + 1);
	if (uncPath.length() == 0) {
	// must specify a valid path
	isValid = false;
	} else {
	// the top level path must be valid
	index = libFullPath.indexOf(File.separatorChar, index + 1);
	if (index < 0) {
	uncPath = libFullPath;
	} else {
	uncPath = libFullPath.substring(0, index);
	}

	File f = new File(uncPath);
	if (!f.exists()) {
	isValid = false;
	}
	}
	}

	if (!isValid) {
	// no new resource string, wait later
	// return new Status(Status.ERROR,
	// LibraryPlugin.getDefault().getId(), 1, "Invalid path", null);
	return EMPTY_METHOD_LIBRARY_PATH_STATUS;
	}
	}

	// Check for presence of a .project file.
	IProjectDescription description = null;
	try {
	description = ResourcesPlugin
	.getWorkspace()
	.loadProjectDescription(
	new Path(libFullPath + File.separator
	+ IProjectDescription.DESCRIPTION_FILE_NAME));
	if (description != null) {
	return Status.OK_STATUS;
	}
	} catch (CoreException e) {
	}

	// If a .project file does not exists, use it to validate the path.
	// only call validateProjectLocation if path is not on workspace
	// for some reason, validateProjectLocation only works on paths not on
	// the workspace
	if (Platform.getLocation().isPrefixOf(new Path(libFullPath))) {
	return Status.OK_STATUS;
	}
	IProject project = ResourceUtil.findProject(libFullPath);
	if (project == null) {
	project = ResourcesPlugin.getWorkspace().getRoot().getProject(
	libPath.getName());
	}

	return ResourcesPlugin.getWorkspace().validateProjectLocation(project,
	new Path(libFullPath));
	}

	/**
	* Validates a method library path.
	*
	* @param path
	* an absolute path to a method library
	* @return <code>true</code> if the given path is a valid method library
	* folder
	*/
	public static IStatus isValidLibrary(String path) {
	return isValidLibrary(path, false);
	}

	/**
	* Checks whether a method library needs to be upgraded to a new format.
	*
	* @param path
	* An absolute path to a method library
	* @return <code>true</code> if the method library needs to be upgraded
	*/
	public static boolean isMethodLibraryUpgradeRequired(String path,
	VersionUtil.VersionCheckInfo info) {
	return isMethodLibraryUpgradeRequired(path,
	XMILibraryManager.LIBRARY_XMI, info);
	}

	public static boolean isMethodLibraryUpgradeRequired(String path,
	String libXmi, VersionUtil.VersionCheckInfo info) {
	return org.eclipse.epf.persistence.migration.MappingUtil
	.conversionRequired(path + File.separator + libXmi, info);
	}

	/**
	* Creates a new XMI method library.
	*
	* @param name
	* a name for the new method library
	* @param path
	* an absolute path to a method library
	* @return a method library
	* @throw <code>LibraryServiceException</code> if an error occurs while
	* performing the operation
	*/
	public static MethodLibrary createMethodLibrary(String name, String path)
	throws LibraryServiceException {
	Map<String, Object> args = new HashMap<String, Object>();
	args.put(XMILibraryManager.ARG_LIBRARY_PATH, path);
	return LibraryService.getInstance().createMethodLibrary(name,
	XMILibraryManager.LIBRARY_TYPE, args);
	}

	/**
	* Opens an existing method library.
	*
	* @param path
	* an absolute path to a method library
	* @return a method library
	* @throw <code>LibraryServiceException</code> if an error occurs while
	* performing the operation
	*/
	public static MethodLibrary openMethodLibrary(String path)
	throws LibraryServiceException {
	Map<String, Object> args = new HashMap<String, Object>();
	args.put(XMILibraryManager.ARG_LIBRARY_PATH, path);
	return LibraryService.getInstance().openMethodLibrary(
	XMILibraryManager.LIBRARY_TYPE, args);
	}

	/**
	* Opens the method library project associated with a method library.
	*
	* @param library
	* a method library
	* @param monitor
	* a progress monitor
	*/
	public static void openMethodLibraryProject(MethodLibrary library,
	IProgressMonitor monitor) {
	if (library != null && library.eResource() != null
	&& library.eResource().getURI().isFile()) {
	IProject project = ResourceUtil.findProject(library);
	if (project != null && !project.isOpen()) {
	try {
	project.open(IResource.BACKGROUND_REFRESH, monitor);
	} catch (CoreException e) {
	XMILibraryPlugin.getDefault().getLogger().logError(e);
	}
	}
	}
	}

	/**
	* Check if the directory given by specified path contains a plugin or
	* config spec export file.
	*
	* @param path
	* an absolute path to a method library
	*/
	public static boolean containsPluginOrConfigSpecExportFile(String path) {
	if (path == null \|\| path.trim().length() == 0) {
	return false;
	}
	path = new File(path).getAbsolutePath();
	path += File.separator + XMILibraryManager.exportFile;
	File exportFile = new File(path);
	return exportFile.exists();
	}

	public static IStatus checkVersion(File file,
	VersionUtil.VersionCheckInfo info) {
	if (info != null && info.result > 0) {
	String message;
	if (info.toolID.equals(VersionUtil.getPrimaryToolID())) {
	message = NLS.bind(LibraryResources.oldToolVersion_err_msg,
	new Object[] { Platform.getProduct().getName(),
	info.toolVersion, file });
	} else {
	message = NLS.bind(
	LibraryResources.toolVersionMismatch_err_msg,
	new Object[] { Platform.getProduct().getName() });
	}
	return new Status(IStatus.ERROR, XMILibraryPlugin.getDefault()
	.getId(), 0, message, null);
	}
	return Status.OK_STATUS;
	}
	}