import org.apache.taverna.robundle.Bundle; //导入依赖的package包/类
/**
 * Creates a new Workflow Research Object Bundle from Git details
 * and saves it to a file
 * @param workflow The workflow to generate a RO bundle for
 * @throws IOException Any API errors which may have occurred
 */
@Async
public void createWorkflowRO(Workflow workflow)
        throws IOException, InterruptedException {
    logger.info("Creating Research Object Bundle");

    // Get the whole containing folder, not just the workflow itself
    GitDetails githubInfo = workflow.getRetrievedFrom();
    GitDetails roDetails = new GitDetails(githubInfo.getRepoUrl(), githubInfo.getBranch(),
            FilenameUtils.getPath(githubInfo.getPath()));

    // Create a new Research Object Bundle
    Bundle bundle = roBundleService.createBundle(workflow, roDetails);

    // Save the bundle to the storage location in properties
    Path bundleLocation = roBundleService.saveToFile(bundle);

    // Add RO Bundle to associated workflow model
    workflow.setRoBundlePath(bundleLocation.toString());
    workflowRepository.save(workflow);
    logger.info("Finished saving Research Object Bundle");
}
 

import org.apache.taverna.robundle.Bundle; //导入依赖的package包/类
/**
 * Test file size limit
 */
@Test
public void filesOverLimit() throws Exception {

    // RO details
    GitDetails lobSTRdraft3RoDetails = new GitDetails("https://github.com/common-workflow-language/workflows.git",
            "933bf2a1a1cce32d88f88f136275535da9df0954", "lobstr-draft3/");

    // Create new RO bundle
    Bundle bundle = roBundleServiceZeroSizeLimit.createBundle(lobSTRdraft3, lobSTRdraft3RoDetails);

    Manifest manifest = bundle.getManifest();

    // Check files are externally linked in the aggregate
    assertEquals(14, manifest.getAggregates().size());

    PathMetadata urlAggregate = manifest.getAggregation(
            new URI("https://w3id.org/cwl/view/git/933bf2a1a1cce32d88f88f136275535da9df0954/lobstr-draft3/models/illumina_v3.pcrfree.stepmodel?format=raw"));
    assertEquals("Mark Robinson", urlAggregate.getAuthoredBy().get(0).getName());

}
 

import org.apache.taverna.robundle.Bundle; //导入依赖的package包/类
private Bundle openInputBundle(CommandLineOptions options) throws IOException {
	if (! options.hasInputBundle()) {
		return DataBundles.createBundle();
	} 
	Path inputBundlePath = Paths.get(options.getInputBundle());
	if (! Files.isReadable(inputBundlePath)) {
		throw new IOException("Can't read inputbundle: " + inputBundlePath);
	}
	if (options.hasSaveResultsToBundle() && 
			safeIsSameFile(inputBundlePath, Paths.get(options.getSaveResultsToBundle()))) {
		// Note: It is valid to do -bundle same.zip -inputbundle same.zip, 
		// in which case we should NOT open it as readOnly, as that
		// might make a copy unnecessarily. In case of symlinks we'll use the
		// path from -bundle to avoid double-opening later
		return DataBundles.openBundle(Paths.get(options.getSaveResultsToBundle()));				
	} else {			
		return DataBundles.openBundleReadOnly(inputBundlePath);
	}
}
 

import org.apache.taverna.robundle.Bundle; //导入依赖的package包/类
/**
 * Constructs an Execution for executing Taverna workflows on a local
 * Taverna Dataflow Engine.
 * 
 * @param workflowBundle
 *            the <code>WorkflowBundle</code> containing the
 *            <code>Workflow</code>s required for execution
 * @param workflow
 *            the <code>Workflow</code> to execute
 * @param profile
 *            the <code>Profile</code> to use when executing the
 *            <code>Workflow</code>
 * @param dataBundle
 *            the <code>Bundle</code> containing the data values for the
 *            <code>Workflow</code>
 * @param referenceService
 *            the <code>ReferenceService</code> used to register inputs,
 *            outputs and intermediate values
 * @throws InvalidWorkflowException
 *             if the specified workflow is invalid
 */
