workflowdescriptor.java

osworkflow修改版本

        ValidationHelper.validate(this.getTriggerFunctions().values());
        ValidationHelper.validate(this.getGlobalActions());
        ValidationHelper.validate(this.getInitialActions());
        ValidationHelper.validate(this.getCommonActions().values());
        ValidationHelper.validate(this.getSteps());
        ValidationHelper.validate(this.getSplits());
        ValidationHelper.validate(this.getJoins());

        Set actions = new HashSet();
        Iterator i = globalActions.iterator();

        while (i.hasNext()) {
            ActionDescriptor action = (ActionDescriptor) i.next();
            actions.add(new Integer(action.getId()));
        }

        i = getSteps().iterator();

        while (i.hasNext()) {
            StepDescriptor step = (StepDescriptor) i.next();
            Iterator j = step.getActions().iterator();

            while (j.hasNext()) {
                ActionDescriptor action = (ActionDescriptor) j.next();

                // check to see if it's a common action (dups are ok)
                if (!this.getCommonActions().containsKey(new Integer(action.getId()))) {
                    if (!actions.add(new Integer(action.getId()))) {
                        throw new InvalidWorkflowDescriptorException("Duplicate occurance of action ID " + action.getId() + " found in step " + step.getId());
                    }
                }
            }
        }

        validateDTD();
    }

    public void writeXML(PrintWriter out, int indent) {
        XMLUtil.printIndent(out, indent++);
        out.println("<workflow>");

        Iterator iter = metaAttributes.entrySet().iterator();

        while (iter.hasNext()) {
            Map.Entry entry = (Map.Entry) iter.next();
            XMLUtil.printIndent(out, indent);
            out.print("<meta name=\"");
            out.print(entry.getKey());
            out.print("\">");
            out.print(entry.getValue());
            out.println("</meta>");
        }

        if (registers.size() > 0) {
            XMLUtil.printIndent(out, indent++);
            out.println("<registers>");

            for (int i = 0; i < registers.size(); i++) {
                RegisterDescriptor register = (RegisterDescriptor) registers.get(i);
                register.writeXML(out, indent);
            }

            XMLUtil.printIndent(out, --indent);
            out.println("</registers>");
        }

        XMLUtil.printIndent(out, indent++);
        out.println("<initial-actions>");

        for (int i = 0; i < initialActions.size(); i++) {
            ActionDescriptor action = (ActionDescriptor) initialActions.get(i);
            action.writeXML(out, indent);
        }

        XMLUtil.printIndent(out, --indent);
        out.println("</initial-actions>");

        if (globalActions.size() > 0) {
            XMLUtil.printIndent(out, indent++);
            out.println("<global-actions>");

            for (int i = 0; i < globalActions.size(); i++) {
                ActionDescriptor action = (ActionDescriptor) globalActions.get(i);
                action.writeXML(out, indent);
            }

            XMLUtil.printIndent(out, --indent);
            out.println("</global-actions>");
        }

        if (commonActions.size() > 0) {
            XMLUtil.printIndent(out, indent++);
            out.println("<common-actions>");

            Iterator commonActionsItr = getCommonActions().values().iterator();

            while (commonActionsItr.hasNext()) {
                ActionDescriptor action = (ActionDescriptor) commonActionsItr.next();
                action.writeXML(out, indent);
            }

            XMLUtil.printIndent(out, --indent);
            out.println("</common-actions>");
        }

        XMLUtil.printIndent(out, indent++);
        out.println("<steps>");

        for (int i = 0; i < steps.size(); i++) {
            StepDescriptor step = (StepDescriptor) steps.get(i);
            step.writeXML(out, indent);
        }

        XMLUtil.printIndent(out, --indent);
        out.println("</steps>");

        if (splits.size() > 0) {
            XMLUtil.printIndent(out, indent++);
            out.println("<splits>");

            for (int i = 0; i < splits.size(); i++) {
                SplitDescriptor split = (SplitDescriptor) splits.get(i);
                split.writeXML(out, indent);
            }

            XMLUtil.printIndent(out, --indent);
            out.println("</splits>");
        }

        if (joins.size() > 0) {
            XMLUtil.printIndent(out, indent++);
            out.println("<joins>");

            for (int i = 0; i < joins.size(); i++) {
                JoinDescriptor join = (JoinDescriptor) joins.get(i);
                join.writeXML(out, indent);
            }

            XMLUtil.printIndent(out, --indent);
            out.println("</joins>");
        }

        XMLUtil.printIndent(out, --indent);
        out.println("</workflow>");
    }

    protected void init(Element root) {
        NodeList children = root.getChildNodes();

        for (int i = 0; i < children.getLength(); i++) {
            Node child = (Node) children.item(i);

            if (child.getNodeName().equals("meta")) {
                Element meta = (Element) child;
                String value = XMLUtil.getText(meta);
                this.metaAttributes.put(meta.getAttribute("name"), value);
            }
        }

        // handle registers - OPTIONAL
        Element r = XMLUtil.getChildElement(root, "registers");

        if (r != null) {
            List registers = XMLUtil.getChildElements(r, "register");

            for (int i = 0; i < registers.size(); i++) {
                Element register = (Element) registers.get(i);
                RegisterDescriptor registerDescriptor = new RegisterDescriptor(register);
                registerDescriptor.setParent(this);
                this.registers.add(registerDescriptor);
            }
        }

        // handle initial-steps - REQUIRED
        Element intialActionsElement = XMLUtil.getChildElement(root, "initial-actions");
        List initialActions = XMLUtil.getChildElements(intialActionsElement, "action");

        for (int i = 0; i < initialActions.size(); i++) {
            Element initialAction = (Element) initialActions.get(i);
            ActionDescriptor actionDescriptor = new ActionDescriptor(initialAction);
            actionDescriptor.setParent(this);
            this.initialActions.add(actionDescriptor);
        }

        // handle global-actions - OPTIONAL
        Element globalActionsElement = XMLUtil.getChildElement(root, "global-actions");

        if (globalActionsElement != null) {
            List globalActions = XMLUtil.getChildElements(globalActionsElement, "action");

            for (int i = 0; i < globalActions.size(); i++) {
                Element globalAction = (Element) globalActions.get(i);
                ActionDescriptor actionDescriptor = new ActionDescriptor(globalAction);
                actionDescriptor.setParent(this);
                this.globalActions.add(actionDescriptor);
            }
        }

        // handle common-actions - OPTIONAL
        //   - Store actions in HashMap for now. When parsing Steps, we'll resolve
        //      any common actions into local references.
        Element commonActionsElement = XMLUtil.getChildElement(root, "common-actions");

        if (commonActionsElement != null) {
            List commonActions = XMLUtil.getChildElements(commonActionsElement, "action");

            for (int i = 0; i < commonActions.size(); i++) {
                Element commonAction = (Element) commonActions.get(i);
                ActionDescriptor actionDescriptor = new ActionDescriptor(commonAction);
                actionDescriptor.setParent(this);
                addCommonAction(actionDescriptor);
            }
        }

        // handle timer-functions - OPTIONAL
        Element timerFunctionsElement = XMLUtil.getChildElement(root, "trigger-functions");

        if (timerFunctionsElement != null) {
            List timerFunctions = XMLUtil.getChildElements(timerFunctionsElement, "trigger-function");

            for (int i = 0; i < timerFunctions.size(); i++) {
                Element timerFunction = (Element) timerFunctions.get(i);
                Integer id = new Integer(timerFunction.getAttribute("id"));
                FunctionDescriptor function = new FunctionDescriptor(XMLUtil.getChildElement(timerFunction, "function"));
                function.setParent(this);
                this.timerFunctions.put(id, function);
            }
        }

        // handle steps - REQUIRED
        Element stepsElement = XMLUtil.getChildElement(root, "steps");
        List steps = XMLUtil.getChildElements(stepsElement, "step");

        for (int i = 0; i < steps.size(); i++) {
            Element step = (Element) steps.get(i);
            StepDescriptor stepDescriptor = new StepDescriptor(step, this);
            this.steps.add(stepDescriptor);
        }

        // handle splits - OPTIONAL
        Element splitsElement = XMLUtil.getChildElement(root, "splits");

        if (splitsElement != null) {
            List split = XMLUtil.getChildElements(splitsElement, "split");

            for (int i = 0; i < split.size(); i++) {
                Element s = (Element) split.get(i);
                SplitDescriptor splitDescriptor = new SplitDescriptor(s);
                splitDescriptor.setParent(this);
                this.splits.add(splitDescriptor);
            }
        }

        // handle joins - OPTIONAL:
        Element joinsElement = XMLUtil.getChildElement(root, "joins");

        if (joinsElement != null) {
            List join = XMLUtil.getChildElements(joinsElement, "join");

            for (int i = 0; i < join.size(); i++) {
                Element s = (Element) join.get(i);
                JoinDescriptor joinDescriptor = new JoinDescriptor(s);
                joinDescriptor.setParent(this);
                this.joins.add(joinDescriptor);
            }
        }
    }

    // refactored this out from the three addAction methods above
    private void addAction(Object actionsCollectionOrMap, ActionDescriptor descriptor) {
        if (getAction(descriptor.getId()) != null) {
            throw new IllegalArgumentException("action with id " + descriptor.getId() + " already exists for this step.");
        }

        if (actionsCollectionOrMap instanceof Map) {
            ((Map) actionsCollectionOrMap).put(new Integer(descriptor.getId()), descriptor);
        } else {
            ((Collection) actionsCollectionOrMap).add(descriptor);
        }
    }

    private void validateDTD() throws InvalidWorkflowDescriptorException {
        DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
        dbf.setNamespaceAware(true);
        dbf.setValidating(true);

        StringWriter sw = new StringWriter();
        PrintWriter writer = new PrintWriter(sw);
        writer.println(XML_HEADER);
        writer.println(DOCTYPE_DECL);
        writeXML(writer, 0);

        try {
            DocumentBuilder db = dbf.newDocumentBuilder();
            db.setEntityResolver(new DTDEntityResolver());

            WorkflowLoader.AllExceptionsErrorHandler errorHandler = new WorkflowLoader.AllExceptionsErrorHandler();
            db.setErrorHandler(errorHandler);
            db.parse(new InputSource(new StringReader(sw.toString())));

            if (errorHandler.getExceptions().size() > 0) {
                throw new InvalidWorkflowDescriptorException(errorHandler.getExceptions().toString());
            }
        } catch (InvalidWorkflowDescriptorException e) {
            throw e;
        } catch (Exception e) {
            throw new InvalidWorkflowDescriptorException(e.toString());
        }
    }
}