org/objectweb/proactive/core/descriptor/data/ProActiveDescriptorImpl.java

/* 
 * ################################################################
 * 
 * ProActive: The Java(TM) library for Parallel, Distributed, 
 *            Concurrent computing with Security and Mobility
 * 
 * Copyright (C) 1997-2007 INRIA/University of Nice-Sophia Antipolis
 * Contact: proactive@objectweb.org
 * 
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or any later version.
 *  
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
 * USA
 *  
 *  Initial developer(s):               The ProActive Team
 *                        http://www.inria.fr/oasis/ProActive/contacts.html
 *  Contributor(s): 
 * 
 * ################################################################
 */ 
package org.objectweb.proactive.core.descriptor.data;

import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

import org.apache.log4j.Logger;
import org.objectweb.proactive.ProActive;
import org.objectweb.proactive.core.ProActiveException;
import org.objectweb.proactive.core.body.ProActiveMetaObjectFactory;
import org.objectweb.proactive.core.descriptor.services.ServiceUser;
import org.objectweb.proactive.core.descriptor.services.TechnicalService;
import org.objectweb.proactive.core.descriptor.services.TechnicalServiceWrapper;
import org.objectweb.proactive.core.descriptor.services.TechnicalServiceXmlType;
import org.objectweb.proactive.core.descriptor.services.UniversalService;
import org.objectweb.proactive.core.process.AbstractSequentialListProcessDecorator;
import org.objectweb.proactive.core.process.ExternalProcess;
import org.objectweb.proactive.core.process.ExternalProcessDecorator;
import org.objectweb.proactive.core.process.HierarchicalProcess;
import org.objectweb.proactive.core.process.JVMProcess;
import org.objectweb.proactive.core.process.JVMProcessImpl;
import org.objectweb.proactive.core.process.filetransfer.FileTransferDefinition;
import org.objectweb.proactive.core.runtime.ProActiveRuntimeImpl;
import org.objectweb.proactive.core.util.log.Loggers;
import org.objectweb.proactive.core.util.log.ProActiveLogger;
import org.objectweb.proactive.core.xml.VariableContract;
import org.objectweb.proactive.ext.security.PolicyServer;
import org.objectweb.proactive.ext.security.ProActiveSecurityDescriptorHandler;
import org.objectweb.proactive.ext.security.ProActiveSecurityManager;
import org.objectweb.proactive.ext.security.exceptions.InvalidPolicyFile;


public class ProActiveDescriptorImpl implements ProActiveDescriptor {
    //
    //  ----- PRIVATE MEMBERS -----------------------------------------------------------------------------------
    //
    protected static Logger logger = ProActiveLogger.getLogger(Loggers.DEPLOYMENT);
    private String lastMainDefinitionID;

    private Map<String, MainDefinition> mainDefinitionMapping;

    private java.util.HashMap<String, VirtualNode> virtualNodeMapping;

    private java.util.HashMap<String, VirtualMachine> virtualMachineMapping;

    private java.util.HashMap processMapping;

    private java.util.HashMap<String, ProcessUpdater> pendingProcessMapping;

    private java.util.HashMap<String, UniversalService> serviceMapping;

    private java.util.HashMap pendingServiceMapping;

    private java.util.HashMap<String, FileTransferDefinition> fileTransferMapping;

    private VariableContract variableContract;

    private String url;
    private String jobID;
    private String descriptorURL;
    private boolean mainDefined;

    protected ProActiveSecurityManager proactiveSecurityManager;
    public PolicyServer policyServer;

    //  public X509Certificate creatorCertificate;
    public String securityFile;
    private HashMap<String, TechnicalService> technicalServiceMapping;

    //
    //  ----- CONSTRUCTORS -----------------------------------------------------------------------------------
    //
    public ProActiveDescriptorImpl(String url) {
        mainDefinitionMapping = new HashMap<String, MainDefinition>();
        virtualNodeMapping = new java.util.HashMap<String, VirtualNode>();
        virtualMachineMapping = new java.util.HashMap<String, VirtualMachine>();
        processMapping = new java.util.HashMap();
        pendingProcessMapping = new java.util.HashMap<String, ProcessUpdater>();
        serviceMapping = new java.util.HashMap<String, UniversalService>();
        pendingServiceMapping = new java.util.HashMap();
        fileTransferMapping = new java.util.HashMap<String, FileTransferDefinition>();
        variableContract = new VariableContract();
        this.url = url;
        this.descriptorURL = url;
        mainDefined = false;
        this.technicalServiceMapping = new HashMap<String, TechnicalService>();
    }

