org.knime.core.node.workflow
Class WorkflowManager

java.lang.Object
  org.knime.core.node.workflow.NodeContainer
      org.knime.core.node.workflow.WorkflowManager

All Implemented Interfaces:

EventListener, NodeProgressListener, NodeUIInformationListener

public final class WorkflowManager
extends NodeContainer
implements NodeUIInformationListener

Container holding nodes and connections of a (sub) workflow. In contrast to previous implementations, this class will now handle all control, such as transport of data and specs from node to subsequent nodes. That is, nodes do not know their pre- or successors anymore. A WorkflowManager can also play the role of a NodeContainer, thus representing a metanode/subworkflow.

Author:

M. Berthold/B. Wiswedel, University of Konstanz

Nested Class Summary

Nested classes/interfaces inherited from class org.knime.core.node.workflow.NodeContainer

NodeContainer.NodeContainerSettings, NodeContainer.State

Field Summary

(package private) static String	CFG_CREATED_BY Version of KNIME that has written the workflow.
(package private) static String	CFG_VERSION Workflow version, indicates the "oldest" version that is compatible to the current workflow format.
static WorkflowManager	ROOT The root of everything, a workflow with no in- or outputs.

Fields inherited from class org.knime.core.node.workflow.NodeContainer

m_nodeMutex

Method Summary

