| /* |
| * 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.taverna.platform.execution.impl.local; |
| |
| import java.net.URI; |
| import java.util.ArrayList; |
| import java.util.HashMap; |
| import java.util.IdentityHashMap; |
| import java.util.List; |
| import java.util.Map; |
| |
| import org.apache.taverna.reference.ExternalReferenceSPI; |
| import org.apache.taverna.workflowmodel.Dataflow; |
| import org.apache.taverna.workflowmodel.DataflowInputPort; |
| import org.apache.taverna.workflowmodel.DataflowOutputPort; |
| import org.apache.taverna.workflowmodel.Datalink; |
| import org.apache.taverna.workflowmodel.EditException; |
| import org.apache.taverna.workflowmodel.Edits; |
| import org.apache.taverna.workflowmodel.EventForwardingOutputPort; |
| import org.apache.taverna.workflowmodel.EventHandlingInputPort; |
| import org.apache.taverna.workflowmodel.Merge; |
| import org.apache.taverna.workflowmodel.MergeInputPort; |
| import org.apache.taverna.workflowmodel.ProcessorInputPort; |
| import org.apache.taverna.workflowmodel.ProcessorOutputPort; |
| import org.apache.taverna.workflowmodel.processor.activity.ActivityInputPort; |
| import org.apache.taverna.workflowmodel.processor.activity.ActivityOutputPort; |
| import org.apache.taverna.workflowmodel.processor.activity.NestedDataflow; |
| import org.apache.taverna.workflowmodel.processor.dispatch.DispatchLayer; |
| import org.apache.taverna.workflowmodel.processor.dispatch.DispatchStack; |
| import org.apache.taverna.workflowmodel.processor.iteration.IterationStrategy; |
| import org.apache.taverna.workflowmodel.processor.iteration.NamedInputPortNode; |
| import org.apache.taverna.platform.capability.api.ActivityConfigurationException; |
| import org.apache.taverna.platform.capability.api.ActivityNotFoundException; |
| import org.apache.taverna.platform.capability.api.ActivityService; |
| import org.apache.taverna.platform.capability.api.DispatchLayerConfigurationException; |
| import org.apache.taverna.platform.capability.api.DispatchLayerNotFoundException; |
| import org.apache.taverna.platform.capability.api.DispatchLayerService; |
| import org.apache.taverna.platform.execution.api.InvalidWorkflowException; |
| import org.apache.taverna.scufl2.api.activity.Activity; |
| import org.apache.taverna.scufl2.api.common.Scufl2Tools; |
| import org.apache.taverna.scufl2.api.configurations.Configuration; |
| import org.apache.taverna.scufl2.api.container.WorkflowBundle; |
| import org.apache.taverna.scufl2.api.core.BlockingControlLink; |
| import org.apache.taverna.scufl2.api.core.ControlLink; |
| import org.apache.taverna.scufl2.api.core.DataLink; |
| import org.apache.taverna.scufl2.api.core.Processor; |
| import org.apache.taverna.scufl2.api.core.Workflow; |
| import org.apache.taverna.scufl2.api.iterationstrategy.CrossProduct; |
| import org.apache.taverna.scufl2.api.iterationstrategy.DotProduct; |
| import org.apache.taverna.scufl2.api.iterationstrategy.IterationStrategyNode; |
| import org.apache.taverna.scufl2.api.iterationstrategy.IterationStrategyStack; |
| import org.apache.taverna.scufl2.api.iterationstrategy.IterationStrategyTopNode; |
| import org.apache.taverna.scufl2.api.iterationstrategy.PortNode; |
| import org.apache.taverna.scufl2.api.port.InputActivityPort; |
| import org.apache.taverna.scufl2.api.port.InputProcessorPort; |
| import org.apache.taverna.scufl2.api.port.InputWorkflowPort; |
| import org.apache.taverna.scufl2.api.port.OutputActivityPort; |
| import org.apache.taverna.scufl2.api.port.OutputProcessorPort; |
| import org.apache.taverna.scufl2.api.port.OutputWorkflowPort; |
| import org.apache.taverna.scufl2.api.port.Port; |
| import org.apache.taverna.scufl2.api.port.ReceiverPort; |
| import org.apache.taverna.scufl2.api.port.SenderPort; |
| import org.apache.taverna.scufl2.api.profiles.ProcessorBinding; |
| import org.apache.taverna.scufl2.api.profiles.ProcessorInputPortBinding; |
| import org.apache.taverna.scufl2.api.profiles.ProcessorOutputPortBinding; |
| import org.apache.taverna.scufl2.api.profiles.Profile; |
| |
| import com.fasterxml.jackson.databind.JsonNode; |
| |
| /** |
| * Translates a scufl2 {@link Workflow} into a {@link Dataflow}. |
| * |
| * @author David Withers |
| */ |
| public class WorkflowToDataflowMapper { |
| private static final URI NESTED_WORKFLOW_URI = URI |
| .create("http://ns.taverna.org.uk/2010/activity/nested-workflow"); |
| |
| private Edits edits; |
| private final Scufl2Tools scufl2Tools = new Scufl2Tools(); |
| private final Map<Port, EventHandlingInputPort> inputPorts; |
| private final Map<Port, EventForwardingOutputPort> outputPorts; |
| private final Map<Port, Merge> merges; |
| private final Map<Workflow, Dataflow> workflowToDataflow; |
| private final Map<Dataflow, Workflow> dataflowToWorkflow; |
| private final Map<Processor, org.apache.taverna.workflowmodel.Processor> workflowToDataflowProcessors; |
| private final Map<org.apache.taverna.workflowmodel.Processor, Processor> dataflowToWorkflowProcessors; |
| private final Map<Activity, org.apache.taverna.workflowmodel.processor.activity.Activity<?>> workflowToDataflowActivities; |
| private final Map<org.apache.taverna.workflowmodel.processor.activity.Activity<?>, Activity> dataflowToWorkflowActivities; |
| @SuppressWarnings("unused") |
| private final WorkflowBundle workflowBundle; |
| private final Profile profile; |
| private final ActivityService activityService; |
| private final DispatchLayerService dispatchLayerService; |
| |
| public WorkflowToDataflowMapper(WorkflowBundle workflowBundle, |
| Profile profile, Edits edits, ActivityService activityService, |
| DispatchLayerService dispatchLayerService) { |
| this.workflowBundle = workflowBundle; |
| this.profile = profile; |
| this.edits = edits; |
| this.activityService = activityService; |
| this.dispatchLayerService = dispatchLayerService; |
| inputPorts = new IdentityHashMap<>(); |
| outputPorts = new IdentityHashMap<>(); |
| merges = new IdentityHashMap<>(); |
| workflowToDataflow = new IdentityHashMap<>(); |
| dataflowToWorkflow = new HashMap<>(); |
| workflowToDataflowProcessors = new IdentityHashMap<>(); |
| dataflowToWorkflowProcessors = new HashMap<>(); |
| workflowToDataflowActivities = new IdentityHashMap<>(); |
| dataflowToWorkflowActivities = new HashMap<>(); |
| } |
| |
| public Workflow getWorkflow(Dataflow dataflow) { |
| return dataflowToWorkflow.get(dataflow); |
| } |
| |
| public Dataflow getDataflow(Workflow workflow) |
| throws InvalidWorkflowException { |
| if (!workflowToDataflow.containsKey(workflow)) { |
| try { |
| Dataflow dataflow = createDataflow(workflow); |
| workflowToDataflow.put(workflow, dataflow); |
| dataflowToWorkflow.put(dataflow, workflow); |
| } catch (EditException | ActivityConfigurationException |
| | DispatchLayerConfigurationException |
| | ActivityNotFoundException |
| | DispatchLayerNotFoundException e) { |
| throw new InvalidWorkflowException(e); |
| } |
| } |
| return workflowToDataflow.get(workflow); |
| } |
| |
| public Processor getWorkflowProcessor( |
| org.apache.taverna.workflowmodel.Processor dataflowProcessor) { |
| return dataflowToWorkflowProcessors.get(dataflowProcessor); |
| } |
| |
| public org.apache.taverna.workflowmodel.Processor getDataflowProcessor( |
| Processor workflowProcessor) { |
| return workflowToDataflowProcessors.get(workflowProcessor); |
| } |
| |
| public Activity getWorkflowActivity( |
| org.apache.taverna.workflowmodel.processor.activity.Activity<?> dataflowActiviy) { |
| return dataflowToWorkflowActivities.get(dataflowActiviy); |
| } |
| |
| public org.apache.taverna.workflowmodel.processor.activity.Activity<?> getDataflowActivity( |
| Activity workflowActivity) { |
| return workflowToDataflowActivities.get(workflowActivity); |
| } |
| |
| protected Dataflow createDataflow(Workflow workflow) throws EditException, |
| ActivityNotFoundException, ActivityConfigurationException, |
| InvalidWorkflowException, DispatchLayerNotFoundException, |
| DispatchLayerConfigurationException { |
| // create the dataflow |
| Dataflow dataflow = edits.createDataflow(); |
| // set the dataflow name |
| edits.getUpdateDataflowNameEdit(dataflow, workflow.getName()).doEdit(); |
| |
| addInputPorts(workflow, dataflow); |
| addOutputPorts(workflow, dataflow); |
| addProcessors(workflow, dataflow); |
| addDataLinks(workflow, dataflow); |
| addControlLinks(workflow); |
| |
| return dataflow; |
| } |
| |
| private void addProcessors(Workflow workflow, Dataflow dataflow) |
| throws EditException, ActivityNotFoundException, |
| ActivityConfigurationException, InvalidWorkflowException, |
| DispatchLayerNotFoundException, DispatchLayerConfigurationException { |
| for (Processor processor : workflow.getProcessors()) { |
| org.apache.taverna.workflowmodel.Processor dataflowProcessor = edits |
| .createProcessor(processor.getName()); |
| edits.getAddProcessorEdit(dataflow, dataflowProcessor).doEdit(); |
| // map the processor |
| workflowToDataflowProcessors.put(processor, dataflowProcessor); |
| dataflowToWorkflowProcessors.put(dataflowProcessor, processor); |
| // add input ports |
| for (InputProcessorPort inputProcessorPort : processor |
| .getInputPorts()) { |
| if (inputProcessorPort.getDatalinksTo().isEmpty()) |
| continue; |
| ProcessorInputPort processorInputPort = edits |
| .createProcessorInputPort(dataflowProcessor, |
| inputProcessorPort.getName(), |
| inputProcessorPort.getDepth()); |
| edits.getAddProcessorInputPortEdit(dataflowProcessor, |
| processorInputPort).doEdit(); |
| inputPorts.put(inputProcessorPort, processorInputPort); |
| } |
| // add output ports |
| for (OutputProcessorPort outputProcessorPort : processor |
| .getOutputPorts()) { |
| ProcessorOutputPort processorOutputPort = edits |
| .createProcessorOutputPort(dataflowProcessor, |
| outputProcessorPort.getName(), |
| outputProcessorPort.getDepth(), |
| outputProcessorPort.getGranularDepth()); |
| edits.getAddProcessorOutputPortEdit(dataflowProcessor, |
| processorOutputPort).doEdit(); |
| outputPorts.put(outputProcessorPort, processorOutputPort); |
| } |
| |
| // add dispatch stack |
| addDispatchStack(processor, dataflowProcessor); |
| |
| addIterationStrategy(processor, dataflowProcessor); |
| |
| // add bound activities |
| for (ProcessorBinding processorBinding : scufl2Tools |
| .processorBindingsForProcessor(processor, profile)) |
| addActivity(processorBinding); |
| } |
| } |
| |
| private void addDispatchStack(Processor processor, |
| org.apache.taverna.workflowmodel.Processor dataflowProcessor) |
| throws DispatchLayerNotFoundException, |
| DispatchLayerConfigurationException, EditException { |
| DispatchStack dispatchStack = dataflowProcessor.getDispatchStack(); |
| |
| JsonNode json = null; |
| try { |
| json = processor.getConfiguration(profile).getJson(); |
| } catch (IndexOutOfBoundsException e) { |
| // no configuration for processor |
| } |
| |
| int layer = 0; |
| addDispatchLayer( |
| dispatchStack, |
| URI.create("http://ns.taverna.org.uk/2010/scufl2/taverna/dispatchlayer/Parallelize"), |
| layer++, json == null ? null : json.get("parallelize")); |
| addDispatchLayer( |
| dispatchStack, |
| URI.create("http://ns.taverna.org.uk/2010/scufl2/taverna/dispatchlayer/ErrorBounce"), |
| layer++, null); |
| addDispatchLayer( |
| dispatchStack, |
| URI.create("http://ns.taverna.org.uk/2010/scufl2/taverna/dispatchlayer/Failover"), |
| layer++, null); |
| addDispatchLayer( |
| dispatchStack, |
| URI.create("http://ns.taverna.org.uk/2010/scufl2/taverna/dispatchlayer/Retry"), |
| layer++, json == null ? null : json.get("retry")); |
| addDispatchLayer( |
| dispatchStack, |
| URI.create("http://ns.taverna.org.uk/2010/scufl2/taverna/dispatchlayer/Stop"), |
| layer++, null); |
| addDispatchLayer( |
| dispatchStack, |
| URI.create("http://ns.taverna.org.uk/2010/scufl2/taverna/dispatchlayer/Invoke"), |
| layer++, null); |
| |
| } |
| |
| private void addDispatchLayer(DispatchStack dispatchStack, |
| URI dispatchLayerType, int layer, JsonNode json) |
| throws DispatchLayerConfigurationException, |
| DispatchLayerNotFoundException, EditException { |
| // create the dispatch layer |
| DispatchLayer<?> dispatchLayer = dispatchLayerService |
| .createDispatchLayer(dispatchLayerType, json); |
| // add the dispatch layer to the dispatch layer stack |
| edits.getAddDispatchLayerEdit(dispatchStack, dispatchLayer, layer) |
| .doEdit(); |
| } |
| |
| private void addIterationStrategy(Processor processor, |
| org.apache.taverna.workflowmodel.Processor dataflowProcessor) |
| throws EditException, InvalidWorkflowException { |
| // get the iteration strategy from the processor |
| org.apache.taverna.workflowmodel.processor.iteration.IterationStrategyStack dataflowIterationStrategyStack = dataflowProcessor |
| .getIterationStrategy(); |
| // clear the iteration strategy |
| edits.getClearIterationStrategyStackEdit(dataflowIterationStrategyStack) |
| .doEdit(); |
| IterationStrategyStack iterationStrategyStack = processor |
| .getIterationStrategyStack(); |
| for (IterationStrategyTopNode iterationStrategyTopNode : iterationStrategyStack) { |
| // create iteration strategy |
| IterationStrategy dataflowIterationStrategy = edits |
| .createIterationStrategy(); |
| // add iteration strategy to the stack |
| edits.getAddIterationStrategyEdit(dataflowIterationStrategyStack, |
| dataflowIterationStrategy).doEdit(); |
| // add the node to the iteration strategy |
| addIterationStrategyNode(dataflowIterationStrategy, |
| dataflowIterationStrategy.getTerminalNode(), |
| iterationStrategyTopNode); |
| } |
| } |
| |
| private void addIterationStrategyNode( |
| IterationStrategy dataflowIterationStrategy, |
| org.apache.taverna.workflowmodel.processor.iteration.IterationStrategyNode dataflowIterationStrategyNode, |
| IterationStrategyNode iterationStrategyNode) throws EditException, |
| InvalidWorkflowException { |
| org.apache.taverna.workflowmodel.processor.iteration.IterationStrategyNode childDataflowIterationStrategyNode = null; |
| if (iterationStrategyNode instanceof CrossProduct) { |
| CrossProduct crossProduct = (CrossProduct) iterationStrategyNode; |
| childDataflowIterationStrategyNode = new org.apache.taverna.workflowmodel.processor.iteration.CrossProduct(); |
| for (IterationStrategyNode iterationStrategyNode2 : crossProduct) |
| addIterationStrategyNode(dataflowIterationStrategy, |
| childDataflowIterationStrategyNode, |
| iterationStrategyNode2); |
| } else if (iterationStrategyNode instanceof DotProduct) { |
| DotProduct dotProduct = (DotProduct) iterationStrategyNode; |
| childDataflowIterationStrategyNode = new org.apache.taverna.workflowmodel.processor.iteration.DotProduct(); |
| for (IterationStrategyNode iterationStrategyNode2 : dotProduct) |
| addIterationStrategyNode(dataflowIterationStrategy, |
| childDataflowIterationStrategyNode, |
| iterationStrategyNode2); |
| } else if (iterationStrategyNode instanceof PortNode) { |
| PortNode portNode = (PortNode) iterationStrategyNode; |
| Integer desiredDepth = portNode.getDesiredDepth(); |
| if (desiredDepth == null) |
| desiredDepth = portNode.getInputProcessorPort().getDepth(); |
| NamedInputPortNode namedInputPortNode = new NamedInputPortNode( |
| portNode.getInputProcessorPort().getName(), desiredDepth); |
| edits.getAddIterationStrategyInputNodeEdit( |
| dataflowIterationStrategy, namedInputPortNode).doEdit(); |
| childDataflowIterationStrategyNode = namedInputPortNode; |
| } else { |
| throw new InvalidWorkflowException( |
| "Unknown IterationStrategyNode type : " |
| + iterationStrategyNode.getClass().getName()); |
| } |
| childDataflowIterationStrategyNode |
| .setParent(dataflowIterationStrategyNode); |
| } |
| |
| private void addActivity(ProcessorBinding processorBinding) |
| throws EditException, ActivityNotFoundException, |
| ActivityConfigurationException, InvalidWorkflowException { |
| org.apache.taverna.workflowmodel.Processor processor = workflowToDataflowProcessors |
| .get(processorBinding.getBoundProcessor()); |
| Activity scufl2Activity = processorBinding.getBoundActivity(); |
| URI activityType = scufl2Activity.getType(); |
| if (!activityService.activityExists(activityType)) |
| throw new ActivityNotFoundException("No activity exists for " |
| + activityType); |
| Configuration configuration = scufl2Activity.getConfiguration(); |
| |
| // create the activity |
| org.apache.taverna.workflowmodel.processor.activity.Activity<?> activity = activityService |
| .createActivity(activityType, configuration.getJson()); |
| // check if we have a nested workflow |
| if (activityType.equals(NESTED_WORKFLOW_URI)) { |
| if (activity instanceof NestedDataflow) { |
| Workflow nestedWorkflow = scufl2Tools |
| .nestedWorkflowForProcessor( |
| processorBinding.getBoundProcessor(), profile); |
| ((NestedDataflow) activity) |
| .setNestedDataflow(getDataflow(nestedWorkflow)); |
| } else |
| throw new ActivityConfigurationException( |
| "Activity is not an instance of NestedDataflow"); |
| } |
| |
| // add the activity to the processor |
| edits.getAddActivityEdit(processor, activity).doEdit(); |
| |
| // add input ports |
| for (InputActivityPort inputActivityPort : scufl2Activity |
| .getInputPorts()) { |
| ActivityInputPort activityInputPort = edits |
| .createActivityInputPort( |
| inputActivityPort.getName(), |
| inputActivityPort.getDepth(), |
| false, |
| new ArrayList<Class<? extends ExternalReferenceSPI>>(), |
| String.class); |
| edits.getAddActivityInputPortEdit(activity, activityInputPort) |
| .doEdit(); |
| } |
| // add output ports |
| for (OutputActivityPort outputActivityPort : scufl2Activity |
| .getOutputPorts()) { |
| ActivityOutputPort activitytOutputPort = edits |
| .createActivityOutputPort(outputActivityPort.getName(), |
| outputActivityPort.getDepth(), |
| outputActivityPort.getGranularDepth()); |
| edits.getAddActivityOutputPortEdit(activity, activitytOutputPort) |
| .doEdit(); |
| } |
| // map input ports |
| for (ProcessorInputPortBinding portBinding : processorBinding |
| .getInputPortBindings()) { |
| InputProcessorPort processorPort = portBinding |
| .getBoundProcessorPort(); |
| InputActivityPort activityPort = portBinding.getBoundActivityPort(); |
| edits.getAddActivityInputPortMappingEdit(activity, |
| processorPort.getName(), activityPort.getName()).doEdit(); |
| } |
| // map output ports |
| for (ProcessorOutputPortBinding portBinding : processorBinding |
| .getOutputPortBindings()) { |
| OutputProcessorPort processorPort = portBinding |
| .getBoundProcessorPort(); |
| OutputActivityPort activityPort = portBinding |
| .getBoundActivityPort(); |
| edits.getAddActivityOutputPortMappingEdit(activity, |
| processorPort.getName(), activityPort.getName()).doEdit(); |
| } |
| workflowToDataflowActivities.put(scufl2Activity, activity); |
| dataflowToWorkflowActivities.put(activity, scufl2Activity); |
| } |
| |
| private void addDataLinks(Workflow workflow, Dataflow dataflow) |
| throws EditException { |
| for (DataLink dataLink : workflow.getDataLinks()) { |
| ReceiverPort receiverPort = dataLink.getSendsTo(); |
| SenderPort senderPort = dataLink.getReceivesFrom(); |
| EventForwardingOutputPort source = outputPorts.get(senderPort); |
| EventHandlingInputPort sink = inputPorts.get(receiverPort); |
| Integer mergePosition = dataLink.getMergePosition(); |
| if (mergePosition != null) { |
| if (!merges.containsKey(receiverPort)) { |
| Merge merge = edits.createMerge(dataflow); |
| edits.getAddMergeEdit(dataflow, merge).doEdit(); |
| merges.put(receiverPort, merge); |
| } |
| Merge merge = merges.get(receiverPort); |
| // create merge input port |
| MergeInputPort mergeInputPort = edits.createMergeInputPort( |
| merge, "input" + mergePosition, sink.getDepth()); |
| // add it to the correct position in the merge |
| @SuppressWarnings("unchecked") |
| List<MergeInputPort> mergeInputPorts = (List<MergeInputPort>) merge |
| .getInputPorts(); |
| if (mergePosition > mergeInputPorts.size()) |
| mergeInputPorts.add(mergeInputPort); |
| else |
| mergeInputPorts.add(mergePosition, mergeInputPort); |
| // connect a datalink into the merge |
| Datalink datalinkIn = edits.createDatalink(source, |
| mergeInputPort); |
| edits.getConnectDatalinkEdit(datalinkIn).doEdit(); |
| // check if the merge output has been connected |
| EventForwardingOutputPort mergeOutputPort = merge |
| .getOutputPort(); |
| if (mergeOutputPort.getOutgoingLinks().isEmpty()) { |
| Datalink datalinkOut = edits.createDatalink( |
| merge.getOutputPort(), sink); |
| edits.getConnectDatalinkEdit(datalinkOut).doEdit(); |
| } else if (mergeOutputPort.getOutgoingLinks().size() == 1) { |
| if (mergeOutputPort.getOutgoingLinks().iterator().next() |
| .getSink() != sink) |
| throw new EditException( |
| "Cannot add a different sinkPort to a Merge that already has one defined"); |
| } else |
| throw new EditException( |
| "The merge instance cannot have more that 1 outgoing Datalink"); |
| } else { |
| Datalink datalink = edits.createDatalink(source, sink); |
| edits.getConnectDatalinkEdit(datalink).doEdit(); |
| } |
| } |
| } |
| |
| private void addControlLinks(Workflow workflow) throws EditException { |
| for (ControlLink controlLink : workflow.getControlLinks()) { |
| if (controlLink instanceof BlockingControlLink) { |
| BlockingControlLink blockingControlLink = (BlockingControlLink) controlLink; |
| Processor untilFinished = blockingControlLink |
| .getUntilFinished(); |
| Processor block = blockingControlLink.getBlock(); |
| edits.getCreateConditionEdit( |
| workflowToDataflowProcessors.get(untilFinished), |
| workflowToDataflowProcessors.get(block)).doEdit(); |
| } |
| } |
| } |
| |
| private void addOutputPorts(Workflow workflow, Dataflow dataflow) |
| throws EditException { |
| for (OutputWorkflowPort outputWorkflowPort : workflow.getOutputPorts()) { |
| DataflowOutputPort dataflowOutputPort = edits |
| .createDataflowOutputPort(outputWorkflowPort.getName(), |
| dataflow); |
| edits.getAddDataflowOutputPortEdit(dataflow, dataflowOutputPort) |
| .doEdit(); |
| inputPorts.put(outputWorkflowPort, |
| dataflowOutputPort.getInternalInputPort()); |
| } |
| } |
| |
| private void addInputPorts(Workflow workflow, Dataflow dataflow) |
| throws EditException { |
| for (InputWorkflowPort inputWorkflowPort : workflow.getInputPorts()) { |
| DataflowInputPort dataflowInputPort = edits |
| .createDataflowInputPort(inputWorkflowPort.getName(), |
| inputWorkflowPort.getDepth(), |
| inputWorkflowPort.getDepth(), dataflow); |
| edits.getAddDataflowInputPortEdit(dataflow, dataflowInputPort) |
| .doEdit(); |
| outputPorts.put(inputWorkflowPort, |
| dataflowInputPort.getInternalOutputPort()); |
| } |
| } |
| } |