    //
    //  ----- PUBLIC METHODS -----------------------------------------------------------------------------------
    //
    public String getUrl() {
        return this.url;
    }
    
    public String getProActiveDescriptorURL() {
        return descriptorURL;
    }

    public void createMainDefinition(String id) {
        lastMainDefinitionID = id;
        mainDefinitionMapping.put(id, new MainDefinition());
    }

    public void mainDefinitionSetMainClass(String mainClass) {
        getMainDefinition().setMainClass(mainClass);
    }

    public void mainDefinitionAddParameter(String parameter) {
        getMainDefinition().addParameter(parameter);
    }

    public String[] mainDefinitionGetParameters(String mainDefinitionId) {
        return getMainDefinition(mainDefinitionId).getParameters();
    }

    public void mainDefinitionAddVirtualNode(VirtualNode virtualNode) {
        getMainDefinition().addVirtualNode(virtualNode);
    }

    public boolean isMainDefined() {
        return mainDefined;
    }

    public void setMainDefined(boolean mainDefined) {
        this.mainDefined = mainDefined;
    }

    public void activateMains() {
        if (!isMainDefined()) {
            return;
        }

        for (String id : mainDefinitionMapping.keySet()) {
                activateMain(id);
        }
    }

    public void activateMain(String mainDefinitionId) {
        MainDefinition mainDefinition = getMainDefinition(mainDefinitionId);

        if (mainDefinition != null) {
            mainDefinition.activateMain();
        }
    }

    public Map getMainDefinitionMapping() {
        return mainDefinitionMapping;
    }

    public void setMainDefinitionMapping(HashMap<String, MainDefinition> newMapping) {
        mainDefinitionMapping = newMapping;
    }

    public Map<String, VirtualNode> getVirtualNodeMapping() {
        return virtualNodeMapping;
    }

    public void setVirtualNodeMapping(HashMap<String, VirtualNode> newMapping) {
        virtualNodeMapping = newMapping;
    }

    public MainDefinition[] getMainDefinitions() {
        MainDefinition[] mainDefinitions = new MainDefinition[mainDefinitionMapping.size()];
        Set<String> mainsId = mainDefinitionMapping.keySet();
        Iterator it = mainsId.iterator();
        int i = 0;

        while (it.hasNext()) {
            String id = (String) it.next();
            mainDefinitions[i] = getMainDefinition(id);
            i++;
        }

        return mainDefinitions;
    }

    public VirtualNode[] getVirtualNodes() {
        int i = 0;
        VirtualNode[] virtualNodeArray = new VirtualNode[virtualNodeMapping.size()];
        Collection collection = virtualNodeMapping.values();

        for (Iterator iter = collection.iterator(); iter.hasNext();) {
            virtualNodeArray[i] = (VirtualNode) iter.next();
            i++;
        }

        return virtualNodeArray;
    }

    public VirtualNode getVirtualNode(String name) {
        return virtualNodeMapping.get(name);
    }

    public VirtualMachine getVirtualMachine(String name) {
        return virtualMachineMapping.get(name);
    }

    public ExternalProcess getProcess(String name) {
        return (ExternalProcess) processMapping.get(name);
    }

    public ExternalProcess getHierarchicalProcess(String vmname) {
        VirtualMachine vm = getVirtualMachine(vmname);

        if (vm == null) {
            logger.warn("" + vmname + "cannot be found");

            return null;
        }

        if (vm.getProcess() instanceof HierarchicalProcess) {
            return ((HierarchicalProcess) vm.getProcess()).getHierarchicalProcess();
        } else {
            logger.warn("" + vmname +
                " does not contain a hierarchical process !");

            return null;
        }
    }

    public UniversalService getService(String serviceID) {
        return serviceMapping.get(serviceID);
    }

    protected FileTransferDefinition createFileTransferDefinition(
        String fileTransferID) {
        FileTransferDefinition ft = new FileTransferDefinition(fileTransferID);
        fileTransferMapping.put(fileTransferID, ft);

        if (logger.isDebugEnabled()) {
            logger.debug("created FileTransfer id=" + fileTransferID);
        }

        return ft;
    }

    public VirtualNode createVirtualNode(String vnName, boolean lookup) {
        return createVirtualNode(vnName, lookup, false);
    }