public LocalExecution(WorkflowBundle workflowBundle, Workflow workflow,
		Profile profile, Bundle dataBundle,
		ReferenceService referenceService, Edits edits,
		ActivityService activityService,
		DispatchLayerService dispatchLayerService)
		throws InvalidWorkflowException {
	super(workflowBundle, workflow, profile, dataBundle);
	this.referenceService = referenceService;
	try {
		mapping = new WorkflowToDataflowMapper(workflowBundle, profile,
				edits, activityService, dispatchLayerService);
		Dataflow dataflow = mapping.getDataflow(workflow);
		for (DataflowInputPort dataflowInputPort : dataflow.getInputPorts())
			inputPorts.put(dataflowInputPort.getName(), dataflowInputPort);
		facade = edits.createWorkflowInstanceFacade(dataflow,
				createContext(), "");
		executionMonitor = new LocalExecutionMonitor(getWorkflowReport(),
				getDataBundle(), mapping, facade.getIdentifier());
	} catch (InvalidDataflowException e) {
		throw new InvalidWorkflowException(e);
	}
}
 

import org.apache.taverna.robundle.Bundle; //导入依赖的package包/类
@Override
public String open(Path runFile) throws IOException {
	try {
		String runID = runFile.getFileName().toString();
		int dot = runID.indexOf('.');
		if (dot > 0)
			runID = runID.substring(0, dot);
		if (!runMap.containsKey(runID)) {
			Bundle bundle = DataBundles.openBundle(runFile);
			Run run = new Run(runID, bundle);
			runMap.put(run.getID(), run);
		}
		postEvent(RUN_OPENED, runID);
		return runID;
	} catch (ReaderException | ParseException e) {
		throw new IOException("Error opening file " + runFile, e);
	}
}
 

import org.apache.taverna.robundle.Bundle; //导入依赖的package包/类
@Before
public void exampleBundle() throws IOException {
	Path source;
	try (Bundle bundle = Bundles.createBundle()) {
		source = bundle.getSource();
		Path r = bundle.getRoot();
		Files.createFile(r.resolve("hello.txt"));
		Path f = r.resolve("f");
		Files.createDirectory(f);
		Files.createFile(f.resolve("file3.txt"));
		Files.createFile(f.resolve("file2.txt"));
		Files.createFile(f.resolve("file1.txt"));

		Path nested = f.resolve("nested");
		Files.createDirectory(nested);
		Files.createFile(nested.resolve("file1.txt"));

		Files.createDirectory(nested.resolve("empty"));
		bundle.setDeleteOnClose(false);
	}
	bundle = Bundles.openBundle(source);
}
 

import org.apache.taverna.robundle.Bundle; //导入依赖的package包/类
@Test
public void openHelloWorld() throws Exception {
	URL helloworld = getClass().getResource("/helloworld.wfbundle");
	assertNotNull(helloworld);
	try (Bundle bundle = Bundles.openBundle(helloworld)) {
		assertEquals("application/vnd.taverna.scufl2.workflow-bundle",
				Bundles.getMimeType(bundle));
		Path t2flow = bundle
				.getPath("history/8781d5f4-d0ba-48a8-a1d1-14281bd8a917.t2flow");
		assertEquals("application/vnd.taverna.t2flow+xml", bundle
				.getManifest().getAggregation(t2flow).getMediatype());
		Path manifestRdf = bundle.getPath("META-INF/manifest.xml");
		assertTrue(Files.exists(manifestRdf));
		assertTrue(bundle.getManifest().getManifest().contains(manifestRdf));
	}
}
 

import org.apache.taverna.robundle.Bundle; //导入依赖的package包/类
private void runWorkflow(WorkflowBundle workflowBundle, Profile profile,
		ExecutionEnvironment executionEnvironment, Bundle workflowInputs) {
	try {
		RunProfile runProfile = createRunProfile(workflowBundle, profile,
				executionEnvironment, workflowInputs);
		if (runProfile != null) {
			String runId = runService.createRun(runProfile);
			runService.start(runId);
		}
	} catch (InvalidWorkflowException | RunProfileException | InvalidRunIdException
			| RunStateException | InvalidExecutionIdException e) {
		String message = "Could not run workflow " + workflowBundle.getName();
		logger.warn(message, e);
		InvalidDataflowReport.showErrorDialog(e.getMessage(), message);
	}
}
 

