Attachment #59630 for bug #167588

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.

View | Details | Raw Unified | Return to bug 167588
Collapse All | Expand All




	 *             Throws exception while getting WSDL files and also while
	 *             merging them
	 */
	public static Document createMergedWSDL(ManageableResourceType mrt, String address)
			throws Exception
	{
		// Get the MRT file and load it into memory
		URI uri = URI.createFileURI(mrtFile.toString());
		ManageableResourceType mrt = MrtUtils.loadMRT(uri);

		checkReadersWriters();

		List wsdlFiles = null;

Lines 33-38 Link Here

(-)src/org/eclipse/tptp/wsdm/tooling/nls/messages/mrt/internal/messages.properties (+2 lines)
33	HOOKUP_WIZARD_TXT1 = Deployment target and generation options	33	HOOKUP_WIZARD_TXT1 = Deployment target and generation options
34	HOOKUP_WIZARD_TXT2 = This wizard creates code for touchpoint	34	HOOKUP_WIZARD_TXT2 = This wizard creates code for touchpoint
35	HOOKUP_WIZARD_TXT3 = Overwrite files if necessary	35	HOOKUP_WIZARD_TXT3 = Overwrite files if necessary
		36	HOOKUP_WIZARD_PERSIST = Persist extra artifacts
36	HOOKUP_WIZARD_TXT4 = Output project	37	HOOKUP_WIZARD_TXT4 = Output project
37	HOOKUP_WIZARD_TXT5 = Browse...	38	HOOKUP_WIZARD_TXT5 = Browse...
38	HOOKUP_WIZARD_TXT6 = Location	39	HOOKUP_WIZARD_TXT6 = Location
Lines 126-131 Link Here
126	CODE_GEN_STEP1 = Initializing Code Generation	127	CODE_GEN_STEP1 = Initializing Code Generation
127	CODE_GEN_STEP2 = Merging WSDL	128	CODE_GEN_STEP2 = Merging WSDL
128	CODE_GEN_STEP3 = Creating project	129	CODE_GEN_STEP3 = Creating project
		130	CODE_GEN_STEP4 = Persisting artifacts
129	CODE_GEN_FAILED_ERROR = Code generation failed, see Error Log	131	CODE_GEN_FAILED_ERROR = Code generation failed, see Error Log
130	CODE_GEN_SUBTASK1 = Running Analyzer	132	CODE_GEN_SUBTASK1 = Running Analyzer
131	CODE_GEN_SUBTASK2 = Running Synthesizer	133	CODE_GEN_SUBTASK2 = Running Synthesizer





package org.eclipse.tptp.wsdm.tooling.codegen.mrt.provisional;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.ws.muse.descriptor.AdditionalJarsType;
import org.apache.ws.muse.descriptor.DescriptorFactory;
import org.apache.ws.muse.descriptor.DocumentRoot;
import org.apache.ws.muse.descriptor.InitialInstancesType;
import org.apache.ws.muse.descriptor.LogLevelType;
import org.apache.ws.muse.descriptor.LoggingType;
import org.apache.ws.muse.descriptor.MuseType;
import org.apache.ws.muse.descriptor.PersistenceType;
import org.apache.ws.muse.descriptor.ResourceTypeType;
import org.apache.ws.muse.descriptor.RootType;
import org.apache.ws.muse.descriptor.RouterType;
import org.apache.ws.muse.descriptor.WsdlType;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.SubProgressMonitor;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.resource.ResourceSet;
import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl;
import org.eclipse.emf.ecore.xmi.XMLResource;
import org.eclipse.tptp.wsdm.tooling.model.capabilities.Capability;
import org.eclipse.tptp.wsdm.tooling.model.manageableResourceType.ManageableResourceType;
import org.eclipse.tptp.wsdm.tooling.nls.messages.dde.internal.Messages;
import org.eclipse.tptp.wsdm.tooling.util.internal.EclipseUtils;
import org.eclipse.tptp.wsdm.tooling.util.internal.MrtUtils;
import org.eclipse.tptp.wsdm.tooling.util.internal.MyDescriptorResourceFactoryImpl;
import org.eclipse.tptp.wsdm.tooling.util.internal.WsdmToolingLog;

 */
public class MRTCodeGenerationDelegate implements CodeGenerationDelegate
{
	private ManageableResourceType _mrt;
	private MrtPreProcessor _mrtPreProcessor;
	private String _ddFilePath;
	private IFile _mrtFile;
	private DocumentRoot _ddRoot;
	
	/**
	 * Constructor of the class
	 * @param mrtFile

	public MRTCodeGenerationDelegate(IFile mrtFile)
	{
		_mrtFile = mrtFile;
		_generatedResourceTypes = new ArrayList();
		_initialInstancesList = new ArrayList();
		_contributedInspectors = new ArrayList();
		URI mrtURI = URI.createPlatformResourceURI(mrtFile.getFullPath()
				.toString());
		_mrt = MrtUtils.loadMRT(mrtURI);
		_mrtPreProcessor = new MrtPreProcessor(_mrt);
	}

	/**
	 * Creates the DD file. 
	 * The method returns a DescriptorHelper which
	 * aggregates all of the work that was done.
	 * 
	 * @param progressMonitor 	A progress monitor to 
	 * 							show the progress done during this 
	 * 							task. 

	public DescriptorHelper run(SubProgressMonitor progressMonitor)
			throws Exception
	{
		byte[] serializedDD = createDD();
		Map mrtObjectMap = _mrtPreProcessor.getMrtObjectMap();
		return new DescriptorHelper(new ByteArrayInputStream(serializedDD), mrtObjectMap);
	}
	
	private byte[] createDD()
	{
		_mrtPreProcessor.preProcess();
		_ddRoot = _mrtPreProcessor.getDDDocumentRoot();
		ResourceSet resourceSet = new ResourceSetImpl();
		resourceSet.getResourceFactoryRegistry().getExtensionToFactoryMap()
		.put(Resource.Factory.Registry.DEFAULT_EXTENSION,
				new MyDescriptorResourceFactoryImpl());
		URI uri = URI.createURI("dummy.xml");
		Resource resource = resourceSet.createResource(uri);
		resource.getContents().add(_ddRoot);
		Map map = new HashMap();
		ByteArrayOutputStream baos = new ByteArrayOutputStream();
		try 
		{
			resource.save(baos, map);
		} 
		catch (IOException e) 
		{
			e.printStackTrace();
		}
		return baos.toByteArray();
	}
	
	private String createDDFilePath()
	{
		IPath ddIPath = _mrtFile.getFullPath().removeFileExtension()
				.addFileExtension("dd");
		return ddIPath.toString();
	}

	/**
	 * Create and return a new instance of given ResourceTypeType. Only
	 * ContextPath, JavaIdFactoryClass, JavaResourceClass and WsdlType fields
	 * have been copied.
	 */
	public static ResourceTypeType cloneResourceType(ResourceTypeType rt)
	{
		ResourceTypeType clone = DescriptorFactory.eINSTANCE
				.createResourceTypeType();
		clone.setContextPath(rt.getContextPath());
		clone.setJavaIdFactoryClass(rt.getJavaIdFactoryClass());
		clone.setJavaResourceClass(rt.getJavaResourceClass());
		WsdlType wClone = DescriptorFactory.eINSTANCE.createWsdlType();
		wClone.setWsdlFile(rt.getWsdl().getWsdlFile());
		wClone.setWsdlPortType(rt.getWsdl().getWsdlPortType());
		clone.setWsdl(wClone);
		return clone;
	}

	/**
	 * This method will persist the extra artifacts generated at codegen time.
	 */
	public void persistArtifacts() 
	{
		_mrtPreProcessor.persistArtifacts();
		persistDDFile();		
	}
	
	private void persistDDFile()
	{
		_ddFilePath = createDDFilePath();


		//
		// Add the initial model object to the contents.
		//
		if (_ddRoot != null)
		if (rootObject != null)
		{
			resource.getContents().add(_ddRoot);
		}

		//

		options.put(XMLResource.OPTION_ENCODING, "UTF-8");
		try
		{
			resource.save(options);		

			IFile file = EclipseUtils.getIFile(ResourcesPlugin.getWorkspace()
					.getRoot(), fileURI.toString());
			//return file.getLocation().toFile();
			return file;
		}
		catch (Exception exception)
		{

					Messages.FAILED_TO_INITIALIZE_MUSE_DESCRIPTOR_ERROR_,
					exception);
		}

		return null;
	}

	private String createDDFilePath()
	{
		IPath ddIPath = _mrtFile.getFullPath().removeFileExtension()
				.addFileExtension("dd");
		return ddIPath.toString();
	}

	protected EObject createInitialModel()
	{
		_root = DescriptorFactory.eINSTANCE.createDocumentRoot();
		RootType _rootType = DescriptorFactory.eINSTANCE.createRootType();
		MuseType _muse = DescriptorFactory.eINSTANCE.createMuseType();
		AdditionalJarsType jars = DescriptorFactory.eINSTANCE
				.createAdditionalJarsType();
		_rootType.setMuse(_muse);
		_rootType.setAdditionalJars(jars);
		_root.setRoot(_rootType);

		// Add the router to muse descriptor
		RouterType router = createRouterType();
		_muse.setRouter(router);

		ResourceTypeType[] resourceTypes = process();
		for (int i = 0; i < resourceTypes.length; i++)
			_muse.getResourceType().add(resourceTypes[i]);

		// Create initial instances
		InitialInstancesType[] instances = getInitialInstances();
		for (int i = 0; i < instances.length; i++)
			_rootType.getInitialInstances().add(instances[i]);

		return _root;
	}

	private RouterType createRouterType()
	{
		RouterType router = DescriptorFactory.eINSTANCE.createRouterType();
		router
				.setJavaRouterClass("org.apache.muse.core.routing.SimpleResourceRouter");
		LoggingType logging = DescriptorFactory.eINSTANCE.createLoggingType();
		logging.setLogFile("/log/muse.log");
		logging.setLogLevel(LogLevelType.OFF_LITERAL);
		router.setLogging(logging);
		PersistenceType persistence = DescriptorFactory.eINSTANCE
				.createPersistenceType();
		persistence
				.setJavaPersistenceClass("org.apache.muse.core.routing.RouterFilePersistence");
		persistence.setPersistenceLocation("router-entries");
		router.setPersistence(persistence);
		return router;
	}

	private ManageableResourceType _mrt;

	private List _generatedResourceTypes;

	private List _initialInstancesList;

	private List _contributedInspectors;

	/**
	 * This method processes the given manageable resource type to check whether
	 * we need any extra resource type in muse descriptor file such as
	 * Subscription manager etc. It will returns all the proper ResourceTypeType
	 * objects. So it will return atleast one ResourceTypeType object that
	 * represents the given manageable resource type.
	 */
	public ResourceTypeType[] process()
	{
		Capability[] mrtCapabilities = new Capability[0];
		try
		{
			mrtCapabilities = MrtUtils.getCapabilities(_mrt);
		}
		catch (Exception e)
		{
		}
		// Analyze the given manageable resource type for Subscription manager
		// etc.
		// If needed add the extra resource type for Subscription manager
		List inspectors = getAllMrtInspectors();
		for (int i = 0; i < inspectors.size(); i++)
		{
			MrtInspector inspector = (MrtInspector) inspectors.get(i);
			inspector.setMrtParentDirectory(_mrtFile.getParent().getFullPath()
					.toString());
			ResourceTypeType resourceType = inspector.inspect(mrtCapabilities);
			if (resourceType != null)
			{
				_generatedResourceTypes.add(resourceType);
				InitialInstancesType[] instances = inspector
						.getInitialInstances();
				for (int j = 0; j < instances.length; j++)
					_initialInstancesList.add(instances[j]);
				_contributedInspectors.add(inspector);
			}
		}
		return (ResourceTypeType[]) _generatedResourceTypes
				.toArray(new ResourceTypeType[_generatedResourceTypes.size()]);
	}

	private List getAllMrtInspectors()
	{
		List inspectors = new ArrayList();
		inspectors.add(new BasicMrtInspector(_mrtFile, _mrt, _root));
		inspectors.add(new SubscriptionManagerInspector(_root));
		return inspectors;
	}

	/**
	 * Create and return a new instance of given ResourceTypeType. Only
	 * ContextPath, JavaIdFactoryClass, JavaResourceClass and WsdlType fields
	 * have been copied.
	 */
	public static ResourceTypeType cloneResourceType(ResourceTypeType rt)
	{
		ResourceTypeType clone = DescriptorFactory.eINSTANCE
				.createResourceTypeType();
		clone.setContextPath(rt.getContextPath());
		clone.setJavaIdFactoryClass(rt.getJavaIdFactoryClass());
		clone.setJavaResourceClass(rt.getJavaResourceClass());
		WsdlType wClone = DescriptorFactory.eINSTANCE.createWsdlType();
		wClone.setWsdlFile(rt.getWsdl().getWsdlFile());
		wClone.setWsdlPortType(rt.getWsdl().getWsdlPortType());
		clone.setWsdl(wClone);
		return clone;
	}

	/**
	 * Returns the initial instances
	 * @return IntialInstancesType[]
	 */
	public InitialInstancesType[] getInitialInstances()
	{
		return (InitialInstancesType[]) _initialInstancesList
				.toArray(new InitialInstancesType[_initialInstancesList.size()]);
	}
}




