| /* |
| * 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. |
| */ |
| |
| import Ember from 'ember'; |
| import Constants from '../utils/constants'; |
| import {FindNodeMixin} from '../domain/findnode-mixin'; |
| import {NodeFactory} from '../domain/node-factory'; |
| import SchemaVersions from '../domain/schema-versions'; |
| import {NodeVisitor} from '../domain/node-visitor'; |
| import {SlaInfo} from '../domain/sla-info'; |
| var Workflow= Ember.Object.extend(FindNodeMixin,{ |
| name:"", |
| startNode:null, |
| globalSetting:null, |
| parameters: null, |
| usePlaceholders: true, |
| killNodes : null, |
| nodeVisitor : null, |
| nodeFactory:NodeFactory.create({}), |
| credentials : Ember.A([]), |
| initialize(){ |
| this.nodeVisitor=NodeVisitor.create({}); |
| var schemaVersions=SchemaVersions.create({}); |
| this.schemaVersions = {}; |
| this.schemaVersions.workflowVersion = schemaVersions.getDefaultVersion('workflow'); |
| this.set("xmlns","uri:oozie:workflow:"+this.schemaVersions.workflowVersion); |
| var actionsMap = new Map(); |
| Constants.actions.forEach((action)=>{ |
| if(action.supportsSchema){ |
| actionsMap.set(action.name, schemaVersions.getDefaultVersion(action.name)); |
| } |
| }); |
| this.schemaVersions.actionVersions = actionsMap; |
| var src =this.nodeFactory.createStartNode(); |
| var dest =this.nodeFactory.createEndNode("end"); |
| this.set("startNode", src); |
| this.set("killNodes",Ember.A([])); |
| this.set("globalSetting",null); |
| this.set("name",""); |
| this.set("draftVersion", "v1"); |
| this.set("parameters", null); |
| this.set("credentials", Ember.A([])); |
| this.set("sla", SlaInfo.create({})); |
| this.appendDefaultKillNode(); |
| src.addTransitionTo(dest); |
| }, |
| appendDefaultKillNode(){ |
| this.createKillNode(Constants.defaultKillNodeName,"${wf:errorMessage(wf:lastErrorNode())}"); |
| }, |
| createKillNode(name, message){ |
| var killNode=this.nodeFactory.createKillNode(name,message); |
| this.get("killNodes").pushObject(killNode); |
| }, |
| resetKillNodes(){ |
| this.set("killNodes",Ember.A([])); |
| }, |
| resetWorfklow(){ |
| //TODO idGen.reset(); |
| this.initialize(); |
| }, |
| |
| findJoinNode(node){ |
| if (node.isDecisionNode()){ |
| return this.findCommonTargetNode(this.startNode,node); |
| }else if (node.isForkNode()) { |
| return node.getDefaultTransitionTarget(); |
| }else{ |
| return null; |
| } |
| }, |
| addBranch(sourceNode){ |
| var target=this.findJoinNode(sourceNode); |
| if (this.get("usePlaceholders")){ |
| var placeholderNode=this.nodeFactory.createPlaceholderNode(target) ; |
| sourceNode.addTransitionTo(placeholderNode); |
| }else{ |
| sourceNode.addTransitionTo(target); |
| } |
| }, |
| addDecisionBranch(settings){ |
| if (!settings.targetNode){ |
| return; |
| } |
| var sourceNode=settings.sourceNode; |
| var insertNodeOnPath=settings.newNodeType?true:false; |
| var target=settings.targetNode; |
| if (!insertNodeOnPath){ |
| if (this.get("usePlaceholders")){ |
| var placeholderNode=this.nodeFactory.createPlaceholderNode(target) ; |
| sourceNode.addTransitionTo(placeholderNode,settings.condition); |
| }else{ |
| sourceNode.addTransitionTo(target,settings.condition); |
| } |
| }else{ |
| //not yet implemented |
| } |
| }, |
| getDefaultKillNode(){ |
| var defaultKillNode = this.get('killNodes').findBy('name',Constants.defaultKillNodeName); |
| return defaultKillNode ? defaultKillNode : this.get('killNodes').objectAt(0); |
| }, |
| generatedNode(target,type,settings){ |
| var generatedNode=null; |
| if ("decision" === type){ |
| generatedNode=this.nodeFactory.generateDecisionNode(target); |
| }else if ("fork" === type){ |
| generatedNode=this.nodeFactory.generateForkNode(target); |
| }else if ("kill" === type){ |
| generatedNode = this.nodeFactory.createKillNode(settings.name); |
| //source.deleteCurrentKillNode();//TODO how to get source... |
| }else{ |
| generatedNode = this.nodeFactory.createActionNode(type); |
| generatedNode.addTransitionTo(target); |
| generatedNode.addTransitionTo(this.getDefaultKillNode(), "error"); |
| } |
| return generatedNode; |
| }, |
| |
| addKillNode(source,settings){ |
| var generatedNode=this.generatedNode(null,"kill",settings); |
| return source.addTransitionTo(generatedNode,"error"); |
| }, |
| addNode(transition,type,settings, id) { |
| var target=transition.targetNode; |
| var computedTarget=target; |
| if (target && target.isPlaceholder()){ |
| computedTarget=target.getTargets()[0]; |
| } |
| var generatedNode=this.generatedNode(computedTarget,type,settings); |
| if(id){ |
| generatedNode.name = generatedNode.name+ "_"+ id; |
| } |
| var sourceNode=transition.source; |
| if (sourceNode && sourceNode.isPlaceholder()) { |
| var orignalTransition=this.findTransitionTo(this.startNode,sourceNode.id); |
| orignalTransition.targetNode=generatedNode; |
| if (orignalTransition.isOnError()){ |
| orignalTransition.source.set("errorNode",generatedNode); |
| } |
| } else { |
| transition.targetNode=generatedNode; |
| if (transition.isOnError()){ |
| transition.source.set("errorNode",generatedNode); |
| } |
| } |
| return generatedNode; |
| }, |
| deleteKillNode(node){ |
| let killNodes = this.get("killNodes"); |
| var killNodeReferenced=false; |
| this.nodeVisitor.process(this.startNode,function(n){ |
| if (n.errorNode && n.errorNode.name===node.name){ |
| killNodeReferenced=true; |
| } |
| }); |
| if (killNodeReferenced){ |
| return{ |
| status: false, |
| message: "Kill node is being referenced by other nodes." |
| }; |
| } |
| for(var i=0; i<killNodes.length; i++){ |
| if(node.id === killNodes[i].id){ |
| this.get("killNodes").removeObject(killNodes[i]); |
| break; |
| } |
| } |
| return { |
| status:true |
| }; |
| }, |
| deleteNode(node,transitionslist){ |
| var self=this; |
| var target=node.getDefaultTransitionTarget(); |
| if (target && !target.isEndNode() && (node.isForkNode()|| node.isDecisionNode())){ |
| target=this.findJoinNode(node); |
| if (!target){//A bug will give target as null if the decision has single path. |
| target=node.getDefaultTransitionTarget(); |
| } |
| if (target.isJoinNode()){ |
| target=target.getDefaultTransitionTarget(); |
| } |
| } |
| transitionslist.forEach(function(tran){ |
| var sourceNode=tran.sourceNode; |
| var joinNode; |
| if (sourceNode.isDecisionNode()){ |
| joinNode=self.findJoinNode(sourceNode); |
| if (joinNode===target){ |
| if (tran.isDefaultCasePath()){ |
| tran.targetNode=self.nodeFactory.createPlaceholderNode(target); |
| }else if (sourceNode.getOkTransitionCount()>2){ |
| sourceNode.removeTransition(tran); |
| }else{ |
| tran.targetNode=self.nodeFactory.createPlaceholderNode(target); |
| } |
| }else{ |
| tran.targetNode=target; |
| } |
| }else if (sourceNode.isForkNode()){ |
| joinNode=self.findJoinNode(sourceNode); |
| if (joinNode===target){ |
| if (sourceNode.getOkTransitionCount()>2){ |
| sourceNode.removeTransition(tran); |
| }else{ |
| tran.targetNode=self.nodeFactory.createPlaceholderNode(target); |
| } |
| }else{ |
| tran.targetNode=target; |
| } |
| }else{ |
| tran.targetNode=target; |
| if (tran.isOnError()){ |
| tran.sourceNode.set("errorNode",target ); |
| } |
| } |
| }); |
| }, |
| deleteTransition(transition){ |
| transition.sourceNode.removeTransition(transition); |
| }, |
| deleteEmptyTransitions(transitionslist){ |
| var self=this; |
| transitionslist.forEach(function(tran){ |
| var sourceNode=this.findNodeById(self.startNode,tran.sourceNodeId); |
| if (sourceNode.isForkNode()&& tran.getTargetNode().isJoinNode()){ |
| sourceNode.removeTransition(tran); |
| } |
| }); |
| }, |
| findTransistionsToNode(matchingNode){ |
| var transitionslist=[]; |
| this.findTransistionsToNodeInternal(this.startNode,matchingNode,transitionslist); |
| return transitionslist; |
| }, |
| findTransistionsToNodeInternal(node,matchingNode,transitionslist){ |
| var self=this; |
| if (node.transitions){ |
| node.transitions.forEach(function(tran){ |
| if (tran.getTargetNode()===matchingNode){ |
| transitionslist.push(tran); |
| } |
| self.findTransistionsToNodeInternal(tran.getTargetNode(),matchingNode,transitionslist); |
| }); |
| } |
| } |
| }); |
| export {Workflow}; |