    public VirtualNode createVirtualNode(String vnName, boolean lookup,
        boolean isMainNode) {
        VirtualNode vn = getVirtualNode(vnName);

        if (jobID == null) {
            if (isMainDefined()) {
                this.jobID = generateNewJobID();

                //System.out.println("new id generated : " + jobID);
            } else {
                this.jobID = ProActive.getJobId();

                //System.out.println("using runtime id : " + jobID);
            }

            this.url = url + this.jobID;
        }

        if (vn == null) {
            if (lookup) {
                vn = new VirtualNodeLookup(vnName);
            } else {
                vn = new VirtualNodeImpl(vnName, proactiveSecurityManager,
                        this.url, isMainNode, this);
                ((VirtualNodeImpl) vn).jobID = this.jobID;

                //System.out.println("vn created with url: " + padURL + " and jobid : " + ((VirtualNodeImpl) vn).jobID);
            }

            virtualNodeMapping.put(vnName, vn);

            if (logger.isInfoEnabled()) {
                logger.info("created VirtualNode name=" + vnName);
            }
        }

        return vn;
    }

    public VirtualMachine createVirtualMachine(String vmName) {
        VirtualMachine vm = getVirtualMachine(vmName);

        if (vm == null) {
            vm = new VirtualMachineImpl();
            vm.setName(vmName);
            virtualMachineMapping.put(vmName, vm);
        }

        if (logger.isDebugEnabled()) {
            logger.debug("created virtualMachine name=" + vmName);
        }

        return vm;
    }

    public ExternalProcess createProcess(String processID,
        String processClassName) throws ProActiveException {
        ExternalProcess process = getProcess(processID);

        if (process == null) {
            process = createProcess(processClassName);
            addExternalProcess(processID, process);
        }

        return process;
    }

    public ExternalProcess createProcess(String processClassName)
        throws ProActiveException {
        try {
            Class processClass = Class.forName(processClassName);
            ExternalProcess process = (ExternalProcess) processClass.newInstance();

            return process;
        } catch (ClassNotFoundException e) {
            throw new ProActiveException(e);
        } catch (InstantiationException e) {
            throw new ProActiveException(e);
        } catch (IllegalAccessException e) {
            throw new ProActiveException(e);
        }
    }

    public void registerProcess(VirtualMachine virtualMachine, String processID) {
        ExternalProcess process = getProcess(processID);

        if (process == null) {
            addPendingProcess(processID, virtualMachine);
        } else {
            virtualMachine.setProcess(process);
        }
    }

    public synchronized FileTransferDefinition getFileTransfer(
        String fileTransferID) {
        //TODO throw new ProActiveException 
        //if(fileTransferID.equalsIgnoreCase("implicit")) throw new ProActiveException();
        FileTransferDefinition ft = fileTransferMapping.get(fileTransferID);

        if (ft == null) {
            ft = createFileTransferDefinition(fileTransferID);
            fileTransferMapping.put(fileTransferID, ft);

            if (logger.isDebugEnabled()) {
                logger.debug("created FileTransfer id=" + fileTransferID);
            }
        }

        return ft;
    }

    public void registerProcess(ExternalProcessDecorator compositeProcess,
        String processID) {
        ExternalProcess process = getProcess(processID);

        if (process == null) {
            addPendingProcess(processID, compositeProcess);
        } else {
            compositeProcess.setTargetProcess(process);
        }
    }

    public void addProcessToSequenceList(
        AbstractSequentialListProcessDecorator sequentialListProcess,
        String processID) {
        ExternalProcess process = (ExternalProcess) getProcess(processID);
        if (process == null) {
            addSequentialPendingProcess(processID, sequentialListProcess);
        } else {
            sequentialListProcess.addProcessToList(process);
        }
    }

    public void addServiceToSequenceList(
        AbstractSequentialListProcessDecorator sequentialListProcess,
        String processID) {
        UniversalService service = (UniversalService) processMapping.get(processID);
        if (service == null) {
            addSequentialPendingService(processID, sequentialListProcess);
            sequentialListProcess.setFirstElementIsService(true);
        } else {
            sequentialListProcess.addServiceToList(service);
            sequentialListProcess.setFirstElementIsService(true);
        }
    }

    public void mapToExtendedJVM(JVMProcess jvmProcess, String processID)
        throws ProActiveException {
        try {
            JVMProcessImpl process = (JVMProcessImpl) getProcess(processID);

            if (process == null) {
                throw new ProActiveException("The jvmProcess with id " +
                    processID +
                    " is not yet defined in the descriptor. The extended jvmProcess must be defined before all jvmProcesses that extend it");

                //addPendingJVMProcess(processID, jvmProcess);
            } else {
                jvmProcess.setExtendedJVM(process);
            }
        } catch (ClassCastException e) {
            logger.fatal(
                "ERROR: a jvmProcess can only extend another jvmProcess. Correct the Descriptor");
            e.printStackTrace();
        }
    }