package org.eclipse.tptp.wsdm.tooling.codegen.mrt.provisional;

import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;

import javax.wsdl.Operation;
import javax.xml.namespace.QName;

import org.apache.muse.tools.Activator;
import org.apache.muse.util.xml.XmlUtils;
import org.apache.ws.muse.descriptor.CapabilityType;
import org.apache.ws.muse.descriptor.DescriptorFactory;
import org.apache.ws.muse.descriptor.DocumentRoot;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.Path;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.resource.ResourceSet;
import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl;

import org.eclipse.tptp.wsdm.tooling.util.internal.EclipseUtils;
import org.eclipse.tptp.wsdm.tooling.util.internal.MrtUtils;
import org.eclipse.tptp.wsdm.tooling.util.internal.WsdlUtils;
import org.osgi.framework.Bundle;
import org.w3c.dom.Attr;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.xml.sax.SAXException;

/**
 * This class analyzes the given manageable resource type and provide an extra


	private DocumentRoot _root;

	private static String WSDL_FILE_PATH = "artifacts/resourceTypes/SubscriptionManager.wsdl";

	private ResourceTypeType _subManagerResourceType;
	
	private ManageableResourceType _subManagerMRT;
	/**
	 * Constructor of the class
	 * @param root

		_root = root;
	}

	private String getModelSmashedWSDLLocation()
	{
		Bundle modelPlugin = Activator.getDefault().getBundle();
		Path wsdlFilePath = new Path(WSDL_FILE_PATH);
		String filePath = EclipseUtils.getResolvedPath(modelPlugin,
				wsdlFilePath);
		return filePath;
	}

	/**
	 * Analyzes the given manageable resource type for NotificationProducer
	 * capability, and if the capability available then returns the muse

	private ResourceTypeType createSubscriptionManagerResourceType()
	{
		createSubManagerMrt();

		/*
		 * try { copySubManagerMergedWSDL(); } catch (IOException e) { // TODO
		 * Log e.printStackTrace(); }
		 */

		_subManagerResourceType = createSubManagerMuseResourceType();
		return _subManagerResourceType;
	}

	private void createSubManagerMrt()
	{
		_subManagerMRT = ManageableResourceTypeFactory.eINSTANCE
				.createManageableResourceType();
		_subManagerMRT.setIdentifier("SubscriptionManager");
		_subManagerMRT
				.setNamespace("http://docs.oasis-open.org/wsn/b-2/SubscriptionManager");
		_subManagerMRT
				.getImplements()
				.add(
						"platform:/plugin/org.apache.muse.tools/artifacts/managementCapabilities/Identity.wsdl");
		_subManagerMRT
				.getImplements()
				.add(
						"platform:/plugin/org.apache.muse.tools/artifacts/managementCapabilities/ManageabilityCharacteristics.wsdl");
		_subManagerMRT
				.getImplements()
				.add(
						"platform:/plugin/org.apache.muse.tools/artifacts/managementCapabilities/MetadataExchange.wsdl");
		_subManagerMRT
				.getImplements()
				.add(
						"platform:/plugin/org.apache.muse.tools/artifacts/resourcePropertyCapabilities/GetProperty.wsdl");
		_subManagerMRT
				.getImplements()
				.add(
						"platform:/plugin/org.apache.muse.tools/artifacts/resourcePropertyCapabilities/SetProperty.wsdl");
		_subManagerMRT
				.getImplements()
				.add(
						"platform:/plugin/org.apache.muse.tools/artifacts/resourcePropertyCapabilities/QueryProperty.wsdl");
		_subManagerMRT
				.getImplements()
				.add(
						"platform:/plugin/org.apache.muse.tools/artifacts/resourceLifetimeCapabilities/ImmediateResourceTermination.wsdl");
		_subManagerMRT
				.getImplements()
				.add(
						"platform:/plugin/org.apache.muse.tools/artifacts/resourceLifetimeCapabilities/ScheduledResourceTermination.wsdl");

		_subManagerMRT
				.getImplements()
				.add(
						"platform:/plugin/org.apache.muse.tools/artifacts/resourceTypes/SubscriptionManagerCapability.wsdl");		

		ResourceSet rs = new ResourceSetImpl();
		byte[] rawNewMRT = MrtUtils.serializeMRT(mrt, rs, URI
				.createURI("dummy.xml"), true);
		InputStream stream = new ByteArrayInputStream(rawNewMRT);

		try
		{
			String subManagerMrt = _mrtParentDirName + "/"
					+ "SubscriptionManager.mrt";
			IFile subManagerMrtFile = EclipseUtils.getIFile(subManagerMrt);
			if (subManagerMrtFile.exists())
			{
				subManagerMrtFile.setContents(stream, true, true,
						new NullProgressMonitor());
			}
			else
			{
				subManagerMrtFile.create(stream, true,
						new NullProgressMonitor());
			}
			try
			{
				stream.close();
			}
			catch (IOException e)
			{
				// TODO Log
				e.printStackTrace();
			}
		}
		catch (CoreException e)
		{
			// TODO Log
			e.printStackTrace();
		}
	}

	private ResourceTypeType createSubManagerMuseResourceType()

	}

	/**
	 * Returns the merged wsdl file document for SubscriptionManager.
	 */
	public Document[] getWsdlDocuments(String baseAddress)
	{
		String mergedSubManagerWsdl = getModelSmashedWSDLLocation();

		Document document = null;
		try
		{
			// document = XmlUtils.createDocument(new
			// File(_mergedWsdlFilePath));
			document = XmlUtils.createDocument(new File(mergedSubManagerWsdl));
			makeServiceAddress(document, baseAddress);
		}
		catch (IOException e)
		{
			e.printStackTrace();
		}
		catch (SAXException e)
		{
			e.printStackTrace();
		}
		return new Document[] { document };
	}

	private void makeServiceAddress(Document mergedWsdl, String basePath)
	{
		Element serviceElement = XmlUtils.findFirstInSubTree(mergedWsdl
				.getDocumentElement(), new QName(WSDL_NAMESPACE, "service"));
		if (serviceElement == null) // Can't find the service element in smashed
			// wsdl
			return;
		Element portInServiceElement = XmlUtils.findFirstInSubTree(
				serviceElement, new QName(WSDL_NAMESPACE, "port"));
		if (portInServiceElement == null) // Can't find the port element
			// inside service element
			return;
		Element addressElement = XmlUtils.findFirstInSubTree(
				portInServiceElement, new QName(
						"http://schemas.xmlsoap.org/wsdl/soap/", "address"));
		if (addressElement == null) // Can't find address element inside port
			// element
			return;
		Attr locationAttr = addressElement.getAttributeNode("location");
		if (locationAttr == null || locationAttr.getNodeValue().equals(""))
			return;
		int beginIndex = locationAttr.getNodeValue().lastIndexOf('/') + 1;
		String serviceName = locationAttr.getNodeValue().substring(beginIndex);
		locationAttr.setNodeValue(basePath + "/" + serviceName);
	}
	/**
	 * Sets the parent directory 
	 * @param mrtParentDir
	 */

		instance.setReferenceParameters(refParam);
		return new InitialInstancesType[] { instance };
	}

	/**
	 * This method will persist the extra artifacts generated at codegen time (SubscriptionManager.mrt file).
	 */
	public void persistArtifacts()
	{
		ResourceSet rs = new ResourceSetImpl();
		byte[] rawNewMRT = MrtUtils.serializeMRT(_subManagerMRT, rs, URI
				.createURI("dummy.xml"), true);
		InputStream stream = new ByteArrayInputStream(rawNewMRT);

		try
		{
			String subManagerMrt = _mrtParentDirName + "/"
					+ "SubscriptionManager.mrt";
			IFile subManagerMrtFile = EclipseUtils.getIFile(subManagerMrt);
			if (subManagerMrtFile.exists())
			{
				subManagerMrtFile.setContents(stream, true, true,
						new NullProgressMonitor());
			}
			else
			{
				subManagerMrtFile.create(stream, true,
						new NullProgressMonitor());
			}
			try
			{
				stream.close();
			}
			catch (IOException e)
			{
				// TODO Log
				e.printStackTrace();
			}
		}
		catch (CoreException e)
		{
			// TODO Log
			e.printStackTrace();
		}
	}

	/**
	 * This method will returns the extra generated ManageableResourceType object equivalent to SubscriptionManager.
	 */
	public ManageableResourceType getExtraGeneratedMrt() 
	{
		return _subManagerMRT;
	}

	/**
	 * This method should return the persistance location for extra generated ManageableResourceType object equivalent to SubscriptionManager.
	 */
	public String getExtraGeneratedMrtPersistanceLocation() 
	{
		return _mrtParentDirName+"/SubscriptionManager.mrt";
	}
}




