protected ScuflModel getModel() { return new ScuflModel(); } }
/** * Returns the processor that user pointed to obtain a breakpoint */ private Processor getPointedProcessor(int X, int Y, JTable table) { final Processor[] processors = theModel.getProcessors(); for (int i = 0; i < processors.length; i++) if (table.getCellRect(i, 5, true).contains(X, Y)) return processors[i]; return null; }
public Set<Scavenger> getFromModel(ScuflModel model) { Set<Scavenger> result = new HashSet<Scavenger>(); Processor[] processors = model.getProcessorsOfType(RDFGeneratorProcessor.class); if (processors.length>0) { try { result.add(new RDFGeneratorScavenger()); } catch (ScavengerCreationException e) { logger.warn("Error creating RDFGeneratorScavenger", e); } } return result; }
/** * Construct a new processor with a blank internal workflow */ public WorkflowProcessor(ScuflModel model, String name) throws ProcessorCreationException, DuplicateProcessorNameException { super(model, name); theInternalModel = new ScuflModel(); try { if (model != null) { theInternalModel.setOffline(model.isOffline()); } } catch (SetOnlineException soe) { // } }
public void modelChanged(String modelName, Object oldModel, Object newModel) { ScuflModel oldWorkflow = (ScuflModel) oldModel; ScuflModel newWorkflow = (ScuflModel) newModel; oldWorkflow.removeListener(listener); newWorkflow.addListener(listener); setWorkflow(newWorkflow); }
public static void main(String[] args) throws Exception { System.out.println("Starting test : SoaplabProcessorCreation"); // Create a new ScuflModel ScuflModel model = new ScuflModel(); // Register a listener to print to stdout model.addListener(new ScuflModelEventPrinter(null)); // Attempt to create a new SoaplabProcessor model.addProcessor(new SoaplabProcessor(model, "my_processor", "http://industry.ebi.ac.uk/soap/soaplab/nucleic_gene_finding::getorf")); System.out.println("Finished test : SoaplabProcessorCreation"); }
public void testConstruction() { ScuflModel model = new ScuflModel(); assertFalse(model.offline); ArrayAssert.assertEquals(new Processor[0], model.getProcessors()); ArrayAssert.assertEquals(new DataConstraint[0], model .getDataConstraints()); ArrayAssert.assertEquals(new ConcurrencyConstraint[0], model .getConcurrencyConstraints()); ArrayAssert.assertEquals(new ScuflModelEventListener[0], model .getListeners()); ArrayAssert.assertEquals(new Port[0], model.getWorkflowSinkPorts()); ArrayAssert.assertEquals(new Port[0], model.getWorkflowSourcePorts()); assertNotNull(model.getDescription()); // NOTE: the log level does not seem to be used for anything assertEquals(0, model.getLogLevel()); }
DuplicateProcessorNameException, UnknownProcessorException, UnknownPortException, MalformedNameException, SetOnlineException { ScuflModel model = new ScuflModel(); String valid_name = model.getValidProcessorName("Fish: and-$problems"); assertEquals("Fish__and__problems", valid_name); model.addProcessor(new Processor(model, valid_name) { public Properties getProperties() { return null; assertEquals(valid_name, model.getProcessors()[0].getName()); assertEquals(1, model.getProcessorsOfType(Processor.class).length); assertEquals(valid_name, model.locateProcessor(valid_name).getName()); valid_name = model.getValidProcessorName("Fish: and-$problems"); assertEquals("Fish__and__problems1", valid_name); model.addProcessor(new Processor(model, valid_name) { public Properties getProperties() { return null; assertEquals(valid_name, model.getProcessors()[1].getName()); model.locateProcessor("DoesNotExist"); fail("Didn't throw UnknownProcessorException for 'DoesNotExist'"); } catch (UnknownProcessorException ex) { model.locatePort("invalid:port:spec"); fail("Didn't throw MalformedNameException for 'invalid:port:spec'"); } catch (MalformedNameException ex) {
public void translate(InputStream stream, String outputDirectory) { model = new ScuflModel(); try { XScuflParser.populate(stream, model, null); .getProcessors();
if (pf instanceof ScuflWorkflowProcessorFactory) { ScuflWorkflowProcessor wp = (ScuflWorkflowProcessor) pf.createProcessor("workflow", new ScuflModel()); m = wp.getInternalModel(); } else { m = new ScuflModel(); m.getDescription().setTitle(pf.getName()); Processor p = pf.createProcessor("processor", m); for (int i = 0; i < ip.length; i++) { String portName = ip[i].getName(); OutputPort port = new OutputPort(m.getWorkflowSourceProcessor(), portName); m.getWorkflowSourceProcessor().addPort(port); m.addDataConstraint(new DataConstraint(m, port, ip[i])); InputPort port = new InputPort(m.getWorkflowSinkProcessor(), portName); m.getWorkflowSinkProcessor().addPort(port); m.addDataConstraint(new DataConstraint(m, op[i], port));
ScuflModel model = new ScuflModel(); model.addListener(new ScuflModelEventListener() { public void receiveModelEvent(ScuflModelEvent event) { synchronized (events) { model.forceUpdate(); assertEquals("Forced update", getEvent(events, model.notifyThread)); model.setOffline(true); assertEquals("Offline status change", getEvent(events, model.notifyThread)); model.addProcessor(new Processor(model, "proc"){ public Properties getProperties() { return null; model.clear(); assertEquals("Reset model to initial state.", getEvent(events, model.notifyThread)); model.removeListeners(); notifyThread.join((long)(NotifyThread.max_sleep*1.1)); assertFalse(notifyThread.loop);
/** * Create a new Workflow scavenger, the single parameter should be * resolvable to a location from which the definition could be fetched. */ public WorkflowScavenger(String definitionURL) throws ScavengerCreationException { super(new WorkflowProcessorFactory(definitionURL)); // Get a reference back to the processor factory ProcessorFactory rootPF = (ProcessorFactory) getUserObject(); // Crafty addition of a load of the workflow in offline mode // followed by extraction of all the processors... ScuflModel model = new ScuflModel(); try { model.setOffline(true); XScuflParser.populate(new URL(definitionURL).openStream(), model, null); rootPF.setDescription(model.getDescription().getText()); } catch (Exception ex) { ex.printStackTrace(); } doChildren(model); }
throws WorkflowTranslationException { for (org.embl.ebi.escience.scufl.Processor t1Processor : scuflModel .getProcessors()) { for (org.embl.ebi.escience.scufl.InputPort t1InputPort : t1Processor .getInputPorts()) { scuflModel, processorName, t1InputPort .getDefaultValue()); scuflModel.addProcessor(stringConstantProcessor); DataConstraint constraint = new DataConstraint( scuflModel, stringConstantProcessor .getOutputPorts()[0], t1InputPort); scuflModel.addDataConstraint(constraint); } catch (ProcessorCreationException e) { throw new WorkflowTranslationException(e);
/** * Construct a new processor from the supplied JDOM element, this element * being the 'scufl' top level workflow element from an inline nested * workflow declaration */ public WorkflowProcessor(ScuflModel model, String name, Element scuflElement) throws ProcessorCreationException, DuplicateProcessorNameException { super(model, name); // Have to clone the element because it already has a parent // so will not work with a new document instance try { Document doc = new Document((Element) scuflElement.clone()); theInternalModel = new ScuflModel(); try { if (model != null) { theInternalModel.setOffline(model.isOffline()); } } catch (SetOnlineException soe) { // } XScuflParser.populate(doc, theInternalModel, null); setDescription(theInternalModel.getDescription().getText()); buildPorts(); } catch (Exception e) { throw new ProcessorCreationException("The workflow processor '" + name + "' caused an exception :\n" + e.getMessage() + "\n during creation. The exception had type :\n" + e.getClass().toString()); } }
private List getRoots(ScuflModel scuflModel) Processor processor = scuflModel.getWorkflowSinkProcessor(); if (processor.getPorts().length != 0) processor = scuflModel.getWorkflowSourceProcessor(); if (processor.getPorts().length != 0) newRoots.addAll(Arrays.asList(scuflModel.getProcessors())); newRoots.addAll(Arrays.asList(scuflModel.getConcurrencyConstraints())); newRoots.addAll(Arrays.asList(scuflModel.getDataConstraints())); roots.addAll(Arrays.asList(scuflModel.getProcessors())); roots.addAll(Arrays.asList(scuflModel.getConcurrencyConstraints())); roots.addAll(Arrays.asList(scuflModel.getDataConstraints())); Iterator iterator = roots.iterator(); while (iterator.hasNext())
public void testNotifyThread() { ScuflModel model = new ScuflModel(); assertNull("notify thread should be null",model.notifyThread); ScuflModelEventListener listener = new ScuflModelEventListener() { public void receiveModelEvent(ScuflModelEvent event) { } }; model.addListener(listener); assertNotNull("notify thread should not be null",model.notifyThread); model.removeListener(listener); assertNull("notify thread should be null",model.notifyThread); }
""); if (name != null) { name = model.getValidProcessorName(name); splitter.setUpInputs(inputPort); LocalServiceProcessor processor = new LocalServiceProcessor( model, model.getValidProcessorName(name), splitter); model.addProcessor(processor); model.addDataConstraint(new DataConstraint(model, processor.getOutputPorts()[0], inputPort));
public void testListener() { ScuflModel model = new ScuflModel(); for (ScuflModelEventListener listener : model.getListeners() ) { assertFalse(listener instanceof XScuflView); } // Should add it self automatically XScuflView view = new XScuflView(model); for (ScuflModelEventListener listener : model.getListeners() ) { assertTrue(listener instanceof XScuflView); } // But we have to remove it manually model.removeListener(view); for (ScuflModelEventListener listener : model.getListeners() ) { assertFalse(listener instanceof XScuflView); } } }
public void testStoreWorkflow() throws Exception { ScuflModel storedModel = new ScuflModel(); // The unique LSID for this particular workflow that was run String storedLSID = "urn:example.com:storedLSID" + System.nanoTime(); // The one inside the workflow String wfLSID = "urn:example.com:testLSID" + +System.nanoTime(); storedModel.getDescription().setLSID(wfLSID); assertEquals(wfLSID, storedModel.getDescription().getLSID()); DataService dataService = DataServiceFactory.getInstance(configuration); dataService.storeWorkflow(storedLSID, storedModel); ScuflModel retrievedModel = new ScuflModel(); dataService.populateWorkflowModel(storedLSID, retrievedModel); assertNotSame(storedModel, retrievedModel); assertEquals(storedModel.getDescription().getLSID(), wfLSID); try { dataService.populateWorkflowModel(wfLSID, new ScuflModel()); } catch (DataServiceException e) { // As expected return; } fail("Should not be able to fetch by LSID " + wfLSID); }
public void testDuplicate() throws ProcessorCreationException, DuplicateProcessorNameException { ScuflModel model = new ScuflModel(); model.addProcessor(new RservProcessor(model, "Duplicate")); try { new RservProcessor(model, "Duplicate"); fail("Should have raised DuplicateProcessorNameException for 2x'Rserv'"); } catch (DuplicateProcessorNameException e) { } }