threadedtoolagentmanager.java

Sequoia ERP是一个真正的企业级开源ERP解决方案。它提供的模块包括：电子商务应用(e-commerce), POS系统(point of sales),知识管理,存货与仓库管理

/*
 * $Id: ThreadedToolAgentManager.java 5462 2005-08-05 18:35:48Z jonesde $
 *
 */
package org.enhydra.shark;

import java.util.List;
import java.util.ArrayList;
import java.util.Properties;
import java.util.Iterator;
import java.util.Map;
import java.util.HashMap;
import java.util.Collection;

import org.enhydra.shark.api.internal.working.ToolAgentManager;
import org.enhydra.shark.api.internal.working.WfActivityInternal;
import org.enhydra.shark.api.internal.working.CallbackUtilities;
import org.enhydra.shark.api.internal.working.WfProcessInternal;
import org.enhydra.shark.api.internal.toolagent.AppParameter;
import org.enhydra.shark.api.internal.toolagent.SessionHandle;
import org.enhydra.shark.api.internal.toolagent.ToolAgent;
import org.enhydra.shark.api.internal.toolagent.ConnectFailed;
import org.enhydra.shark.api.internal.toolagent.ToolAgentGeneralException;
import org.enhydra.shark.api.internal.appmappersistence.ApplicationMap;
import org.enhydra.shark.api.internal.appmappersistence.ApplicationMappingManager;
import org.enhydra.shark.api.SharkTransaction;
import org.enhydra.shark.api.RootException;
import org.enhydra.shark.api.TransactionException;
import org.enhydra.shark.api.ApplicationMappingTransaction;
import org.enhydra.shark.api.client.wfbase.BaseException;
import org.enhydra.shark.api.client.wfmodel.InvalidData;
import org.enhydra.shark.api.client.wfmodel.UpdateNotAllowed;
import org.enhydra.shark.api.client.wfmodel.CannotComplete;
import org.enhydra.shark.xpdl.elements.Tool;
import org.enhydra.shark.xpdl.elements.WorkflowProcess;
import org.enhydra.shark.xpdl.elements.Application;
import org.enhydra.shark.xpdl.elements.ActualParameters;
import org.enhydra.shark.xpdl.elements.FormalParameters;
import org.enhydra.shark.xpdl.elements.FormalParameter;
import org.enhydra.shark.xpdl.elements.ActualParameter;
import org.enhydra.shark.xpdl.XMLComplexChoice;
import org.enhydra.shark.xpdl.XMLComplexElement;

/**
 * @author     <a href="mailto:[e-mail]">Andy Zeneski</a>
 * @version    $Rev: 5462 $
 * @since      3.2
 */
public class ThreadedToolAgentManager implements ToolAgentManager {

    private final static String TOOL_AGENT_PREFIX = "ToolAgent.";
    private final static String DEFAULT_TOOL_AGENT = "DefaultToolAgent";
    private final static long APP_STATUS_INVALID = -1;
    private static List toolMonitors = new ArrayList();

    private String defaultToolAgentClassName = null;
    private List toolAgents = null;
    private CallbackUtilities cus = null;

    ThreadedToolAgentManager() {
        this.cus = SharkEngineManager.getInstance().getCallbackUtilities();
        createToolAgentList();
    }

    public void executeActivity(SharkTransaction t, WfActivityInternal act) throws BaseException, ToolAgentGeneralException {
        ThreadedToolAgentManager.toolMonitors.add(new ToolRunnerManager(t, act));
    }

    /**
     * Returns all tool agents registered at nameserver.
     */
    public String[] getDefinedToolAgents() {
        String[] ata = new String[toolAgents.size()];
        toolAgents.toArray(ata);
        return ata;
    }