    public void registerHierarchicalProcess(HierarchicalProcess hp,
        String processID) {
        ExternalProcess process = getProcess(processID);

        if (process == null) {
            addHierarchicalPendingProcess(processID, hp);
        } else {
            hp.setHierarchicalProcess(process);
        }
    }

    public void addService(String serviceID, UniversalService service) {
        ServiceUpdater serviceUpdater = (ServiceUpdater) pendingServiceMapping.remove(serviceID);

        if (serviceUpdater != null) {
            if (logger.isDebugEnabled()) {
                logger.debug("Updating Service name=" + serviceID);
            }

            serviceUpdater.updateService(service);
        }

        processMapping.put(serviceID, service);
    }

    public void registerService(ServiceUser serviceUser, String serviceID) {
        UniversalService service = getService(serviceID);

        if (service == null) {
            addPendingService(serviceID, serviceUser);
        } else {
            try {
                serviceUser.setService(service);
            } catch (ProActiveException e) {
                e.printStackTrace();
                logger.error("the given service " + service.getServiceName() +
                    " cannot be set for class " + serviceUser.getUserClass());
            }
        }
    }

    public void activateMappings() {
        VirtualNode[] virtualNodeArray = getVirtualNodes();

        for (int i = 0; i < virtualNodeArray.length; i++) {
            virtualNodeArray[i].activate();
        }
    }

    public void activateMapping(String virtualNodeName) {
        VirtualNode virtualNode = getVirtualNode(virtualNodeName);
        virtualNode.activate();
    }

    public void killall(boolean softly) throws ProActiveException {
        ProActiveRuntimeImpl part = (ProActiveRuntimeImpl) ProActiveRuntimeImpl.getProActiveRuntime();

        part.removeDescriptor(this.url);

        VirtualNode[] vnArray = getVirtualNodes();

        for (int i = 0; i < vnArray.length; i++) {
            vnArray[i].killAll(softly);
            virtualNodeMapping.remove(vnArray[i].getName());

            //vnArray[i] = null;                
        }
    }

    public int getVirtualNodeMappingSize() {
        return virtualNodeMapping.size();
    }

    // SECURITY

    public void createProActiveSecurityManager(String file) {
        securityFile = file;

        try {
            policyServer = ProActiveSecurityDescriptorHandler.createPolicyServer(file);
            proactiveSecurityManager = new ProActiveSecurityManager(policyServer);

            // set the security policyserver to the default proactive meta object
            // by the way, the HalfBody will be associated to a security manager
            // derivated from this one.
            ProActiveSecurityManager psm = proactiveSecurityManager.generateSiblingCertificate(
                    "HalfBody");
            ProActiveMetaObjectFactory.newInstance()
                                      .setProActiveSecurityManager(psm);
        } catch (InvalidPolicyFile e) {
            e.printStackTrace();
        }
    }

    public PolicyServer getPolicyServer() {
        return policyServer;
    }

    /* (non-Javadoc)
     * @see org.objectweb.proactive.core.descriptor.data.ProActiveDescriptor#getSecurityFilePath()
     */
    public String getSecurityFilePath() {
        return securityFile;
    }

    //
    //  ----- PROTECTED METHODS -----------------------------------------------------------------------------------
    //
    //
    //  ----- PRIVATE METHODS -----------------------------------------------------------------------------------
    //
    private MainDefinition getMainDefinition(String mainDefinitionID) {
        return mainDefinitionMapping.get(mainDefinitionID);
    }

    private MainDefinition getMainDefinition() {
        return getMainDefinition(lastMainDefinitionID);
    }

    private void addExternalProcess(String processID, ExternalProcess process) {
        ProcessUpdater processUpdater = (ProcessUpdater) pendingProcessMapping.remove(processID);

        if (processUpdater != null) {
            if (logger.isDebugEnabled()) {
                logger.debug("Updating Process name=" + processID);
            }

            processUpdater.updateProcess(process);
        }

        processMapping.put(processID, process);
    }

    private void addPendingProcess(String processID,
        VirtualMachine virtualMachine) {
        ProcessUpdater updater = new VirtualMachineUpdater(virtualMachine);

        //pendingProcessMapping.put(processID, updater);
        addProcessUpdater(processID, updater);
    }