package org.eclipse.tptp.wsdm.tooling.codegen.mrt.provisional;

import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
import java.util.Arrays;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;

import javax.xml.namespace.QName;

import org.apache.muse.core.descriptor.DescriptorConstants;
import org.apache.muse.util.xml.XmlUtils;
import org.apache.ws.muse.descriptor.AdditionalJarsType;
import org.apache.ws.muse.descriptor.DescriptorPackage;
import org.apache.ws.muse.descriptor.DocumentRoot;
import org.apache.ws.muse.descriptor.RootType;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IWorkspace;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.IPath;
import org.eclipse.emf.common.util.URI;
import org.eclipse.tptp.wsdm.tooling.model.manageableResourceType.ManageableResourceType;
import org.eclipse.tptp.wsdm.tooling.util.internal.MrtUtils;
import org.eclipse.tptp.wsdm.tooling.editor.dde.util.internal.DdeUtil;
import org.eclipse.tptp.wsdm.tooling.nls.messages.mrt.internal.Messages;
import org.eclipse.tptp.wsdm.tooling.util.internal.MyDescriptorResourceFactoryImpl;
import org.eclipse.tptp.wsdm.tooling.util.internal.WsdmToolingLog;
import org.eclipse.tptp.wsdm.tooling.wizard.mrt.internal.NewMrtWizard;
import org.w3c.dom.Document;
import org.w3c.dom.Element;

	private Object[][] _instances;
	
	private IFile ddIFile;
	
	/**
	 * Descriptor file stores the MRT file reference in Wsdl-File element.
	 * When we do the codegeneration we generate some extra MRTs such as SubscriptionManager,
	 * so we pass the map of these MRTs to this class.
	 * Key will be the persisted location of MRT and value will be the ManageableREsourceType object.
	 */
	private Map _mrtObjectMap = new HashMap();

	/**
	 * A do-something constructor. Take a file, if that file is null, then load

	 */
	public DescriptorHelper(File file) throws Exception
	{
		this(new FileInputStream(file), null);
	}
	
	/**
	 * A do-something constructor. Take a inputstream, if that inputstream is null, then load
	 * up a default template. Otherwise load up the inputstream and pull out the
	 * instances, descriptor and additional jars. For the null inputstream case, there
	 * will be no instances of additional-jars, hence the constants defined
	 * above.
	 * 
	 * @param inputstream - The inputstream to analyze, can be null.
	 * @param mrtObjectMap - The map of MRTLocation-MRTObject pair, can be null.
	 * @throws Exception - If anything goes wrong.
	 */
	public DescriptorHelper(InputStream inputStream, Map mrtObjectMap) throws Exception
	{
		if(mrtObjectMap!=null)
			_mrtObjectMap = mrtObjectMap;
		
		Document rootDocument = XmlUtils.createDocument(inputStream);

		_descriptorDocument = extractDescriptorDocument(rootDocument);
		_instances = extractInstances(rootDocument);

	 * find all of the MRT files referenced therein. For each MRT file use
	 * <code>WsdlMerge</code> to merge the MRT's WSDL into a consolidate WSDL.
	 * Return the Muse Descriptor document-order list of the WSDL files.
	 * The passed map will contain the MRT file location as key and MRT object as value.
	 * So first search the map for MRT if not found then load the MRT from location.
	 * 
	 * @return A list of merged WSDL files as gathered from the deployment
	 *         descriptor

					resourceTypes[i], DescriptorConstants.WSDL_FILE_QNAME);

			String wsdlPath = XmlUtils.extractText(wsdlFileElement);
			String mrtPath = getMRTPathFromWSDLPath(wsdlPath);
			ManageableResourceType mrt = null;
			String serviceAddress = null;
			if(_mrtObjectMap!=null && _mrtObjectMap.containsKey(mrtPath))
			{
				mrt = (ManageableResourceType) _mrtObjectMap.get(mrtPath);
				serviceAddress = baseAddress+"/"+mrt.getIdentifier();
			}
			else
			{
				IWorkspace workspace = ResourcesPlugin.getWorkspace();
				IWorkspaceRoot root = workspace.getRoot();
				IPath mrtFilePath = root.findMember(mrtPath).getFullPath();
				URI uri = URI.createFileURI(mrtFilePath.toString());
				mrt = MrtUtils.loadMRT(uri);
				serviceAddress = makeServiceAddress(baseAddress, mrtFilePath);
			}
			if(mrt!=null)
			{
				try
				{
					mergedWSDLs[i] = NewMrtWizard.createMergedWSDL(mrt, serviceAddress);
							makeServiceAddress(baseAddress, mrtFilePath));
				}
				catch (Exception e)
				{

				throw new RuntimeException();
			}
		}

		return mergedWSDLs;
	}


	 */
	public void addAdditionalJars(String serverLocation, String[] axis2files)
	{
		List additionalJarFiles = new LinkedList();
		if(_jarFiles!=null)
			additionalJarFiles.addAll(Arrays.asList(_jarFiles));
		for(int i = 0 ; i < axis2files.length ; i++ )
			additionalJarFiles.add(new File(serverLocation + File.separator + axis2files[i]));
		_jarFiles = (File[]) additionalJarFiles.toArray(new File[additionalJarFiles.size()]);
		root.setRoot(rootType);
		save(root);
	}
	
	private void save(DocumentRoot root)
	{
		ensureMusePackagePresent();
		URI ddFileURI = URI.createPlatformResourceURI(ddIFile.getFullPath().toString());
		ResourceSetImpl rsImpl = new ResourceSetImpl();
		rsImpl.getResourceFactoryRegistry().getExtensionToFactoryMap()
		.put(Resource.Factory.Registry.DEFAULT_EXTENSION,
				new MyDescriptorResourceFactoryImpl());
		rsImpl.getPackageRegistry().put(DescriptorPackage.eNS_URI,
		DescriptorPackage.eINSTANCE);
		Resource ddRes = rsImpl.getResource(ddFileURI, true);
		ddRes.getContents().remove(0);
		ddRes.getContents().add(root);
		try 
		{
			ddRes.save(Collections.EMPTY_MAP);
		} 
		catch (IOException e) 
		{
			e.printStackTrace();
		}
	}
	
	private void ensureMusePackagePresent()
	{
		// Ensure EMF knows about Muse descriptor
		if (DescriptorPackage.eINSTANCE == null)
		{
			WsdmToolingLog.logError(Messages.FAILED_TO_INITIALIZE_MUSE_DESCRIPTOR_ERROR_, new Throwable());
		}
	} 	
}

Lines 112-117 Link Here

(-)src/org/eclipse/tptp/wsdm/tooling/codegen/mrt/provisional/GenerationOptionsPage.java (+9 lines)
112		112
113	private boolean axis2Project;	113	private boolean axis2Project;
114		114
		115	private Button _persistExtraArtifactsButton;
		116