ConnectionContainer	addConnection(org.knime.core.node.workflow.NodeID source, int sourcePort, org.knime.core.node.workflow.NodeID dest, int destPort) Add new connection - throw Exception if the same connection already exists.
void	addListener(WorkflowListener listener) Add listener to list.
org.knime.core.node.workflow.NodeID	addNodeAndApplyContext(NodeFactory<?> factory, NodeCreationContext context)
void	addWorkflowAnnotation(WorkflowAnnotation annotation) Add new workflow annotation, fire events.
void	addWorkflowVariables(boolean skipReset, FlowVariable... newVars) Set new workflow variables.
boolean	areDialogAndNodeSettingsEqual()
(package private) boolean	areSettingsValid(NodeSettingsRO settings)
(package private) void	assembleInputSpecs(org.knime.core.node.workflow.NodeID id, PortObjectSpec[] inSpecs) Fill array holding all input specs for the given node.
boolean	canAddConnection(org.knime.core.node.workflow.NodeID source, int sourcePort, org.knime.core.node.workflow.NodeID dest, int destPort) Check if a new connection can be added.
boolean	canCancelNode(org.knime.core.node.workflow.NodeID nodeID) Check if a node can be cancelled individually.
(package private) void	cancelExecution() Cancel execution of a marked, queued, or executing node.
void	cancelExecution(NodeContainer nc) Cancel execution of the given NodeContainer.
String	canCollapseNodesIntoMetaNode(org.knime.core.node.workflow.NodeID[] orgIDs) Check if we can collapse selected set of nodes into a metanode.
boolean	canExecuteNode(org.knime.core.node.workflow.NodeID nodeID) Check if a node can be executed directly.
String	canExpandMetaNode(org.knime.core.node.workflow.NodeID wfmID) Check if we can expand the selected metanode into a set of nodes in this WFM.
(package private) boolean	canPerformReset()
boolean	canRemoveConnection(ConnectionContainer cc) Check if a connection can safely be removed.
boolean	canRemoveNode(org.knime.core.node.workflow.NodeID nodeID) Check if specific node can be removed (i.e.
boolean	canResetNode(org.knime.core.node.workflow.NodeID nodeID) Check if a node can be reset, meaning that it is executed and all of its successors are idle or executed as well.
boolean	canSetJobManager(org.knime.core.node.workflow.NodeID nodeID) Is the node with the given ID ready to take a new job manager.
boolean	canUpdateMetaNodeLink(org.knime.core.node.workflow.NodeID id) Returns true if the argument node is a valid meta node link and is not executing and has no successor in execution.
<T> T	castNodeModel(org.knime.core.node.workflow.NodeID id, Class<T> cl) Retrieves the node with the given ID, fetches the underlying NodeModel and casts it to the argument class.
boolean	checkUpdateMetaNodeLink(org.knime.core.node.workflow.NodeID id, WorkflowLoadHelper loadHelper) Query the template to the linked meta node with the given ID and check whether a newer version is available.
(package private) void	cleanOutputPortsInWFMConnectedToInPorts(Set<Integer> inPorts) Clean outports of nodes connected to set of input ports.
(package private) void	cleanup() Method that's called when the node is discarded.
WorkflowManager	collapseNodesIntoMetaNode(org.knime.core.node.workflow.NodeID[] orgIDs, String name) Collapse selected set of nodes into a metanode.
boolean	containsExecutedNode()
boolean	containsNodeContainer(org.knime.core.node.workflow.NodeID id) Does the workflow contain a node with the argument id?
(package private) boolean	continueExecutionOnLoad(NodeContainer nc, NodeContainerPersistor persistor)
WorkflowPersistor	copy(boolean isUndoableDeleteCommand, WorkflowCopyContent content) Copy the nodes with the given ids.
WorkflowPersistor	copy(WorkflowCopyContent content) Copy the given content.
WorkflowCopyContent	copyFromAndPasteHere(WorkflowManager sourceManager, WorkflowCopyContent content) Copies the nodes with the given ids from the argument workflow manager into this wfm instance.
org.knime.core.node.workflow.NodeID	createAndAddNode(NodeFactory<?> factory) Uses given Factory to create a new node and then adds new node to the workflow manager.
WorkflowManager	createAndAddProject(String name) Create new project - which is the same as creating a new subworkflow at this level with no in- or outports.
WorkflowManager	createAndAddSubWorkflow(PortType[] inPorts, PortType[] outPorts, String name) Creates new meta node.
WorkflowExecutionResult	createExecutionResult(ExecutionMonitor exec) Saves all internals that are necessary to mimic the computed result into a new execution result object.
static WorkflowPersistorVersion1xx	createLoadPersistor(File directory, WorkflowLoadHelper loadHelper)
(package private) WorkflowManager	createSubWorkflow(WorkflowPersistor persistor, org.knime.core.node.workflow.NodeID newID) Creates new meta node from a persistor instance.
(package private) void	deleteObsoleteNodeDirs() Delete directories of removed nodes.
(package private) void	doAfterExecution(NodeContainer nc, NodeContainerExecutionStatus status) Cleanup a node after execution.
(package private) void	doBeforeExecution(NodeContainer nc) Call-back from NodeContainer called before node is actually executed.
(package private) void	doBeforePostExecution(NodeContainer nc) Callback from NodeContainer to request a safe transition into the NodeContainer.State.POSTEXECUTE state.
(package private) boolean	doBeforePreExecution(NodeContainer nc) Callback from NodeContainer to request a safe transition into the NodeContainer.State.PREEXECUTE state.
void	executeAll() Convenience method: (Try to) Execute all nodes in the workflow.
boolean	executeAllAndWaitUntilDone() Convenience method: execute all and wait for execution to be done.
void	executeUpToHere(org.knime.core.node.workflow.NodeID... ids) mark these nodes and all not-yet-executed predecessors for execution.
org.knime.core.node.workflow.NodeID[]	expandMetaNode(org.knime.core.node.workflow.NodeID wfmID) Expand the selected metanode into a set of nodes in this WFM and remove the old metanode.
<T> Map<org.knime.core.node.workflow.NodeID,T>	findNodes(Class<T> nodeModelClass, boolean recurse) Find all nodes in this workflow, whose underlying NodeModel is of the requested type.
ConnectionContainer	getConnection(ConnectionID id) Gets a connection by id.
Collection<ConnectionContainer>	getConnectionContainers()
protected NodeContainerPersistor	getCopyPersistor(HashMap<Integer,ContainerTable> tableRep, boolean preserveDeletableFlags, boolean isUndoableDeleteCommand) Get a new persistor that is used to copy this node (copy&paste action).
CredentialsStore	getCredentialsStore() Get reference to credentials store used to persist name/passwords.
(package private) NodeDialogPane	getDialogPane()
(package private) NodeDialogPane	getDialogPaneWithSettings(PortObjectSpec[] inSpecs)
(package private) HashMap<Integer,ContainerTable>	getGlobalTableRepository()
URL	getIcon()
ConnectionContainer	getIncomingConnectionFor(org.knime.core.node.workflow.NodeID id, int portIdx) Returns the incoming connection of the node with the passed node id at the specified port.
Set<ConnectionContainer>	getIncomingConnectionsFor(org.knime.core.node.workflow.NodeID id) Get all incoming connections for a node.
WorkflowInPort	getInPort(int index)
UIInformation	getInPortsBarUIInfo() Get UI information for workflow input ports.
String	getName() Get the name of the workflow.
String	getNameField()
NodeContainer	getNodeContainer(org.knime.core.node.workflow.NodeID id)
Collection<NodeContainer>	getNodeContainers()
List<org.knime.core.node.workflow.NodeMessage>	getNodeErrorMessages()
NodeView<NodeModel>	getNodeView(int i) Return the view with the specified index provided by the node.
String	getNodeViewName(int i)
int	getNrInPorts()
int	getNrNodeViews() Returns the number of views provided by the node implementation.
int	getNrOutPorts()
int	getNrWorkflowIncomingPorts()
int	getNrWorkflowOutgoingPorts()
Set<ConnectionContainer>	getOutgoingConnectionsFor(org.knime.core.node.workflow.NodeID id) Get all outgoing connections for a node.
Set<ConnectionContainer>	getOutgoingConnectionsFor(org.knime.core.node.workflow.NodeID id, int portIdx) Returns the set of outgoing connections for the node with the passed id at the specified port.
WorkflowOutPort	getOutPort(int index)
UIInformation	getOutPortsBarUIInfo() Get UI information for workflow output ports.
MetaNodeTemplateInformation	getTemplateInformation()
NodeFactory.NodeType	getType()
(package private) Workflow	getWorkflow()
Collection<WorkflowAnnotation>	getWorkflowAnnotations()
NodeOutPort	getWorkflowIncomingPort(int i)
NodeInPort	getWorkflowOutgoingPort(int i)
List<FlowVariable>	getWorkflowVariables() Get read-only access on the current workflow variables.
ReferencedFile	getWorkingDir() Get working folder associated with this WFM.
boolean	hasDialog()
(package private) void	invokeResetOnPortSuccessors(int inportIndex) Reset those nodes which are connected to a specific workflow incoming port.
protected boolean	isLocalWFM() Is this node a to be locally executed workflow.
(package private) boolean	isResetable() check if node can be safely reset.
boolean	isWriteProtected() Is this workflow represents a linked meta node (locked for edit).
WorkflowPersistor.WorkflowLoadResult	load(File directory, ExecutionMonitor exec, WorkflowLoadHelper loadHelper, boolean keepNodeMessages) Loads the workflow contained in the directory as node into this workflow instance.
WorkflowPersistor.WorkflowLoadResult	load(WorkflowPersistorVersion1xx persistor, ExecutionMonitor exec, boolean keepNodeMessages) Loads the content of the argument persistor into this node.
(package private) WorkflowCopyContent	loadContent(NodeContainerPersistor nodePersistor, Map<Integer,BufferedDataTable> tblRep, FlowObjectStack ignoredStack, ExecutionMonitor exec, WorkflowPersistor.LoadResult loadResult, boolean preserveNodeMessage) Restore content from persistor.
void	loadExecutionResult(NodeContainerExecutionResult result, ExecutionMonitor exec, WorkflowPersistor.LoadResult loadResult) Load information from execution result.
void	loadNodeSettings(org.knime.core.node.workflow.NodeID id, NodeSettingsRO settings) Load Settings into specified node.
static WorkflowPersistor.WorkflowLoadResult	loadProject(File directory, ExecutionMonitor exec, WorkflowLoadHelper loadHelper)
(package private) void	loadSettings(NodeSettingsRO settings)
(package private) void	markForExecution(boolean flag) Enable (or disable) queuing of underlying node for execution.
(package private) void	markForExecutionNodesInWFMConnectedToInPorts(Set<Integer> inPorts, boolean markExecutedNodes) Mark all nodes in this workflow that are connected to the given inports.
(package private) void	mimicRemoteExecuted(NodeContainerExecutionStatus status) Put this node into either the NodeContainer.State.EXECUTED or NodeContainer.State.IDLE state depending on the argument.
(package private) void	mimicRemoteExecuting() Marks this node as remotely executing.
(package private) void	mimicRemotePostExecute() Puts this node (and all its children) into the NodeContainer.State.POSTEXECUTE state.
(package private) void	mimicRemotePreExecute() Puts this node (and all its children) into the NodeContainer.State.PREEXECUTE state.
void	nodeUIInformationChanged(NodeUIInformationEvent evt) Listener to annotations, etc; sets content dirty.
protected void	notifyNodePropertyChangedListener(NodePropertyChangedEvent.NodeProperty property)
WorkflowCopyContent	paste(WorkflowPersistor persistor) Pastes the contents of the argument persistor into this wfm.
void	pauseLoopExecution(NodeContainer nc) Pause loop execution of the given NodeContainer (=loop end).
(package private) void	performShutdown() Called when the workflow is to be disposed.
(package private) void	performStateTransitionEXECUTED(NodeContainerExecutionStatus status) This should be used to change the nodes states correctly (and likely needs to be synchronized with other changes visible to successors of this node as well!) AFTER the actual execution.
(package private) void	performStateTransitionEXECUTING() This should be used to change the nodes states correctly (and likely needs to be synchronized with other changes visible to successors of this node as well!) BEFORE the actual execution.
(package private) void	performStateTransitionPOSTEXECUTE() Called when the state of a node should switch from NodeContainer.State.EXECUTING (or NodeContainer.State.EXECUTINGREMOTELY) to NodeContainer.State.POSTEXECUTE.
(package private) boolean	performStateTransitionPREEXECUTE() Called when the state of a node should switch from NodeContainer.State.QUEUED to NodeContainer.State.PREEXECUTE.
String	printNodeSummary(org.knime.core.node.workflow.NodeID prefix, int indent) Produce summary of node.
(package private) void	reconfigureAllNodesOnlyInThisWFM() Re-configure all configured (NOT executed) nodes in this workflow to make sure that new workflow variables are spread accordingly.
void	removeAnnotation(WorkflowAnnotation annotation) Remove workflow annotation, fire events.
void	removeConnection(ConnectionContainer cc) Remove connection.
void	removeListener(WorkflowListener listener) Remove listener.
void	removeNode(org.knime.core.node.workflow.NodeID nodeID) Remove node if possible.
void	removeProject(org.knime.core.node.workflow.NodeID id) Remove a project - the same as remove node but we make sure it really looks like a project (i.e.
void	removeWorkflowVariable(String name) Remove workflow variable of given name.
boolean	renameWorkflowDirectory(String newName) Renames the underlying workflow directory to the new name.
void	resetAll() Deprecated. Use resetAndConfigureAll() instead
(package private) void	resetAllNodesInWFM() Reset all nodes in this workflow.
void	resetAndConfigureAll() Resets and freshly configures all nodes in this workflow.
void	resetAndConfigureNode(org.knime.core.node.workflow.NodeID id) Reset node and all executed successors of a specific node.
(package private) void	resetAndReconfigureAllNodesInWFM() Reset all executed nodes in this workflow to make sure that new workflow variables are spread accordingly.
(package private) void	resetNodesInWFMConnectedToInPorts(Set<Integer> inPorts) Reset all nodes in this workflow that are connected to the given inports.
void	resumeLoopExecution(NodeContainer nc, boolean oneStep) Resume operation of a paused loop.
void	save(File directory, ExecutionMonitor exec, boolean isSaveData)
MetaNodeTemplateInformation	saveAsMetaNodeTemplate(File directory, ExecutionMonitor exec)
void	saveNodeSettings(org.knime.core.node.workflow.NodeID id, NodeSettingsWO settings) write node settings into Settings object.
(package private) void	saveSettings(NodeSettingsWO settings)
void	setDirty() Mark this node container to be changed, that is, it needs to be saved.
void	setInPortsBarUIInfo(UIInformation inPortsBarUIInfo) Set UI information for workflow's input ports (typically aligned as a bar).
void	setJobManager(org.knime.core.node.workflow.NodeID nodeID, NodeExecutionJobManager jobMgr) Sets a new job manager on the node with the given ID.
void	setName(String name) Set new name of this workflow or null to reset the name (will then return the workflow directory in getName() or null if this flow has not been saved yet).
protected void	setNodeContainerDirectory(ReferencedFile directory)
void	setOutPortsBarUIInfo(UIInformation outPortsBarUIInfo) Set UI information for workflow's output ports (typically aligned as a bar).
(package private) void	setTemplateInformation(MetaNodeTemplateInformation tI) Set new template info (not null!), fire events.
MetaNodeTemplateInformation	setTemplateInformation(org.knime.core.node.workflow.NodeID id, MetaNodeTemplateInformation templateInformation) Sets the argument template info on the node with the given ID.
void	shutdown() Attempts to cancel or running nodes in preparation for a removal of this node (or its parent) from the root.
(package private) boolean	sweep(boolean propagate) Performs sanity check on workflow.
String	toString()
void	updateCredentials(Credentials... credentialsList) Update user/password fields in the credentials store assigned to the workflow and update the node configuration.
WorkflowPersistor.MetaNodeLinkUpdateResult	updateMetaNodeLink(org.knime.core.node.workflow.NodeID id, ExecutionMonitor exec, WorkflowLoadHelper loadHelper) Update link meta nodes with the given ID.
boolean	waitWhileInExecution(long time, TimeUnit unit) Causes the current thread to wait until the the workflow has reached a non-executing state unless a given timeout elapsed.

Methods inherited from class org.knime.core.node.workflow.NodeContainer

addNodeMessageListener, addNodePropertyChangedListener, addNodeStateChangeListener, addProgressListener, addUIInformationListener, addWaitingLoop, applySettingsFromDialog, areDialogSettingsValid, clearWaitingLoopList, closeAllJobManagerViews, continueExecutionOnLoad, findJobManager, getCustomDescription, getCustomName, getDialogPaneWithSettings, getDisplayLabel, getExecutionJob, getID, getJobManager, getNameWithID, getNodeContainerDirectory, getNodeMessage, getNrViews, getParent, getProgressMonitor, getSplitType, getState, getUIInformation, getView, getViewName, getWaitingLoops, isDeletable, isDirty, notifyMessageListeners, notifyParentExecuteFinished, notifyParentExecuteStart, notifyParentPostExecuteStart, notifyParentPreExecuteStart, notifyProgressListeners, notifyStateChangeListeners, notifyUIListeners, openDialogInJFrame, progressChanged, queue, removeNodeMessageListener, removeNodeProgressListener, removeNodePropertyChangedListener, removeNodeStateChangeListener, removeUIInformationListener, removeWaitingLoopHeadNode, resetJobManagerViews, saveExecutionResult, saveNodeExecutionJobReconnectInfo, setCustomDescription, setCustomName, setExecutionJob, setJobManager, setNodeMessage, setState, setState, setUIInformation, throwIllegalStateException, unsetDirty

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Field Detail

ROOT

public static final WorkflowManager ROOT

The root of everything, a workflow with no in- or outputs. This workflow holds the top level projects.

CFG_VERSION

static final String CFG_VERSION

Workflow version, indicates the "oldest" version that is compatible to the current workflow format.

See Also:

Constant Field Values

CFG_CREATED_BY

static final String CFG_CREATED_BY

Version of KNIME that has written the workflow.

See Also:

Constant Field Values

Method Detail

getWorkflow

Workflow getWorkflow()

Returns:

workflow

createAndAddProject

public WorkflowManager createAndAddProject(String name)

Create new project - which is the same as creating a new subworkflow at this level with no in- or outports.

Parameters:

name - The name of the workflow (null value is ok)

Returns:

newly created workflow

removeProject

public void removeProject(org.knime.core.node.workflow.NodeID id)

Remove a project - the same as remove node but we make sure it really looks like a project (i.e. has no in- or outports).

Parameters:

id - of the project to be removed.

createAndAddNode

public org.knime.core.node.workflow.NodeID createAndAddNode(NodeFactory<?> factory)

Uses given Factory to create a new node and then adds new node to the workflow manager. We will automatically find the next available free index for the new node within the given prefix.

Parameters:

factory - NodeFactory used to create the new node

Returns:

newly created (unique) NodeID

addNodeAndApplyContext

public org.knime.core.node.workflow.NodeID addNodeAndApplyContext(NodeFactory<?> factory,
                                                                  NodeCreationContext context)

Parameters:

factory -

context -

Returns:

the node id of the created node.

canRemoveNode

public boolean canRemoveNode(org.knime.core.node.workflow.NodeID nodeID)

Check if specific node can be removed (i.e. is not currently being executed or waiting to be).

Parameters:

nodeID - id of node to be removed

Returns:

true if node can safely be removed.

removeNode

public void removeNode(org.knime.core.node.workflow.NodeID nodeID)

Remove node if possible. Throws an exception if node is "busy" and can not be removed at this time. If the node does not exist, this method returns without exception.

Parameters:

nodeID - id of node to be removed

createAndAddSubWorkflow

public WorkflowManager createAndAddSubWorkflow(PortType[] inPorts,
                                               PortType[] outPorts,
                                               String name)

Creates new meta node. We will automatically find the next available free index for the new node within this workflow.

Parameters:

inPorts - types of external inputs (going into this workflow)

outPorts - types of external outputs (exiting this workflow)

name - Name of the workflow (null values will be handled)

Returns:

newly created WorkflowManager

createSubWorkflow

WorkflowManager createSubWorkflow(WorkflowPersistor persistor,
                                  org.knime.core.node.workflow.NodeID newID)

Creates new meta node from a persistor instance.

Parameters:

persistor - to read from

newID - new id to be used

Returns:

newly created WorkflowManager

addConnection

public ConnectionContainer addConnection(org.knime.core.node.workflow.NodeID source,
                                         int sourcePort,
                                         org.knime.core.node.workflow.NodeID dest,
                                         int destPort)

Add new connection - throw Exception if the same connection already exists.

Parameters:

source - node id

sourcePort - port index at source node

dest - destination node id

destPort - port index at destination node

Returns:

newly created Connection object

Throws:

IllegalArgumentException - if connection already exists

canAddConnection

public boolean canAddConnection(org.knime.core.node.workflow.NodeID source,
                                int sourcePort,
                                org.knime.core.node.workflow.NodeID dest,
                                int destPort)

Check if a new connection can be added.

Parameters:

source - node id

sourcePort - port index at source node

dest - destination node id

destPort - port index at destination node

Returns:

true if connection can be added.

canRemoveConnection

public boolean canRemoveConnection(ConnectionContainer cc)

Check if a connection can safely be removed.

Parameters:

cc - connection

Returns:

true if connection cc is removable.

removeConnection

public void removeConnection(ConnectionContainer cc)

Remove connection.

Parameters:

cc - connection

getOutgoingConnectionsFor

public Set<ConnectionContainer> getOutgoingConnectionsFor(org.knime.core.node.workflow.NodeID id,
                                                          int portIdx)

Returns the set of outgoing connections for the node with the passed id at the specified port.

Parameters:

id - id of the node of interest

portIdx - port index of that node

Returns:

all outgoing connections for the passed node at the specified port

getOutgoingConnectionsFor

public Set<ConnectionContainer> getOutgoingConnectionsFor(org.knime.core.node.workflow.NodeID id)

Get all outgoing connections for a node.

Parameters:

id - The requested node

Returns:

All current outgoing connections in a new set.

Throws:

IllegalArgumentException - If the node is unknown or null.

getIncomingConnectionFor

public ConnectionContainer getIncomingConnectionFor(org.knime.core.node.workflow.NodeID id,
                                                    int portIdx)

Returns the incoming connection of the node with the passed node id at the specified port.

Parameters:

id - id of the node of interest

portIdx - port index

Returns:

incoming connection at that port of the given node or null if it doesn't exist

getIncomingConnectionsFor

public Set<ConnectionContainer> getIncomingConnectionsFor(org.knime.core.node.workflow.NodeID id)

Get all incoming connections for a node.

Parameters:

id - The requested node

Returns:

All current incoming connections in a new set.

Throws:

IllegalArgumentException - If the node is unknown or null.

getConnection

public ConnectionContainer getConnection(ConnectionID id)

Gets a connection by id.

Parameters:

id - of the connection to return

Returns:

the connection with the specified id

loadNodeSettings

public void loadNodeSettings(org.knime.core.node.workflow.NodeID id,
                             NodeSettingsRO settings)
                      throws org.knime.core.node.InvalidSettingsException

Load Settings into specified node.

Parameters:

id - of node

settings - to be load by node

Throws:

org.knime.core.node.InvalidSettingsException - if settings are wrong

IllegalArgumentException - if node does not exist

saveNodeSettings

public void saveNodeSettings(org.knime.core.node.workflow.NodeID id,
                             NodeSettingsWO settings)
                      throws org.knime.core.node.InvalidSettingsException

write node settings into Settings object.

Parameters:

id - of node

settings - to be saved to

Throws:

org.knime.core.node.InvalidSettingsException - thrown if nonsense is written

markForExecutionNodesInWFMConnectedToInPorts

void markForExecutionNodesInWFMConnectedToInPorts(Set<Integer> inPorts,
                                                  boolean markExecutedNodes)

Mark all nodes in this workflow that are connected to the given inports. Note that this routine will NOT trigger any actions connected to possible outports of this WFM.

Parameters:

inPorts - set of port indices of the WFM.

markExecutedNodes - if true also (re)mark executed nodes.

reconfigureAllNodesOnlyInThisWFM

void reconfigureAllNodesOnlyInThisWFM()

Re-configure all configured (NOT executed) nodes in this workflow to make sure that new workflow variables are spread accordingly. Note that this does NOT affect any successors of this workflow manager but touches all nodes inside this wfm and its kids.

resetAndReconfigureAllNodesInWFM

void resetAndReconfigureAllNodesInWFM()

Reset all executed nodes in this workflow to make sure that new workflow variables are spread accordingly. If a node is already reset (or we just reset it), also configure it. Note that this does NOT affect any successors of this workflow manager but touches all nodes inside this wfm and its kids. TODO Maybe redundant: call resetAllNodes... and then configure them (only called when WorkflowVariables are set)

resetAll

@Deprecated
public void resetAll()

Deprecated. Use resetAndConfigureAll() instead

Resets and freshly configures all nodes in this workflow.

resetAndConfigureAll

public void resetAndConfigureAll()

Resets and freshly configures all nodes in this workflow.

resetAllNodesInWFM

void resetAllNodesInWFM()

Reset all nodes in this workflow. Note that this routine will NOT trigger any resets connected to possible outports of this WFM.

resetNodesInWFMConnectedToInPorts

void resetNodesInWFMConnectedToInPorts(Set<Integer> inPorts)

Reset all nodes in this workflow that are connected to the given inports. The reset is performed in the correct order, that is last nodes are reset first. Note that this routine will NOT trigger any resets connected to possible outports of this WFM.

Parameters:

inPorts - set of port indices of the WFM.

cleanOutputPortsInWFMConnectedToInPorts

void cleanOutputPortsInWFMConnectedToInPorts(Set<Integer> inPorts)

Clean outports of nodes connected to set of input ports. Used while restarting the loop, whereby the loop body is not to be reset (special option in start nodes). Clearing is done in correct order: downstream nodes first.

Parameters:

inPorts - set of port indices of the WFM.

executeUpToHere

public void executeUpToHere(org.knime.core.node.workflow.NodeID... ids)

mark these nodes and all not-yet-executed predecessors for execution. They will be marked first, queued when all inputs are available and finally executed.

Parameters:

ids - node ids to mark

doBeforePreExecution

boolean doBeforePreExecution(NodeContainer nc)

Callback from NodeContainer to request a safe transition into the NodeContainer.State.PREEXECUTE state. This method is mostly only called with SingleNodeContainer as argument but may also be called with a remotely executed meta node.

Parameters:

nc - node whose execution is about to start

Returns:

whether there was an actual state transition, false if the execution was canceled (cancel checking to be done in synchronized block)

doBeforePostExecution

void doBeforePostExecution(NodeContainer nc)

Callback from NodeContainer to request a safe transition into the NodeContainer.State.POSTEXECUTE state. This method is mostly only called with SingleNodeContainer as argument but may also be called with a remotely executed meta node.

Parameters:

nc - node whose execution is ending (and is now copying result data, e.g.)

doBeforeExecution

void doBeforeExecution(NodeContainer nc)

Call-back from NodeContainer called before node is actually executed. The argument node is in usually a SingleNodeContainer, although it can also be a meta node (i.e. a WorkflowManager), which is executed remotely (execution takes place as a single operation).

Parameters:

nc - node whose execution is about to start

Throws:

IllegalFlowObjectStackException - If loop end nodes have problems identifying their start node

doAfterExecution

void doAfterExecution(NodeContainer nc,
                      NodeContainerExecutionStatus status)

Cleanup a node after execution. This will also permit the argument node to change its state in performStateTransitionEXECUTED(NodeContainerExecutionStatus). This method also takes care of restarting loops, if there are any to be continued.

As in doBeforeExecution(NodeContainer) the argument node is usually a SingleNodeContainer but can also be a remotely executed WorkflowManager.

Parameters:

nc - node which just finished execution

status - indicates if node execution was finished successfully (note that this does not imply State=EXECUTED e.g. for loop ends)

canExpandMetaNode

public String canExpandMetaNode(org.knime.core.node.workflow.NodeID wfmID)

Check if we can expand the selected metanode into a set of nodes in this WFM. This essentially checks if the nodes can be moved (=deleted from the original WFM) or if they are executed

Parameters:

orgID - the id of the metanode to be expanded

Returns:

null of ok otherwise reason (String) why not

expandMetaNode

public org.knime.core.node.workflow.NodeID[] expandMetaNode(org.knime.core.node.workflow.NodeID wfmID)
                                                     throws IllegalArgumentException

Expand the selected metanode into a set of nodes in this WFM and remove the old metanode.

Parameters:

orgID - the id of the metanode to be expanded

Throws:

IllegalArgumentException - if expand can not be done

canCollapseNodesIntoMetaNode

public String canCollapseNodesIntoMetaNode(org.knime.core.node.workflow.NodeID[] orgIDs)

Check if we can collapse selected set of nodes into a metanode. This essentially checks if the nodes can be moved (=deleted from the original WFM), if they are executed, or if moving them would result in cycles in the original WFM (outgoing connections fed back into inports of the new Metanode).

Parameters:

orgIDs - the ids of the nodes to be moved to the new metanode.

Returns:

null or reason why this can not be done as string.

collapseNodesIntoMetaNode

public WorkflowManager collapseNodesIntoMetaNode(org.knime.core.node.workflow.NodeID[] orgIDs,
                                                 String name)
                                          throws IllegalArgumentException

Collapse selected set of nodes into a metanode. Make sure connections from and two nodes not contained in this set are passed through appropriate ports of the new metanode.

Parameters:

orgIDs - the ids of the nodes to be moved to the new metanode.

name - of the new metanode

Returns:

newly create metanode

Throws:

IllegalArgumentException - if collapse can not be done

isResetable

boolean isResetable()

check if node can be safely reset. In case of a WFM we will check if one of the internal nodes can be reset and none of the nodes are "in progress".

Specified by:

isResetable in class NodeContainer

Returns:

if all internal nodes can be reset.

canPerformReset

boolean canPerformReset()

Specified by:

canPerformReset in class NodeContainer

Returns:

true if this node is executed or contains executed nodes.

markForExecution

void markForExecution(boolean flag)

Enable (or disable) queuing of underlying node for execution. This really only changes the state of the node and once all pre-conditions for execution are fulfilled (e.g. configuration succeeded and all ingoing objects are available) the node will be actually queued.

Specified by:

markForExecution in class NodeContainer

Parameters:

flag - determines if node is marked or unmarked for execution

mimicRemoteExecuting

void mimicRemoteExecuting()

Marks this node as remotely executing. This is necessary if the entire (sub-) flow that this node is part of is executed remotely.

Specified by:

mimicRemoteExecuting in class NodeContainer

mimicRemotePreExecute

void mimicRemotePreExecute()

Puts this node (and all its children) into the NodeContainer.State.PREEXECUTE state. This method is used when a workflow is executed remotely.

Specified by:

mimicRemotePreExecute in class NodeContainer

mimicRemotePostExecute

void mimicRemotePostExecute()

Puts this node (and all its children) into the NodeContainer.State.POSTEXECUTE state. This method is used when a workflow is executed remotely.

Specified by:

mimicRemotePostExecute in class NodeContainer

mimicRemoteExecuted

void mimicRemoteExecuted(NodeContainerExecutionStatus status)

Put this node into either the NodeContainer.State.EXECUTED or NodeContainer.State.IDLE state depending on the argument. This method is applied recursively on all of this node's children (if a meta node).

Specified by:

mimicRemoteExecuted in class NodeContainer

Parameters:

status - Where to get the success flag from.

performStateTransitionPREEXECUTE

boolean performStateTransitionPREEXECUTE()

Called when the state of a node should switch from NodeContainer.State.QUEUED to NodeContainer.State.PREEXECUTE. The method is to be called from the node's parent in a synchronized environment.

Specified by:

performStateTransitionPREEXECUTE in class NodeContainer

Returns:

whether there was an actual state transition, false if the execution was canceled (cancel checking to be done in synchronized block)

performStateTransitionEXECUTING

void performStateTransitionEXECUTING()

This should be used to change the nodes states correctly (and likely needs to be synchronized with other changes visible to successors of this node as well!) BEFORE the actual execution. The main reason is that the actual execution should be performed unsynchronized!

Specified by:

performStateTransitionEXECUTING in class NodeContainer

performStateTransitionPOSTEXECUTE

void performStateTransitionPOSTEXECUTE()

Called when the state of a node should switch from NodeContainer.State.EXECUTING (or NodeContainer.State.EXECUTINGREMOTELY) to NodeContainer.State.POSTEXECUTE. The method is to be called from the node's parent in a synchronized environment.

Specified by:

performStateTransitionPOSTEXECUTE in class NodeContainer

performStateTransitionEXECUTED

void performStateTransitionEXECUTED(NodeContainerExecutionStatus status)

This should be used to change the nodes states correctly (and likely needs to be synchronized with other changes visible to successors of this node as well!) AFTER the actual execution. The main reason is that the actual execution should be performed unsynchronized!

Specified by:

performStateTransitionEXECUTED in class NodeContainer

Parameters:

status - indicates if execution was successful

canResetNode

public boolean canResetNode(org.knime.core.node.workflow.NodeID nodeID)

Check if a node can be reset, meaning that it is executed and all of its successors are idle or executed as well. We do not want to mess with executing chains.

Parameters:

nodeID - the id of the node

Returns:

true if the node can safely be reset.

invokeResetOnPortSuccessors

void invokeResetOnPortSuccessors(int inportIndex)

Reset those nodes which are connected to a specific workflow incoming port.

Parameters:

inportIndex - index of port.

resetAndConfigureNode

public void resetAndConfigureNode(org.knime.core.node.workflow.NodeID id)

Reset node and all executed successors of a specific node.

Parameters:

id - of first node in chain to be reset.

canExecuteNode

public boolean canExecuteNode(org.knime.core.node.workflow.NodeID nodeID)

Check if a node can be executed directly.

Parameters:

nodeID - id of node

Returns:

true of node is configured and all immediate predecessors are executed.

canCancelNode

public boolean canCancelNode(org.knime.core.node.workflow.NodeID nodeID)

Check if a node can be cancelled individually.

Parameters:

nodeID - id of node

Returns:

true if node can be cancelled

cancelExecution

void cancelExecution()

Cancel execution of a marked, queued, or executing node. (Tolerate execute as this may happen throughout cancelation).

Specified by:

cancelExecution in class NodeContainer

cancelExecution

public void cancelExecution(NodeContainer nc)

Cancel execution of the given NodeContainer.

Parameters:

nc - node to be canceled

pauseLoopExecution

public void pauseLoopExecution(NodeContainer nc)

Pause loop execution of the given NodeContainer (=loop end).

Parameters:

nc - node to be canceled

resumeLoopExecution

public void resumeLoopExecution(NodeContainer nc,
                                boolean oneStep)

Resume operation of a paused loop. Depending on the flag we either step (= run only one iteration and pause again) or run until the loop is finished.

Parameters:

nc -

canSetJobManager

public boolean canSetJobManager(org.knime.core.node.workflow.NodeID nodeID)

Is the node with the given ID ready to take a new job manager. This is generally true if the node is currently not executing.

Parameters:

nodeID - The node in question.

Returns:

Whether it's save to invoke the setJobManager(NodeID, NodeExecutionJobManager) method.

setJobManager

public void setJobManager(org.knime.core.node.workflow.NodeID nodeID,
                          NodeExecutionJobManager jobMgr)

Sets a new job manager on the node with the given ID.

Parameters:

nodeID - The node in question.

jobMgr - The new job manager (may be null to use parent's one).

Throws:

IllegalStateException - If the node is not ready

IllegalArgumentException - If the node is unknown

See Also:

canSetJobManager(NodeID)

shutdown

public void shutdown()

Attempts to cancel or running nodes in preparation for a removal of this node (or its parent) from the root. Executing nodes, which can be disconnected from the execution (e.g. remote cluster execution) are disconnected if their status has been saved before.

performShutdown

void performShutdown()

Called when the workflow is to be disposed. It will cancel this node if it is still running. If this node is being executed remotely (cluster execution) and has been saved, it will just disconnect it.

Overrides:

performShutdown in class NodeContainer

executeAllAndWaitUntilDone

public boolean executeAllAndWaitUntilDone()

Convenience method: execute all and wait for execution to be done.

Returns:

true if execution was successful

waitWhileInExecution

public boolean waitWhileInExecution(long time,
                                    TimeUnit unit)
                             throws InterruptedException

Causes the current thread to wait until the the workflow has reached a non-executing state unless a given timeout elapsed.

Parameters:

time - the maximum time to wait (0 or negative for waiting infinitely)

unit - the time unit of the time argument

Returns:

false if the waiting time detectably elapsed before return from the method, else true. It returns true if the time argument is 0 or negative.

Throws:

InterruptedException - if the current thread is interrupted

executeAll

public void executeAll()

Convenience method: (Try to) Execute all nodes in the workflow. This method returns immediately, leaving it to the associated executor to do the job.

continueExecutionOnLoad

boolean continueExecutionOnLoad(NodeContainer nc,
                                NodeContainerPersistor persistor)
                          throws org.knime.core.node.InvalidSettingsException,
                                 NodeExecutionJobReconnectException

Throws:

org.knime.core.node.InvalidSettingsException

NodeExecutionJobReconnectException

hasDialog

public boolean hasDialog()

Specified by:

hasDialog in class NodeContainer

getDialogPaneWithSettings

NodeDialogPane getDialogPaneWithSettings(PortObjectSpec[] inSpecs)
                                   throws NotConfigurableException

Specified by:

getDialogPaneWithSettings in class NodeContainer

Throws:

NotConfigurableException

getDialogPane

NodeDialogPane getDialogPane()

Specified by:

getDialogPane in class NodeContainer

areDialogAndNodeSettingsEqual

public boolean areDialogAndNodeSettingsEqual()

Specified by:

areDialogAndNodeSettingsEqual in class NodeContainer

getGlobalTableRepository

HashMap<Integer,ContainerTable> getGlobalTableRepository()

Returns:

global table repository for this WFM.

assembleInputSpecs

void assembleInputSpecs(org.knime.core.node.workflow.NodeID id,
                        PortObjectSpec[] inSpecs)

Fill array holding all input specs for the given node.

Parameters:

id - of node

inSpecs - return array for specs of all predecessors

printNodeSummary

public String printNodeSummary(org.knime.core.node.workflow.NodeID prefix,
                               int indent)

Produce summary of node.

Parameters:

prefix - if containing node/workflow

indent - number of leading spaces

Returns:

string

toString

public String toString()

Overrides:

toString in class NodeContainer

Returns:

Node name with status information.

getNodeContainers

public Collection<NodeContainer> getNodeContainers()

Returns:

collection of NodeContainers in this WFM

getConnectionContainers

public Collection<ConnectionContainer> getConnectionContainers()

Returns:

collection of ConnectionContainer in this WFM

getNodeContainer

public NodeContainer getNodeContainer(org.knime.core.node.workflow.NodeID id)

Parameters:

id - node ID

Returns:

NodeContainer for given ID

containsNodeContainer

public boolean containsNodeContainer(org.knime.core.node.workflow.NodeID id)

Does the workflow contain a node with the argument id?

Parameters:

id - The id in question.

Returns:

true if there is node with the given id, false otherwise.

containsExecutedNode

public boolean containsExecutedNode()

Returns:

true if this workflow or its child workflows contain at least one executed node.

getNodeErrorMessages

public List<org.knime.core.node.workflow.NodeMessage> getNodeErrorMessages()

Returns:

list of errors messages (list empty if none exist).

isWriteProtected

public boolean isWriteProtected()

Is this workflow represents a linked meta node (locked for edit). This flag is only a hint for the UI -- non of the add/remove operations will read this flag.

Returns:

Whether edit operations are not permitted.

getTemplateInformation

public MetaNodeTemplateInformation getTemplateInformation()

Returns:

the templateInformation

setTemplateInformation

void setTemplateInformation(MetaNodeTemplateInformation tI)

Set new template info (not null!), fire events.

Parameters:

tI - the new templateInformation

checkUpdateMetaNodeLink

public boolean checkUpdateMetaNodeLink(org.knime.core.node.workflow.NodeID id,
                                       WorkflowLoadHelper loadHelper)
                                throws IOException

Query the template to the linked meta node with the given ID and check whether a newer version is available.

Parameters:

id - The ID of the linked meta node

loadHelper - The load helper to load the template

Returns:

true if a newer revision is available, false if not or this is not a meta node link.

Throws:

IOException - If that fails (template not accessible)

canUpdateMetaNodeLink

public boolean canUpdateMetaNodeLink(org.knime.core.node.workflow.NodeID id)

Returns true if the argument node is a valid meta node link and is not executing and has no successor in execution. Used from the GUI to enable or disable the update action. It does not test whether there is a newer version of the meta node available. It may also return true even if the meta node is executed or contains executed nodes.

Parameters:

id - The meta node in question.

Returns:

The above described property.

updateMetaNodeLink

public WorkflowPersistor.MetaNodeLinkUpdateResult updateMetaNodeLink(org.knime.core.node.workflow.NodeID id,
                                                                     ExecutionMonitor exec,
                                                                     WorkflowLoadHelper loadHelper)
                                                              throws CanceledExecutionException

Update link meta nodes with the given ID.

Parameters:

id - The ids of the meta node (must be existing meta node and must be a link).

exec - The execution monitor used to load a copy of the template

loadHelper - A load helper.

Returns:

The load result of the newly inserted link copy.

Throws:

CanceledExecutionException - If canceled

IllegalArgumentException - If the node does not exist or is not a meta node.

saveAsMetaNodeTemplate

public MetaNodeTemplateInformation saveAsMetaNodeTemplate(File directory,
                                                          ExecutionMonitor exec)
                                                   throws IOException,
                                                          CanceledExecutionException,
                                                          LockFailedException

Throws:

IOException

CanceledExecutionException

LockFailedException

setTemplateInformation

public MetaNodeTemplateInformation setTemplateInformation(org.knime.core.node.workflow.NodeID id,
                                                          MetaNodeTemplateInformation templateInformation)

Sets the argument template info on the node with the given ID. The node must be a valid meta node contained in this workflow.

Parameters:

id - The id of the node to change (must be an existing meta node).

templateInformation - the templateInformation to set

Returns:

The old template info associated with the node.

Throws:

NullPointerException - If either argument is null.

IllegalArgumentException - If the id does not represent a valid meta node.

addListener

public void addListener(WorkflowListener listener)

Add listener to list.

Parameters:

listener - new listener

removeListener

public void removeListener(WorkflowListener listener)

Remove listener.

Parameters:

listener - listener to be removed

notifyNodePropertyChangedListener

protected void notifyNodePropertyChangedListener(NodePropertyChangedEvent.NodeProperty property)

Overrides:

notifyNodePropertyChangedListener in class NodeContainer

getCopyPersistor

protected NodeContainerPersistor getCopyPersistor(HashMap<Integer,ContainerTable> tableRep,
                                                  boolean preserveDeletableFlags,
                                                  boolean isUndoableDeleteCommand)

Get a new persistor that is used to copy this node (copy&paste action).

Specified by:

getCopyPersistor in class NodeContainer

Parameters:

tableRep - Table repository of the destination.

preserveDeletableFlags - Whether the "isdeleteable" annotation should be copied also (false when individual nodes are copied but true when an entire meta node is copied).

isUndoableDeleteCommand - If to keep the location of the node directories (important for undo of delete commands, see copy(boolean, WorkflowCopyContent) for details.)

Returns:

A new persistor for copying.

copyFromAndPasteHere

public WorkflowCopyContent copyFromAndPasteHere(WorkflowManager sourceManager,
                                                WorkflowCopyContent content)

Copies the nodes with the given ids from the argument workflow manager into this wfm instance. All nodes wil be reset (and configured id possible). Connections among the nodes are kept.

Parameters:

sourceManager - The wfm to copy from

content - The content to copy (must exist in sourceManager)

Returns:

Inserted NodeIDs and annotations.

copy

public WorkflowPersistor copy(WorkflowCopyContent content)

Copy the given content.

Parameters:

content - The content to copy (must exist).

Returns:

A workflow persistor hosting the node templates, ready to be used in the paste(WorkflowPersistor) method.

copy

public WorkflowPersistor copy(boolean isUndoableDeleteCommand,
                              WorkflowCopyContent content)

Copy the nodes with the given ids.

Parameters:

isUndoableDeleteCommand - True if the returned persistor is used in the delete command (which supports undo). This has two effects:

1. It keeps the locations of the node's directories (e.g. <workflow>/File Reader (#xy)/). This is true if the copy serves as backup of an undoable delete command (undoable = undo enabled). If it is undone, the directories must not be cleared before the next save (in order to keep the drop folder)
2. The returned persistor will insert a reference to the contained workflow annotations instead of copying them (enables undo on previous move or edit commands.

content - The content to copy (must exist).

Returns:

A workflow persistor hosting the node templates, ready to be used in the paste(WorkflowPersistor) method.

paste

public WorkflowCopyContent paste(WorkflowPersistor persistor)

Pastes the contents of the argument persistor into this wfm.

Parameters:

persistor - The persistor created with copy(WorkflowCopyContent) method.

Returns:

The new node ids of the inserted nodes and the annotations in a dedicated object.

getWorkingDir

public ReferencedFile getWorkingDir()

Get working folder associated with this WFM. May be null if not saved yet.

Returns:

working directory.

loadProject

public static WorkflowPersistor.WorkflowLoadResult loadProject(File directory,
                                                               ExecutionMonitor exec,
                                                               WorkflowLoadHelper loadHelper)
                                                        throws IOException,
                                                               org.knime.core.node.InvalidSettingsException,
                                                               CanceledExecutionException,
                                                               UnsupportedWorkflowVersionException,
                                                               LockFailedException

Throws:

IOException

org.knime.core.node.InvalidSettingsException

CanceledExecutionException

UnsupportedWorkflowVersionException

LockFailedException

createExecutionResult

public WorkflowExecutionResult createExecutionResult(ExecutionMonitor exec)
                                              throws CanceledExecutionException

Saves all internals that are necessary to mimic the computed result into a new execution result object. This method is called on node instances, which are, e.g. executed on a server and later on read back into a true KNIME instance (upon which #loadExecutionResult(NodeContainerExecutionResult, ExecutionMonitor, LoadResult) is called).

Specified by:

createExecutionResult in class NodeContainer

Parameters:

exec - For progress information (this method will copy port objects).

Returns:

A new execution result instance.

Throws:

CanceledExecutionException - If canceled.

loadExecutionResult

public void loadExecutionResult(NodeContainerExecutionResult result,
                                ExecutionMonitor exec,
                                WorkflowPersistor.LoadResult loadResult)

Load information from execution result. Subclasses will override this method and will call this implementation as super.loadEx....

Overrides:

loadExecutionResult in class NodeContainer

Parameters:

result - The execution result (contains port objects, messages, etc)

exec - For progress information (no cancelation supported)

loadResult - A load result that contains, e.g. error messages.

createLoadPersistor

public static WorkflowPersistorVersion1xx createLoadPersistor(File directory,
                                                              WorkflowLoadHelper loadHelper)
                                                       throws IOException,
                                                              UnsupportedWorkflowVersionException

Throws:

IOException

UnsupportedWorkflowVersionException

load

public WorkflowPersistor.WorkflowLoadResult load(File directory,
                                                 ExecutionMonitor exec,
                                                 WorkflowLoadHelper loadHelper,
                                                 boolean keepNodeMessages)
                                          throws IOException,
                                                 org.knime.core.node.InvalidSettingsException,
                                                 CanceledExecutionException,
                                                 UnsupportedWorkflowVersionException,
                                                 LockFailedException

Loads the workflow contained in the directory as node into this workflow instance. Loading a whole new project is usually done using loadProject(File, ExecutionMonitor, WorkflowLoadHelper) .

Parameters:

directory - to load from

exec - For progress/cancellation (currently not supported)

loadHelper - callback to load credentials and such (if available) during load of the underlying SingleNodeContainer (may be null).

keepNodeMessages - Whether to keep the messages that are associated with the nodes in the loaded workflow (mostly false but true when remotely computed results are loaded).

Returns:

A workflow load result, which also contains the loaded workflow.

Throws:

IOException - If errors reading the "important" files fails due to I/O problems (file not present, e.g.)

org.knime.core.node.InvalidSettingsException - If parsing the "important" files fails.

CanceledExecutionException - If canceled.

UnsupportedWorkflowVersionException - If the version of the workflow is unknown (future version)

LockFailedException - if the flow can't be locked for opening

load

public WorkflowPersistor.WorkflowLoadResult load(WorkflowPersistorVersion1xx persistor,
                                                 ExecutionMonitor exec,
                                                 boolean keepNodeMessages)
                                          throws IOException,
                                                 org.knime.core.node.InvalidSettingsException,
                                                 CanceledExecutionException,
                                                 UnsupportedWorkflowVersionException

Loads the content of the argument persistor into this node.

Parameters:

persistor - The persistor containing the node(s) to be loaded as children to this node.

exec - For progress/cancellation (currently not supported)

keepNodeMessages - Whether to keep the messages that are associated with the nodes in the loaded workflow (mostly false but true when remotely computed results are loaded).

Returns:

A workflow load result, which also contains the loaded node(s).

Throws:

IOException - If errors reading the "important" files fails due to I/O problems (file not present, e.g.)

org.knime.core.node.InvalidSettingsException - If parsing the "important" files fails.

CanceledExecutionException - If canceled.

UnsupportedWorkflowVersionException - If the version of the workflow is unknown (future version)

loadContent

WorkflowCopyContent loadContent(NodeContainerPersistor nodePersistor,
                                Map<Integer,BufferedDataTable> tblRep,
                                FlowObjectStack ignoredStack,
                                ExecutionMonitor exec,
                                WorkflowPersistor.LoadResult loadResult,
                                boolean preserveNodeMessage)
                          throws CanceledExecutionException

Restore content from persistor. This represents the second step when loading a workflow.

Specified by:

loadContent in class NodeContainer

Parameters:

nodePersistor - To load from.

tblRep - A table repository to restore BufferedDatTables

ignoredStack - Incoming FlowObjectStack.

exec - For progress

loadResult - Where to report errors/warnings to

preserveNodeMessage - Whether possible node messages in the persistor are to be preserved (parameter to configure method that is called during load).

Returns:

The workflow content that was inserted (NodeID's and annotations), for single node containers the result is null.

Throws:

CanceledExecutionException - If canceled.

save

public void save(File directory,
                 ExecutionMonitor exec,
                 boolean isSaveData)
          throws IOException,
                 CanceledExecutionException,
                 LockFailedException

Throws:

IOException

CanceledExecutionException

LockFailedException

deleteObsoleteNodeDirs

void deleteObsoleteNodeDirs()

Delete directories of removed nodes. This is part of the save routine to commit the changes. Called from the saving persistor class

sweep

boolean sweep(boolean propagate)

Performs sanity check on workflow. This is necessary upon load.

Parameters:

propagate - Whether to also reflect state changes in our parent

Returns:

Whether everything was clean before (if false is returned, something was wrong).

isLocalWFM

protected boolean isLocalWFM()

Is this node a to be locally executed workflow. In contrast to remotely executed workflows, the nodes in the encapsulated workflow will be executed independently (each represented by an own job), whereas remote execution means that the entire workflow execution is one single job.

This method returns false for all single node container.

Specified by:

isLocalWFM in class NodeContainer

Returns:

The above described property.

setDirty

public void setDirty()

Mark this node container to be changed, that is, it needs to be saved.

Overrides:

setDirty in class NodeContainer

getNrInPorts

public int getNrInPorts()

Specified by:

getNrInPorts in class NodeContainer

getInPort

public WorkflowInPort getInPort(int index)

Specified by:

getInPort in class NodeContainer

getOutPort

public WorkflowOutPort getOutPort(int index)

Specified by:

getOutPort in class NodeContainer

getNrOutPorts

public int getNrOutPorts()

Specified by:

getNrOutPorts in class NodeContainer

setName

public void setName(String name)

Set new name of this workflow or null to reset the name (will then return the workflow directory in getName() or null if this flow has not been saved yet).

Parameters:

name - The new name or null

renameWorkflowDirectory

public boolean renameWorkflowDirectory(String newName)

Renames the underlying workflow directory to the new name.

Parameters:

newName - The name of the directory.

Returns:

Whether that was successful.

Throws:

IllegalStateException - If the workflow has not been saved yet (has no corresponding node directory).

getCredentialsStore

public CredentialsStore getCredentialsStore()

Get reference to credentials store used to persist name/passwords.

Returns:

password store associated with this workflow/meta-node.

updateCredentials

public void updateCredentials(Credentials... credentialsList)

Update user/password fields in the credentials store assigned to the workflow and update the node configuration.

Parameters:

credentialsList - the list of credentials to be updated. It will find matching crendentials in this workflow and update their fields.

Throws:

IllegalArgumentException - If any of the credentials is unknown

getName

public String getName()

Get the name of the workflow. If none has been set, a name is derived from the workflow directory name. If no directory has been set, a static string is returned. This method never returns null.

Specified by:

getName in class NodeContainer

getNameField

public String getNameField()

Returns:

the name set in the constructor or via setName(String). In comparison to getName() this method does not use the workflow directory name if no other name is set.

getNrNodeViews

public int getNrNodeViews()

Returns the number of views provided by the node implementation.

Specified by:

getNrNodeViews in class NodeContainer

Returns:

the number of views provided by the node implementation

getNodeView

public NodeView<NodeModel> getNodeView(int i)

Return the view with the specified index provided by the node.

Specified by:

getNodeView in class NodeContainer

Parameters:

i - the view to create

Returns:

a new view instance with index i provided by the node

getNodeViewName

public String getNodeViewName(int i)

Specified by:

getNodeViewName in class NodeContainer

loadSettings

void loadSettings(NodeSettingsRO settings)
            throws org.knime.core.node.InvalidSettingsException

Overrides:

loadSettings in class NodeContainer

Throws:

org.knime.core.node.InvalidSettingsException

saveSettings

void saveSettings(NodeSettingsWO settings)

Overrides:

saveSettings in class NodeContainer

areSettingsValid

boolean areSettingsValid(NodeSettingsRO settings)

Overrides:

areSettingsValid in class NodeContainer

getType

public NodeFactory.NodeType getType()

Specified by:

getType in class NodeContainer

getIcon

public URL getIcon()

Specified by:

getIcon in class NodeContainer

cleanup

void cleanup()

Method that's called when the node is discarded. The single node container overwrites this method and cleans the outport data of the node (deletes temp files).

Overrides:

cleanup in class NodeContainer

setNodeContainerDirectory

protected void setNodeContainerDirectory(ReferencedFile directory)

Overrides:

setNodeContainerDirectory in class NodeContainer

Parameters:

directory - the nodeContainerDirectory to set

getNrWorkflowIncomingPorts

public int getNrWorkflowIncomingPorts()

getNrWorkflowOutgoingPorts

public int getNrWorkflowOutgoingPorts()

getWorkflowIncomingPort

public NodeOutPort getWorkflowIncomingPort(int i)

getWorkflowOutgoingPort

public NodeInPort getWorkflowOutgoingPort(int i)

setInPortsBarUIInfo

public void setInPortsBarUIInfo(UIInformation inPortsBarUIInfo)

Set UI information for workflow's input ports (typically aligned as a bar).

Parameters:

inPortsBarUIInfo - The new UI info.

setOutPortsBarUIInfo

public void setOutPortsBarUIInfo(UIInformation outPortsBarUIInfo)

Set UI information for workflow's output ports (typically aligned as a bar).

Parameters:

outPortsBarUIInfo - The new UI info.

getInPortsBarUIInfo

public UIInformation getInPortsBarUIInfo()

Get UI information for workflow input ports.

Returns:

the ui info or null if not set.

See Also:

setInPortsBarUIInfo(UIInformation)

getOutPortsBarUIInfo

public UIInformation getOutPortsBarUIInfo()

Get UI information for workflow output ports.

Returns:

the ui info or null if not set.

See Also:

setOutPortsBarUIInfo(UIInformation)

getWorkflowVariables

public List<FlowVariable> getWorkflowVariables()

Get read-only access on the current workflow variables.

Returns:

the current workflow variables, never null.

addWorkflowVariables

public void addWorkflowVariables(boolean skipReset,
                                 FlowVariable... newVars)

Set new workflow variables. All nodes within this workflow will have access to these variables. The method may change in future versions or removed entirely (bug 1937).

Parameters:

newVars - new variables to be set

skipReset - if false the workflow will be re-configured

getWorkflowAnnotations

public Collection<WorkflowAnnotation> getWorkflowAnnotations()

Returns:

read-only collection of all currently registered annotations.

addWorkflowAnnotation

public void addWorkflowAnnotation(WorkflowAnnotation annotation)

Add new workflow annotation, fire events.

Parameters:

annotation - to add

Throws:

IllegalArgumentException - If annotation already registered.

removeAnnotation

public void removeAnnotation(WorkflowAnnotation annotation)

Remove workflow annotation, fire events.

Parameters:

annotation - to remove

Throws:

IllegalArgumentException - If annotation is not registered.

nodeUIInformationChanged

public void nodeUIInformationChanged(NodeUIInformationEvent evt)

Listener to annotations, etc; sets content dirty.

Specified by:

nodeUIInformationChanged in interface NodeUIInformationListener

Parameters:

evt - Change event.

castNodeModel

public <T> T castNodeModel(org.knime.core.node.workflow.NodeID id,
                           Class<T> cl)

Retrieves the node with the given ID, fetches the underlying NodeModel and casts it to the argument class.

Type Parameters:

T - The type the class

Parameters:

id - The node of interest

cl - The class object the underlying NodeModel needs to implement

Returns:

The casted node model.

Throws:

IllegalArgumentException - If the node does not exist, is not a SingleNodeContainer or the model does not implement the requested type.

findNodes

public <T> Map<org.knime.core.node.workflow.NodeID,T> findNodes(Class<T> nodeModelClass,
                                                                boolean recurse)

Find all nodes in this workflow, whose underlying NodeModel is of the requested type. Intended purpose is to allow certain extensions (reporting, web service, ...) access to specialized nodes.

Type Parameters:

T - Specific NodeModel derivation or another interface implemented by NodeModel instances.

Parameters:

nodeModelClass - The class of interest

recurse - Whether to recurse into contained meta nodes.

Returns:

A (unsorted) list of nodes matching the class criterion

removeWorkflowVariable

public void removeWorkflowVariable(String name)

Remove workflow variable of given name. The method may change in future versions or removed entirely (bug 1937).

Parameters:

name - of variable to be removed.