| /** |
| * 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.gui.model.repo; |
| |
| //OODT imports |
| import org.apache.oodt.cas.metadata.Metadata; |
| import org.apache.oodt.cas.workflow.gui.model.ModelGraph; |
| import org.apache.oodt.cas.workflow.gui.model.ModelNode; |
| import org.apache.oodt.commons.xml.XMLUtils; |
| |
| //JDK imports |
| import java.io.File; |
| import java.io.FileNotFoundException; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| import java.util.UUID; |
| import java.util.Vector; |
| import java.util.logging.Level; |
| import java.util.logging.Logger; |
| |
| import javax.xml.parsers.DocumentBuilder; |
| import javax.xml.parsers.DocumentBuilderFactory; |
| import javax.xml.parsers.ParserConfigurationException; |
| import javax.xml.xpath.XPath; |
| import javax.xml.xpath.XPathConstants; |
| import javax.xml.xpath.XPathExpression; |
| import javax.xml.xpath.XPathFactory; |
| import org.apache.commons.io.FileUtils; |
| import org.apache.commons.lang.StringUtils; |
| import org.w3c.dom.Document; |
| import org.w3c.dom.Element; |
| import org.w3c.dom.NamedNodeMap; |
| import org.w3c.dom.Node; |
| import org.w3c.dom.NodeList; |
| |
| /** |
| * |
| * Model Repository which stores models in xml files |
| * |
| * @author bfoster |
| * @author mattmann |
| * |
| */ |
| public class XmlWorkflowModelRepository { |
| |
| private File workspace; |
| private List<File> files; |
| private Set<ModelGraph> graphs; |
| private Map<String, ConfigGroup> globalConfigGroups; |
| private static final Logger LOG = Logger |
| .getLogger(XmlWorkflowModelRepository.class.getName()); |
| |
| public XmlWorkflowModelRepository(File workspace) { |
| this.files = new Vector<File>(); |
| for (File file : (this.workspace = workspace).listFiles()) |
| if (!file.isDirectory()) |
| this.files.add(file); |
| } |
| |
| public void loadGraphs(Set<String> supportedProcessorIds) throws Exception { |
| this.graphs = new HashSet<ModelGraph>(); |
| HashMap<String, ConfigGroup> globalConfGroups = new HashMap<String, ConfigGroup>(); |
| DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance(); |
| factory.setNamespaceAware(true); |
| DocumentBuilder parser = factory.newDocumentBuilder(); |
| List<FileBasedElement> rootElements = new Vector<FileBasedElement>(); |
| for (File file : files) { |
| System.out.println("Loading: " + file); |
| rootElements.add(new FileBasedElement(file, parser.parse(file) |
| .getDocumentElement())); |
| } |
| for (FileBasedElement root : rootElements) { |
| loadConfiguration(rootElements, root, null, globalConfGroups); |
| NodeList rootChildren = root.getElement().getChildNodes(); |
| for (int i = 0; i < rootChildren.getLength(); i++) |
| if (rootChildren.item(i).getNodeType() == Node.ELEMENT_NODE |
| && !rootChildren.item(i).getNodeName().equals("configuration") |
| && !rootChildren.item(i).getNodeName().equals("event")) { |
| System.out.println("node name: [" |
| + rootChildren.item(i).getNodeName() + "]"); |
| ModelGraph graph = this.loadGraph(rootElements, new FileBasedElement( |
| root.getFile(), (Element) rootChildren.item(i)), new Metadata(), |
| globalConfGroups, supportedProcessorIds); |
| this.graphs.add(graph); |
| } |
| } |
| ensureUniqueIds(graphs); |
| this.globalConfigGroups = globalConfGroups; |
| System.out.println(this.globalConfigGroups.keySet()); |
| } |
| |
| public Set<ModelGraph> getGraphs() { |
| return this.graphs; |
| } |
| |
| public Map<String, ConfigGroup> getGlobalConfigGroups() { |
| return this.globalConfigGroups; |
| } |
| |
| public void setGlobalConfigGroups(Map<String, ConfigGroup> globalConfigGroups) { |
| this.globalConfigGroups = new HashMap<String, ConfigGroup>( |
| globalConfigGroups); |
| } |
| |
| public List<File> getFiles() { |
| return this.files; |
| } |
| |
| public void save() throws Exception { |
| this.backupCurrentFiles(); |
| this.saveGraphs(); |
| } |
| |
| private void backupCurrentFiles() throws Exception { |
| File backupDir = new File(this.workspace, ".backup"); |
| for (File file : this.files) { |
| FileUtils.copyFile(file, new File(backupDir, file.getName())); |
| file.delete(); |
| } |
| this.files.clear(); |
| } |
| |
| private void saveGraphs() throws FileNotFoundException, |
| ParserConfigurationException { |
| Map<File, Document> documents = new HashMap<File, Document>(); |
| for (ModelGraph graph : this.graphs) { |
| Document document = documents.get(graph.getModel().getFile()); |
| if (document == null) { |
| document = createDocument(); |
| document.appendChild(document.createElement("workflows")); |
| documents.put(graph.getModel().getFile(), document); |
| } |
| saveGraph(graph, document.getDocumentElement(), document); |
| } |
| saveGlobalConfigGroups(documents); |
| writeOutDocuments(documents); |
| this.files = new ArrayList<File>(documents.keySet()); |
| } |
| |
| private void writeOutDocuments(Map<File, Document> documents) { |
| for (File file : documents.keySet()) { |
| XMLUtils.writeXmlFile(documents.get(file), file.getAbsolutePath()); |
| } |
| } |
| |
| private void saveGlobalConfigGroups(Map<File, Document> documents) |
| throws ParserConfigurationException { |
| File globalConfigGroupsFile = new File(workspace, |
| "shared-configuration.xml"); |
| Document document = documents.get(globalConfigGroupsFile); |
| if (document == null) { |
| document = createDocument(); |
| document.appendChild(document.createElement("workflows")); |
| documents.put(globalConfigGroupsFile, document); |
| } |
| for (String configName : this.globalConfigGroups.keySet()) { |
| ConfigGroup globalConfig = this.globalConfigGroups.get(configName); |
| Element configElem = document.createElement("configuration"); |
| document.getDocumentElement().appendChild(configElem); |
| configElem.setAttribute("name", globalConfig.getName()); |
| if (!globalConfig.getExtends().isEmpty()) { |
| configElem.setAttribute("extends", |
| StringUtils.join(globalConfig.getExtends(), ", ")); |
| } |
| |
| String[] properties = globalConfig.getMetadata().getAllKeys() |
| .toArray(new String[globalConfig.getMetadata().getAllKeys().size()]); |
| Arrays.sort(properties); |
| for (String property : properties) { |
| Element propElem = document.createElement("property"); |
| configElem.appendChild(propElem); |
| propElem.setAttribute("name", property); |
| propElem.setAttribute("value", |
| globalConfig.getMetadata().getMetadata(property)); |
| } |
| } |
| } |
| |
| private void saveGraph(ModelGraph graph, Element parentElem, Document document) |
| throws FileNotFoundException, ParserConfigurationException { |
| ModelNode node = graph.getModel(); |
| |
| Element workflowElem = document.createElement(node.getExecutionType()); |
| parentElem.appendChild(workflowElem); |
| |
| if (node.isRef()) { |
| workflowElem.setAttribute("id-ref", node.getModelId()); |
| if (node.getAlias() != null) { |
| workflowElem.setAttribute("alias", node.getAlias()); |
| } |
| saveConfiguration(node, workflowElem, document); |
| } else { |
| workflowElem.setAttribute("id", node.getModelId()); |
| workflowElem.setAttribute("name", node.getModelName()); |
| if (node.getInstanceClass() != null) { |
| workflowElem.setAttribute("class", node.getInstanceClass()); |
| } |
| |
| saveConfiguration(node, workflowElem, document); |
| |
| // handle preconditions |
| if (graph.getPreConditions() != null) { |
| Element preConditions = document.createElement("conditions"); |
| workflowElem.appendChild(preConditions); |
| preConditions.setAttribute("type", "pre"); |
| preConditions.setAttribute("execution", graph.getPreConditions() |
| .getModel().getExecutionType()); |
| preConditions.setAttribute("timeout", String.valueOf(graph.getModel().getTimeout())); |
| preConditions.setAttribute("optional", String.valueOf(graph.getModel().isOptional())); |
| for (ModelGraph preCondition : graph.getPreConditions().getChildren()) { |
| saveGraph(preCondition, preConditions, document); |
| } |
| } |
| |
| // handle subprocessors |
| for (ModelGraph subProcessor : graph.getChildren()) { |
| saveGraph(subProcessor, workflowElem, document); |
| } |
| |
| // handle postconditions |
| if (graph.getPostConditions() != null) { |
| Element postConditions = document.createElement("conditions"); |
| workflowElem.appendChild(postConditions); |
| postConditions.setAttribute("type", "post"); |
| postConditions.setAttribute("execution", graph.getPostConditions() |
| .getModel().getExecutionType()); |
| postConditions.setAttribute("timeout", String.valueOf(graph.getModel().getTimeout())); |
| postConditions.setAttribute("optional", String.valueOf(graph.getModel().isOptional())); |
| for (ModelGraph postCondition : graph.getPostConditions().getChildren()) { |
| saveGraph(postCondition, postConditions, document); |
| } |
| } |
| } |
| if (!node.getExcusedSubProcessorIds().isEmpty()) { |
| workflowElem.setAttribute("excused", |
| StringUtils.join(node.getExcusedSubProcessorIds(), ",")); |
| } |
| if (node.isEntryPoint()) { |
| workflowElem.setAttribute("entryPoint", "true"); |
| } |
| } |
| |
| private void saveConfiguration(ModelNode node, Element workflowElem, |
| Document document) { |
| if (!node.getStaticMetadata().getAllKeys().isEmpty()) { |
| Element configElem = document.createElement("configuration"); |
| workflowElem.appendChild(configElem); |
| if (!node.getExtendsConfig().isEmpty()) { |
| configElem.setAttribute("extends", |
| StringUtils.join(node.getExtendsConfig(), ", ")); |
| } |
| String[] properties = node.getStaticMetadata().getAllKeys() |
| .toArray(new String[node.getStaticMetadata().getAllKeys().size()]); |
| Arrays.sort(properties); |
| for (String property : properties) { |
| Element propElem = document.createElement("property"); |
| configElem.appendChild(propElem); |
| propElem.setAttribute("name", property); |
| propElem.setAttribute("value", |
| node.getStaticMetadata().getMetadata(property)); |
| } |
| } |
| } |
| |
| private Document createDocument() throws ParserConfigurationException { |
| DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance(); |
| factory.setNamespaceAware(true); |
| return factory.newDocumentBuilder().newDocument(); |
| } |
| |
| private void ensureUniqueIds(Set<ModelGraph> graphs) { |
| for (ModelGraph graph : graphs) { |
| HashSet<String> names = new HashSet<String>(); |
| Vector<ModelGraph> stack = new Vector<ModelGraph>(); |
| stack.add(graph); |
| while (!stack.isEmpty()) { |
| ModelGraph currentGraph = stack.remove(0); |
| String currentId = currentGraph.getId(); |
| for (int i = 1; names.contains(currentId); i++) |
| currentId = currentGraph.getId() + "-" + i; |
| names.add(currentId); |
| if (!currentId.equals(currentGraph.getId())) |
| currentGraph.getModel().setModelId(currentId); |
| stack.addAll(currentGraph.getChildren()); |
| } |
| } |
| } |
| |
| private ModelGraph loadGraph(List<FileBasedElement> rootElements, |
| FileBasedElement workflowNode, Metadata staticMetadata, |
| HashMap<String, ConfigGroup> globalConfGroups, |
| Set<String> supportedProcessorIds) throws Exception { |
| |
| String modelIdRef = null; |
| String modelId = null; |
| String modelName = null; |
| String alias = null; |
| String executionType = null; |
| List<String> excused = new Vector<String>(); |
| String clazz = null; |
| long timeout = -1; |
| boolean optional = false; |
| boolean entryPoint = false; |
| |
| NamedNodeMap attributes = workflowNode.getElement().getAttributes(); |
| for (int i = 0; attributes != null && i < attributes.getLength(); i++) { |
| Node node = workflowNode.getElement().getAttributes().item(i); |
| if (node.getNodeName().equals("id")) { |
| modelId = node.getNodeValue(); |
| } else if (node.getNodeName().equals("name")) { |
| modelName = node.getNodeValue(); |
| } else if (node.getNodeName().equals("class")) { |
| clazz = node.getNodeValue(); |
| } else if (node.getNodeName().equals("id-ref")) { |
| modelIdRef = node.getNodeValue(); |
| } else if (node.getNodeName().equals("excused")) { |
| excused.addAll(Arrays.asList(node.getNodeValue().split(","))); |
| } else if (node.getNodeName().equals("entryPoint")) { |
| entryPoint = Boolean.parseBoolean(node.getNodeValue()); |
| } else if (node.getNodeName().equals("alias")) { |
| alias = node.getNodeValue(); |
| } else if (node.getNodeName().equals("execution")) { |
| executionType = node.getNodeValue(); |
| } else if (node.getNodeName().equals("timeout")) { |
| timeout = node.getNodeValue() != null |
| && !node.getNodeValue().equals("") ? Long.valueOf(node |
| .getNodeValue()) : -1; |
| } |
| else if(node.getNodeName().equals("optional")){ |
| optional = Boolean.valueOf(node.getNodeValue()); |
| } |
| else if (node.getNodeName().startsWith("p:")) { |
| staticMetadata.replaceMetadata(node.getNodeName().substring(2), |
| node.getNodeValue()); |
| } |
| } |
| |
| if (modelId == null && modelIdRef == null) |
| modelId = UUID.randomUUID().toString(); |
| |
| ModelGraph graph = null; |
| if (modelId != null) { |
| |
| if (workflowNode.getElement().getNodeName().equals("workflow") |
| || workflowNode.getElement().getNodeName().equals("conditions") |
| || workflowNode.getElement().getNodeName().equals("tasks")) { |
| if (executionType == null) { |
| LOG.log(Level.WARNING, "workflow model '" |
| + workflowNode.getElement().getNodeName() |
| + "' missing execution type: assuming sequential"); |
| executionType = "sequential"; |
| } |
| } else { |
| executionType = workflowNode.getElement().getNodeName(); |
| } |
| |
| if (!supportedProcessorIds.contains(executionType)) |
| LOG.log(Level.WARNING, "Unsupported execution type id '" |
| + executionType + "'"); |
| |
| ModelNode modelNode = new ModelNode(workflowNode.getFile()); |
| modelNode.setModelId(modelId); |
| modelNode.setModelName(modelName); |
| modelNode.setExecutionType(executionType); |
| modelNode.setStaticMetadata(staticMetadata); |
| modelNode.setExcusedSubProcessorIds(excused); |
| modelNode.setInstanceClass(clazz); |
| modelNode.setEntryPoint(entryPoint); |
| modelNode.setTimeout(timeout); |
| modelNode.setOptional(optional); |
| |
| loadConfiguration(rootElements, workflowNode, modelNode, globalConfGroups); |
| |
| graph = new ModelGraph(modelNode); |
| |
| boolean loadedPreConditions = false; |
| NodeList children = workflowNode.getElement().getChildNodes(); |
| for (int i = 0; i < children.getLength(); i++) { |
| Node curChild = children.item(i); |
| if (curChild.getNodeType() == Node.ELEMENT_NODE) { |
| if (curChild.getNodeName().equals("conditions")) { |
| boolean isPreCondition = !loadedPreConditions; |
| String type = ((Element) curChild).getAttribute("type"); |
| if (type.length() > 0) |
| isPreCondition = type.toLowerCase().equals("pre"); |
| if (isPreCondition) |
| graph.setPreConditions(this.loadGraph(rootElements, |
| new FileBasedElement(workflowNode.getFile(), |
| (Element) curChild), new Metadata(staticMetadata), |
| globalConfGroups, supportedProcessorIds)); |
| else |
| graph.setPostConditions(this.loadGraph(rootElements, |
| new FileBasedElement(workflowNode.getFile(), |
| (Element) curChild), new Metadata(staticMetadata), |
| globalConfGroups, supportedProcessorIds)); |
| loadedPreConditions = true; |
| } else if (!curChild.getNodeName().equals("configuration") |
| && !curChild.getNodeName().equals("requiredMetFields")) { |
| graph.addChild(this.loadGraph(rootElements, new FileBasedElement( |
| workflowNode.getFile(), (Element) curChild), new Metadata( |
| staticMetadata), globalConfGroups, supportedProcessorIds)); |
| |
| } |
| } |
| } |
| |
| } else if (modelIdRef != null) { |
| graph = this.findGraph(rootElements, modelIdRef, new Metadata( |
| staticMetadata), globalConfGroups, supportedProcessorIds); |
| if (graph == null) |
| throw new Exception("Workflow '" + modelIdRef |
| + "' has not been defined in this context"); |
| graph.setIsRef(true); |
| graph.getModel().setStaticMetadata(new Metadata()); |
| loadConfiguration(rootElements, workflowNode, graph.getModel(), |
| globalConfGroups); |
| graph.getModel().setAlias(alias); |
| } |
| |
| if (entryPoint && graph.getParent() != null) { |
| this.graphs.add(graph); |
| } |
| |
| return graph; |
| } |
| |
| protected ModelGraph findGraph(List<FileBasedElement> rootElements, |
| String modelIdRef, Metadata staticMetadata, |
| HashMap<String, ConfigGroup> globalConfGroups, |
| Set<String> supportedProcessorIds) throws Exception { |
| XPath xpath = XPathFactory.newInstance().newXPath(); |
| XPathExpression expr = xpath.compile("//*[@id = '" + modelIdRef + "']"); |
| for (FileBasedElement rootElement : rootElements) { |
| Node node = (Node) expr.evaluate(rootElement.getElement(), |
| XPathConstants.NODE); |
| if (node != null) { |
| return this.loadGraph(rootElements, |
| new FileBasedElement(rootElement.getFile(), (Element) node), |
| staticMetadata, globalConfGroups, supportedProcessorIds); |
| } |
| } |
| return null; |
| } |
| |
| private void loadConfiguration(List<FileBasedElement> rootElements, |
| FileBasedElement workflowNode, ModelNode modelNode, |
| HashMap<String, ConfigGroup> globalConfGroups) throws Exception { |
| NodeList children = workflowNode.getElement().getChildNodes(); |
| for (int i = 0; i < children.getLength(); i++) { |
| Node curChild = children.item(i); |
| if (curChild.getNodeName().equals("configuration")) { |
| Metadata curMetadata = new Metadata(); |
| if (modelNode != null |
| && !((Element) curChild).getAttribute("extends").equals("")) |
| modelNode.setExtendsConfig(Arrays.asList(((Element) curChild) |
| .getAttribute("extends").split(","))); |
| curMetadata.replaceMetadata(this.loadConfiguration(rootElements, |
| curChild, globalConfGroups)); |
| if (!((Element) curChild).getAttribute("name").equals("")) { |
| ConfigGroup configGroup = new ConfigGroup( |
| ((Element) curChild).getAttribute("name"), curMetadata); |
| if (modelNode != null) { |
| List<String> extendsConfig = new Vector<String>( |
| modelNode.getExtendsConfig()); |
| configGroup.addAllExtends(extendsConfig); |
| extendsConfig.add(configGroup.getName()); |
| modelNode.setExtendsConfig(extendsConfig); |
| } |
| globalConfGroups.put(((Element) curChild).getAttribute("name"), |
| configGroup); |
| } else if (modelNode != null) { |
| modelNode.setStaticMetadata(curMetadata); |
| } |
| } |
| } |
| } |
| |
| private Metadata loadConfiguration(List<FileBasedElement> rootElements, |
| Node configNode, HashMap<String, ConfigGroup> globalConfGroups) |
| 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)) |
| curMetadata.replaceMetadata(name + "/envReplace", "true"); |
| 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 class FileBasedElement { |
| |
| private File file; |
| private Element element; |
| |
| public FileBasedElement(File file, Element element) { |
| this.file = file; |
| this.element = element; |
| } |
| |
| public File getFile() { |
| return this.file; |
| } |
| |
| public Element getElement() { |
| return this.element; |
| } |
| |
| } |
| |
| public class ConfigGroup { |
| |
| private String name; |
| private Metadata metadata; |
| private List<String> extendsConfig; |
| |
| public ConfigGroup(String name, Metadata metadata) { |
| this.name = name; |
| this.metadata = metadata; |
| this.extendsConfig = new Vector<String>(); |
| } |
| |
| public String getName() { |
| return this.name; |
| } |
| |
| public Metadata getMetadata() { |
| return this.metadata; |
| } |
| |
| public void addExtends(String child) { |
| this.extendsConfig.add(child); |
| } |
| |
| public void addAllExtends(List<String> children) { |
| this.extendsConfig.addAll(children); |
| } |
| |
| public void removeExtends(String child) { |
| this.extendsConfig.remove(child); |
| } |
| |
| public List<String> getExtends() { |
| return this.extendsConfig; |
| } |
| |
| public int hashCode() { |
| return this.name.hashCode(); |
| } |
| |
| public boolean equals(Object obj) { |
| if (obj instanceof ConfigGroup) { |
| ConfigGroup comp = (ConfigGroup) obj; |
| return comp.name.equals(this.name); |
| } else |
| return false; |
| } |
| |
| public String toString() { |
| return this.name; |
| } |
| |
| } |
| |
| } |
