BuilderUtil.java

/*******************************************************************************
 * Copyright (c) 2006-2010 eBay Inc. All Rights Reserved.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *    http://www.apache.org/licenses/LICENSE-2.0
 *******************************************************************************/
package org.ebayopensource.turmeric.eclipse.buildsystem.utils;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

import javax.wsdl.Definition;

import org.apache.commons.io.FileUtils;
import org.apache.commons.lang.StringUtils;
import org.ebayopensource.turmeric.eclipse.buildsystem.resources.SOAMessages;
import org.ebayopensource.turmeric.eclipse.core.logging.SOALogger;
import org.ebayopensource.turmeric.eclipse.core.resources.constants.SOAProjectConstants;
import org.ebayopensource.turmeric.eclipse.exception.core.SOANullParameterException;
import org.ebayopensource.turmeric.eclipse.exception.resources.SOAResourceNotAccessibleException;
import org.ebayopensource.turmeric.eclipse.repositorysystem.model.BaseCodeGenModel;
import org.ebayopensource.turmeric.eclipse.repositorysystem.utils.TurmericServiceUtils;
import org.ebayopensource.turmeric.eclipse.resources.model.ISOAConsumerProject.SOAClientConfig;
import org.ebayopensource.turmeric.eclipse.resources.model.SOAImplMetadata;
import org.ebayopensource.turmeric.eclipse.resources.util.SOAConsumerUtil;
import org.ebayopensource.turmeric.eclipse.resources.util.SOAImplUtil;
import org.ebayopensource.turmeric.eclipse.resources.util.SOAServiceUtil;
import org.ebayopensource.turmeric.eclipse.utils.lang.StringUtil;
import org.ebayopensource.turmeric.eclipse.utils.plugin.JDTUtil;
import org.ebayopensource.turmeric.eclipse.utils.plugin.ProgressUtil;
import org.ebayopensource.turmeric.eclipse.utils.plugin.WorkspaceUtil;
import org.ebayopensource.turmeric.eclipse.utils.wsdl.WSDLUtil;
import org.eclipse.core.resources.ICommand;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IFolder;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IProjectDescription;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IResourceDelta;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.jdt.core.IClasspathEntry;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.JavaCore;


/**
 * The standard Utility class for the builder. Most builders will need the code
 * generation models and engine in their functions. This utility mainly caters
 * these two objects so that the builder has a commonality in the way in which
 * they invoke the code generation engine.
 * 
 * @author smathew
 * 
 */
public class BuilderUtil {

	/**
	 * Foundation Code generation Model for builders. This is the base code
	 * generation model which will be specialized before used in most cases.
	 * Fills the metadata file(properties file) information into this model. All
	 * the common data that any model required will be filled in at this phase.
	 * But The gen type that is the most crucial factor is not decided here. It
	 * is decided in the specialization phase. Its also called heavily from
	 * context menu actions which includes codegen.
	 *
	 * @param project the project
	 * @param monitor the monitor
	 * @return the base code gen model
	 * @throws Exception the exception
	 */
	public static BaseCodeGenModel buildBaseCodeGenModel(final IProject project, 
			final IProgressMonitor monitor)
			throws Exception {
		return ModelTransformer.generateCodeGenModel(project, monitor);
	}

	/**
	 * Returns trues if the WSDL file is changed. This is not a straight forward
	 * API. It does not care about the changes in the WSDL file if it is not an
	 * interface projects. So please don't use it as a generic API.
	 *
	 * @param delta the delta
	 * @param project the project
	 * @return true, if is wSDL file changed
	 * @throws CoreException the core exception
	 */
	public static boolean isWSDLFileChanged(IResourceDelta delta,
			IProject project) throws CoreException {
		if (TurmericServiceUtils.isSOAInterfaceProject(project) == false)
			return false;
		final IFile wsdlFile = SOAServiceUtil.getWsdlFile(project, project
				.getName());
		return isWSDLFileChanged(delta, wsdlFile.getFullPath());
	}

	/**
	 * Parses the delta and returns true if the WSDL file is changed. Recursive
	 * function but does not use the visitor pattern.
	 * 
	 * @param delta
	 * @param wsdlPath
	 * @return
	 */
	private static boolean isWSDLFileChanged(IResourceDelta delta,
			IPath wsdlPath) {
		if (delta == null)
			return false;
		for (IResourceDelta childDelta : delta
				.getAffectedChildren(IResourceDelta.CHANGED)) {
			if (childDelta.getFullPath().equals(wsdlPath))
				return true;
			else if (isWSDLFileChanged(childDelta, wsdlPath)) {
				return true;
			}
		}
		return false;
	}