115	/**	117	/**
116	* For cheatsheet purpose only This constructor will be used in cheatsheet	118	* For cheatsheet purpose only This constructor will be used in cheatsheet
117	* only	119	* only
Lines 174-179 Link Here
174		176
175	_buttonOverwrite = makeButton(column, Messages.HOOKUP_WIZARD_TXT3,	177	_buttonOverwrite = makeButton(column, Messages.HOOKUP_WIZARD_TXT3,
176	SWT.CHECK);	178	SWT.CHECK);
		179
		180	_persistExtraArtifactsButton = makeButton(column, Messages.HOOKUP_WIZARD_PERSIST, SWT.CHECK);
177	}	181	}
178		182
179	private Group createProjectizerGroup(Composite parent)	183	private Group createProjectizerGroup(Composite parent)
Lines 659-664 Link Here
659	{	663	{
660	return _buttonOverwrite.getSelection();	664	return _buttonOverwrite.getSelection();
661	}	665	}
		666
		667	public boolean shouldPersistArtifacts()
		668	{
		669	return _persistExtraArtifactsButton.getSelection();
		670	}
662		671
663	/**	672	/**
664	* Return the value of the output project	673	* Return the value of the output project

Lines 63-68 Link Here

(-)src/org/eclipse/tptp/wsdm/tooling/codegen/mrt/provisional/NewProjectWizard.java (-1 / +9 lines)
63	private String _projectName;	63	private String _projectName;
64		64
65	private boolean _overwrite;	65	private boolean _overwrite;
		66
		67	private boolean _shouldPersistArtifacts;
66		68
67	private Projectizer _projectizer;	69	private Projectizer _projectizer;
68		70
Lines 118-124 Link Here
118	{	120	{
119	try	121	try
120	{	122	{
121	monitor.beginTask(Messages.CODE_GEN_START, 6);	123	monitor.beginTask(Messages.CODE_GEN_START, 7);
122		124
123	if(_isAxis2Project)	125	if(_isAxis2Project)
124	{	126	{
Lines 179-184 Link Here
179	throw new InvocationTargetException(new Exception(	181	throw new InvocationTargetException(new Exception(
180	Messages.CODE_GEN_FAILED_ERROR, e));	182	Messages.CODE_GEN_FAILED_ERROR, e));
181	}	183	}
		184
		185	monitor.subTask(Messages.CODE_GEN_STEP4);
		186	if(_shouldPersistArtifacts)
		187	_codeGenerationDelegate.persistArtifacts();
		188	monitor.worked(1);
182	}	189	}
183	finally	190	finally
184	{	191	{
Lines 197-202 Link Here
197	_synthesizer = _generationOptionsPage.getSynthesizer();	204	_synthesizer = _generationOptionsPage.getSynthesizer();
198	_analyzer = _generationOptionsPage.getAnalyzer();	205	_analyzer = _generationOptionsPage.getAnalyzer();
199	_overwrite = _generationOptionsPage.isOverwrite();	206	_overwrite = _generationOptionsPage.isOverwrite();
		207	_shouldPersistArtifacts = _generationOptionsPage.shouldPersistArtifacts();
200	_projectName = _generationOptionsPage.getProjectName();	208	_projectName = _generationOptionsPage.getProjectName();
201	_baseAddress = _generationOptionsPage.getBaseAddress();	209	_baseAddress = _generationOptionsPage.getBaseAddress();
202	_isAxis2Project = _generationOptionsPage.isAxis2Project();	210	_isAxis2Project = _generationOptionsPage.isAxis2Project();

Lines 15-20 Link Here

(-)src/org/eclipse/tptp/wsdm/tooling/codegen/mrt/provisional/MrtInspector.java (+26 lines)
15	import org.apache.ws.muse.descriptor.InitialInstancesType;	15	import org.apache.ws.muse.descriptor.InitialInstancesType;
16	import org.apache.ws.muse.descriptor.ResourceTypeType;	16	import org.apache.ws.muse.descriptor.ResourceTypeType;
17	import org.eclipse.tptp.wsdm.tooling.model.capabilities.Capability;	17	import org.eclipse.tptp.wsdm.tooling.model.capabilities.Capability;
		18	import org.eclipse.tptp.wsdm.tooling.model.manageableResourceType.ManageableResourceType;
18		19
19	/**	20	/**
20	* This interface is created for some cases where we expect some extra resource	21	* This interface is created for some cases where we expect some extra resource
Lines 28-36 Link Here
28	{	29	{
29	public static String WSDL_NAMESPACE = "http://schemas.xmlsoap.org/wsdl/";	30	public static String WSDL_NAMESPACE = "http://schemas.xmlsoap.org/wsdl/";
30		31
		32	/**
		33	* Analyzes the given manageable resource type capabilities and then returns the muse
		34	* resource type for some extra generated artifact else returns the null.
		35	*/
31	ResourceTypeType inspect(Capability[] mrtCapabilities);	36	ResourceTypeType inspect(Capability[] mrtCapabilities);
32		37
		38	/**
		39	* This method should set the parent directory for extra generated artifact.
		40	*/
33	void setMrtParentDirectory(String mrtParentDir);	41	void setMrtParentDirectory(String mrtParentDir);
34		42
		43	/**
		44	* Returns initial instances for extra generated artifact.
		45	*/
35	InitialInstancesType[] getInitialInstances();	46	InitialInstancesType[] getInitialInstances();
		47
		48	/**
		49	* This method will persist the extra artifacts generated at codegen time.
		50	*/
		51	void persistArtifacts();
		52
		53	/**
		54	* This method will returns the extra ManageableResourceType object generated at codegen time.
		55	*/
		56	ManageableResourceType getExtraGeneratedMrt();
		57
		58	/**
		59	* This method should return the persistance location for extra generated ManageableResourceType object.
		60	*/
		61	String getExtraGeneratedMrtPersistanceLocation();
36	}	62	}

Lines 35-38 Link Here

(-)src/org/eclipse/tptp/wsdm/tooling/codegen/mrt/provisional/CodeGenerationDelegate.java (+5 lines)
35	* @throws Exception	35	* @throws Exception
36	*/	36	*/
37	DescriptorHelper run(SubProgressMonitor progressMonitor) throws Exception;	37	DescriptorHelper run(SubProgressMonitor progressMonitor) throws Exception;
		38
		39	/**
		40	* Persist the extra artifacts generated during codegeneration such as SubscriptionManager.mrt etc.
		41	*/
		42	void persistArtifacts();
38	}	43	}




	public void setMrtParentDirectory(String mrtParentDir)
	{
	}

	public void persistArtifacts()
	{
	}

	public ManageableResourceType getExtraGeneratedMrt() 
	{
		return null;
	}

	public String getExtraGeneratedMrtPersistanceLocation() 
	{
		return null;
	}
}

class Mrt2DescriptorResourceType





package org.eclipse.tptp.wsdm.tooling.codegen.dd.internal;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;

import org.apache.ws.muse.descriptor.CapabilityType;
import org.apache.ws.muse.descriptor.DescriptorPackage;
import org.apache.ws.muse.descriptor.DocumentRoot;
import org.apache.ws.muse.descriptor.MuseType;
import org.apache.ws.muse.descriptor.ResourceTypeType;
import org.apache.ws.muse.descriptor.RootType;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.SubProgressMonitor;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.resource.ResourceSet;
import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl;
import org.eclipse.emf.ecore.xmi.XMLResource;
import org.eclipse.tptp.wsdm.tooling.codegen.mrt.provisional.CodeGenerationDelegate;
import org.eclipse.tptp.wsdm.tooling.codegen.mrt.provisional.DescriptorHelper;
import org.eclipse.tptp.wsdm.tooling.codegen.mrt.provisional.MrtPreProcessor;
import org.eclipse.tptp.wsdm.tooling.editor.dde.util.internal.DdeUtil;
import org.eclipse.tptp.wsdm.tooling.model.capabilities.Capability;
import org.eclipse.tptp.wsdm.tooling.model.manageableResourceType.ManageableResourceType;
import org.eclipse.tptp.wsdm.tooling.nls.messages.dde.internal.Messages;
import org.eclipse.tptp.wsdm.tooling.util.internal.MrtUtils;
import org.eclipse.tptp.wsdm.tooling.util.internal.MyDescriptorResourceFactoryImpl;
import org.eclipse.tptp.wsdm.tooling.util.internal.WsdmToolingLog;


 * Descriptor and find all of the MCap files and resolve them and merge them
 * into WSDL documents.
 */
public class DDCodeGenerationDelegate implements CodeGenerationDelegate
{
	
	/**
	 * The IFile of the unparsed descriptor file
	 */
	private IFile _descriptorFile;
	private DocumentRoot _ddRoot;
	private List _mrtPreProcessors = new LinkedList();

	public DDCodeGenerationDelegate(IFile descriptorFile) 
	{
		_descriptorFile = descriptorFile;
	}
	
	public DescriptorHelper run(SubProgressMonitor progressMonitor) throws Exception 
	{		
		_ddRoot = DdeUtil.getDocRoot(_descriptorFile);
		ManageableResourceType[] mrts = getMrtsFromDD();
		Map mrtObjectMap = new HashMap();
		for(int i=0;i<mrts.length;i++)
		{
			MrtPreProcessor mrtPreProcessor = new MrtPreProcessor(mrts[i], _ddRoot);
			mrtPreProcessor.preProcess();
			_mrtPreProcessors.add(mrtPreProcessor);
			mrtObjectMap.putAll(mrtPreProcessor.getMrtObjectMap());
		}
		byte[] serializedDD = serializeDD();
		return new DescriptorHelper(new ByteArrayInputStream(serializedDD), mrtObjectMap);
	}
	
	private ManageableResourceType[] getMrtsFromDD()
	{
		List mrts = new LinkedList();
		if(_ddRoot.getRoot()!=null)
		{
			if(_ddRoot.getRoot().getMuse()!=null)
		RootType root = docRoot.getRoot();
		MuseType mt = root.getMuse();
		List rts = mt.getResourceType();
		if(rts == null || rts.size() == 0)
		{
			return;
		}
		List mrts = subManagerAdded(rts);// This method returns a list of mrts if subscriptionmanager is not already added. else null
		if(mrts == null || mrts.size() == 0) 
		{
			return;
		}
		for(int i = 0; i < mrts.size(); i++)
		{
			ManageableResourceType mrt = (ManageableResourceType) mrts.get(i);
			Capability[] capDefs = getMrtCapabilities(mrt);
			ResourceTypeType subMgr = inspector.inspect(capDefs);
			if(subMgr == null)
			{
				continue;
			}
			else
			{
				MuseType muse = _ddRoot.getRoot().getMuse();
				if(muse.getResourceType()!=null)
				{
					List resourceTypes = muse.getResourceType();
					for(int i=0;i<resourceTypes.size();i++)
					{
						ResourceTypeType resourceType = (ResourceTypeType) resourceTypes.get(i);
						IResource mrtFile = DdeUtil.getIFileFromName(DdeUtil
								.getMrtFileName(resourceType.getWsdl().getWsdlFile()),
								"mrt");
						if(mrtFile!=null)
						{
							ManageableResourceType mrt = DdeUtil.loadMrtFile((IFile)mrtFile);
							mrts.add(mrt);
						}						
					}
				}
			}
		}
		return (ManageableResourceType[]) mrts.toArray(new ManageableResourceType[mrts.size()]);
	}
	
	private byte[] serializeDD()
		Capability[] capList = null;
		try {
			capList = MrtUtils.getCapabilities(mrt);
		} catch (Exception e) {
			WsdmToolingLog
					.logError(
							org.eclipse.tptp.wsdm.tooling.nls.messages.mrt.internal.Messages.MRT_ERROR_CANNOT_TRACE_CAPS,
							e);
		}

		if (capList != null)
			return capList;
		return new Capability[0];
	}
	