import org.apache.taverna.robundle.Bundle; //导入依赖的package包/类
@Test
public void safeMove() throws Exception {
	Path tmp = Files.createTempDirectory("test");
	tmp.toFile().deleteOnExit();
	Path f1 = tmp.resolve("f1");
	f1.toFile().deleteOnExit();
	Files.createFile(f1);
	assertFalse(isEmpty(tmp));

	try (Bundle db = Bundles.createBundle()) {
		Path f2 = db.getRoot().resolve("f2");
		Bundles.safeMove(f1, f2);
		assertFalse(Files.exists(f1));
		assertTrue(isEmpty(tmp));
		assertEquals(Arrays.asList("f2", "mimetype"), ls(db.getRoot()));
	}

}
 

import org.apache.taverna.robundle.Bundle; //导入依赖的package包/类
@Test
public void safeCopy() throws Exception {
	Path tmp = Files.createTempDirectory("test");
	tmp.toFile().deleteOnExit();
	Path f1 = tmp.resolve("f1");
	f1.toFile().deleteOnExit();
	Files.createFile(f1);
	assertFalse(isEmpty(tmp));

	try (Bundle db = Bundles.createBundle()) {
		Path f2 = db.getRoot().resolve("f2");
		Bundles.safeCopy(f1, f2);
		assertTrue(Files.exists(f1));
		assertTrue(Files.exists(f2));
		assertEquals(Arrays.asList("f2", "mimetype"), ls(db.getRoot()));
	}

}
 

import org.apache.taverna.robundle.Bundle; //导入依赖的package包/类
@Test
public void setReference() throws Exception {
	try (Bundle bundle = Bundles.createBundle()) {

		Path ref = bundle.getRoot().resolve("ref");
		Bundles.setReference(ref, URI.create("http://example.org/test"));

		URI uri = URI.create("http://example.org/test");
		Path f = Bundles.setReference(ref, uri);
		assertEquals("ref.url", f.getFileName().toString());
		assertEquals(bundle.getRoot(), f.getParent());
		assertFalse(Files.exists(ref));

		List<String> uriLines = Files.readAllLines(f,
				Charset.forName("ASCII"));
		assertEquals(3, uriLines.size());
		assertEquals("[InternetShortcut]", uriLines.get(0));
		assertEquals("URL=http://example.org/test", uriLines.get(1));
		assertEquals("", uriLines.get(2));
	}
}
 

import org.apache.taverna.robundle.Bundle; //导入依赖的package包/类
/**
 * Save the Research Object Bundle to disk
 * @param roBundle The bundle to be saved
 * @return The path to the research object
 * @throws IOException Any errors in saving
 */
public Path saveToFile(Bundle roBundle) throws IOException {
    String fileName = "bundle-" + java.util.UUID.randomUUID() + ".zip";
    Path bundleLocation = Files.createFile(bundleStorage.resolve(fileName));
    Bundles.closeAndSaveBundle(roBundle, bundleLocation);
    return bundleLocation;
}
 

import org.apache.taverna.robundle.Bundle; //导入依赖的package包/类
/**
 * Add an aggregation to the Research Object Bundle
 * @param roBundle The bundle to add to
 * @param fileName The file name of the aggregation
 * @param manifestAnnotations The list of manifest aggregations
 * @param content The identifier for the resource containing the
 *                body of the annotation
 * @throws IOException Errors accessing the bundle
 */
private void addAggregation(Bundle roBundle,
                            List<PathAnnotation> manifestAnnotations,
                            String fileName,
                            String content) throws IOException {
    Path annotations = Bundles.getAnnotations(roBundle);
    Path packedPath = annotations.resolve(fileName);
    Bundles.setStringValue(packedPath, content);
    PathAnnotation packedFile = new PathAnnotation();
    packedFile.setContent(packedPath);
    packedFile.setAbout(roBundle.getManifest().getId());
    packedFile.generateAnnotationId();
    manifestAnnotations.add(packedFile);
}
 

