001    /**
002     * Licensed to the Apache Software Foundation (ASF) under one
003     * or more contributor license agreements.  See the NOTICE file
004     * distributed with this work for additional information
005     * regarding copyright ownership.  The ASF licenses this file
006     * to you under the Apache License, Version 2.0 (the
007     * "License"); you may not use this file except in compliance
008     * with the License.  You may obtain a copy of the License at
009     *
010     *      http://www.apache.org/licenses/LICENSE-2.0
011     *
012     * Unless required by applicable law or agreed to in writing, software
013     * distributed under the License is distributed on an "AS IS" BASIS,
014     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
015     * See the License for the specific language governing permissions and
016     * limitations under the License.
017     */
018    package org.apache.oozie.workflow.lite;
019    
020    import org.apache.oozie.service.XLogService;
021    import org.apache.oozie.service.DagXLogInfoService;
022    import org.apache.oozie.client.OozieClient;
023    import org.apache.hadoop.io.Writable;
024    import org.apache.hadoop.util.ReflectionUtils;
025    import org.apache.hadoop.conf.Configuration;
026    import org.apache.oozie.workflow.WorkflowApp;
027    import org.apache.oozie.workflow.WorkflowException;
028    import org.apache.oozie.workflow.WorkflowInstance;
029    import org.apache.oozie.util.ParamChecker;
030    import org.apache.oozie.util.XLog;
031    import org.apache.oozie.util.XConfiguration;
032    import org.apache.oozie.ErrorCode;
033    
034    import java.io.DataInput;
035    import java.io.DataOutput;
036    import java.io.IOException;
037    import java.io.ByteArrayOutputStream;
038    import java.io.ByteArrayInputStream;
039    import java.util.ArrayList;
040    import java.util.Arrays;
041    import java.util.Collections;
042    import java.util.Comparator;
043    import java.util.Date;
044    import java.util.HashMap;
045    import java.util.List;
046    import java.util.Map;
047    
048    //TODO javadoc
049    public class LiteWorkflowInstance implements Writable, WorkflowInstance {
050        private static final String TRANSITION_TO = "transition.to";
051    
052        private final Date FAR_INTO_THE_FUTURE = new Date(Long.MAX_VALUE);
053    
054        private XLog log;
055    
056        private static String PATH_SEPARATOR = "/";
057        private static String ROOT = PATH_SEPARATOR;
058        private static String TRANSITION_SEPARATOR = "#";
059    
060        // Using unique string to indicate version. This is to make sure that it
061        // doesn't match with user data.
062        private static final String DATA_VERSION = "V==1";
063    
064        private static class NodeInstance {
065            String nodeName;
066            boolean started = false;
067    
068            private NodeInstance(String nodeName) {
069                this.nodeName = nodeName;
070            }
071        }
072    
073        private class Context implements NodeHandler.Context {
074            private NodeDef nodeDef;
075            private String executionPath;
076            private String exitState;
077            private Status status = Status.RUNNING;
078    
079            private Context(NodeDef nodeDef, String executionPath, String exitState) {
080                this.nodeDef = nodeDef;
081                this.executionPath = executionPath;
082                this.exitState = exitState;
083            }
084    
085            public NodeDef getNodeDef() {
086                return nodeDef;
087            }
088    
089            public String getExecutionPath() {
090                return executionPath;
091            }
092    
093            public String getParentExecutionPath(String executionPath) {
094                return LiteWorkflowInstance.getParentPath(executionPath);
095            }
096    
097            public String getSignalValue() {
098                return exitState;
099            }
100    
101            public String createExecutionPath(String name) {
102                return LiteWorkflowInstance.createChildPath(executionPath, name);
103            }
104    
105            public String createFullTransition(String executionPath, String transition) {
106                return LiteWorkflowInstance.createFullTransition(executionPath, transition);
107            }
108    
109            public void deleteExecutionPath() {
110                if (!executionPaths.containsKey(executionPath)) {
111                    throw new IllegalStateException();
112                }
113                executionPaths.remove(executionPath);
114                executionPath = LiteWorkflowInstance.getParentPath(executionPath);
115            }
116    
117            public void failJob() {
118                status = Status.FAILED;
119            }
120    
121            public void killJob() {
122                status = Status.KILLED;
123            }
124    
125            public void completeJob() {
126                status = Status.SUCCEEDED;
127            }
128    
129            @Override
130            public Object getTransientVar(String name) {
131                return LiteWorkflowInstance.this.getTransientVar(name);
132            }
133    
134            @Override
135            public String getVar(String name) {
136                return LiteWorkflowInstance.this.getVar(name);
137            }
138    
139            @Override
140            public void setTransientVar(String name, Object value) {
141                LiteWorkflowInstance.this.setTransientVar(name, value);
142            }
143    
144            @Override
145            public void setVar(String name, String value) {
146                LiteWorkflowInstance.this.setVar(name, value);
147            }
148    
149            @Override
150            public LiteWorkflowInstance getProcessInstance() {
151                return LiteWorkflowInstance.this;
152            }
153    
154        }
155    
156        private LiteWorkflowApp def;
157        private Configuration conf;
158        private String instanceId;
159        private Status status;
160        private Map<String, NodeInstance> executionPaths = new HashMap<String, NodeInstance>();
161        private Map<String, String> persistentVars = new HashMap<String, String>();
162        private Map<String, Object> transientVars = new HashMap<String, Object>();
163        private ActionEndTimesComparator actionEndTimesComparator = null;
164    
165        protected LiteWorkflowInstance() {
166            log = XLog.getLog(getClass());
167        }
168    
169        public LiteWorkflowInstance(LiteWorkflowApp def, Configuration conf, String instanceId) {
170            this();
171            this.def = ParamChecker.notNull(def, "def");
172            this.instanceId = ParamChecker.notNull(instanceId, "instanceId");
173            this.conf = ParamChecker.notNull(conf, "conf");
174            refreshLog();
175            status = Status.PREP;
176        }
177    
178        public LiteWorkflowInstance(LiteWorkflowApp def, Configuration conf, String instanceId, Map<String, Date> actionEndTimes) {
179            this(def, conf, instanceId);
180            actionEndTimesComparator = new ActionEndTimesComparator(actionEndTimes);
181        }
182    
183        public synchronized boolean start() throws WorkflowException {
184            if (status != Status.PREP) {
185                throw new WorkflowException(ErrorCode.E0719);
186            }
187            log.debug(XLog.STD, "Starting job");
188            status = Status.RUNNING;
189            executionPaths.put(ROOT, new NodeInstance(StartNodeDef.START));
190            return signal(ROOT, StartNodeDef.START);
191        }
192    
193        //todo if suspended store signal and use when resuming
194    
195        public synchronized boolean signal(String executionPath, String signalValue) throws WorkflowException {
196            ParamChecker.notEmpty(executionPath, "executionPath");
197            ParamChecker.notNull(signalValue, "signalValue");
198            log.debug(XLog.STD, "Signaling job execution path [{0}] signal value [{1}]", executionPath, signalValue);
199            if (status != Status.RUNNING) {
200                throw new WorkflowException(ErrorCode.E0716);
201            }
202            NodeInstance nodeJob = executionPaths.get(executionPath);
203            if (nodeJob == null) {
204                status = Status.FAILED;
205                log.error("invalid execution path [{0}]", executionPath);
206            }
207            NodeDef nodeDef = null;
208            if (!status.isEndState()) {
209                nodeDef = def.getNode(nodeJob.nodeName);
210                if (nodeDef == null) {
211                    status = Status.FAILED;
212                    log.error("invalid transition [{0}]", nodeJob.nodeName);
213                }
214            }
215            if (!status.isEndState()) {
216                NodeHandler nodeHandler = newInstance(nodeDef.getHandlerClass());
217                boolean exiting = true;
218    
219                Context context = new Context(nodeDef, executionPath, signalValue);
220                if (!nodeJob.started) {
221                    try {
222                        nodeHandler.loopDetection(context);
223                        exiting = nodeHandler.enter(context);
224                        nodeJob.started = true;
225                    }
226                    catch (WorkflowException ex) {
227                        status = Status.FAILED;
228                        List<String> killedNodes = terminateNodes(Status.KILLED);
229                        if (killedNodes.size() > 1) {
230                            log.warn(XLog.STD, "Workflow completed [{0}], killing [{1}] running nodes", status, killedNodes
231                                    .size());
232                        }
233                        throw ex;
234                    }
235                }
236    
237                if (exiting) {
238                    List<String> pathsToStart = new ArrayList<String>();
239                    List<String> fullTransitions;
240                    try {
241                        fullTransitions = nodeHandler.multiExit(context);
242                        int last = fullTransitions.size() - 1;
243                        // TEST THIS
244                        if (last >= 0) {
245                            String transitionTo = getTransitionNode(fullTransitions.get(last));
246                            if (nodeDef instanceof ForkNodeDef) {
247                                transitionTo = "*"; // WF action cannot hold all transitions for a fork.
248                                                    // transitions are hardcoded in the WF app.
249                            }
250                            persistentVars.put(nodeDef.getName() + WorkflowInstance.NODE_VAR_SEPARATOR + TRANSITION_TO,
251                                               transitionTo);
252                        }
253                    }
254                    catch (WorkflowException ex) {
255                        status = Status.FAILED;
256                        throw ex;
257                    }
258    
259                    if (context.status == Status.KILLED) {
260                        status = Status.KILLED;
261                        log.debug(XLog.STD, "Completing job, kill node [{0}]", nodeJob.nodeName);
262                    }
263                    else {
264                        if (context.status == Status.FAILED) {
265                            status = Status.FAILED;
266                            log.debug(XLog.STD, "Completing job, fail node [{0}]", nodeJob.nodeName);
267                        }
268                        else {
269                            if (context.status == Status.SUCCEEDED) {
270                                status = Status.SUCCEEDED;
271                                log.debug(XLog.STD, "Completing job, end node [{0}]", nodeJob.nodeName);
272                            }
273    /*
274                    else if (context.status == Status.SUSPENDED) {
275                        status = Status.SUSPENDED;
276                        log.debug(XLog.STD, "Completing job, end node [{0}]", nodeJob.nodeName);
277                    }
278    */
279                            else {
280                                for (String fullTransition : fullTransitions) {
281                                    // this is the whole trick for forking, we need the
282                                    // executionpath and the transition
283                                    // in the case of no forking last element of
284                                    // executionpath is different from transition
285                                    // in the case of forking they are the same
286    
287                                    log.debug(XLog.STD, "Exiting node [{0}] with transition[{1}]", nodeJob.nodeName,
288                                              fullTransition);
289    
290                                    String execPathFromTransition = getExecutionPath(fullTransition);
291                                    String transition = getTransitionNode(fullTransition);
292                                    def.validateTransition(nodeJob.nodeName, transition);
293    
294                                    NodeInstance nodeJobInPath = executionPaths.get(execPathFromTransition);
295                                    if ((nodeJobInPath == null) || (!transition.equals(nodeJobInPath.nodeName))) {
296                                        // TODO explain this IF better
297                                        // If the WfJob is signaled with the parent
298                                        // execution executionPath again
299                                        // The Fork node will execute again.. and replace
300                                        // the Node WorkflowJobBean
301                                        // so this is required to prevent that..
302                                        // Question : Should we throw an error in this case
303                                        // ??
304                                        executionPaths.put(execPathFromTransition, new NodeInstance(transition));
305                                        pathsToStart.add(execPathFromTransition);
306                                    }
307    
308                                }
309    
310                                // If we're doing a rerun, then we need to make sure to put the actions in pathToStart into the order
311                                // that they ended in.  Otherwise, it could result in an error later on in some edge cases.
312                                // e.g. You have a fork with two nodes, A and B, that both succeeded, followed by a join and some more
313                                // nodes, some of which failed.  If you do the rerun, it will always signal A and then B, even if in the
314                                // original run B signaled first and then A.  By sorting this, we maintain the proper signal ordering.
315                                if (actionEndTimesComparator != null && pathsToStart.size() > 1) {
316                                    Collections.sort(pathsToStart, actionEndTimesComparator);
317                                }
318    
319                                // signal all new synch transitions
320                                for (String pathToStart : pathsToStart) {
321                                    signal(pathToStart, "::synch::");
322                                }
323                            }
324                        }
325                    }
326                }
327            }
328            if (status.isEndState()) {
329                if (status == Status.FAILED) {
330                    List<String> failedNodes = terminateNodes(status);
331                    log.warn(XLog.STD, "Workflow completed [{0}], failing [{1}] running nodes", status, failedNodes
332                            .size());
333                }
334                else {
335                    List<String> killedNodes = terminateNodes(Status.KILLED);
336    
337                    if (killedNodes.size() > 1) {
338                        log.warn(XLog.STD, "Workflow completed [{0}], killing [{1}] running nodes", status, killedNodes
339                                .size());
340                    }
341                }
342            }
343            return status.isEndState();
344        }
345    
346        /**
347         * Get NodeDef from workflow instance
348         * @param executionPath execution path
349         * @return node def
350         */
351        public NodeDef getNodeDef(String executionPath) {
352            NodeInstance nodeJob = executionPaths.get(executionPath);
353            NodeDef nodeDef = null;
354            if (nodeJob == null) {
355                log.error("invalid execution path [{0}]", executionPath);
356            }
357            else {
358                nodeDef = def.getNode(nodeJob.nodeName);
359                if (nodeDef == null) {
360                    log.error("invalid transition [{0}]", nodeJob.nodeName);
361                }
362            }
363            return nodeDef;
364        }
365    
366        public synchronized void fail(String nodeName) throws WorkflowException {
367            if (status.isEndState()) {
368                throw new WorkflowException(ErrorCode.E0718);
369            }
370            String failedNode = failNode(nodeName);
371            if (failedNode != null) {
372                log.warn(XLog.STD, "Workflow Failed. Failing node [{0}]", failedNode);
373            }
374            else {
375                //TODO failed attempting to fail the action. EXCEPTION
376            }
377            List<String> killedNodes = killNodes();
378            if (killedNodes.size() > 1) {
379                log.warn(XLog.STD, "Workflow Failed, killing [{0}] nodes", killedNodes.size());
380            }
381            status = Status.FAILED;
382        }
383    
384        public synchronized void kill() throws WorkflowException {
385            if (status.isEndState()) {
386                throw new WorkflowException(ErrorCode.E0718);
387            }
388            log.debug(XLog.STD, "Killing job");
389            List<String> killedNodes = killNodes();
390            if (killedNodes.size() > 1) {
391                log.warn(XLog.STD, "workflow killed, killing [{0}] nodes", killedNodes.size());
392            }
393            status = Status.KILLED;
394        }
395    
396        public synchronized void suspend() throws WorkflowException {
397            if (status != Status.RUNNING) {
398                throw new WorkflowException(ErrorCode.E0716);
399            }
400            log.debug(XLog.STD, "Suspending job");
401            this.status = Status.SUSPENDED;
402        }
403    
404        public boolean isSuspended() {
405            return (status == Status.SUSPENDED);
406        }
407    
408        public synchronized void resume() throws WorkflowException {
409            if (status != Status.SUSPENDED) {
410                throw new WorkflowException(ErrorCode.E0717);
411            }
412            log.debug(XLog.STD, "Resuming job");
413            status = Status.RUNNING;
414        }
415    
416        public void setVar(String name, String value) {
417            if (value != null) {
418                persistentVars.put(name, value);
419            }
420            else {
421                persistentVars.remove(name);
422            }
423        }
424    
425        @Override
426        public Map<String, String> getAllVars() {
427            return persistentVars;
428        }
429    
430        @Override
431        public void setAllVars(Map<String, String> varMap) {
432            persistentVars.putAll(varMap);
433        }
434    
435        public String getVar(String name) {
436            return persistentVars.get(name);
437        }
438    
439    
440        public void setTransientVar(String name, Object value) {
441            if (value != null) {
442                transientVars.put(name, value);
443            }
444            else {
445                transientVars.remove(name);
446            }
447        }
448    
449        public boolean hasTransientVar(String name) {
450            return transientVars.containsKey(name);
451        }
452    
453        public Object getTransientVar(String name) {
454            return transientVars.get(name);
455        }
456    
457        public boolean hasEnded() {
458            return status.isEndState();
459        }
460    
461        private List<String> terminateNodes(Status endStatus) {
462            List<String> endNodes = new ArrayList<String>();
463            for (Map.Entry<String, NodeInstance> entry : executionPaths.entrySet()) {
464                if (entry.getValue().started) {
465                    NodeDef nodeDef = def.getNode(entry.getValue().nodeName);
466                    if (!(nodeDef instanceof ControlNodeDef)) {
467                        NodeHandler nodeHandler = newInstance(nodeDef.getHandlerClass());
468                        try {
469                            if (endStatus == Status.KILLED) {
470                                nodeHandler.kill(new Context(nodeDef, entry.getKey(), null));
471                            }
472                            else {
473                                if (endStatus == Status.FAILED) {
474                                    nodeHandler.fail(new Context(nodeDef, entry.getKey(), null));
475                                }
476                            }
477                            endNodes.add(nodeDef.getName());
478                        }
479                        catch (Exception ex) {
480                            log.warn(XLog.STD, "Error Changing node state to [{0}] for Node [{1}]", endStatus.toString(),
481                                     nodeDef.getName(), ex);
482                        }
483                    }
484                }
485            }
486            return endNodes;
487        }
488    
489        private String failNode(String nodeName) {
490            String failedNode = null;
491            for (Map.Entry<String, NodeInstance> entry : executionPaths.entrySet()) {
492                String node = entry.getKey();
493                NodeInstance nodeInstance = entry.getValue();
494                if (nodeInstance.started && nodeInstance.nodeName.equals(nodeName)) {
495                    NodeDef nodeDef = def.getNode(nodeInstance.nodeName);
496                    NodeHandler nodeHandler = newInstance(nodeDef.getHandlerClass());
497                    try {
498                        nodeHandler.fail(new Context(nodeDef, node, null));
499                        failedNode = nodeDef.getName();
500                        nodeInstance.started = false;
501                    }
502                    catch (Exception ex) {
503                        log.warn(XLog.STD, "Error failing node [{0}]", nodeDef.getName(), ex);
504                    }
505                    return failedNode;
506                }
507            }
508            return failedNode;
509        }
510    
511        private List<String> killNodes() {
512            List<String> killedNodes = new ArrayList<String>();
513            for (Map.Entry<String, NodeInstance> entry : executionPaths.entrySet()) {
514                String node = entry.getKey();
515                NodeInstance nodeInstance = entry.getValue();
516                if (nodeInstance.started) {
517                    NodeDef nodeDef = def.getNode(nodeInstance.nodeName);
518                    NodeHandler nodeHandler = newInstance(nodeDef.getHandlerClass());
519                    try {
520                        nodeHandler.kill(new Context(nodeDef, node, null));
521                        killedNodes.add(nodeDef.getName());
522                    }
523                    catch (Exception ex) {
524                        log.warn(XLog.STD, "Error killing node [{0}]", nodeDef.getName(), ex);
525                    }
526                }
527            }
528            return killedNodes;
529        }
530    
531        public LiteWorkflowApp getProcessDefinition() {
532            return def;
533        }
534    
535        private static String createChildPath(String path, String child) {
536            return path + child + PATH_SEPARATOR;
537        }
538    
539        private static String getParentPath(String path) {
540            path = path.substring(0, path.length() - 1);
541            return (path.length() == 0) ? null : path.substring(0, path.lastIndexOf(PATH_SEPARATOR) + 1);
542        }
543    
544        private static String createFullTransition(String executionPath, String transition) {
545            return executionPath + TRANSITION_SEPARATOR + transition;
546        }
547    
548        private static String getExecutionPath(String fullTransition) {
549            int index = fullTransition.indexOf(TRANSITION_SEPARATOR);
550            if (index == -1) {
551                throw new IllegalArgumentException("Invalid fullTransition");
552            }
553            return fullTransition.substring(0, index);
554        }
555    
556        private static String getTransitionNode(String fullTransition) {
557            int index = fullTransition.indexOf(TRANSITION_SEPARATOR);
558            if (index == -1) {
559                throw new IllegalArgumentException("Invalid fullTransition");
560            }
561            return fullTransition.substring(index + 1);
562        }
563    
564        private NodeHandler newInstance(Class<? extends NodeHandler> handler) {
565            return (NodeHandler) ReflectionUtils.newInstance(handler, null);
566        }
567    
568        private void refreshLog() {
569            XLog.Info.get().setParameter(XLogService.USER, conf.get(OozieClient.USER_NAME));
570            XLog.Info.get().setParameter(XLogService.GROUP, conf.get(OozieClient.GROUP_NAME));
571            XLog.Info.get().setParameter(DagXLogInfoService.APP, def.getName());
572            XLog.Info.get().setParameter(DagXLogInfoService.TOKEN, conf.get(OozieClient.LOG_TOKEN, ""));
573            XLog.Info.get().setParameter(DagXLogInfoService.JOB, instanceId);
574            log = XLog.getLog(getClass());
575        }
576    
577        public Status getStatus() {
578            return status;
579        }
580    
581        public void setStatus(Status status) {
582            this.status = status;
583        }
584    
585        @Override
586        public void write(DataOutput dOut) throws IOException {
587            dOut.writeUTF(instanceId);
588    
589            //Hadoop Configuration has to get its act right
590            ByteArrayOutputStream baos = new ByteArrayOutputStream();
591            conf.writeXml(baos);
592            baos.close();
593            byte[] array = baos.toByteArray();
594            dOut.writeInt(array.length);
595            dOut.write(array);
596    
597            def.write(dOut);
598            dOut.writeUTF(status.toString());
599            dOut.writeInt(executionPaths.size());
600            for (Map.Entry<String, NodeInstance> entry : executionPaths.entrySet()) {
601                dOut.writeUTF(entry.getKey());
602                dOut.writeUTF(entry.getValue().nodeName);
603                dOut.writeBoolean(entry.getValue().started);
604            }
605            dOut.writeInt(persistentVars.size());
606            for (Map.Entry<String, String> entry : persistentVars.entrySet()) {
607                dOut.writeUTF(entry.getKey());
608                writeStringAsBytes(entry.getValue(), dOut);
609            }
610            if (actionEndTimesComparator != null) {
611                Map<String, Date> actionEndTimes = actionEndTimesComparator.getActionEndTimes();
612                dOut.writeInt(actionEndTimes.size());
613                for (Map.Entry<String, Date> entry : actionEndTimes.entrySet()) {
614                    dOut.writeUTF(entry.getKey());
615                    dOut.writeLong(entry.getValue().getTime());
616                }
617            }
618        }
619    
620        @Override
621        public void readFields(DataInput dIn) throws IOException {
622            instanceId = dIn.readUTF();
623    
624            //Hadoop Configuration has to get its act right
625            int len = dIn.readInt();
626            byte[] array = new byte[len];
627            dIn.readFully(array);
628            ByteArrayInputStream bais = new ByteArrayInputStream(array);
629            conf = new XConfiguration(bais);
630    
631            def = new LiteWorkflowApp();
632            def.readFields(dIn);
633            status = Status.valueOf(dIn.readUTF());
634            int numExPaths = dIn.readInt();
635            for (int x = 0; x < numExPaths; x++) {
636                String path = dIn.readUTF();
637                String nodeName = dIn.readUTF();
638                boolean isStarted = dIn.readBoolean();
639                NodeInstance nodeInstance = new NodeInstance(nodeName);
640                nodeInstance.started = isStarted;
641                executionPaths.put(path, nodeInstance);
642            }
643            int numVars = dIn.readInt();
644            for (int x = 0; x < numVars; x++) {
645                String vName = dIn.readUTF();
646                String vVal = readBytesAsString(dIn);
647                persistentVars.put(vName, vVal);
648            }
649            int numActionEndTimes = -1;
650            try {
651                numActionEndTimes = dIn.readInt();
652            } catch (IOException ioe) {
653                // This means that there isn't an actionEndTimes, so just ignore
654            }
655            if (numActionEndTimes > 0) {
656                Map<String, Date> actionEndTimes = new HashMap<String, Date>(numActionEndTimes);
657                for (int x = 0; x < numActionEndTimes; x++) {
658                    String name = dIn.readUTF();
659                    long endTime = dIn.readLong();
660                    actionEndTimes.put(name, new Date(endTime));
661                }
662                actionEndTimesComparator = new ActionEndTimesComparator(actionEndTimes);
663            }
664            refreshLog();
665        }
666    
667        private void writeStringAsBytes(String value, DataOutput dOut) throws IOException {
668            if (value == null) {
669                dOut.writeUTF(null);
670                return;
671            }
672            dOut.writeUTF(DATA_VERSION);
673            byte[] data = value.getBytes("UTF-8");
674            dOut.writeInt(data.length);
675            dOut.write(data);
676        }
677    
678        private String readBytesAsString(DataInput dIn) throws IOException {
679            String value = dIn.readUTF();
680            if (value != null && value.equals(DATA_VERSION)) {
681                int length = dIn.readInt();
682                byte[] data = new byte[length];
683                dIn.readFully(data);
684                value = new String(data, "UTF-8");
685            }
686            return value;
687        }
688    
689        @Override
690        public Configuration getConf() {
691            return conf;
692        }
693    
694        @Override
695        public WorkflowApp getApp() {
696            return def;
697        }
698    
699        @Override
700        public String getId() {
701            return instanceId;
702        }
703    
704        @Override
705        public String getTransition(String node) {
706            return persistentVars.get(node + WorkflowInstance.NODE_VAR_SEPARATOR + TRANSITION_TO);
707        }
708    
709        @Override
710        public boolean equals(Object o) {
711            return (o != null) && (getClass().isInstance(o)) && ((WorkflowInstance) o).getId().equals(instanceId);
712        }
713    
714        @Override
715        public int hashCode() {
716            return instanceId.hashCode();
717        }
718    
719        private class ActionEndTimesComparator implements Comparator<String> {
720    
721            private final Map<String, Date> actionEndTimes;
722    
723            public ActionEndTimesComparator(Map<String, Date> actionEndTimes) {
724                this.actionEndTimes = actionEndTimes;
725            }
726    
727            @Override
728            public int compare(String node1, String node2) {
729                Date date1 = null;
730                Date date2 = null;
731                NodeInstance node1Instance = executionPaths.get(node1);
732                if (node1Instance != null) {
733                    date1 = this.actionEndTimes.get(node1Instance.nodeName);
734                }
735                NodeInstance node2Instance = executionPaths.get(node2);
736                if (node2Instance != null) {
737                    date2 = this.actionEndTimes.get(node2Instance.nodeName);
738                }
739                date1 = (date1 == null) ? FAR_INTO_THE_FUTURE : date1;
740                date2 = (date2 == null) ? FAR_INTO_THE_FUTURE : date2;
741                return date1.compareTo(date2);
742            }
743    
744            public Map<String, Date> getActionEndTimes() {
745                return actionEndTimes;
746            }
747        }
748    }