    private void addPendingProcess(String processID,
        ExternalProcessDecorator compositeProcess) {
        ProcessUpdater updater = new CompositeExternalProcessUpdater(compositeProcess);

        //pendingProcessMapping.put(processID, updater);
        addProcessUpdater(processID, updater);
    }

    private void addHierarchicalPendingProcess(String processID,
        HierarchicalProcess hp) {
        ProcessUpdater updater = new HierarchicalProcessUpdater(hp);
        addProcessUpdater(processID, updater);
    }

    private void addSequentialPendingProcess(String processID,
        AbstractSequentialListProcessDecorator sp) {
        ProcessUpdater updater = new SequentialProcessUpdater(sp);
        addProcessUpdater(processID, updater);
    }

    private void addSequentialPendingService(String processID,
        AbstractSequentialListProcessDecorator sp) {
        ServiceUpdater updater = new SequentialServiceUpdater(sp);
        addServiceUpdater(processID, updater);
    }

    //Commented in the fist version of jvm extension
    //    private void addPendingJVMProcess(String processID, JVMProcess jvmProcess) {
    //        ProcessUpdater updater = new ExtendedJVMProcessUpdater(jvmProcess);
    //
    //        //pendingProcessMapping.put(processID, updater);
    //        addProcessUpdater(processID, updater);
    //    }
    private void addProcessUpdater(String processID,
        ProcessUpdater processUpdater) {
        CompositeProcessUpdater compositeProcessUpdater = (CompositeProcessUpdater) pendingProcessMapping.get(processID);

        if (compositeProcessUpdater == null) {
            compositeProcessUpdater = new CompositeProcessUpdater();

            //pendingProcessMapping.put(processID, processUpdater);
            pendingProcessMapping.put(processID, compositeProcessUpdater);
        }

        compositeProcessUpdater.addProcessUpdater(processUpdater);
    }

    private void addPendingService(String serviceID, ServiceUser serviceUser) {
        ServiceUpdater updater = null;

        if (serviceUser instanceof VirtualMachine) {
            updater = new VirtualMachineUpdater((VirtualMachine) serviceUser);
        } else {
            updater = new ServiceUpdaterImpl(serviceUser);
        }

        addServiceUpdater(serviceID, updater);
    }

    private void addServiceUpdater(String serviceID,
        ServiceUpdater serviceUpdater) {
        CompositeServiceUpdater compositeServiceUpdater = (CompositeServiceUpdater) pendingServiceMapping.get(serviceID);

        if (compositeServiceUpdater == null) {
            compositeServiceUpdater = new CompositeServiceUpdater();

            //pendingProcessMapping.put(processID, processUpdater);
            pendingServiceMapping.put(serviceID, compositeServiceUpdater);
        }

        compositeServiceUpdater.addServiceUpdater(serviceUpdater);
    }

    private String generateNewJobID() {
        return "JOB-" + System.currentTimeMillis();
    }

    //
    //  ----- INNER CLASSES -----------------------------------------------------------------------------------
    //
    private interface ServiceUpdater {
        public void updateService(UniversalService service);
    }

    private interface ProcessUpdater {
        public void updateProcess(ExternalProcess p);
    }

    private class CompositeServiceUpdater implements ServiceUpdater {
        private java.util.ArrayList<ServiceUpdater> updaterList;

        public CompositeServiceUpdater() {
            updaterList = new java.util.ArrayList<ServiceUpdater>();
        }

        public void addServiceUpdater(ServiceUpdater s) {
            updaterList.add(s);
        }

        public void updateService(UniversalService s) {

            for (ServiceUpdater serviceUpdater : updaterList) {
                serviceUpdater.updateService(s);
            }

            updaterList.clear();
        }
    }

    private class CompositeProcessUpdater implements ProcessUpdater {
        private java.util.ArrayList<ProcessUpdater> updaterList;

        public CompositeProcessUpdater() {
            updaterList = new java.util.ArrayList<ProcessUpdater>();
        }

        public void addProcessUpdater(ProcessUpdater p) {
            updaterList.add(p);
        }

        public void updateProcess(ExternalProcess p) {
           
                for (ProcessUpdater processUpdater : updaterList) {
                        processUpdater.updateProcess(p);
            }

            updaterList.clear();
        }
    }

    private class CompositeExternalProcessUpdater implements ProcessUpdater {
        private ExternalProcessDecorator compositeExternalProcess;