import org.apache.taverna.robundle.Bundle; //导入依赖的package包/类
public Bundle registerInputs(Map<String, InputWorkflowPort> portMap,
		CommandLineOptions options) throws InvalidOptionException,
		ReadInputException, IOException {
	
	Bundle inputDataBundle = openInputBundle(options);
	if (Boolean.getBoolean("debug.bundle")) {
		inputDataBundle.setDeleteOnClose(false);
		System.out.println("Bundle: " + inputDataBundle.getSource());
	}
	
	Path inputs = DataBundles.getInputs(inputDataBundle);

	URL url;
	try {
		url = new URL("file:");
	} catch (MalformedURLException e1) {
		// Should never happen, but just in case:
		throw new ReadInputException(
				"The was an internal error setting up the URL to open the inputs. You should contact Taverna support.",
				e1);
	}

	if (options.hasInputFiles()) {
		regesterInputsFromFiles(portMap, options, inputs, url);
	}

	if (options.hasInputValues()) {
		registerInputsFromValues(portMap, options, inputs);

	}

	return inputDataBundle;
}
 

import org.apache.taverna.robundle.Bundle; //导入依赖的package包/类
@Override
protected Execution createExecutionImpl(WorkflowBundle workflowBundle,
		Workflow workflow, Profile profile, Bundle dataBundle)
		throws InvalidWorkflowException {
	return new LocalExecution(workflowBundle, workflow, profile,
			dataBundle, referenceService, edits, activityService,
			dispatchLayerService);
}
 

import org.apache.taverna.robundle.Bundle; //导入依赖的package包/类
public LocalExecutionMonitor(WorkflowReport workflowReport,
		Bundle dataBundle, WorkflowToDataflowMapper mapping, String facadeId)
		throws InvalidWorkflowException {
	this.dataBundle = dataBundle;
	this.facadeId = facadeId;
	reports = new HashMap<>();
	invocations = new HashMap<>();
	invocationToActivity = new HashMap<>();
	referenceToPath = new HashMap<>();
	mapReports("", workflowReport, mapping);
}
 

import org.apache.taverna.robundle.Bundle; //导入依赖的package包/类
public void saveData(Path bundlePath) throws FileNotFoundException,
        IOException {
    Bundle bundle = DataBundles.createBundle();
    // String folderName = bundlePath.getFileName().toString();
    // if (folderName.endsWith(".")) {
    // bundlePath = bundlePath.resolveSibling(folderName.substring(0,
    // folderName.length() - 1));
    // }
    setBundle(bundle);
    saveToFolder(bundle.getRoot(), getChosenReferences(),
            getReferenceService());
    DataBundles.closeAndSaveBundle(bundle, bundlePath);
}
 

import org.apache.taverna.robundle.Bundle; //导入依赖的package包/类
@Override
public String createExecution(ExecutionEnvironment executionEnvironment,
		WorkflowBundle workflowBundle, Workflow workflow, Profile profile,
		Bundle dataBundle) throws InvalidWorkflowException {
	Execution execution = createExecutionImpl(workflowBundle, workflow, profile, dataBundle);
	executionMap.put(execution.getID(), execution);
	return execution.getID();
}
 

import org.apache.taverna.robundle.Bundle; //导入依赖的package包/类
@Override
public void save(String runID, Path runFile) throws InvalidRunIdException, IOException {
	Run run = getRun(runID);
	Bundle dataBundle = run.getDataBundle();
	try {
		DataBundles.closeAndSaveBundle(dataBundle, runFile);
	} catch (InvalidPathException e) {
		throw new IOException(e);
	}
}
 

import org.apache.taverna.robundle.Bundle; //导入依赖的package包/类
@Override
public void delete(String runID) throws InvalidRunIdException, InvalidExecutionIdException {
	Run run = getRun(runID);
	run.delete();
	Bundle dataBundle = run.getDataBundle();
	try {
		DataBundles.closeBundle(dataBundle);
	} catch (IOException e) {
		logger.log(Level.WARNING, "Error closing data bundle for run " + runID, e);
	}
	runMap.remove(runID);
	postEvent(RUN_DELETED, runID);
}