	/**
	 * Returns true if the WSDL target name space has been changed in an
	 * interface project. To be precise, it does NOT compare the WSDl's old name
	 * space and the new name space, but compares the WSDL's current namespace
	 * to the namespace in the implementation projects metadata file.
	 *
	 * @param delta the delta
	 * @param serviceName the service name
	 * @param intfProject the intf project
	 * @param implProject the impl project
	 * @return null means no change or the new targetNamespace otherwise.
	 * @throws Exception the exception
	 */
	public static String isWSDLTargetNamespaceChanged(IResourceDelta delta,
			String serviceName, IProject intfProject, IProject implProject)
			throws Exception {
		final IFile wsdlFile = SOAServiceUtil.getWsdlFile(intfProject,
				serviceName);
		if (isWSDLFileChanged(delta, wsdlFile.getFullPath()) == false)
			return null;
		final Definition wsdl = WSDLUtil.readWSDL(wsdlFile.getLocation()
				.toString());
		final SOAImplMetadata metadata = SOAImplUtil.loadServiceConfig(
				implProject, serviceName);
		if (!StringUtils.equals(wsdl.getTargetNamespace(), metadata
				.getTargetNamespace())) {
			return wsdl.getTargetNamespace();
		}
		return null;
	}

	/**
	 * Returns true if the WSDL target name space has been changed in an
	 * interface project. To be precise, it does NOT compare the WSDl's old name
	 * space and the new name space, but compares the WSDL's current namespace
	 * to the namespace in the client config file of the consumer.
	 *
	 * @param serviceName the service name
	 * @param intfProject the intf project
	 * @param consumerProject the consumer project
	 * @return null means no change or the new targetNamespace otherwise.
	 * @throws Exception the exception
	 */
	public static String isWSDLTargetNamespaceChangedInConsumerProject(
			String serviceName, IProject intfProject, IProject consumerProject)
			throws Exception {
		final IFile wsdlFile = SOAServiceUtil.getWsdlFile(intfProject,
				serviceName);
		if (wsdlFile.isAccessible() == false)
			return null;
		final Definition wsdl = WSDLUtil.readWSDL(wsdlFile.getLocation()
				.toString());
		String envName = null; 
		if (SOAConsumerUtil.isOldClientConfigDirStructure(consumerProject) == false) {
			List<String> envs = SOAConsumerUtil.getClientEnvironmentList(consumerProject, null);
			if (envs.isEmpty() == false)
				envName = envs.get(0);
		}
		
		final SOAClientConfig clientConfig = SOAConsumerUtil.loadClientConfig(
				consumerProject, envName, serviceName);
		if (clientConfig == null)
			return null;
		if (!StringUtils.equals(wsdl.getTargetNamespace(), clientConfig
				.getTargetNamespace())) {
			return wsdl.getTargetNamespace();
		}
		return null;
	}

	/**
	 * This algorithm is the decision maker for all SOA builders. If this is
	 * true builder gets kicked off and return silently otherwise. Remember
	 * there are two builders most of the time and its very imp to silently
	 * return at some point of time to avoid cyclic builds.
	 *
	 * @param delta the delta
	 * @param project the project
	 * @param criteriaString -
	 * this is mostly the extensions that we are interested in
	 * rebuilding. something like WSDT EXT, XSD EXT etc
	 * @return true, if successful
	 * @throws Exception the exception
	 */
	public static boolean shouldBuild(IResourceDelta delta, IProject project,
			String... criteriaString) throws Exception {
		// first time the delta is null
		if (delta == null)
			return true;
		BuildResourceDeltaVisitor buildDeltaVisitor = new BuildResourceDeltaVisitor(
				project, criteriaString);
		delta.accept(buildDeltaVisitor);
		return buildDeltaVisitor.isBuildRequired();
	}

	/**
	 * This is required because V3 appears to mess with the build order. This
	 * will stay here until V3 comes up with a bug fix.
	 *
	 * @param project the project
	 * @throws CoreException the core exception
	 */
	public static void reOrderBuildersIfRequired(IProject project)
			throws CoreException {
		ICommand commands[] = project.getDescription().getBuildSpec();
		List<ICommand> oldList = Arrays.asList(commands);
		List<ICommand> newList = new ArrayList<ICommand>();
		for (ICommand command : commands) {
			newList.add(command);
		}

		// Scanning if the order has changed
		for (int i = 0; i < newList.size(); i++) {
			// true means order changed
			if (!StringUtils.equals(oldList.get(i).getBuilderName(), newList
					.get(i).getBuilderName())) {
				IProjectDescription description = project.getDescription();
				description.setBuildSpec(newList.toArray(new ICommand[0]));
				project.setDescription(description, IResource.FORCE,
						ProgressUtil.getDefaultMonitor(null));
			}
		}
	}

