@Override public void receiveResultCompletion(DispatchCompletionEvent completionEvent) { Activity<?> condition = config.getCondition(); if (condition == null) { super.receiveResultCompletion(completionEvent); return; } synchronized (outgoingJobs) { outgoingJobs.put(jobIdentifier(completionEvent), completionEvent); } checkCondition(completionEvent); }
private Map<String, T2Reference> prepareInputs( AbstractAsynchronousActivity asyncCondition, String jobIdentifier) { Map<String, T2Reference> inputs = new HashMap<String, T2Reference>(); Map<String, T2Reference> inData = getInData(jobIdentifier); Map<String, T2Reference> outData = getOutData(jobIdentifier); Set<ActivityInputPort> inputPorts = asyncCondition.getInputPorts(); for (ActivityInputPort conditionIn : inputPorts) { String conditionPort = conditionIn.getName(); if (outData.containsKey(conditionPort)) { // Copy from previous output inputs.put(conditionPort, outData.get(conditionPort)); } else if (inData.containsKey(conditionPort)) { // Copy from original input inputs.put(conditionPort, inData.get(conditionPort)); } } return inputs; }
protected LoopConfigureAction(Frame owner, LoopContextualView contextualView, Loop loopLayer) { super("Configure"); this.owner = owner; this.contextualView = contextualView; this.loopLayer = loopLayer; this.processor = loopLayer.getProcessor(); }
private void checkCondition(AbstractDispatchEvent event) { Activity<?> condition; condition = config.getCondition(); if (condition == null) { super.receiveError(new DispatchErrorEvent(event.getOwningProcess(), event.getIndex(), event.getContext(), "Can't invoke condition service: null", null, DispatchErrorType.INVOCATION, condition)); return; } if (!(condition instanceof AbstractAsynchronousActivity)) { DispatchErrorEvent errorEvent = new DispatchErrorEvent( event.getOwningProcess(), event.getIndex(), event.getContext(), "Can't invoke condition service " + condition + " is not an instance of AbstractAsynchronousActivity", null, DispatchErrorType.INVOCATION, condition); super.receiveError(errorEvent); return; } AbstractAsynchronousActivity asyncCondition = (AbstractAsynchronousActivity) condition; String jobIdentifier = jobIdentifier(event); Map<String, T2Reference> inputs = prepareInputs(asyncCondition, jobIdentifier); AsynchronousActivityCallback callback = new ConditionCallBack( jobIdentifier); asyncCondition.executeAsynch(inputs, callback); }
public void actionPerformed(ActionEvent e) { if (contextualView != null) { contextualView.refreshView(); } loopConfigurationPanel.setConfiguration(loopLayer .getConfiguration()); }
@Override public DispatchLayer<?> createDispatchLayer(URI uri) { DispatchLayer<?> dispatchLayer = null; if (parallelizeLayer.equals(uri)) { dispatchLayer = new Parallelize(); } else if (errorBounceLayer.equals(uri)) { dispatchLayer = new ErrorBounce(); } else if (failoverLayer.equals(uri)) { dispatchLayer = new Failover(); } else if (retryLayer.equals(uri)) { dispatchLayer = new Retry(); } else if (invokeLayer.equals(uri)) { dispatchLayer = new Invoke(); } else if (loopLayer.equals(uri)) { dispatchLayer = new Loop(); } else if (intermediateProvenanceLayer.equals(uri)) { dispatchLayer = new IntermediateProvenance(); } else if (stopLayer.equals(uri)) { dispatchLayer = new Stop(); } return dispatchLayer; }
public void fail(String message, Throwable t, DispatchErrorType errorType) { logger.warn("Failed (" + errorType + ") invoking conditional " + jobIdentifier + ":" + message, t); AbstractDispatchEvent originalEvent; synchronized (incomingJobs) { originalEvent = incomingJobs.get(jobIdentifier); } receiveError(new DispatchErrorEvent(originalEvent .getOwningProcess(), originalEvent.getIndex(), originalEvent.getContext(), "Can't invoke conditional activity ", t, DispatchErrorType.INVOCATION, null)); }
private void checkCondition(AbstractDispatchEvent event) { Activity<?> condition; condition = config.getCondition(); if (condition == null) { super.receiveError(new DispatchErrorEvent(event.getOwningProcess(), event.getIndex(), event.getContext(), "Can't invoke conditional activity: null", null, DispatchErrorType.INVOCATION, condition)); return; } if (!(condition instanceof AbstractAsynchronousActivity)) { DispatchErrorEvent errorEvent = new DispatchErrorEvent( event.getOwningProcess(), event.getIndex(), event.getContext(), "Can't invoke conditional activity " + condition + " is not an instance of AbstractAsynchronousActivity", null, DispatchErrorType.INVOCATION, condition); super.receiveError(errorEvent); return; } AbstractAsynchronousActivity asyncCondition = (AbstractAsynchronousActivity) condition; String jobIdentifier = jobIdentifier(event); Map<String, T2Reference> inputs = prepareInputs(asyncCondition, jobIdentifier); AsynchronousActivityCallback callback = new ConditionCallBack( jobIdentifier); asyncCondition.executeAsynch(inputs, callback); }
public LoopConfigurationPanel(Processor processor, Loop loopLayer) { this.processor = processor; this.loopLayer = loopLayer; this.setBorder(new EmptyBorder(10,10,10,10)); initialise(); setConfiguration(loopLayer.getConfiguration()); }
public Loop findLoopLayer() throws EditException { DispatchStack dispatchStack = processor.getDispatchStack(); Loop loopLayer = null; for (DispatchLayer<?> layer : dispatchStack.getLayers()) { if (layer instanceof Loop) { loopLayer = (Loop) layer; } } if (loopLayer == null) { loopLayer = new Loop(); insertLoopLayer(dispatchStack, loopLayer); } return loopLayer; }
public void fail(String message, Throwable t, DispatchErrorType errorType) { logger.warn("Failed (" + errorType + ") invoking condition service " + jobIdentifier + ":" + message, t); AbstractDispatchEvent originalEvent; synchronized (incomingJobs) { originalEvent = incomingJobs.get(jobIdentifier); } receiveError(new DispatchErrorEvent(originalEvent .getOwningProcess(), originalEvent.getIndex(), originalEvent.getContext(), "Can't invoke condition service ", t, DispatchErrorType.INVOCATION, null)); }
@Override public void receiveResult(DispatchResultEvent resultEvent) { Activity<?> condition = config.getCondition(); if (condition == null) { super.receiveResult(resultEvent); return; } synchronized (outgoingJobs) { outgoingJobs.put(jobIdentifier(resultEvent), resultEvent); } checkCondition(resultEvent); }
private Map<String, T2Reference> prepareInputs( AbstractAsynchronousActivity asyncCondition, String jobIdentifier) { Map<String, T2Reference> inputs = new HashMap<String, T2Reference>(); Map<String, T2Reference> inData = getInData(jobIdentifier); Map<String, T2Reference> outData = getOutData(jobIdentifier); Set<ActivityInputPort> inputPorts = asyncCondition.getInputPorts(); for (ActivityInputPort conditionIn : inputPorts) { String conditionPort = conditionIn.getName(); if (outData.containsKey(conditionPort)) { // Copy from previous output inputs.put(conditionPort, outData.get(conditionPort)); } else if (inData.containsKey(conditionPort)) { // Copy from original input inputs.put(conditionPort, inData.get(conditionPort)); } } return inputs; }
Properties properties = loopLayer.getConfiguration().getProperties(); if (properties.getProperty(ActivityGenerator.COMPARISON, ActivityGenerator.CUSTOM_COMPARISON).equals( ActivityGenerator.CUSTOM_COMPARISON)) { Activity<?> condition = loopLayer.getConfiguration().getCondition(); if (condition != null) { description.append("Looping using custom conditional ");
public LoopContextualView(Loop loopLayer) { super(); this.loopLayer = loopLayer; processor = loopLayer.getProcessor(); initialise(); initView(); }
@Override public void receiveJobQueue(DispatchJobQueueEvent jobQueueEvent) { synchronized (incomingJobs) { incomingJobs.put(jobIdentifier(jobQueueEvent), jobQueueEvent); } if (config.isRunFirst()) { // We'll do the conditional in receiveResult instead super.receiveJobQueue(jobQueueEvent); return; } checkCondition(jobQueueEvent); }
if ((ll != null) && (ll.getConfiguration() != null) && (ll.getConfiguration().getCondition() != null)) { node.setOuterShown(true);
@Override public void receiveJobQueue(DispatchJobQueueEvent jobQueueEvent) { synchronized (incomingJobs) { incomingJobs.put(jobIdentifier(jobQueueEvent), jobQueueEvent); } if (config.isRunFirst()) { // We'll do the conditional in receiveResult instead super.receiveJobQueue(jobQueueEvent); return; } checkCondition(jobQueueEvent); }
@Override public void receiveJob(DispatchJobEvent jobEvent) { synchronized (incomingJobs) { incomingJobs.put(jobIdentifier(jobEvent), jobEvent); } if (config.isRunFirst()) { // We'll do the conditional in receiveResult instead super.receiveJob(jobEvent); return; } checkCondition(jobEvent); }
@Override public void receiveResultCompletion(DispatchCompletionEvent completionEvent) { Activity<?> condition = config.getCondition(); if (condition == null) { super.receiveResultCompletion(completionEvent); return; } synchronized (outgoingJobs) { outgoingJobs.put(jobIdentifier(completionEvent), completionEvent); } checkCondition(completionEvent); }