/**
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.oodt.cas.workflow.util;
//JDK imports
import java.util.Arrays;
import java.util.List;
import java.util.Properties;
import java.util.Vector;
import java.util.HashMap;
import java.util.logging.Logger;
import org.w3c.dom.Node;
import org.w3c.dom.Text;
import org.w3c.dom.NodeList;
import org.w3c.dom.Element;
//OODT imports
import org.apache.oodt.cas.metadata.Metadata;
import org.apache.oodt.cas.metadata.util.PathUtils;
import org.apache.oodt.cas.workflow.structs.Workflow;
import org.apache.oodt.cas.workflow.structs.WorkflowConditionConfiguration;
import org.apache.oodt.cas.workflow.structs.WorkflowTask;
import org.apache.oodt.cas.workflow.structs.WorkflowTaskConfiguration;
import org.apache.oodt.cas.workflow.structs.WorkflowCondition;
/**
* * A class for constructing Workflow Manager objects from XML {@link Node}s
* and {@link Element}s.
*
* @author mattmann
* @version $Revsion$
*
*/
public final class XmlStructFactory {
/* our log stream */
public static Logger LOG = Logger.getLogger(XmlStructFactory.class.getName());
private XmlStructFactory() throws InstantiationException {
throw new InstantiationException("Don't instantiate XML Struct Factories!");
}
/**
* <p>
* Creates {@link Workflow}s from the XML Node and the map of existing
* {@link WorkflowTask}s.
* </p>
*
* @param node
* The XML node to construct the Workflow from.
* @param tasks
* The {@link HashMap} of existing {@link WorkflowTask}s.
*
* @param conditions
* The {@link HashMap} of existing {@link WorkflowCondition}s.
*
* @return A new {@link Workflow} created from the XML node.
*/
public static Workflow getWorkflow(Node node, HashMap tasks,
HashMap conditions) {
Element workflowRoot = (Element) node;
String id = workflowRoot.getAttribute("id");
String name = workflowRoot.getAttribute("name");
Workflow workflow = new Workflow();
workflow.setName(name);
workflow.setId(id);
Element taskElem = getFirstElement("tasks", workflowRoot);
Element conditionsElem = getFirstElement("conditions", workflowRoot);
if (taskElem != null)
workflow.setTasks(getTasks(taskElem, tasks));
if (conditionsElem != null)
workflow.setConditions(getConditions(conditionsElem, conditions));
return workflow;
}
/**
* <p>
* Constructs a new {@link WorkflowTask} from the given XML node and
* {@link HashMap} of {@link WorkflowCondition}s.
* </p>
*
* @param node
* The XML node to construct the {@link WorkflowTask} from.
* @param conditions
* The {@link HashMap} of {@link WorkflowCondition}s to use when
* constructing the WorkflowTask.
* @return A new {@link WorkflowTask} created from the given XML node.
*/
public static WorkflowTask getWorkflowTask(Node node, HashMap conditions) {
Element taskNode = (Element) node;
String taskClassName = taskNode.getAttribute("class");
WorkflowTask task = new WorkflowTask();
task.setTaskInstanceClassName(taskClassName);
task.setTaskId(taskNode.getAttribute("id"));
task.setTaskName(taskNode.getAttribute("name"));
// get the list of condition IDs for this task and then get the
// conditions for them
task.setConditions(getConditions(taskNode, conditions));
Element reqMetFieldsElem = getFirstElement("requiredMetFields", taskNode);
if (reqMetFieldsElem != null) {
task.setRequiredMetFields(getRequiredMetFields(reqMetFieldsElem));
}
// load its configuration
Element configElement = getFirstElement("configuration", taskNode);
if (configElement != null) {
task.setTaskConfig(new WorkflowTaskConfiguration(
getConfiguration(configElement)));
}
return task;
}
/**
* <p>
* Constructs a new {@link WorkflowCondition} from the given XML Node.
* </p>
*
* @param node
* The XML node to construct the WorkflowCondition from.
* @return A new {@link WorkflowCondition} from the given XML node.
*/
public static WorkflowCondition getWorkflowCondition(Node node) {
Element conditionElement = (Element) node;
String conditionClassName = conditionElement.getAttribute("class");
WorkflowCondition condition = new WorkflowCondition();
condition.setConditionInstanceClassName(conditionClassName);
condition.setConditionId(conditionElement.getAttribute("id"));
condition.setConditionName(conditionElement.getAttribute("name"));
condition
.setTimeoutSeconds(Long.valueOf(conditionElement
.getAttribute("timeout") != null
&& !conditionElement.getAttribute("timeout").equals("") ? conditionElement
.getAttribute("timeout") : "-1"));
condition.setOptional(Boolean.valueOf(conditionElement
.getAttribute("optional")));
// load its configuration
Element configElement = getFirstElement("configuration", conditionElement);
if (configElement != null) {
condition.setCondConfig(new WorkflowConditionConfiguration(
getConfiguration(configElement)));
}
return condition;
}
/**
*
* @param node
* @return
*/
public static List getRequiredMetFields(Node node) {
Element reqMetFieldsElem = (Element) node;
NodeList reqMetFieldNodes = reqMetFieldsElem
.getElementsByTagName("metfield");
List reqFields = null;
if (reqMetFieldNodes != null && reqMetFieldNodes.getLength() > 0) {
reqFields = new Vector(reqMetFieldNodes.getLength());
for (int i = 0; i < reqMetFieldNodes.getLength(); i++) {
Element reqMetFieldElem = (Element) reqMetFieldNodes.item(i);
String reqFieldName = reqMetFieldElem.getAttribute("name");
reqFields.add(reqFieldName);
}
}
return reqFields;
}
/**
* <p>
* Constructs a new {@link WorkflowTaskConfiguration} from the given XML node.
* </p>
*
* @param node
* The XML node to construct the WorkflowTaskConfiguration from.
* @return A new {@link WorkflowTaskConfiguration} constructed from the given
* XML node.
*/
public static Properties getConfiguration(Node node) {
Element configNode = (Element) node;
NodeList configProperties = configNode.getElementsByTagName("property");
if (configProperties == null) {
return null;
}
Properties properties = new Properties();
for (int i = 0; i < configProperties.getLength(); i++) {
Element propElem = (Element) configProperties.item(i);
String value = propElem.getAttribute("value");
boolean doReplace = Boolean.valueOf(propElem.getAttribute("envReplace"))
.booleanValue();
if (doReplace) {
value = PathUtils.replaceEnvVariables(value);
}
properties.put(propElem.getAttribute("name"), value);
}
return properties;
}
public static Metadata getConfigurationAsMetadata(Node configNode)
throws Exception {
Metadata curMetadata = new Metadata();
NodeList curGrandChildren = configNode.getChildNodes();
for (int k = 0; k < curGrandChildren.getLength(); k++) {
if (curGrandChildren.item(k).getNodeName().equals("property")) {
Element property = (Element) curGrandChildren.item(k);
String delim = property.getAttribute("delim");
String envReplace = property.getAttribute("envReplace");
String name = property.getAttribute("name");
String value = property.getAttribute("value");
if (Boolean.parseBoolean(envReplace))
value = PathUtils.doDynamicReplacement(value);
List<String> values = new Vector<String>();
if (delim.length() > 0)
values.addAll(Arrays.asList(value.split("\\" + delim)));
else
values.add(value);
curMetadata.replaceMetadata(name, values);
}
}
return curMetadata;
}
private static List<WorkflowTask> getTasks(Element rootNode, HashMap tasks) {
NodeList taskList = rootNode.getElementsByTagName("task");
List<WorkflowTask> workflowTasks = null;
if (taskList != null && taskList.getLength() > 0) {
workflowTasks = new Vector<WorkflowTask>(taskList.getLength());
for (int i = 0; i < taskList.getLength(); i++) {
Element taskElement = (Element) taskList.item(i);
WorkflowTask t = (WorkflowTask) tasks.get(taskElement
.getAttribute("id"));
if (t != null) {
WorkflowTask workflowTask = new WorkflowTask();
workflowTask.setTaskInstanceClassName(t.getTaskInstanceClassName());
workflowTask.setConditions(t.getConditions());
workflowTask.setTaskId(t.getTaskId());
workflowTask.setTaskConfig(t.getTaskConfig());
workflowTask.setTaskName(t.getTaskName());
workflowTask.setOrder(i + 1);
workflowTask.setRequiredMetFields(t.getRequiredMetFields());
workflowTasks.add(workflowTask);
}
}
}
return workflowTasks;
}
private static List<WorkflowCondition> getConditions(Element rootNode,
HashMap conditions) {
List<WorkflowCondition> conditionList = new Vector<WorkflowCondition>();
NodeList conditionNodes = rootNode.getElementsByTagName("condition");
if (conditionNodes != null && conditionNodes.getLength() > 0) {
conditionList = new Vector<WorkflowCondition>(conditionNodes.getLength());
for (int i = 0; i < conditionNodes.getLength(); i++) {
Element conditionNode = (Element) conditionNodes.item(i);
WorkflowCondition condition = (WorkflowCondition) conditions
.get(conditionNode.getAttribute("id"));
if (condition != null) {
WorkflowCondition workflowCondition = new WorkflowCondition();
workflowCondition.setConditionInstanceClassName(condition
.getConditionInstanceClassName());
workflowCondition.setConditionId(condition.getConditionId());
workflowCondition.setConditionName(condition.getConditionName());
workflowCondition.setOrder(i + 1);
workflowCondition.setTimeoutSeconds(condition.getTimeoutSeconds());
workflowCondition.setOptional(condition.isOptional());
workflowCondition.setCondConfig(condition.getCondConfig());
conditionList.add(workflowCondition);
}
}
}
return conditionList;
}
private static Element getFirstElement(String name, Element root) {
NodeList list = root.getElementsByTagName(name);
if (list != null) {
return (Element) list.item(0);
} else
return null;
}
private static String getSimpleElementText(Element node) {
if (node.getChildNodes().item(0) instanceof Text) {
return node.getChildNodes().item(0).getNodeValue();
} else
return null;
}
private static String getElementText(String elemName, Element root) {
Element elem = getFirstElement(elemName, root);
return getSimpleElementText(elem);
}
}