	/**
	 * Cleans the bin/META-INF folder and do a refresh.
	 *
	 * @param project the project
	 * @param monitor the monitor
	 * @throws IOException Signals that an I/O exception has occurred.
	 * @throws CoreException the core exception
	 */
	public static void cleanBinMetaInfDir(final IProject project,
			IProgressMonitor monitor) throws IOException, CoreException {
		final IFolder metaFolder = project
				.getFolder(SOAProjectConstants.FOLDER_OUTPUT_DIR
						+ WorkspaceUtil.PATH_SEPERATOR
						+ SOAProjectConstants.FOLDER_META_INF);
		metaFolder.getParent().refreshLocal(IResource.DEPTH_ONE, monitor);
		if (metaFolder.isAccessible()) {
			SOALogger.getLogger().warning(
					StringUtil.formatString(SOAMessages.CLEAN_FOLDER, metaFolder
							.getLocation()));
			FileUtils.cleanDirectory(metaFolder.getLocation().toFile());
		}
	}

	/**
	 * Returns the required project for any given project. Scans the build bath
	 * and finds all the project references and returns it back.
	 *
	 * @param project the project
	 * @param natureIds the nature ids
	 * @return the required projects
	 */
	public static IProject[] getRequiredProjects(IProject project,
			String... natureIds) {
		IJavaProject javaProject = JavaCore.create(project);
		if (javaProject == null)
			return new IProject[0];
		ArrayList<IProject> projects = new ArrayList<IProject>();
		try {
			for (final IClasspathEntry entry : javaProject
					.getResolvedClasspath(true)) {
				if (entry.getEntryKind() == IClasspathEntry.CPE_PROJECT) {
					IProject reqProject = WorkspaceUtil.getProject(entry
							.getPath());
					if (reqProject != null && !projects.contains(reqProject)) {
						if (natureIds != null) {
							for (String natureId : natureIds) {
								if (reqProject.hasNature(natureId)) {
									projects.add(reqProject);
									break;
								}
							}
						} else {
							projects.add(reqProject);
						}
					}
				}
			}
		} catch (Exception e) {
			return new IProject[0];
		}
		IProject[] result = new IProject[projects.size()];
		projects.toArray(result);
		return result;
	}

	/**
	 * Creates missing source folders as per the projects java model. If it
	 * exists, it is a no operation.
	 *
	 * @param project the project
	 * @param monitor the monitor
	 * @throws CoreException the core exception
	 */
	public static void generateSourceDirectories(final IProject project,
			final IProgressMonitor monitor) throws CoreException {
		if (project == null || project.isAccessible() == false)
			return;
		final IPath projectPath = project.getFullPath();
		final List<String> missingFolders = new ArrayList<String>();
		for (IPath srcPath : JDTUtil.getSourceDirectories(project)) {
			if (projectPath.isPrefixOf(srcPath)) {
				srcPath = srcPath.removeFirstSegments(1);
			}
			final IFolder srcFolder = project.getFolder(srcPath);
			if (!srcFolder.exists()) {
				srcFolder.refreshLocal(IResource.DEPTH_ZERO, monitor);
				if (srcFolder.exists() == false) {
					missingFolders.add(srcPath.toString());
				}
			}
		}
		if (missingFolders.isEmpty() == false) {
			WorkspaceUtil.createFolders(project, missingFolders, monitor);
		}
	}

	/**
	 * Deletes the gen folder content of interface projects(for now). The types
	 * are generated in the folder and we don't want stale java types to live
	 * there. Washing it out in this call.
	 *
	 * @param project the project
	 * @throws CoreException the core exception
	 * @throws SOANullParameterException the sOA null parameter exception
	 * @throws SOAResourceNotAccessibleException the sOA resource not accessible exception
	 */
	public static void cleanGenFolders(IProject project) throws CoreException,
			SOANullParameterException, SOAResourceNotAccessibleException {
		// Intf Project
		if (TurmericServiceUtils.isSOAInterfaceProject(project)) {
			IFolder clientFolder = project
					.getFolder(SOAProjectConstants.FOLDER_GEN_SRC_CLIENT);
			WorkspaceUtil.deleteContents(clientFolder, true);

		}
	}
}