	private void save(DocumentRoot root)
	{
		ResourceSet resourceSet = new ResourceSetImpl();
		resourceSet.getResourceFactoryRegistry().getExtensionToFactoryMap()
		ResourceSetImpl rsImpl = new ResourceSetImpl();
		rsImpl.getResourceFactoryRegistry().getExtensionToFactoryMap()
		.put(Resource.Factory.Registry.DEFAULT_EXTENSION,
				new MyDescriptorResourceFactoryImpl());
		URI uri = URI.createURI("dummy.xml");
		Resource resource = resourceSet.createResource(uri);
		resource.getContents().add(_ddRoot);
		Map map = new HashMap();
		ByteArrayOutputStream baos = new ByteArrayOutputStream();
		try 
		{
			resource.save(baos, map);
		} 
		catch (IOException e) 
		{
			e.printStackTrace();
		}
		return baos.toByteArray();
	}
	
	/**
	 * This method will persist the extra artifacts generated at codegen time.
	 */
	public void persistArtifacts() 
	{
		for(int i=0;i<_mrtPreProcessors.size();i++)
		if (DescriptorPackage.eINSTANCE == null)
		{
			MrtPreProcessor mrtPreProcessor = (MrtPreProcessor) _mrtPreProcessors.get(i);
			mrtPreProcessor.persistArtifacts();
		}
		persistDDFile();		
	}
	
	private void persistDDFile()
	 * This method takes alist of resourceTypes and checks whether subscriptionmanager is already present.<br>
	 * if so returns null. else converts the resourcetypes into mrts and returns the list.
	 * @param rts
	 * @return
	 */
	private List subManagerAdded(List rts)
	{
		//
		// Create a resource set
		//
		ResourceSet resourceSet = new ResourceSetImpl();
		resourceSet.getResourceFactoryRegistry().getExtensionToFactoryMap()
				.put(Resource.Factory.Registry.DEFAULT_EXTENSION,
						new MyDescriptorResourceFactoryImpl());

		//
		// Get the URI of the model file.
		//
		URI fileURI = URI.createPlatformResourceURI(_descriptorFile.getFullPath().toString());

		//
		// Create a resource for this file.
		//
		Resource resource = resourceSet.createResource(fileURI);

		//
		// Add the initial model object to the contents.
		//
		if (_ddRoot != null)
		{
			resource.getContents().add(_ddRoot);
		}

		//
		// Save the contents of the resource to the file system.
		//
		Map options = new HashMap();
		options.put(XMLResource.OPTION_ENCODING, "UTF-8");
		try
		{
			resource.save(options);		
		}
		catch (Exception exception)
		{
			exception.printStackTrace();
			WsdmToolingLog.logError(
					Messages.FAILED_TO_INITIALIZE_MUSE_DESCRIPTOR_ERROR_,
					exception);
			for(int j = 0; j < capList.size(); j++)
			{
				CapabilityType ctype = (CapabilityType) capList.get(j);
				if(ctype.getCapabilityUri().equals("http://docs.oasis-open.org/wsn/bw-2/SubscriptionManager"))
				{
					return null;
				}
			}
		}
		return mrts;
	}
}




/*******************************************************************************
 * Copyright (c) 2007 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * 
 * Contributors:
 * 	Andrew Eberbach (aeberbac@us.ibm.com)
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.tptp.wsdm.tooling.codegen.mrt.provisional;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;

import org.apache.ws.muse.descriptor.AdditionalJarsType;
import org.apache.ws.muse.descriptor.DescriptorFactory;
import org.apache.ws.muse.descriptor.DocumentRoot;
import org.apache.ws.muse.descriptor.InitialInstancesType;
import org.apache.ws.muse.descriptor.LogLevelType;
import org.apache.ws.muse.descriptor.LoggingType;
import org.apache.ws.muse.descriptor.MuseType;
import org.apache.ws.muse.descriptor.PersistenceType;
import org.apache.ws.muse.descriptor.ResourceTypeType;
import org.apache.ws.muse.descriptor.RootType;
import org.apache.ws.muse.descriptor.RouterType;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.tptp.wsdm.tooling.model.capabilities.Capability;
import org.eclipse.tptp.wsdm.tooling.model.manageableResourceType.ManageableResourceType;
import org.eclipse.tptp.wsdm.tooling.util.internal.EclipseUtils;
import org.eclipse.tptp.wsdm.tooling.util.internal.MrtUtils;

/**
 * This class analyzes the given ManageableResourceType object and check whether it needs
 * any other extra ManageableResourceType object such as SubscriptionManager based on the capabilities 
 * available in given ManagableResourceType.   
 */

public class MrtPreProcessor 
{
	private ManageableResourceType _mrt;
	private DocumentRoot _ddRoot;
	private IFile _mrtFile;
	private List _generatedResourceTypes = new LinkedList();
	private List _initialInstancesList = new LinkedList();
	private List _contributedInspectors = new LinkedList();
	private Map _mrtObjectMap = new HashMap();
	
	/**
	 * Creates instance of this class.
	 * 
	 * @param mrt
	 * 			Given MRT to analyze.
	 * 
	 * @param ddRoot
	 * 			Given Descriptor file document root, can be null.
	 */
	public MrtPreProcessor(ManageableResourceType mrt, DocumentRoot ddRoot)
	{
		_mrt = mrt;
		if(ddRoot == null)
			ddRoot = createDDModel();
		_ddRoot = ddRoot;
		String mrtLocation = _mrt.eResource().getURI().toString();
		try 
		{
			_mrtFile = EclipseUtils.getIFile(mrtLocation);
		} 
		catch (CoreException e) 
		{
			e.printStackTrace();
		}
	}
	
	/**
	 * Creates instance of this class.
	 * 
	 * @param mrt
	 * 			Given MRT to analyze.
	 */
	public MrtPreProcessor(ManageableResourceType mrt)
	{
		this(mrt,null);
	}
	
	private DocumentRoot createDDModel()
	{
		DocumentRoot root = DescriptorFactory.eINSTANCE.createDocumentRoot();
		RootType _rootType = DescriptorFactory.eINSTANCE.createRootType();
		MuseType _muse = DescriptorFactory.eINSTANCE.createMuseType();
		AdditionalJarsType jars = DescriptorFactory.eINSTANCE
				.createAdditionalJarsType();
		_rootType.setMuse(_muse);
		_rootType.setAdditionalJars(jars);
		root.setRoot(_rootType);
		
		RouterType router = createRouterType();
		_muse.setRouter(router);
		
		return root;
	}
	
	private RouterType createRouterType()
	{
		RouterType router = DescriptorFactory.eINSTANCE.createRouterType();
		router
				.setJavaRouterClass("org.apache.muse.core.routing.SimpleResourceRouter");
		LoggingType logging = DescriptorFactory.eINSTANCE.createLoggingType();
		logging.setLogFile("/log/muse.log");
		logging.setLogLevel(LogLevelType.OFF_LITERAL);
		router.setLogging(logging);
		PersistenceType persistence = DescriptorFactory.eINSTANCE
				.createPersistenceType();
		persistence
				.setJavaPersistenceClass("org.apache.muse.core.routing.RouterFilePersistence");
		persistence.setPersistenceLocation("router-entries");
		router.setPersistence(persistence);
		return router;
	}
	
	/**
	 * Returns the modified Descriptor document root. 
	 */
	public DocumentRoot getDDDocumentRoot()
	{
		return _ddRoot;
	}
	
	/**
	 * Analyzes the given MRT file for extra required artifacts. 
	 */
	public void preProcess()
	{
		if(_ddRoot!=null)
		{
			RootType root = _ddRoot.getRoot();
			MuseType muse = root.getMuse();		
			ResourceTypeType[] resourceTypes = process();
			for (int i = 0; i < resourceTypes.length; i++)
				muse.getResourceType().add(resourceTypes[i]);
			
			// Create initial instances
			
			InitialInstancesType[] instances = getInitialInstances();
			for (int i = 0; i < instances.length; i++)
				root.getInitialInstances().add(instances[i]);
		}
	}
	
	private boolean hasResourceTypeInDD(ResourceTypeType givenResourceType)
	{
		if(_ddRoot!=null)
		{
			if(_ddRoot.getRoot()!=null)
			{
				if(_ddRoot.getRoot().getMuse()!=null)
				{
					MuseType muse = _ddRoot.getRoot().getMuse();
					List resourceTypes = muse.getResourceType();
					if(resourceTypes!=null)
					{
						for(int i=0;i<resourceTypes.size();i++)
						{
							ResourceTypeType resourceType = (ResourceTypeType)resourceTypes.get(i);
							boolean equalContextPath = givenResourceType.getContextPath().equals(resourceType.getContextPath());
							boolean equalWsdlFile = givenResourceType.getWsdl().getWsdlFile().equals(resourceType.getWsdl().getWsdlFile());
							boolean equalWsdlPortType = givenResourceType.getWsdl().getWsdlPortType().equals(resourceType.getWsdl().getWsdlPortType());
							if(equalContextPath && equalWsdlFile && equalWsdlPortType)
								return true;
						}
					}
				}
			}
		}
		return false;
	}
	
	/**
	 * This method processes the given manageable resource type to check whether
	 * we need any extra resource type in muse descriptor file such as
	 * Subscription manager etc. It will returns all the proper ResourceTypeType
	 * objects. So it will return atleast one ResourceTypeType object that
	 * represents the given manageable resource type.
	 */
	private ResourceTypeType[] process()
	{
		Capability[] mrtCapabilities = new Capability[0];
		try
		{
			mrtCapabilities = MrtUtils.getCapabilities(_mrt);
		}
		catch (Exception e)
		{
		}
		// Analyze the given manageable resource type for Subscription manager
		// etc.
		// If needed add the extra resource type for Subscription manager
		List inspectors = getAllMrtInspectors();
		for (int i = 0; i < inspectors.size(); i++)
		{
			MrtInspector inspector = (MrtInspector) inspectors.get(i);
			inspector.setMrtParentDirectory(_mrtFile.getParent().getFullPath()
					.toString());
			ResourceTypeType resourceType = inspector.inspect(mrtCapabilities);
			if (resourceType != null)
			{
				if(!hasResourceTypeInDD(resourceType))
				{
					_generatedResourceTypes.add(resourceType);
					InitialInstancesType[] instances = inspector
							.getInitialInstances();
					for (int j = 0; j < instances.length; j++)
						_initialInstancesList.add(instances[j]);
					if(inspector.getExtraGeneratedMrt()!=null)
						_mrtObjectMap.put(inspector.getExtraGeneratedMrtPersistanceLocation(), inspector.getExtraGeneratedMrt());
					_contributedInspectors.add(inspector);
				}
			}
		}
		return (ResourceTypeType[]) _generatedResourceTypes
				.toArray(new ResourceTypeType[_generatedResourceTypes.size()]);
	}

