plugins/org.eclipse.sphinx.emf.mwe.dynamic/src/org/eclipse/sphinx/emf/mwe/dynamic/internal/WorkflowInstanceFactory.java - sphinx/org.eclipse.sphinx - Git at Google

 /**
  * <copyright>
  *
  * Copyright (c) 2016 itemis and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v2.0
  * which accompanies this distribution, and is available at
  * https://www.eclipse.org/org/documents/epl-2.0/EPL-2.0.html
  *
  * Contributors:
  *     itemis - Initial API and implementation
  *
  * </copyright>
  */
 package org.eclipse.sphinx.emf.mwe.dynamic.internal;

 import java.lang.reflect.Field;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;

 import org.apache.commons.lang.ClassUtils;
 import org.eclipse.core.resources.IFile;
 import org.eclipse.core.runtime.Assert;
 import org.eclipse.core.runtime.CoreException;
 import org.eclipse.core.runtime.IStatus;
 import org.eclipse.emf.mwe2.runtime.workflow.IWorkflowComponent;
 import org.eclipse.emf.mwe2.runtime.workflow.Workflow;
 import org.eclipse.jdt.core.ICompilationUnit;
 import org.eclipse.jdt.core.IJavaElement;
 import org.eclipse.jdt.core.IType;
 import org.eclipse.sphinx.emf.mwe.dynamic.WorkflowContributorRegistry;
 import org.eclipse.sphinx.emf.mwe.dynamic.WorkspaceWorkflow;
 import org.eclipse.sphinx.emf.mwe.dynamic.annotations.WorkflowParameter;
 import org.eclipse.sphinx.emf.mwe.dynamic.util.XtendUtil;
 import org.eclipse.sphinx.jdt.loaders.ProjectClassLoader;
 import org.eclipse.sphinx.platform.util.PlatformLogUtil;
 import org.eclipse.sphinx.platform.util.StatusUtil;

 public class WorkflowInstanceFactory {

 	public Workflow createWorkflowInstance(Object workflow) throws CoreException {
 		try {
 			// Retrieve workflow class
 			Class<Workflow> workflowClass = getWorkflowClass(workflow);
 			if (workflowClass == null) {
 				return null;
 			}

 			// Create workflow instance
 			return workflowClass.newInstance();
 		} catch (CoreException ex) {
 			throw ex;
 		} catch (Exception ex) {
 			IStatus status = StatusUtil.createErrorStatus(Activator.getPlugin(), ex);
 			throw new CoreException(status);
 		}
 	}

 	public Workflow createWorkflowInstance(Object workflow, Map<String, Object> arguments) throws CoreException {
 		// Create workflow instance
 		Workflow workflowInstance = createWorkflowInstance(workflow);

 		// Inject arguments into workflow instance and its components as appropriate
 		injectArguments(workflowInstance, arguments);
 		return workflowInstance;
 	}

 	protected Class<Workflow> getWorkflowClass(Object workflow) throws CoreException {
 		IType workflowType = getWorkflowType(workflow);
 		if (workflowType != null) {
 			return loadWorkflowClass(workflowType);
 		}
 		return doGetWorkflowClass(workflow);
 	}

 	protected Class<Workflow> doGetWorkflowClass(Object workflow) throws CoreException {
 		if (workflow instanceof Class<?>) {
 			Class<?> clazz = (Class<?>) workflow;
 			if (!Workflow.class.isAssignableFrom(clazz)) {
 				Exception ex = new IllegalStateException("Workflow class '" + clazz.getName() + "' is not a subclass of " + Workflow.class.getName()); //$NON-NLS-1$ //$NON-NLS-2$
 				IStatus status = StatusUtil.createErrorStatus(Activator.getPlugin(), ex);
 				throw new CoreException(status);
 			}
 			@SuppressWarnings("unchecked")
 			Class<Workflow> workflowClass = (Class<Workflow>) clazz;
 			return workflowClass;
 		} else {

 		}
 		return null;
 	}

 	protected IType getWorkflowType(Object workflow) {
 		if (workflow instanceof IType) {
 			return (IType) workflow;
 		}
 		if (workflow instanceof ICompilationUnit) {
 			return ((ICompilationUnit) workflow).findPrimaryType();
 		}
 		if (workflow instanceof IFile) {
 			IJavaElement workflowJavaElement = XtendUtil.getJavaElement((IFile) workflow);
 			if (workflowJavaElement instanceof ICompilationUnit) {
 				return ((ICompilationUnit) workflowJavaElement).findPrimaryType();
 			}
 		}
 		return null;
 	}

 	protected Class<Workflow> loadWorkflowClass(IType workflowType) throws CoreException {
 		Assert.isNotNull(workflowType);

 		try {
 			// Find out where given workflow type originates from
 			if (!workflowType.isBinary()) {
 				// Workflow type refers to an on-the-fly compiled Java class in the runtime workspace

 				// Create project class loader capable of loading Java class behind workflow type from underlying Java
 				// or plug-in project in runtime workspace
 				ProjectClassLoader projectClassLoader = new ProjectClassLoader(workflowType.getJavaProject());

 				// TODO Surround with appropriate tracing option
 				// ClassLoaderExtensions.printHierarchy(projectClassLoader);

 				// Use project class loader to load Java class behind workflow type
 				Class<?> clazz = projectClassLoader.loadClass(workflowType.getFullyQualifiedName());
 				if (!Workflow.class.isAssignableFrom(clazz)) {
 					throw new IllegalStateException("Workflow class '" + clazz.getName() + "' is not a subclass of " + Workflow.class.getName()); //$NON-NLS-1$ //$NON-NLS-2$
 				}
 				@SuppressWarnings("unchecked")
 				Class<Workflow> workflowClass = (Class<Workflow>) clazz;
 				return workflowClass;
 			} else {
 				// Workflow type refers to a binary Java class from the running Eclipse instance

 				// Load Java class behind workflow type from underlying contributor plug-in
 				return WorkflowContributorRegistry.INSTANCE.loadContributedWorkflowClass(workflowType);
 			}
 		} catch (CoreException ex) {
 			throw ex;
 		} catch (Exception ex) {
 			IStatus status = StatusUtil.createErrorStatus(Activator.getPlugin(), ex);
 			throw new CoreException(status);
 		}
 	}

 	public Map<String, Class<?>> getWorkflowParameters(Workflow workflowInstance) {
 		// Retrieve parameters of workflow class itself
 		Map<String, Class<?>> workflowParameters = doGetWorkflowParameters(workflowInstance.getClass());

 		// Retrive parameters of workflow components if any
 		if (workflowInstance instanceof WorkspaceWorkflow) {
 			List<IWorkflowComponent> children = ((WorkspaceWorkflow) workflowInstance).getChildren();
 			for (IWorkflowComponent component : children) {
 				workflowParameters.putAll(doGetWorkflowParameters(component.getClass()));
 			}
 		}
 		return workflowParameters;
 	}

 	protected Map<String, Class<?>> doGetWorkflowParameters(Class<?> clazz) {
 		// Establish ordered map of workflow parameters
 		Map<String, Class<?>> workflowParameters = new LinkedHashMap<>();
 		for (Field field : clazz.getDeclaredFields()) {
 			if (isWorkflowParameter(field)) {
 				String name = getWorkflowParameterName(field);
 				workflowParameters.put(name, field.getType());
 			}
 		}
 		return workflowParameters;
 	}

 	protected boolean isWorkflowParameter(Field field) {
 		Assert.isNotNull(field);

 		return field.getAnnotation(WorkflowParameter.class) != null;
 	}

 	protected String getWorkflowParameterName(Field parameterField) {
 		Assert.isNotNull(parameterField);
 		Assert.isLegal(isWorkflowParameter(parameterField));

 		// Retrieve workflow parameter name - use field name if no such has been annotated explicitly
 		WorkflowParameter annotation = parameterField.getAnnotation(WorkflowParameter.class);
 		String value = annotation.value();
 		return value != null && !value.isEmpty() ? value : parameterField.getName();
 	}

 	protected boolean isWorkflowParameterTypeAssignableFrom(Class<?> parameterType, Class<?> valueType) {
 		if (parameterType.isPrimitive()) {
 			return ClassUtils.isAssignable(parameterType, valueType, true);
 		}
 		return parameterType.isAssignableFrom(valueType);
 	}

 	protected void setWorkflowParameterValue(Object object, Field parameterField, Object value) throws CoreException {
 		Assert.isNotNull(object);
 		Assert.isNotNull(parameterField);
 		Assert.isLegal(isWorkflowParameter(parameterField));

 		boolean oldAccessible = parameterField.isAccessible();
 		parameterField.setAccessible(true);
 		try {
 			parameterField.set(object, value);
 		} catch (Exception ex) {
 			IStatus status = StatusUtil.createErrorStatus(Activator.getPlugin(), ex);
 			throw new CoreException(status);
 		} finally {
 			parameterField.setAccessible(oldAccessible);
 		}
 	}

 	public void injectArguments(Workflow workflowInstance, Map<String, Object> arguments) throws CoreException {
 		Assert.isNotNull(workflowInstance);

 		// Inject arguments into workflow itself
 		doInjectArguments(workflowInstance, arguments);

 		// Inject arguments into workflow components
 		if (workflowInstance instanceof WorkspaceWorkflow) {
 			List<IWorkflowComponent> children = ((WorkspaceWorkflow) workflowInstance).getChildren();
 			for (IWorkflowComponent component : children) {
 				doInjectArguments(component, arguments);
 			}
 		}
 	}

 	protected void doInjectArguments(Object object, Map<String, Object> arguments) throws CoreException {
 		Class<?> clazz = object.getClass();
 		for (Field field : clazz.getDeclaredFields()) {
 			if (isWorkflowParameter(field)) {
 				String name = getWorkflowParameterName(field);
 				Object value = arguments.get(name);
 				if (value != null) {
 					if (isWorkflowParameterTypeAssignableFrom(field.getType(), value.getClass())) {
 						setWorkflowParameterValue(object, field, value);
 					} else {
 						RuntimeException ex = new RuntimeException("Workflow argument '" + name + " : " + value.getClass().getName() //$NON-NLS-1$ //$NON-NLS-2$
 								+ "' cannot be assigned to workflow parameter '" + field.getName() + " : " + field.getType().getName() //$NON-NLS-1$ //$NON-NLS-2$
 								+ "'"); //$NON-NLS-1$
 						PlatformLogUtil.logAsWarning(Activator.getPlugin(), ex);
 					}
 				}
 			}
 		}
 	}
 }
	/**
	* <copyright>
	*
	* Copyright (c) 2016 itemis and others.
	* All rights reserved. This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License v2.0
	* which accompanies this distribution, and is available at
	* https://www.eclipse.org/org/documents/epl-2.0/EPL-2.0.html
	*
	* Contributors:
	* itemis - Initial API and implementation
	*
	* </copyright>
	*/
	package org.eclipse.sphinx.emf.mwe.dynamic.internal;

	import java.lang.reflect.Field;
	import java.util.LinkedHashMap;
	import java.util.List;
	import java.util.Map;

	import org.apache.commons.lang.ClassUtils;
	import org.eclipse.core.resources.IFile;
	import org.eclipse.core.runtime.Assert;
	import org.eclipse.core.runtime.CoreException;
	import org.eclipse.core.runtime.IStatus;
	import org.eclipse.emf.mwe2.runtime.workflow.IWorkflowComponent;
	import org.eclipse.emf.mwe2.runtime.workflow.Workflow;
	import org.eclipse.jdt.core.ICompilationUnit;
	import org.eclipse.jdt.core.IJavaElement;
	import org.eclipse.jdt.core.IType;
	import org.eclipse.sphinx.emf.mwe.dynamic.WorkflowContributorRegistry;
	import org.eclipse.sphinx.emf.mwe.dynamic.WorkspaceWorkflow;
	import org.eclipse.sphinx.emf.mwe.dynamic.annotations.WorkflowParameter;
	import org.eclipse.sphinx.emf.mwe.dynamic.util.XtendUtil;
	import org.eclipse.sphinx.jdt.loaders.ProjectClassLoader;
	import org.eclipse.sphinx.platform.util.PlatformLogUtil;
	import org.eclipse.sphinx.platform.util.StatusUtil;

	public class WorkflowInstanceFactory {

	public Workflow createWorkflowInstance(Object workflow) throws CoreException {
	try {
	// Retrieve workflow class
	Class<Workflow> workflowClass = getWorkflowClass(workflow);
	if (workflowClass == null) {
	return null;
	}

	// Create workflow instance
	return workflowClass.newInstance();
	} catch (CoreException ex) {
	throw ex;
	} catch (Exception ex) {
	IStatus status = StatusUtil.createErrorStatus(Activator.getPlugin(), ex);
	throw new CoreException(status);
	}
	}

	public Workflow createWorkflowInstance(Object workflow, Map<String, Object> arguments) throws CoreException {
	// Create workflow instance
	Workflow workflowInstance = createWorkflowInstance(workflow);

	// Inject arguments into workflow instance and its components as appropriate
	injectArguments(workflowInstance, arguments);
	return workflowInstance;
	}

	protected Class<Workflow> getWorkflowClass(Object workflow) throws CoreException {
	IType workflowType = getWorkflowType(workflow);
	if (workflowType != null) {
	return loadWorkflowClass(workflowType);
	}
	return doGetWorkflowClass(workflow);
	}

	protected Class<Workflow> doGetWorkflowClass(Object workflow) throws CoreException {
	if (workflow instanceof Class<?>) {
	Class<?> clazz = (Class<?>) workflow;
	if (!Workflow.class.isAssignableFrom(clazz)) {
	Exception ex = new IllegalStateException("Workflow class '" + clazz.getName() + "' is not a subclass of " + Workflow.class.getName()); //$NON-NLS-1$ //$NON-NLS-2$
	IStatus status = StatusUtil.createErrorStatus(Activator.getPlugin(), ex);
	throw new CoreException(status);
	}
	@SuppressWarnings("unchecked")
	Class<Workflow> workflowClass = (Class<Workflow>) clazz;
	return workflowClass;
	} else {

	}
	return null;
	}

	protected IType getWorkflowType(Object workflow) {
	if (workflow instanceof IType) {
	return (IType) workflow;
	}
	if (workflow instanceof ICompilationUnit) {
	return ((ICompilationUnit) workflow).findPrimaryType();
	}
	if (workflow instanceof IFile) {
	IJavaElement workflowJavaElement = XtendUtil.getJavaElement((IFile) workflow);
	if (workflowJavaElement instanceof ICompilationUnit) {
	return ((ICompilationUnit) workflowJavaElement).findPrimaryType();
	}
	}
	return null;
	}

	protected Class<Workflow> loadWorkflowClass(IType workflowType) throws CoreException {
	Assert.isNotNull(workflowType);

	try {
	// Find out where given workflow type originates from
	if (!workflowType.isBinary()) {
	// Workflow type refers to an on-the-fly compiled Java class in the runtime workspace

	// Create project class loader capable of loading Java class behind workflow type from underlying Java
	// or plug-in project in runtime workspace
	ProjectClassLoader projectClassLoader = new ProjectClassLoader(workflowType.getJavaProject());

	// TODO Surround with appropriate tracing option
	// ClassLoaderExtensions.printHierarchy(projectClassLoader);

	// Use project class loader to load Java class behind workflow type
	Class<?> clazz = projectClassLoader.loadClass(workflowType.getFullyQualifiedName());
	if (!Workflow.class.isAssignableFrom(clazz)) {
	throw new IllegalStateException("Workflow class '" + clazz.getName() + "' is not a subclass of " + Workflow.class.getName()); //$NON-NLS-1$ //$NON-NLS-2$
	}
	@SuppressWarnings("unchecked")
	Class<Workflow> workflowClass = (Class<Workflow>) clazz;
	return workflowClass;
	} else {
	// Workflow type refers to a binary Java class from the running Eclipse instance

	// Load Java class behind workflow type from underlying contributor plug-in
	return WorkflowContributorRegistry.INSTANCE.loadContributedWorkflowClass(workflowType);
	}
	} catch (CoreException ex) {
	throw ex;
	} catch (Exception ex) {
	IStatus status = StatusUtil.createErrorStatus(Activator.getPlugin(), ex);
	throw new CoreException(status);
	}
	}

	public Map<String, Class<?>> getWorkflowParameters(Workflow workflowInstance) {
	// Retrieve parameters of workflow class itself
	Map<String, Class<?>> workflowParameters = doGetWorkflowParameters(workflowInstance.getClass());

	// Retrive parameters of workflow components if any
	if (workflowInstance instanceof WorkspaceWorkflow) {
	List<IWorkflowComponent> children = ((WorkspaceWorkflow) workflowInstance).getChildren();
	for (IWorkflowComponent component : children) {
	workflowParameters.putAll(doGetWorkflowParameters(component.getClass()));
	}
	}
	return workflowParameters;
	}

	protected Map<String, Class<?>> doGetWorkflowParameters(Class<?> clazz) {
	// Establish ordered map of workflow parameters
	Map<String, Class<?>> workflowParameters = new LinkedHashMap<>();
	for (Field field : clazz.getDeclaredFields()) {
	if (isWorkflowParameter(field)) {
	String name = getWorkflowParameterName(field);
	workflowParameters.put(name, field.getType());
	}
	}
	return workflowParameters;
	}

	protected boolean isWorkflowParameter(Field field) {
	Assert.isNotNull(field);

	return field.getAnnotation(WorkflowParameter.class) != null;
	}

	protected String getWorkflowParameterName(Field parameterField) {
	Assert.isNotNull(parameterField);
	Assert.isLegal(isWorkflowParameter(parameterField));

	// Retrieve workflow parameter name - use field name if no such has been annotated explicitly
	WorkflowParameter annotation = parameterField.getAnnotation(WorkflowParameter.class);
	String value = annotation.value();
	return value != null && !value.isEmpty() ? value : parameterField.getName();
	}

	protected boolean isWorkflowParameterTypeAssignableFrom(Class<?> parameterType, Class<?> valueType) {
	if (parameterType.isPrimitive()) {
	return ClassUtils.isAssignable(parameterType, valueType, true);
	}
	return parameterType.isAssignableFrom(valueType);
	}

	protected void setWorkflowParameterValue(Object object, Field parameterField, Object value) throws CoreException {
	Assert.isNotNull(object);
	Assert.isNotNull(parameterField);
	Assert.isLegal(isWorkflowParameter(parameterField));

	boolean oldAccessible = parameterField.isAccessible();
	parameterField.setAccessible(true);
	try {
	parameterField.set(object, value);
	} catch (Exception ex) {
	IStatus status = StatusUtil.createErrorStatus(Activator.getPlugin(), ex);
	throw new CoreException(status);
	} finally {
	parameterField.setAccessible(oldAccessible);
	}
	}

	public void injectArguments(Workflow workflowInstance, Map<String, Object> arguments) throws CoreException {
	Assert.isNotNull(workflowInstance);

	// Inject arguments into workflow itself
	doInjectArguments(workflowInstance, arguments);

	// Inject arguments into workflow components
	if (workflowInstance instanceof WorkspaceWorkflow) {
	List<IWorkflowComponent> children = ((WorkspaceWorkflow) workflowInstance).getChildren();
	for (IWorkflowComponent component : children) {
	doInjectArguments(component, arguments);
	}
	}
	}

	protected void doInjectArguments(Object object, Map<String, Object> arguments) throws CoreException {
	Class<?> clazz = object.getClass();
	for (Field field : clazz.getDeclaredFields()) {
	if (isWorkflowParameter(field)) {
	String name = getWorkflowParameterName(field);
	Object value = arguments.get(name);
	if (value != null) {
	if (isWorkflowParameterTypeAssignableFrom(field.getType(), value.getClass())) {
	setWorkflowParameterValue(object, field, value);
	} else {
	RuntimeException ex = new RuntimeException("Workflow argument '" + name + " : " + value.getClass().getName() //$NON-NLS-1$ //$NON-NLS-2$
	+ "' cannot be assigned to workflow parameter '" + field.getName() + " : " + field.getType().getName() //$NON-NLS-1$ //$NON-NLS-2$
	+ "'"); //$NON-NLS-1$
	PlatformLogUtil.logAsWarning(Activator.getPlugin(), ex);
	}
	}
	}
	}
	}
	}