        public CompositeExternalProcessUpdater(
            ExternalProcessDecorator compositeExternalProcess) {
            this.compositeExternalProcess = compositeExternalProcess;
        }

        public void updateProcess(ExternalProcess p) {
            if (logger.isDebugEnabled()) {
                logger.debug("Updating CompositeExternal Process");
            }

            compositeExternalProcess.setTargetProcess(p);
        }
    }

    private class HierarchicalProcessUpdater implements ProcessUpdater {
        private HierarchicalProcess hp;

        public HierarchicalProcessUpdater(HierarchicalProcess hp) {
            this.hp = hp;
        }

        public void updateProcess(ExternalProcess p) {
            if (logger.isDebugEnabled()) {
                logger.debug("Updating Hierarchical Process");
            }

            hp.setHierarchicalProcess(p);
        }
    }

    private class SequentialProcessUpdater implements ProcessUpdater {
        private AbstractSequentialListProcessDecorator spd;

        public SequentialProcessUpdater(
            AbstractSequentialListProcessDecorator spd) {
            this.spd = spd;
        }

        public void updateProcess(ExternalProcess p) {
            if (logger.isDebugEnabled()) {
                logger.debug("Updating Sequential Process");
            }

            // add the process in head of list
            spd.addProcessToList(0, (ExternalProcessDecorator) p);
        }
    }

    private class SequentialServiceUpdater implements ServiceUpdater {
        private AbstractSequentialListProcessDecorator spd;

        public SequentialServiceUpdater(
            AbstractSequentialListProcessDecorator spd) {
            this.spd = spd;
        }

        public void updateService(UniversalService s) {
            if (logger.isDebugEnabled()) {
                logger.debug("Updating Sequential Service");
            }

            // add the process in head of list
            spd.addServiceToList(0, (UniversalService) s);
        }
    }

    //  Commented in the fist version of jvm extension
    //    private class ExtendedJVMProcessUpdater implements ProcessUpdater {
    //        private JVMProcess jvmProcess;
    //
    //        public ExtendedJVMProcessUpdater(JVMProcess jvmProcess) {
    //            this.jvmProcess = jvmProcess;
    //        }
    //
    //        public void updateProcess(ExternalProcess p) {
    //            jvmProcess.setExtendedJVM((JVMProcessImpl) p);
    //        }
    //    }
    private class VirtualMachineUpdater implements ProcessUpdater,
        ServiceUpdater {
        private VirtualMachine virtualMachine;

        public VirtualMachineUpdater(VirtualMachine virtualMachine) {
            this.virtualMachine = virtualMachine;
        }

        public void updateProcess(ExternalProcess p) {
            if (logger.isDebugEnabled()) {
                logger.debug("Updating VirtualMachine Process");
            }

            virtualMachine.setProcess(p);
        }

        public void updateService(UniversalService s) {
            if (logger.isDebugEnabled()) {
                logger.debug("Updating VirtualMachine Service");
            }

            virtualMachine.setService(s);
        }
    }

    private class ServiceUpdaterImpl implements ServiceUpdater {
        private ServiceUser serviceUser;

        public ServiceUpdaterImpl(ServiceUser serviceUser) {
            this.serviceUser = serviceUser;
        }

        public void updateService(UniversalService s) {
            if (logger.isDebugEnabled()) {
                logger.debug("Updating VirtualMachine Service");
            }

            try {
                serviceUser.setService(s);
            } catch (ProActiveException e) {
                e.printStackTrace();
                logger.error("the given service " + s.getServiceName() +
                    " cannot be set for class " + serviceUser.getUserClass());
            }
        }
    }

    public void setVariableContract(VariableContract variableContract) {
        this.variableContract = variableContract;
    }

    public VariableContract getVariableContract() {
        return this.variableContract;
    }

    public void addTechnicalService(TechnicalServiceXmlType tsParsed)
        throws Exception {
        TechnicalService ts = (TechnicalService) tsParsed.getType().newInstance();
        ((TechnicalService) ts).init(tsParsed.getArgs());
        ((TechnicalServiceWrapper) this.technicalServiceMapping.get(tsParsed.getId())).setTs(ts);
    }

    public TechnicalService getTechnicalService(
        String technicalServiceId) {
        TechnicalService ts =  this.technicalServiceMapping.get(technicalServiceId);

        if (ts == null) {
            ts = new TechnicalServiceWrapper();
            this.technicalServiceMapping.put(technicalServiceId, ts);
        }

        return ts;
    }
}

---