	private List getAllMrtInspectors()
	{
		List inspectors = new ArrayList();
		inspectors.add(new BasicMrtInspector(_mrtFile, _mrt, _ddRoot));
		inspectors.add(new SubscriptionManagerInspector(_ddRoot));
		return inspectors;
	}
	
	/**
	 * Returns the initial instances
	 * @return IntialInstancesType[]
	 */
	private InitialInstancesType[] getInitialInstances()
	{
		return (InitialInstancesType[]) _initialInstancesList
				.toArray(new InitialInstancesType[_initialInstancesList.size()]);
	}

	/**
	 * Returns the map.
	 * Key will be the persisted location of MRT and 
	 * value will be the ManageableREsourceType object. 
	 */
	public Map getMrtObjectMap() 
	{
		return _mrtObjectMap;
	}
	
	/**
	 * This method will persist the extra artifacts generated at codegen time.
	 */
	public void persistArtifacts()
	{
		for(int i=0;i<_contributedInspectors.size();i++)
		{
			MrtInspector inspector = (MrtInspector)_contributedInspectors.get(i);
			inspector.persistArtifacts();
		}		
	}
}

Return to bug 167588

Lines 315-327 Link Here

(-)src/org/eclipse/tptp/wsdm/tooling/wizard/mrt/internal/NewMrtWizard.java (-5 / +1 lines)
315	* Throws exception while getting WSDL files and also while	315	* Throws exception while getting WSDL files and also while
316	* merging them	316	* merging them
317	*/	317	*/
318	public static Document createMergedWSDL(IPath mrtFile, String address)	318	public static Document createMergedWSDL(ManageableResourceType mrt, String address)
319	throws Exception	319	throws Exception
320	{	320	{
321	// Get the MRT file and load it into memory
322	URI uri = URI.createFileURI(mrtFile.toString());
323	ManageableResourceType mrt = MrtUtils.loadMRT(uri);
324
325	checkReadersWriters();	321	checkReadersWriters();
326		322
327	List wsdlFiles = null;	323	List wsdlFiles = null;

Lines 101-106 Link Here

(-)src/org/eclipse/tptp/wsdm/tooling/codegen/mrt/provisional/BasicMrtInspector.java (+14 lines)
101	public void setMrtParentDirectory(String mrtParentDir)	101	public void setMrtParentDirectory(String mrtParentDir)
102	{	102	{
103	}	103	}
		104
		105	public void persistArtifacts()
		106	{
		107	}
		108
		109	public ManageableResourceType getExtraGeneratedMrt()
		110	{
		111	return null;
		112	}
		113
		114	public String getExtraGeneratedMrtPersistanceLocation()
		115	{
		116	return null;
		117	}
104	}	118	}
105		119
106	class Mrt2DescriptorResourceType	120	class Mrt2DescriptorResourceType

Lines 47-52 Link Here

(-)src/org/eclipse/tptp/wsdm/tooling/nls/messages/mrt/internal/Messages.java (+2 lines)
47	public static String HOOKUP_WIZARD_ERROR_1;	47	public static String HOOKUP_WIZARD_ERROR_1;
48	public static String HOOKUP_WIZARD_ERROR_2;	48	public static String HOOKUP_WIZARD_ERROR_2;
49	public static String HOOKUP_WIZARD_ERROR_3;	49	public static String HOOKUP_WIZARD_ERROR_3;
		50	public static String HOOKUP_WIZARD_PERSIST;
50	public static String HOOKUP_WIZARD_ERROR_4;	51	public static String HOOKUP_WIZARD_ERROR_4;
51	public static String HOOKUP_WIZARD_ERROR_5;	52	public static String HOOKUP_WIZARD_ERROR_5;
52	public static String HOOKUP_WIZARD_ERROR_6;	53	public static String HOOKUP_WIZARD_ERROR_6;
Lines 131-136 Link Here
131	public static String CODE_GEN_STEP1;	132	public static String CODE_GEN_STEP1;
132	public static String CODE_GEN_STEP2;	133	public static String CODE_GEN_STEP2;
133	public static String CODE_GEN_STEP3;	134	public static String CODE_GEN_STEP3;
		135	public static String CODE_GEN_STEP4;
134	public static String CODE_GEN_FAILED_ERROR;	136	public static String CODE_GEN_FAILED_ERROR;
135	public static String CODE_GEN_SUBTASK1;	137	public static String CODE_GEN_SUBTASK1;
136	public static String CODE_GEN_SUBTASK2;	138	public static String CODE_GEN_SUBTASK2;

Lines 12-48 Link Here

(-)src/org/eclipse/tptp/wsdm/tooling/codegen/mrt/provisional/MRTCodeGenerationDelegate.java (-172 / +75 lines)
12		12
13	package org.eclipse.tptp.wsdm.tooling.codegen.mrt.provisional;	13	package org.eclipse.tptp.wsdm.tooling.codegen.mrt.provisional;
14		14
15	import java.util.ArrayList;	15	import java.io.ByteArrayInputStream;
		16	import java.io.ByteArrayOutputStream;
		17	import java.io.IOException;