    private void createToolAgentList() {
        this.toolAgents = new ArrayList();
        String taName = null;
        String className = null;
        Properties props = cus.getProperties();

        Iterator it = props.entrySet().iterator();
        while (it.hasNext()) {
            try {
                Map.Entry me = (Map.Entry) it.next();
                taName = me.getKey().toString();
                if (taName.startsWith(TOOL_AGENT_PREFIX)) {
                    taName = taName.substring(TOOL_AGENT_PREFIX.length());
                    className = me.getValue().toString();
                    toolAgents.add(className);
                }
            } catch (Throwable ex) {
                //ex.printStackTrace();
                cus.error("ToolAgentManager -> Creation of Tool Agent " + taName + " from clas " + className + " failed !!!");
            }
        }

        // setting default tool agent
        try {
            defaultToolAgentClassName = (String) props.get(DEFAULT_TOOL_AGENT);

        } catch (Throwable ex) {
            cus.error("ToolAgentManager -> Creation of Default Tool Agent failed !!!");
        }
    }

    public static int howManyActivitiesRunning() {
        return ThreadedToolAgentManager.toolMonitors.size();
    }

    private synchronized static void removeToolMonitor(ToolRunnerManager monitor) {
        ThreadedToolAgentManager.toolMonitors.remove(monitor);
    }

    class ToolContext {

        private Tool tool;
        private Application app;
        private ApplicationMap appMap;
        private String packageId;
        private String processId;
        private String activityId;
        private String resource;
        private AppParameter[] params;

        public ToolContext(Tool tool, Application app, ApplicationMap appMap, String pkgId,
                String procId, String actId, String resource, AppParameter[] params) {
            this.tool = tool;
            this.app = app;
            this.appMap = appMap;
            this.packageId = pkgId;
            this.processId = procId;
            this.activityId = actId;
            this.resource = resource;
            this.params = params;
        }

        public Tool getTool() {
            return tool;
        }

        public Application getApplication() {
            return app;
        }

        public ApplicationMap getApplicationMap() {
            return appMap;
        }

        public String getPackageId() {
            return packageId;
        }

        public String getProcessId() {
            return processId;
        }

        public String getActivityId() {
            return activityId;
        }

        public String getActivityResource() {
            return resource;
        }

        public AppParameter[] getParameters() {
            return params;
        }
    }

    class ToolRunnerManager implements Runnable {

        private String packageKey;
        private String packageVer;
        private String processKey;
        private String activityKey;
        private String resource;
        private List tools;
        private Map context;

        private Map toolResults;
        private List runners;
        private Thread thread;
        private boolean isRunning = false;

        public ToolRunnerManager(SharkTransaction trans, WfActivityInternal activity) throws BaseException {
            this.packageKey = activity.container(trans).package_id(trans);
            this.packageVer = activity.container(trans).manager_version(trans);
            this.processKey = activity.container(trans).key(trans);
            this.packageKey = activity.container(trans).package_id(trans);
            this.activityKey = activity.key(trans);
            this.resource = activity.getResourceUsername(trans);
            this.context = activity.process_context(trans);
            this.tools = this.getTools(trans, activity);
            this.toolResults = new HashMap();
            this.runners = new ArrayList();

            // start the thread
            thread = new Thread(this);
            thread.setDaemon(false);
            thread.setName(this.getClass().getName());
            thread.start();
        }

        private Collection getToolObjs(SharkTransaction trans, WfActivityInternal activity) throws BaseException {
            WfProcessInternal pr = activity.container(trans);
            WorkflowProcess wp = SharkUtilities.getWorkflowProcess(pr.manager(trans).package_id(trans),
                    pr.manager_version(trans), pr.manager(trans).process_definition_id(trans));

            return SharkUtilities.getActivityDefinition(trans, activity, wp,
                    activity.block_activity(trans)).getTools().toCollection();
        }

        private List getTools(SharkTransaction trans, WfActivityInternal activity) throws BaseException {
            Collection tools = getToolObjs(trans, activity);

            List toolList = null;
            if (tools != null) {
                toolList = new ArrayList();
                Iterator i = tools.iterator();
                while (i.hasNext()) {
                    Tool tool = (Tool) i.next();
                    String toolId = tool.getID();

                    Application app = (Application) ((XMLComplexChoice) tool.get("Application")).getChoosen();
                    ApplicationMap appMap = null;
                    try {
                        appMap = getApplicationMap(app, toolId);
                    } catch (Exception e) {