Workflow Listeners

public class FileErrorCollectingListener implements IEwfComponentListener {
    // ---------------------------------------------------------------------------------------------------------
    // Simple getter/setter section - it can be used to pass parameters from the server-config listener
    // Configuration section, configuration example:
    //  <listeners className=ttt>
    //       <logFile>some-file.txt</logFile>
    //  </listeners>

    private String logFile;

    public String getLogFile() {
        return logFile;
    }

    public void setLogFile(String logFile) {
        this.logFile = logFile;
    }

    // ---------------------------------------------------------------------------------------------------------
    // Component listener implementation, it keeps a single instance of the synchronized file writer which is
    // used to write errors.
So writer is created on component start and closed on the component stop.
    private SynchronizedFileWriter fileWriter;

    public void onComponentStart(IEwfEnvironment environment) {
               // note: parameter 'environment' provides the access to the workflow framework
        try {
            if (logFile == null) {
                // error no log file configured
            } else {
                fileWriter = new SynchronizedFileWriter(environment.resolverResourceFile(logFile));
            }
        } catch (Throwable t) {
            // cannot create writer
        }
    }

    public void onComponentStop() {
        try {
            if (fileWriter != null) {
                fileWriter.close();
            }
        } catch (Throwable t) {
            // cannot close writer
        }
    }

    public synchronized void onInstanceStart(IEwfExecution instance) {
        try {
            if (fileWriter != null) {
                // If the writer was successfully created, register listener to the task execution and use the writer
                // to report detected errors
                instance.addPlannerListener(new MyTaskListener(fileWriter, instance.getWorkflow().getWorkflowId()));
            }
        } catch (Throwable t) {
            // Problem registering the task listener
        }
    }

    public void onInstanceFinish(IEwfExecution instance) {
        // empty
    }

    // ---------------------------------------------------------------------------------------------------------
    /* Shared synchronized writer used by the task listeners to write data to the file */
    private static class SynchronizedFileWriter {
        private OutputStreamWriter osw;
        public SynchronizedFileWriter(File f) throws Exception {
             osw = new OutputStreamWriter(new FileOutputStream(f), StringUtil.UTF8);
        }

        public void close() throws IOException {
            if (osw != null) {
                osw.close();
            }
        }
        /**
         * Synchronize write action - it may come from multiple tasks of multiple wf instances.
         * @param message
         */
        public synchronized void write(String message) {
            try {
                osw.write(message);
                osw.flush();
            } catch (IOException e) {
                // problem writing data to the file
            }
        }
    }

    // ---------------------------------------------------------------------------------------------------------
    /* Task listener instance, uses the synchronized file writer to report problems */
    private static class MyTaskListener implements IEwfTaskPlannerListener {
        private SynchronizedFileWriter writer;
        private String workflowId;
        private String instanceId;

        private MyTaskListener(SynchronizedFileWriter writer, String workflowId) {
            this.writer = writer;
            this.workflowId = workflowId;
        }

        // Task state changes must be synchronized, can be called from multiple tasks at the same time
        public synchronized void taskStateChanged(String id, EwfTaskStatus newState, Throwable t) {
            try {
                if (EwfTaskStatus.FINISHED_FAILURE == newState) {
                    StringBuilder sb = new StringBuilder();
                    sb.append("[ERROR] [" + DateUtil.formatUsDate(new Date()) + "]\n");
                    sb.append("WF NAME: ").append(workflowId).append("\n");
                    sb.append("WF INSTANCE ID: ").append(instanceId).append("\n");
                    sb.append("WF TASK ID: ").append(id).append("\n");
                    sb.append("STACK: ").append(ExceptionUtil.collectStackTrace(t)).append("\n");
                    writer.write(sb.toString());
                }
            } catch (Throwable ex) {
                // This should not happen as writer.write() handles exceptions on its own and
                // working with the StringBuilder should be safe
            }
        }

        public void processorStarted(IEwfExecutionContext execContext) {
            this.instanceId = execContext.getInstanceId();
        }

        public void processorFinished(EwfExecutionStatus state) {
            // empty
        }

        public void stopInitiated() {
            // empty
        }

        public void stopPerformed(EwfExecutionStatus state) {
            // empty
        }

        public void linkEvaluated(String sourceId, String targetId,    EwfLinkEvaluation evaluation) {
            // empty
        }
    }
}