16	import java.util.HashMap;	18	import java.util.HashMap;
17	import java.util.List;
18	import java.util.Map;	19	import java.util.Map;
19		20
20	import org.apache.ws.muse.descriptor.AdditionalJarsType;
21	import org.apache.ws.muse.descriptor.DescriptorFactory;	21	import org.apache.ws.muse.descriptor.DescriptorFactory;
22	import org.apache.ws.muse.descriptor.DocumentRoot;	22	import org.apache.ws.muse.descriptor.DocumentRoot;
23	import org.apache.ws.muse.descriptor.InitialInstancesType;
24	import org.apache.ws.muse.descriptor.LogLevelType;
25	import org.apache.ws.muse.descriptor.LoggingType;
26	import org.apache.ws.muse.descriptor.MuseType;
27	import org.apache.ws.muse.descriptor.PersistenceType;
28	import org.apache.ws.muse.descriptor.ResourceTypeType;	23	import org.apache.ws.muse.descriptor.ResourceTypeType;
29	import org.apache.ws.muse.descriptor.RootType;
30	import org.apache.ws.muse.descriptor.RouterType;
31	import org.apache.ws.muse.descriptor.WsdlType;	24	import org.apache.ws.muse.descriptor.WsdlType;
32	import org.eclipse.core.resources.IFile;	25	import org.eclipse.core.resources.IFile;
33	import org.eclipse.core.resources.ResourcesPlugin;
34	import org.eclipse.core.runtime.IPath;	26	import org.eclipse.core.runtime.IPath;
35	import org.eclipse.core.runtime.SubProgressMonitor;	27	import org.eclipse.core.runtime.SubProgressMonitor;
36	import org.eclipse.emf.common.util.URI;	28	import org.eclipse.emf.common.util.URI;
37	import org.eclipse.emf.ecore.EObject;
38	import org.eclipse.emf.ecore.resource.Resource;	29	import org.eclipse.emf.ecore.resource.Resource;
39	import org.eclipse.emf.ecore.resource.ResourceSet;	30	import org.eclipse.emf.ecore.resource.ResourceSet;
40	import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl;	31	import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl;
41	import org.eclipse.emf.ecore.xmi.XMLResource;	32	import org.eclipse.emf.ecore.xmi.XMLResource;
42	import org.eclipse.tptp.wsdm.tooling.model.capabilities.Capability;
43	import org.eclipse.tptp.wsdm.tooling.model.manageableResourceType.ManageableResourceType;	33	import org.eclipse.tptp.wsdm.tooling.model.manageableResourceType.ManageableResourceType;
44	import org.eclipse.tptp.wsdm.tooling.nls.messages.dde.internal.Messages;	34	import org.eclipse.tptp.wsdm.tooling.nls.messages.dde.internal.Messages;
45	import org.eclipse.tptp.wsdm.tooling.util.internal.EclipseUtils;
46	import org.eclipse.tptp.wsdm.tooling.util.internal.MrtUtils;	35	import org.eclipse.tptp.wsdm.tooling.util.internal.MrtUtils;
47	import org.eclipse.tptp.wsdm.tooling.util.internal.MyDescriptorResourceFactoryImpl;	36	import org.eclipse.tptp.wsdm.tooling.util.internal.MyDescriptorResourceFactoryImpl;
48	import org.eclipse.tptp.wsdm.tooling.util.internal.WsdmToolingLog;	37	import org.eclipse.tptp.wsdm.tooling.util.internal.WsdmToolingLog;
Lines 54-64 Link Here
54	*/	43	*/
55	public class MRTCodeGenerationDelegate implements CodeGenerationDelegate	44	public class MRTCodeGenerationDelegate implements CodeGenerationDelegate
56	{	45	{
57		46	private ManageableResourceType _mrt;
		47	private MrtPreProcessor _mrtPreProcessor;
58	private String _ddFilePath;	48	private String _ddFilePath;
59	private IFile _mrtFile;	49	private IFile _mrtFile;
60	private DocumentRoot _root;	50	private DocumentRoot _ddRoot;
61		51
62	/**	52	/**
63	* Constructor of the class	53	* Constructor of the class
64	* @param mrtFile	54	* @param mrtFile
Lines 66-83 Link Here
66	public MRTCodeGenerationDelegate(IFile mrtFile)	56	public MRTCodeGenerationDelegate(IFile mrtFile)
67	{	57	{
68	_mrtFile = mrtFile;	58	_mrtFile = mrtFile;
69	_generatedResourceTypes = new ArrayList();
70	_initialInstancesList = new ArrayList();
71	_contributedInspectors = new ArrayList();
72	URI mrtURI = URI.createPlatformResourceURI(mrtFile.getFullPath()	59	URI mrtURI = URI.createPlatformResourceURI(mrtFile.getFullPath()
73	.toString());	60	.toString());
74	_mrt = MrtUtils.loadMRT(mrtURI);	61	_mrt = MrtUtils.loadMRT(mrtURI);
		62	_mrtPreProcessor = new MrtPreProcessor(_mrt);
75	}	63	}
76		64
77	/**	65	/**
78	* Creates the DD file.	66	* Creates the DD file.
79	* The method returns a DescriptorHelper which	67	* The method returns a DescriptorHelper which
80	* aggregates all of the work that was done.	68	* aggregates all of the work that was done.
		69	*
81	* @param progressMonitor A progress monitor to	70	* @param progressMonitor A progress monitor to
82	* show the progress done during this	71	* show the progress done during this
83	* task.	72	* task.
Lines 86-96 Link Here
86	public DescriptorHelper run(SubProgressMonitor progressMonitor)	75	public DescriptorHelper run(SubProgressMonitor progressMonitor)
87	throws Exception	76	throws Exception
88	{	77	{
89	IFile ddFile = createDDFile();	78	byte[] serializedDD = createDD();
90	return new DescriptorHelper(ddFile);	79	Map mrtObjectMap = _mrtPreProcessor.getMrtObjectMap();
		80	return new DescriptorHelper(new ByteArrayInputStream(serializedDD), mrtObjectMap);
		81	}
		82
		83	private byte[] createDD()
		84	{
		85	_mrtPreProcessor.preProcess();
		86	_ddRoot = _mrtPreProcessor.getDDDocumentRoot();
		87	ResourceSet resourceSet = new ResourceSetImpl();
		88	resourceSet.getResourceFactoryRegistry().getExtensionToFactoryMap()
		89	.put(Resource.Factory.Registry.DEFAULT_EXTENSION,
		90	new MyDescriptorResourceFactoryImpl());
		91	URI uri = URI.createURI("dummy.xml");
		92	Resource resource = resourceSet.createResource(uri);
		93	resource.getContents().add(_ddRoot);
		94	Map map = new HashMap();
		95	ByteArrayOutputStream baos = new ByteArrayOutputStream();
		96	try
		97	{
		98	resource.save(baos, map);
		99	}
		100	catch (IOException e)
		101	{
		102	e.printStackTrace();
		103	}
		104	return baos.toByteArray();
		105	}
		106
		107	private String createDDFilePath()
		108	{
		109	IPath ddIPath = _mrtFile.getFullPath().removeFileExtension()
		110	.addFileExtension("dd");
		111	return ddIPath.toString();
91	}	112	}
92		113
93	private IFile createDDFile()	114	/**
		115	* Create and return a new instance of given ResourceTypeType. Only
		116	* ContextPath, JavaIdFactoryClass, JavaResourceClass and WsdlType fields
		117	* have been copied.
		118	*/
		119	public static ResourceTypeType cloneResourceType(ResourceTypeType rt)
		120	{
		121	ResourceTypeType clone = DescriptorFactory.eINSTANCE
		122	.createResourceTypeType();
		123	clone.setContextPath(rt.getContextPath());
		124	clone.setJavaIdFactoryClass(rt.getJavaIdFactoryClass());
		125	clone.setJavaResourceClass(rt.getJavaResourceClass());
		126	WsdlType wClone = DescriptorFactory.eINSTANCE.createWsdlType();
		127	wClone.setWsdlFile(rt.getWsdl().getWsdlFile());
		128	wClone.setWsdlPortType(rt.getWsdl().getWsdlPortType());
		129	clone.setWsdl(wClone);
		130	return clone;
		131	}
		132
		133	/**
		134	* This method will persist the extra artifacts generated at codegen time.
		135	*/
		136	public void persistArtifacts()
		137	{
		138	_mrtPreProcessor.persistArtifacts();
		139	persistDDFile();
		140	}
		141
		142	private void persistDDFile()
94	{	143	{
95	_ddFilePath = createDDFilePath();	144	_ddFilePath = createDDFilePath();
96		145
Lines 115-124 Link Here
115	//	164	//
116	// Add the initial model object to the contents.	165	// Add the initial model object to the contents.
117	//	166	//
118	EObject rootObject = createInitialModel();	167	if (_ddRoot != null)
119	if (rootObject != null)
120	{	168	{
121	resource.getContents().add(rootObject);	169	resource.getContents().add(_ddRoot);
122	}	170	}
123		171
124	//	172	//
Lines 128-139 Link Here
128	options.put(XMLResource.OPTION_ENCODING, "UTF-8");	176	options.put(XMLResource.OPTION_ENCODING, "UTF-8");
129	try	177	try
130	{	178	{
131	resource.save(options);	179	resource.save(options);
132
133	IFile file = EclipseUtils.getIFile(ResourcesPlugin.getWorkspace()
134	.getRoot(), fileURI.toString());
135	//return file.getLocation().toFile();
136	return file;
137	}	180	}
138	catch (Exception exception)	181	catch (Exception exception)
139	{	182	{
Lines 142-286 Link Here
142	Messages.FAILED_TO_INITIALIZE_MUSE_DESCRIPTOR_ERROR_,	185	Messages.FAILED_TO_INITIALIZE_MUSE_DESCRIPTOR_ERROR_,
143	exception);	186	exception);
144	}	187	}
145
146	return null;
147	}
148
149	private String createDDFilePath()
150	{
151	IPath ddIPath = _mrtFile.getFullPath().removeFileExtension()
152	.addFileExtension("dd");
153	return ddIPath.toString();
154	}
155
156	protected EObject createInitialModel()
157	{
158	_root = DescriptorFactory.eINSTANCE.createDocumentRoot();
159	RootType _rootType = DescriptorFactory.eINSTANCE.createRootType();
160	MuseType _muse = DescriptorFactory.eINSTANCE.createMuseType();
161	AdditionalJarsType jars = DescriptorFactory.eINSTANCE
162	.createAdditionalJarsType();
163	_rootType.setMuse(_muse);
164	_rootType.setAdditionalJars(jars);
165	_root.setRoot(_rootType);
166
167	// Add the router to muse descriptor
168	RouterType router = createRouterType();
169	_muse.setRouter(router);
170
171	ResourceTypeType[] resourceTypes = process();
172	for (int i = 0; i < resourceTypes.length; i++)
173	_muse.getResourceType().add(resourceTypes[i]);
174
175	// Create initial instances
176	InitialInstancesType[] instances = getInitialInstances();
177	for (int i = 0; i < instances.length; i++)
178	_rootType.getInitialInstances().add(instances[i]);
179
180	return _root;
181	}
182
183	private RouterType createRouterType()
184	{
185	RouterType router = DescriptorFactory.eINSTANCE.createRouterType();
186	router
187	.setJavaRouterClass("org.apache.muse.core.routing.SimpleResourceRouter");
188	LoggingType logging = DescriptorFactory.eINSTANCE.createLoggingType();
189	logging.setLogFile("/log/muse.log");
190	logging.setLogLevel(LogLevelType.OFF_LITERAL);
191	router.setLogging(logging);
192	PersistenceType persistence = DescriptorFactory.eINSTANCE
193	.createPersistenceType();
194	persistence
195	.setJavaPersistenceClass("org.apache.muse.core.routing.RouterFilePersistence");
196	persistence.setPersistenceLocation("router-entries");
197	router.setPersistence(persistence);
198	return router;
199	}
200
201	private ManageableResourceType _mrt;
202
203	private List _generatedResourceTypes;
204
205	private List _initialInstancesList;
206
207	private List _contributedInspectors;
208
209	/**
210	* This method processes the given manageable resource type to check whether
211	* we need any extra resource type in muse descriptor file such as
212	* Subscription manager etc. It will returns all the proper ResourceTypeType
213	* objects. So it will return atleast one ResourceTypeType object that
214	* represents the given manageable resource type.
215	*/
216	public ResourceTypeType[] process()
217	{
218	Capability[] mrtCapabilities = new Capability[0];
219	try
220	{
221	mrtCapabilities = MrtUtils.getCapabilities(_mrt);
222	}
223	catch (Exception e)
224	{
225	}
226	// Analyze the given manageable resource type for Subscription manager
227	// etc.
228	// If needed add the extra resource type for Subscription manager
229	List inspectors = getAllMrtInspectors();
230	for (int i = 0; i < inspectors.size(); i++)
231	{
232	MrtInspector inspector = (MrtInspector) inspectors.get(i);
233	inspector.setMrtParentDirectory(_mrtFile.getParent().getFullPath()
234	.toString());
235	ResourceTypeType resourceType = inspector.inspect(mrtCapabilities);
236	if (resourceType != null)
237	{
238	_generatedResourceTypes.add(resourceType);
239	InitialInstancesType[] instances = inspector
240	.getInitialInstances();
241	for (int j = 0; j < instances.length; j++)
242	_initialInstancesList.add(instances[j]);
243	_contributedInspectors.add(inspector);
244	}
245	}
246	return (ResourceTypeType[]) _generatedResourceTypes
247	.toArray(new ResourceTypeType[_generatedResourceTypes.size()]);
248	}
249
250	private List getAllMrtInspectors()
251	{
252	List inspectors = new ArrayList();
253	inspectors.add(new BasicMrtInspector(_mrtFile, _mrt, _root));
254	inspectors.add(new SubscriptionManagerInspector(_root));
255	return inspectors;
256	}
257
258	/**
259	* Create and return a new instance of given ResourceTypeType. Only
260	* ContextPath, JavaIdFactoryClass, JavaResourceClass and WsdlType fields
261	* have been copied.
262	*/
263	public static ResourceTypeType cloneResourceType(ResourceTypeType rt)
264	{
265	ResourceTypeType clone = DescriptorFactory.eINSTANCE
266	.createResourceTypeType();
267	clone.setContextPath(rt.getContextPath());
268	clone.setJavaIdFactoryClass(rt.getJavaIdFactoryClass());
269	clone.setJavaResourceClass(rt.getJavaResourceClass());
270	WsdlType wClone = DescriptorFactory.eINSTANCE.createWsdlType();
271	wClone.setWsdlFile(rt.getWsdl().getWsdlFile());
272	wClone.setWsdlPortType(rt.getWsdl().getWsdlPortType());
273	clone.setWsdl(wClone);
274	return clone;
275	}
276
277	/**
278	* Returns the initial instances
279	* @return IntialInstancesType[]
280	*/
281	public InitialInstancesType[] getInitialInstances()
282	{
283	return (InitialInstancesType[]) _initialInstancesList
284	.toArray(new InitialInstancesType[_initialInstancesList.size()]);
285	}	188	}
286	}	189	}

Added Link Here

(-)src/org/eclipse/tptp/wsdm/tooling/codegen/mrt/provisional/MrtPreProcessor.java (+269 lines)
1	/*******************************************************************************
2	* Copyright (c) 2007 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* Andrew Eberbach (aeberbac@us.ibm.com)
10	* IBM Corporation - initial API and implementation
11	*******************************************************************************/
12
13	package org.eclipse.tptp.wsdm.tooling.codegen.mrt.provisional;
14
15	import java.util.ArrayList;
16	import java.util.HashMap;
17	import java.util.LinkedList;
18	import java.util.List;
19	import java.util.Map;
20
21	import org.apache.ws.muse.descriptor.AdditionalJarsType;
22	import org.apache.ws.muse.descriptor.DescriptorFactory;
23	import org.apache.ws.muse.descriptor.DocumentRoot;
24	import org.apache.ws.muse.descriptor.InitialInstancesType;
25	import org.apache.ws.muse.descriptor.LogLevelType;
26	import org.apache.ws.muse.descriptor.LoggingType;
27	import org.apache.ws.muse.descriptor.MuseType;
28	import org.apache.ws.muse.descriptor.PersistenceType;
29	import org.apache.ws.muse.descriptor.ResourceTypeType;
30	import org.apache.ws.muse.descriptor.RootType;
31	import org.apache.ws.muse.descriptor.RouterType;
32	import org.eclipse.core.resources.IFile;
33	import org.eclipse.core.runtime.CoreException;
34	import org.eclipse.tptp.wsdm.tooling.model.capabilities.Capability;
35	import org.eclipse.tptp.wsdm.tooling.model.manageableResourceType.ManageableResourceType;
36	import org.eclipse.tptp.wsdm.tooling.util.internal.EclipseUtils;
37	import org.eclipse.tptp.wsdm.tooling.util.internal.MrtUtils;
38
39	/**
40	* This class analyzes the given ManageableResourceType object and check whether it needs
41	* any other extra ManageableResourceType object such as SubscriptionManager based on the capabilities
42	* available in given ManagableResourceType.
43	*/
44
45	public class MrtPreProcessor
46	{
47	private ManageableResourceType _mrt;
48	private DocumentRoot _ddRoot;
49	private IFile _mrtFile;
50	private List _generatedResourceTypes = new LinkedList();
51	private List _initialInstancesList = new LinkedList();
52	private List _contributedInspectors = new LinkedList();
53	private Map _mrtObjectMap = new HashMap();
54
55	/**
56	* Creates instance of this class.
57	*
58	* @param mrt
59	* Given MRT to analyze.
60	*
61	* @param ddRoot
62	* Given Descriptor file document root, can be null.
63	*/
64	public MrtPreProcessor(ManageableResourceType mrt, DocumentRoot ddRoot)
65	{
66	_mrt = mrt;
67	if(ddRoot == null)
68	ddRoot = createDDModel();
69	_ddRoot = ddRoot;
70	String mrtLocation = _mrt.eResource().getURI().toString();
71	try
72	{
73	_mrtFile = EclipseUtils.getIFile(mrtLocation);
74	}
75	catch (CoreException e)
76	{
77	e.printStackTrace();
78	}
79	}
80
81	/**
82	* Creates instance of this class.
83	*
84	* @param mrt
85	* Given MRT to analyze.
86	*/
87	public MrtPreProcessor(ManageableResourceType mrt)
88	{
89	this(mrt,null);
90	}
91
92	private DocumentRoot createDDModel()
93	{
94	DocumentRoot root = DescriptorFactory.eINSTANCE.createDocumentRoot();
95	RootType _rootType = DescriptorFactory.eINSTANCE.createRootType();
96	MuseType _muse = DescriptorFactory.eINSTANCE.createMuseType();
97	AdditionalJarsType jars = DescriptorFactory.eINSTANCE
98	.createAdditionalJarsType();
99	_rootType.setMuse(_muse);
100	_rootType.setAdditionalJars(jars);
101	root.setRoot(_rootType);
102
103	RouterType router = createRouterType();
104	_muse.setRouter(router);
105
106	return root;
107	}
108
109	private RouterType createRouterType()
110	{
111	RouterType router = DescriptorFactory.eINSTANCE.createRouterType();
112	router
113	.setJavaRouterClass("org.apache.muse.core.routing.SimpleResourceRouter");
114	LoggingType logging = DescriptorFactory.eINSTANCE.createLoggingType();
115	logging.setLogFile("/log/muse.log");
116	logging.setLogLevel(LogLevelType.OFF_LITERAL);
117	router.setLogging(logging);
118	PersistenceType persistence = DescriptorFactory.eINSTANCE
119	.createPersistenceType();
120	persistence
121	.setJavaPersistenceClass("org.apache.muse.core.routing.RouterFilePersistence");
122	persistence.setPersistenceLocation("router-entries");
123	router.setPersistence(persistence);
124	return router;
125	}
126
127	/**
128	* Returns the modified Descriptor document root.
129	*/
130	public DocumentRoot getDDDocumentRoot()
131	{
132	return _ddRoot;
133	}
134
135	/**
136	* Analyzes the given MRT file for extra required artifacts.
137	*/
138	public void preProcess()
139	{
140	if(_ddRoot!=null)
141	{
142	RootType root = _ddRoot.getRoot();
143	MuseType muse = root.getMuse();
144	ResourceTypeType[] resourceTypes = process();
145	for (int i = 0; i < resourceTypes.length; i++)
146	muse.getResourceType().add(resourceTypes[i]);
147
148	// Create initial instances
149
150	InitialInstancesType[] instances = getInitialInstances();
151	for (int i = 0; i < instances.length; i++)
152	root.getInitialInstances().add(instances[i]);
153	}
154	}
155
156	private boolean hasResourceTypeInDD(ResourceTypeType givenResourceType)
157	{
158	if(_ddRoot!=null)
159	{
160	if(_ddRoot.getRoot()!=null)
161	{
162	if(_ddRoot.getRoot().getMuse()!=null)
163	{
164	MuseType muse = _ddRoot.getRoot().getMuse();
165	List resourceTypes = muse.getResourceType();
166	if(resourceTypes!=null)
167	{
168	for(int i=0;i<resourceTypes.size();i++)
169	{
170	ResourceTypeType resourceType = (ResourceTypeType)resourceTypes.get(i);
171	boolean equalContextPath = givenResourceType.getContextPath().equals(resourceType.getContextPath());
172	boolean equalWsdlFile = givenResourceType.getWsdl().getWsdlFile().equals(resourceType.getWsdl().getWsdlFile());
173	boolean equalWsdlPortType = givenResourceType.getWsdl().getWsdlPortType().equals(resourceType.getWsdl().getWsdlPortType());
174	if(equalContextPath && equalWsdlFile && equalWsdlPortType)
175	return true;
176	}
177	}
178	}
179	}
180	}
181	return false;
182	}
183
184	/**
185	* This method processes the given manageable resource type to check whether
186	* we need any extra resource type in muse descriptor file such as
187	* Subscription manager etc. It will returns all the proper ResourceTypeType
188	* objects. So it will return atleast one ResourceTypeType object that
189	* represents the given manageable resource type.
190	*/
191	private ResourceTypeType[] process()
192	{
193	Capability[] mrtCapabilities = new Capability[0];
194	try
195	{
196	mrtCapabilities = MrtUtils.getCapabilities(_mrt);
197	}
198	catch (Exception e)
199	{
200	}
201	// Analyze the given manageable resource type for Subscription manager
202	// etc.
203	// If needed add the extra resource type for Subscription manager
204	List inspectors = getAllMrtInspectors();
205	for (int i = 0; i < inspectors.size(); i++)
206	{
207	MrtInspector inspector = (MrtInspector) inspectors.get(i);
208	inspector.setMrtParentDirectory(_mrtFile.getParent().getFullPath()
209	.toString());
210	ResourceTypeType resourceType = inspector.inspect(mrtCapabilities);
211	if (resourceType != null)
212	{
213	if(!hasResourceTypeInDD(resourceType))
214	{
215	_generatedResourceTypes.add(resourceType);
216	InitialInstancesType[] instances = inspector
217	.getInitialInstances();
218	for (int j = 0; j < instances.length; j++)
219	_initialInstancesList.add(instances[j]);
220	if(inspector.getExtraGeneratedMrt()!=null)
221	_mrtObjectMap.put(inspector.getExtraGeneratedMrtPersistanceLocation(), inspector.getExtraGeneratedMrt());
222	_contributedInspectors.add(inspector);
223	}
224	}
225	}
226	return (ResourceTypeType[]) _generatedResourceTypes
227	.toArray(new ResourceTypeType[_generatedResourceTypes.size()]);
228	}
229
230	private List getAllMrtInspectors()
231	{
232	List inspectors = new ArrayList();
233	inspectors.add(new BasicMrtInspector(_mrtFile, _mrt, _ddRoot));
234	inspectors.add(new SubscriptionManagerInspector(_ddRoot));
235	return inspectors;
236	}
237
238	/**
239	* Returns the initial instances
240	* @return IntialInstancesType[]
241	*/
242	private InitialInstancesType[] getInitialInstances()
243	{
244	return (InitialInstancesType[]) _initialInstancesList
245	.toArray(new InitialInstancesType[_initialInstancesList.size()]);
246	}
247
248	/**
249	* Returns the map.
250	* Key will be the persisted location of MRT and
251	* value will be the ManageableREsourceType object.
252	*/
253	public Map getMrtObjectMap()
254	{
255	return _mrtObjectMap;
256	}
257
258	/**
259	* This method will persist the extra artifacts generated at codegen time.
260	*/
261	public void persistArtifacts()
262	{
263	for(int i=0;i<_contributedInspectors.size();i++)
264	{
265	MrtInspector inspector = (MrtInspector)_contributedInspectors.get(i);
266	inspector.persistArtifacts();
267	}
268	}
269	}