taverna-scufl2-ucfpackage/src/main/java/org/apache/taverna/scufl2/ucfpackage/UCFPackage.java - incubator-taverna-language - Git at Google

 package org.apache.taverna.scufl2.ucfpackage;
 /*
  *
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF licenses this file
  * to you under the Apache License, Version 2.0 (the
  * "License"); you may not use this file except in compliance
  * with the License.  You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  * KIND, either express or implied.  See the License for the
  * specific language governing permissions and limitations
  * under the License.
  *
 */


 import static java.io.File.createTempFile;
 import static java.util.logging.Level.INFO;

 import java.io.BufferedInputStream;
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
 import java.io.PipedInputStream;
 import java.io.PipedOutputStream;
 import java.net.URI;
 import java.nio.charset.Charset;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;
 import java.util.logging.Logger;

 import javax.xml.bind.JAXBContext;
 import javax.xml.bind.JAXBElement;
 import javax.xml.bind.JAXBException;
 import javax.xml.bind.Marshaller;
 import javax.xml.bind.Unmarshaller;

 import org.apache.taverna.robundle.manifest.odf.ODFJaxb;
 import org.apache.taverna.scufl2.ucfpackage.impl.odfdom.pkg.OdfPackage;
 import org.apache.taverna.scufl2.ucfpackage.impl.odfdom.pkg.manifest.OdfFileEntry;
 import org.apache.taverna.robundle.xml.odf.container.Container;
 import org.apache.taverna.robundle.xml.odf.container.Container.RootFiles;
 import org.apache.taverna.robundle.xml.odf.container.ObjectFactory;
 import org.apache.taverna.robundle.xml.odf.container.RootFile;
 import org.w3c.dom.Document;


 public class UCFPackage extends ODFJaxb implements Cloneable  {
 	private static Logger logger = Logger.getLogger(UCFPackage.class.getName());
 	private static final String CONTAINER_XML = "META-INF/container.xml";
 	private static final Charset UTF_8 = Charset.forName("utf-8");
 	public static final String MIME_BINARY = "application/octet-stream";
 	public static final String MIME_TEXT_PLAIN = "text/plain";
 	public static final String MIME_TEXT_XML = "text/xml";
 	public static final String MIME_RDF = "application/rdf+xml";
 	public static final String MIME_EPUB = "application/epub+zip";
 	public static final String MIME_WORKFLOW_BUNDLE = "application/vnd.taverna.workflow-bundle";
 	public static final String MIME_DATA_BUNDLE = "application/vnd.taverna.data-bundle";
 	public static final String MIME_WORKFLOW_RUN_BUNDLE = "application/vnd.taverna.workflow-run-bundle";
 	public static final String MIME_SERVICE_BUNDLE = "application/vnd.taverna.service-bundle";

 	private static Charset ASCII = Charset.forName("ascii");
 	private OdfPackage odfPackage;
 	private static JAXBContext jaxbContext;
 	private JAXBElement<Container> containerXml;
 	private boolean createdContainerXml = false;
 	private static ObjectFactory containerFactory = new ObjectFactory();

 	public UCFPackage() throws IOException {
 		try {
 			odfPackage = OdfPackage.create();
 			parseContainerXML();
 		} catch (IOException e) {
 			throw e;
 		} catch (Exception e) {
 			throw new IOException("Could not create empty UCF Package", e);
 		}
 		// odfPackage.setMediaType(MIME_EPUB);
 	}

 	public UCFPackage(File containerFile) throws IOException {
 		open(containerFile);
 	}

 	protected void open(File containerFile) throws IOException {
 		try (BufferedInputStream stream = new BufferedInputStream(
 				new FileInputStream(containerFile))) {
 			open(stream);
 		}
 	}

 	public UCFPackage(InputStream inputStream) throws IOException {
 		open(inputStream);
 	}

 	protected void open(InputStream inputStream) throws IOException {
 		try {
 			odfPackage = OdfPackage.loadPackage(inputStream);
 			parseContainerXML();
 		} catch (IOException e) {
 			throw e;
 		} catch (Exception e) {
 			throw new IOException(
 					"Could not load UCF Package from input stream", e);
 		}
 	}

 	@SuppressWarnings("unchecked")
 	protected void parseContainerXML() throws IOException {
 		createdContainerXml = false;
 		InputStream containerStream = getResourceAsInputStream(CONTAINER_XML);
 		if (containerStream == null) {
 			// Make an empty containerXml
 			Container container = containerFactory.createContainer();
 			containerXml = containerFactory.createContainer(container);
 			createdContainerXml = true;
 			return;
 		}
 		try {
 			Unmarshaller unMarshaller = createUnMarshaller();
 			containerXml = (JAXBElement<Container>) unMarshaller
 					.unmarshal(containerStream);
 		} catch (JAXBException e) {
 			throw new IOException("Could not parse " + CONTAINER_XML, e);
 		}
 	}

 	public String getPackageMediaType() {
 		return odfPackage.getMediaType();
 	}

 	public void setPackageMediaType(String mediaType) {
 		if (mediaType == null || !mediaType.contains("/"))
 			throw new IllegalArgumentException("Invalid media type "
 					+ mediaType);
 		if (!ASCII.newEncoder().canEncode(mediaType))
 			throw new IllegalArgumentException("Media type must be ASCII: "
 					+ mediaType);
 		odfPackage.setMediaType(mediaType);
 	}

 	public void save(File packageFile) throws IOException {
 		File tempFile = createTempFile("." + packageFile.getName(), ".tmp",
 				packageFile.getCanonicalFile().getParentFile());
 		prepareAndSave(tempFile);
 		boolean renamed = tempFile.renameTo(packageFile);
 		if (!renamed && packageFile.exists() && tempFile.exists()) {
 			// Could happen on Windows
 			if (!packageFile.delete())
 				// Could have been permission problem
 				throw new IOException("Could not delete existing "
 						+ packageFile);
 			renamed = tempFile.renameTo(packageFile);
 		}
 		if (!renamed)
 			throw new IOException("Could not rename temp file " + tempFile
 					+ " to " + packageFile);
 	}

 	protected void prepareAndSave(File tempFile) throws IOException {
 		if (getPackageMediaType() == null)
 			throw new IllegalStateException("Package media type must be set");

 		// Write using temp file, and do rename in the end

 		try {
 			prepareContainerXML();
 			odfPackage.save(tempFile);
 		} catch (IOException e) {
 			throw e;
 		} catch (Exception e) {
 			throw new IOException("Could not save bundle to " + tempFile, e);
 		} finally {
 			odfPackage.close();
 		}

 		try {
 			open(tempFile);
 		} catch (Exception e) {
 			throw new IOException("Could not reload package from " + tempFile,
 					e);
 		}
 	}

 	protected void prepareContainerXML() throws IOException {
 		if (containerXml == null || createdContainerXml
 				&& containerXml.getValue().getRootFilesOrAny() == null)
 			return;

 		/* Check if we should prune <rootFiles> */
 		Iterator<Object> iterator = containerXml.getValue().getRootFilesOrAny()
 				.iterator();
 		boolean foundAlready = false;
 		while (iterator.hasNext()) {
 			Object anyOrRoot = iterator.next();
 			if (!(anyOrRoot instanceof JAXBElement))
 				continue;
 			@SuppressWarnings("rawtypes")
 			JAXBElement elem = (JAXBElement) anyOrRoot;
 			if (!elem.getDeclaredType().equals(RootFiles.class))
 				continue;
 			RootFiles rootFiles = (RootFiles) elem.getValue();
 			if (foundAlready
 					|| (rootFiles.getOtherAttributes().isEmpty() && rootFiles
 							.getAnyOrRootFile().isEmpty())) {
 				// Delete it!
 				System.err.println("Deleting unneccessary <rootFiles>");
 				iterator.remove();
 			}
 			foundAlready = true;
 		}

 		Marshaller marshaller;
 		try {
 			marshaller = createMarshaller();
 			// XMLStreamWriter xmlStreamWriter = XMLOutputFactory
 			// .newInstance().createXMLStreamWriter(outStream);
 			// xmlStreamWriter.setDefaultNamespace(containerElem.getName()
 			// .getNamespaceURI());
 			//
 			// xmlStreamWriter.setPrefix("dsig",
 			// "http://www.w3.org/2000/09/xmldsig#");
 			// xmlStreamWriter.setPrefix("xmlenc",
 			// "http://www.w3.org/2001/04/xmlenc#");
 			try (OutputStream outStream = odfPackage
 					.insertOutputStream(CONTAINER_XML)) {
 				// FIXME: Set namespace prefixes and default namespace
 				marshaller.setProperty("jaxb.formatted.output", true);
 				// TODO: Ensure using default namespace
 				marshaller.marshal(containerXml, outStream);
 			}
 		} catch (IOException e) {
 			throw e;
 		} catch (Exception e) {
 			throw new IOException("Could not parse " + CONTAINER_XML, e);
 		}
 	}

 	public void addResource(String stringValue, String path, String mediaType)
 			throws IOException {
 		try {
 			odfPackage.insert(stringValue.getBytes(UTF_8), path, mediaType);
 		} catch (IOException e) {
 			throw e;
 		} catch (Exception e) {
 			throw new IOException("Could not add " + path, e);
 		}
 		parseContainerXML();
 	}

 	public void addResource(byte[] bytesValue, String path, String mediaType)
 			throws IOException {
 		try {
 			odfPackage.insert(bytesValue, path, mediaType);
 		} catch (IOException e) {
 			throw e;
 		} catch (Exception e) {
 			throw new IOException("Could not add " + path, e);
 		}
 		if (path.equals(CONTAINER_XML))
 			parseContainerXML();
 	}

 	public void addResource(Document document, String path, String mediaType)
 			throws IOException {
 		try {
 			odfPackage.insert(document, path, mediaType);
 		} catch (IOException e) {
 			throw e;
 		} catch (Exception e) {
 			throw new IOException("Could not add " + path, e);
 		}
 		if (path.equals(CONTAINER_XML))
 			parseContainerXML();
 	}

 	public void addResource(InputStream inputStream, String path,
 			String mediaType) throws IOException {
 		try {
 			odfPackage.insert(inputStream, path, mediaType);
 		} catch (IOException e) {
 			throw e;
 		} catch (Exception e) {
 			throw new IOException("Could not add " + path, e);
 		}
 		if (path.equals(CONTAINER_XML))
 			parseContainerXML();
 	}

 	public void addResource(URI uri, String path, String mediaType)
 			throws IOException {
 		try {
 			odfPackage.insert(uri, path, mediaType);
 		} catch (IOException e) {
 			throw e;
 		} catch (Exception e) {
 			throw new IOException("Could not add " + path, e);
 		}

 		if (path.equals(CONTAINER_XML))
 			parseContainerXML();
 	}

 	public String getResourceAsString(String path) throws IOException {
 		try {
 			return new String(odfPackage.getBytes(path), UTF_8);
 		} catch (IOException e) {
 			throw e;
 		} catch (Exception e) {
 			throw new IOException("Could not get " + path, e);
 		}
 	}

 	public byte[] getResourceAsBytes(String path) throws IOException {
 		try {
 			return odfPackage.getBytes(path);
 		} catch (IOException e) {
 			throw e;
 		} catch (Exception e) {
 			throw new IOException("Could not get " + path, e);
 		}
 	}

 	public InputStream getResourceAsInputStream(String path) throws IOException {
 		try {
 			return odfPackage.getInputStream(path);
 		} catch (IOException e) {
 			throw e;
 		} catch (Exception e) {
 			throw new IOException("Could not get " + path, e);
 		}
 	}

 	public Map<String, ResourceEntry> listResources() {
 		return listResources("", false);
 	}

 	public Map<String, ResourceEntry> listResources(String folderPath) {
 		return listResources(folderPath, false);
 	}

 	protected Map<String, ResourceEntry> listResources(String folderPath,
 			boolean recursive) {
 		if (!folderPath.isEmpty() && !folderPath.endsWith("/"))
 			folderPath = folderPath + "/";
 		HashMap<String, ResourceEntry> content = new HashMap<>();

 		for (Entry<String, OdfFileEntry> entry : odfPackage
 				.getManifestEntries().entrySet()) {
 			String entryPath = entry.getKey();
 			if (!entryPath.startsWith(folderPath))
 				continue;
 			String subPath = entryPath.substring(folderPath.length(),
 					entryPath.length());
 			if (subPath.isEmpty())
 				// The folder itself
 				continue;
 			int firstSlash = subPath.indexOf("/");
 			if (!recursive && firstSlash > -1
 					&& firstSlash < subPath.length() - 1)
 				/*
 				 * Children of a folder (note that we'll include the folder
 				 * itself which ends in /)
 				 */
 				continue;
 			content.put(subPath, new ResourceEntry(entry.getValue()));
 		}
 		return content;
 	}

 	public void removeResource(String path) {
 		if (!odfPackage.contains(path))
 			return;
 		if (path.endsWith("/"))
 			for (ResourceEntry childEntry : listResources(path).values())
 				removeResource(childEntry.getPath());
 		odfPackage.remove(path);
 	}

 	public class ResourceEntry {
 		private final String path;
 		private final long size;
 		private String mediaType;
 		private String version;

 		protected ResourceEntry(OdfFileEntry odfEntry) {
 			path = odfEntry.getPath();
 			size = odfEntry.getSize();
 			mediaType = odfEntry.getMediaType();
 			version = odfEntry.getVersion();
 		}

 		public String getPath() {
 			return path;
 		}

 		public long getSize() {
 			return size;
 		}

 		public String getMediaType() {
 			return mediaType;
 		}

 		public boolean isFolder() {
 			return path.endsWith("/");
 		}

 		public UCFPackage getUcfPackage() {
 			return UCFPackage.this;
 		}

 		@Override
 		public boolean equals(Object obj) {
 			if (!(obj instanceof ResourceEntry))
 				return false;
 			ResourceEntry other = (ResourceEntry) obj;

 			if (!getUcfPackage().equals(other.getUcfPackage()))
 				return false;
 			return getPath().equals(other.getPath());
 		}

 		@Override
 		public int hashCode() {
 			final int prime = 31;
 			int result = 1;
 			result = prime * result + getUcfPackage().hashCode();
 			result = prime * result + ((path == null) ? 0 : path.hashCode());
 			return result;
 		}

 		public String getVersion() {
 			return version;
 		}
 	}

 	public Map<String, ResourceEntry> listAllResources() {
 		return listResources("", true);
 	}

 	public void setRootFile(String path) {
 		setRootFile(path, null);
 	}

 	@SuppressWarnings("rawtypes")
 	public void setRootFile(String path, String version) {
 		ResourceEntry rootFile = getResourceEntry(path);
 		if (rootFile == null)
 			throw new IllegalArgumentException("Unknown resource: " + path);
 		odfPackage.getManifestEntries().get(path).setVersion(version);

 		Container container = containerXml.getValue();

 		RootFiles rootFiles = getRootFiles(container);
 		String mediaType = rootFile.getMediaType();
 		boolean foundExisting = false;
 		// Check any existing files for matching path/mime type
 		Iterator<Object> anyOrRootIt = rootFiles.getAnyOrRootFile().iterator();
 		while (anyOrRootIt.hasNext()) {
 			Object anyOrRoot = anyOrRootIt.next();
 			if (anyOrRoot instanceof JAXBElement)
 				anyOrRoot = ((JAXBElement) anyOrRoot).getValue();
 			if (!(anyOrRoot instanceof RootFile))
 				continue;
 			RootFile rootFileElem = (RootFile) anyOrRoot;
 			if (!rootFileElem.getFullPath().equals(path)
 					&& !rootFileElem.getMediaType().equals(mediaType))
 				// Different path and media type - ignore
 				continue;
 			if (foundExisting) {
 				// Duplicate path/media type, we'll remove it
 				anyOrRootIt.remove();
 				continue;
 			}
 			rootFileElem.setFullPath(rootFile.getPath());
 			if (mediaType != null)
 				rootFileElem.setMediaType(mediaType);

 			foundExisting = true;
 		}
 		if (!foundExisting) {
 			RootFile rootFileElem = containerFactory.createRootFile();
 			rootFileElem.setFullPath(rootFile.getPath());
 			rootFileElem.setMediaType(mediaType);
 			rootFiles.getAnyOrRootFile().add(
 					containerFactory
 							.createContainerRootFilesRootFile(rootFileElem));
 			// rootFiles.getAnyOrRootFile().add(rootFileElem);
 		}
 	}

 	protected RootFiles getRootFiles(Container container) {
 		for (Object o : container.getRootFilesOrAny()) {
 			if (o instanceof JAXBElement) {
 				@SuppressWarnings("rawtypes")
 				JAXBElement jaxbElement = (JAXBElement) o;
 				o = jaxbElement.getValue();
 			}
 			if (o instanceof RootFiles)
 				return (RootFiles) o;
 		}
 		// Not found - add it
 		RootFiles rootFiles = containerFactory.createContainerRootFiles();
 		container.getRootFilesOrAny().add(
 				containerFactory.createContainerRootFiles(rootFiles));
 		return rootFiles;
 	}

 	@SuppressWarnings("rawtypes")
 	public List<ResourceEntry> getRootFiles() {
 		ArrayList<UCFPackage.ResourceEntry> rootFiles = new ArrayList<>();
 		if (containerXml == null)
 			return rootFiles;

 		RootFiles rootFilesElem = getRootFiles(containerXml.getValue());
 		for (Object anyOrRoot : rootFilesElem.getAnyOrRootFile()) {
 			if (anyOrRoot instanceof JAXBElement)
 				anyOrRoot = ((JAXBElement) anyOrRoot).getValue();
 			if (!(anyOrRoot instanceof RootFile))
 				continue;
 			RootFile rf = (RootFile) anyOrRoot;
 			ResourceEntry entry = getResourceEntry(rf.getFullPath());
 			if (rf.getMediaType() != null
 					&& rf.getMediaType() != entry.mediaType)
 				// Override the mime type in the returned entry
 				entry.mediaType = rf.getMediaType();
 			rootFiles.add(entry);
 		}
 		return rootFiles;
 	}

 	public ResourceEntry getResourceEntry(String path) {
 		OdfFileEntry odfFileEntry = odfPackage.getManifestEntries().get(path);
 		if (odfFileEntry == null)
 			return null;
 		return new ResourceEntry(odfFileEntry);
 	}

 	@SuppressWarnings("rawtypes")
 	public void unsetRootFile(String path) {
 		Container container = containerXml.getValue();
 		RootFiles rootFiles = getRootFiles(container);
 		Iterator<Object> anyOrRootIt = rootFiles.getAnyOrRootFile().iterator();
 		while (anyOrRootIt.hasNext()) {
 			Object anyOrRoot = anyOrRootIt.next();
 			if (anyOrRoot instanceof JAXBElement)
 				anyOrRoot = ((JAXBElement) anyOrRoot).getValue();
 			if (!(anyOrRoot instanceof RootFile))
 				continue;
 			RootFile rootFileElem = (RootFile) anyOrRoot;
 			if (rootFileElem.getFullPath().equals(path))
 				anyOrRootIt.remove();
 		}
 	}

 	protected JAXBElement<Container> getContainerXML() {
 		return containerXml;
 	}

 	public void save(OutputStream output) throws IOException {
 		File tempFile = createTempFile("ucfpackage", ".tmp");
 		prepareAndSave(tempFile);

 		// Copy file to the output

 		// Note - Should use IOUtils, but we're trying to avoid external dependencies
 		try (InputStream inStream = new FileInputStream(tempFile)) {
 			byte[] buffer = new byte[8192];
 			int n = 0;
 			do {
 				output.write(buffer, 0, n);
 				n = inStream.read(buffer);
 			} while (n > -1);
 		} finally {
 			tempFile.delete();
 		}
 	}

 	public OutputStream addResourceUsingOutputStream(String path,
 			String mediaType) throws IOException {
 		if (path.equals(CONTAINER_XML))
 			// as we need to parse it after insertion, this must fail
 			throw new IllegalArgumentException("Can't add " + CONTAINER_XML
 					+ " using OutputStream");
 		try {
 			return odfPackage.insertOutputStream(path, mediaType);
 		} catch (IOException e) {
 			throw e;
 		} catch (Exception e) {
 			throw new IOException("Could not add " + path, e);
 		}
 	}

 	@Override
 	public UCFPackage clone() {
 		final PipedOutputStream outputStream = new PipedOutputStream();
 		try {
 			try (PipedInputStream inputStream = copyToOutputStream(outputStream)) {
 				return new UCFPackage(inputStream);
 			}
 		} catch (IOException e) {
 			throw new RuntimeException("Could not clone UCFPackage", e);
 		}
 	}

 	private PipedInputStream copyToOutputStream(
 			final PipedOutputStream outputStream) throws IOException {
 		PipedInputStream inputStream = new PipedInputStream(outputStream);
 		new Thread("Cloning " + this) {
 			@Override
 			public void run() {
 				try {
 					try {
 						save(outputStream);
 					} finally {
 						outputStream.close();
 					}
 				} catch (IOException e) {
 					logger.log(INFO,
 							"Could not save/close UCF package while cloning", e);
 				}
 			}
 		}.start();
 		return inputStream;
 	}

 	public String getRootFileVersion(String rootFile) {
 		return getResourceEntry(rootFile).getVersion();
 	}
 }
	package org.apache.taverna.scufl2.ucfpackage;
	/*
	*
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you under the Apache License, Version 2.0 (the
	* "License"); you may not use this file except in compliance
	* with the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing,
	* software distributed under the License is distributed on an
	* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
	* KIND, either express or implied. See the License for the
	* specific language governing permissions and limitations
	* under the License.
	*
	*/


	import static java.io.File.createTempFile;
	import static java.util.logging.Level.INFO;

	import java.io.BufferedInputStream;
	import java.io.File;
	import java.io.FileInputStream;
	import java.io.IOException;
	import java.io.InputStream;
	import java.io.OutputStream;
	import java.io.PipedInputStream;
	import java.io.PipedOutputStream;
	import java.net.URI;
	import java.nio.charset.Charset;
	import java.util.ArrayList;
	import java.util.HashMap;
	import java.util.Iterator;
	import java.util.List;
	import java.util.Map;
	import java.util.Map.Entry;
	import java.util.logging.Logger;

	import javax.xml.bind.JAXBContext;
	import javax.xml.bind.JAXBElement;
	import javax.xml.bind.JAXBException;
	import javax.xml.bind.Marshaller;
	import javax.xml.bind.Unmarshaller;

	import org.apache.taverna.robundle.manifest.odf.ODFJaxb;
	import org.apache.taverna.scufl2.ucfpackage.impl.odfdom.pkg.OdfPackage;
	import org.apache.taverna.scufl2.ucfpackage.impl.odfdom.pkg.manifest.OdfFileEntry;
	import org.apache.taverna.robundle.xml.odf.container.Container;
	import org.apache.taverna.robundle.xml.odf.container.Container.RootFiles;
	import org.apache.taverna.robundle.xml.odf.container.ObjectFactory;
	import org.apache.taverna.robundle.xml.odf.container.RootFile;
	import org.w3c.dom.Document;


	public class UCFPackage extends ODFJaxb implements Cloneable {
	private static Logger logger = Logger.getLogger(UCFPackage.class.getName());
	private static final String CONTAINER_XML = "META-INF/container.xml";
	private static final Charset UTF_8 = Charset.forName("utf-8");
	public static final String MIME_BINARY = "application/octet-stream";
	public static final String MIME_TEXT_PLAIN = "text/plain";
	public static final String MIME_TEXT_XML = "text/xml";
	public static final String MIME_RDF = "application/rdf+xml";
	public static final String MIME_EPUB = "application/epub+zip";
	public static final String MIME_WORKFLOW_BUNDLE = "application/vnd.taverna.workflow-bundle";
	public static final String MIME_DATA_BUNDLE = "application/vnd.taverna.data-bundle";
	public static final String MIME_WORKFLOW_RUN_BUNDLE = "application/vnd.taverna.workflow-run-bundle";
	public static final String MIME_SERVICE_BUNDLE = "application/vnd.taverna.service-bundle";

	private static Charset ASCII = Charset.forName("ascii");
	private OdfPackage odfPackage;
	private static JAXBContext jaxbContext;
	private JAXBElement<Container> containerXml;
	private boolean createdContainerXml = false;
	private static ObjectFactory containerFactory = new ObjectFactory();

	public UCFPackage() throws IOException {
	try {
	odfPackage = OdfPackage.create();
	parseContainerXML();
	} catch (IOException e) {
	throw e;
	} catch (Exception e) {
	throw new IOException("Could not create empty UCF Package", e);
	}
	// odfPackage.setMediaType(MIME_EPUB);
	}

	public UCFPackage(File containerFile) throws IOException {
	open(containerFile);
	}

	protected void open(File containerFile) throws IOException {
	try (BufferedInputStream stream = new BufferedInputStream(
	new FileInputStream(containerFile))) {
	open(stream);
	}
	}

	public UCFPackage(InputStream inputStream) throws IOException {
	open(inputStream);
	}

	protected void open(InputStream inputStream) throws IOException {
	try {
	odfPackage = OdfPackage.loadPackage(inputStream);
	parseContainerXML();
	} catch (IOException e) {
	throw e;
	} catch (Exception e) {
	throw new IOException(
	"Could not load UCF Package from input stream", e);
	}
	}

	@SuppressWarnings("unchecked")
	protected void parseContainerXML() throws IOException {
	createdContainerXml = false;
	InputStream containerStream = getResourceAsInputStream(CONTAINER_XML);
	if (containerStream == null) {
	// Make an empty containerXml
	Container container = containerFactory.createContainer();
	containerXml = containerFactory.createContainer(container);
	createdContainerXml = true;
	return;
	}
	try {
	Unmarshaller unMarshaller = createUnMarshaller();
	containerXml = (JAXBElement<Container>) unMarshaller
	.unmarshal(containerStream);
	} catch (JAXBException e) {
	throw new IOException("Could not parse " + CONTAINER_XML, e);
	}
	}

	public String getPackageMediaType() {
	return odfPackage.getMediaType();
	}

	public void setPackageMediaType(String mediaType) {
	if (mediaType == null \|\| !mediaType.contains("/"))
	throw new IllegalArgumentException("Invalid media type "
	+ mediaType);
	if (!ASCII.newEncoder().canEncode(mediaType))
	throw new IllegalArgumentException("Media type must be ASCII: "
	+ mediaType);
	odfPackage.setMediaType(mediaType);
	}

	public void save(File packageFile) throws IOException {
	File tempFile = createTempFile("." + packageFile.getName(), ".tmp",
	packageFile.getCanonicalFile().getParentFile());
	prepareAndSave(tempFile);
	boolean renamed = tempFile.renameTo(packageFile);
	if (!renamed && packageFile.exists() && tempFile.exists()) {
	// Could happen on Windows
	if (!packageFile.delete())
	// Could have been permission problem
	throw new IOException("Could not delete existing "
	+ packageFile);
	renamed = tempFile.renameTo(packageFile);
	}
	if (!renamed)
	throw new IOException("Could not rename temp file " + tempFile
	+ " to " + packageFile);
	}

	protected void prepareAndSave(File tempFile) throws IOException {
	if (getPackageMediaType() == null)
	throw new IllegalStateException("Package media type must be set");

	// Write using temp file, and do rename in the end

	try {
	prepareContainerXML();
	odfPackage.save(tempFile);
	} catch (IOException e) {
	throw e;
	} catch (Exception e) {
	throw new IOException("Could not save bundle to " + tempFile, e);
	} finally {
	odfPackage.close();
	}

	try {
	open(tempFile);
	} catch (Exception e) {
	throw new IOException("Could not reload package from " + tempFile,
	e);
	}
	}

	protected void prepareContainerXML() throws IOException {
	if (containerXml == null \|\| createdContainerXml
	&& containerXml.getValue().getRootFilesOrAny() == null)
	return;

	/* Check if we should prune <rootFiles> */
	Iterator<Object> iterator = containerXml.getValue().getRootFilesOrAny()
	.iterator();
	boolean foundAlready = false;
	while (iterator.hasNext()) {
	Object anyOrRoot = iterator.next();
	if (!(anyOrRoot instanceof JAXBElement))
	continue;
	@SuppressWarnings("rawtypes")
	JAXBElement elem = (JAXBElement) anyOrRoot;
	if (!elem.getDeclaredType().equals(RootFiles.class))
	continue;
	RootFiles rootFiles = (RootFiles) elem.getValue();
	if (foundAlready
	\|\| (rootFiles.getOtherAttributes().isEmpty() && rootFiles
	.getAnyOrRootFile().isEmpty())) {
	// Delete it!
	System.err.println("Deleting unneccessary <rootFiles>");
	iterator.remove();
	}
	foundAlready = true;
	}

	Marshaller marshaller;
	try {
	marshaller = createMarshaller();
	// XMLStreamWriter xmlStreamWriter = XMLOutputFactory
	// .newInstance().createXMLStreamWriter(outStream);
	// xmlStreamWriter.setDefaultNamespace(containerElem.getName()
	// .getNamespaceURI());
	//
	// xmlStreamWriter.setPrefix("dsig",
	// "http://www.w3.org/2000/09/xmldsig#");
	// xmlStreamWriter.setPrefix("xmlenc",
	// "http://www.w3.org/2001/04/xmlenc#");
	try (OutputStream outStream = odfPackage
	.insertOutputStream(CONTAINER_XML)) {
	// FIXME: Set namespace prefixes and default namespace
	marshaller.setProperty("jaxb.formatted.output", true);
	// TODO: Ensure using default namespace
	marshaller.marshal(containerXml, outStream);
	}
	} catch (IOException e) {
	throw e;
	} catch (Exception e) {
	throw new IOException("Could not parse " + CONTAINER_XML, e);
	}
	}

	public void addResource(String stringValue, String path, String mediaType)
	throws IOException {
	try {
	odfPackage.insert(stringValue.getBytes(UTF_8), path, mediaType);
	} catch (IOException e) {
	throw e;
	} catch (Exception e) {
	throw new IOException("Could not add " + path, e);
	}
	parseContainerXML();
	}

	public void addResource(byte[] bytesValue, String path, String mediaType)
	throws IOException {
	try {
	odfPackage.insert(bytesValue, path, mediaType);
	} catch (IOException e) {
	throw e;
	} catch (Exception e) {
	throw new IOException("Could not add " + path, e);
	}
	if (path.equals(CONTAINER_XML))
	parseContainerXML();
	}

	public void addResource(Document document, String path, String mediaType)
	throws IOException {
	try {
	odfPackage.insert(document, path, mediaType);
	} catch (IOException e) {
	throw e;
	} catch (Exception e) {
	throw new IOException("Could not add " + path, e);
	}
	if (path.equals(CONTAINER_XML))
	parseContainerXML();
	}

	public void addResource(InputStream inputStream, String path,
	String mediaType) throws IOException {
	try {
	odfPackage.insert(inputStream, path, mediaType);
	} catch (IOException e) {
	throw e;
	} catch (Exception e) {
	throw new IOException("Could not add " + path, e);
	}
	if (path.equals(CONTAINER_XML))
	parseContainerXML();
	}

	public void addResource(URI uri, String path, String mediaType)
	throws IOException {
	try {
	odfPackage.insert(uri, path, mediaType);
	} catch (IOException e) {
	throw e;
	} catch (Exception e) {
	throw new IOException("Could not add " + path, e);
	}

	if (path.equals(CONTAINER_XML))
	parseContainerXML();
	}

	public String getResourceAsString(String path) throws IOException {
	try {
	return new String(odfPackage.getBytes(path), UTF_8);
	} catch (IOException e) {
	throw e;
	} catch (Exception e) {
	throw new IOException("Could not get " + path, e);
	}
	}

	public byte[] getResourceAsBytes(String path) throws IOException {
	try {
	return odfPackage.getBytes(path);
	} catch (IOException e) {
	throw e;
	} catch (Exception e) {
	throw new IOException("Could not get " + path, e);
	}
	}

	public InputStream getResourceAsInputStream(String path) throws IOException {
	try {
	return odfPackage.getInputStream(path);
	} catch (IOException e) {
	throw e;
	} catch (Exception e) {
	throw new IOException("Could not get " + path, e);
	}
	}

	public Map<String, ResourceEntry> listResources() {
	return listResources("", false);
	}

	public Map<String, ResourceEntry> listResources(String folderPath) {
	return listResources(folderPath, false);
	}

	protected Map<String, ResourceEntry> listResources(String folderPath,
	boolean recursive) {
	if (!folderPath.isEmpty() && !folderPath.endsWith("/"))
	folderPath = folderPath + "/";
	HashMap<String, ResourceEntry> content = new HashMap<>();

	for (Entry<String, OdfFileEntry> entry : odfPackage
	.getManifestEntries().entrySet()) {
	String entryPath = entry.getKey();
	if (!entryPath.startsWith(folderPath))
	continue;
	String subPath = entryPath.substring(folderPath.length(),
	entryPath.length());
	if (subPath.isEmpty())
	// The folder itself
	continue;
	int firstSlash = subPath.indexOf("/");
	if (!recursive && firstSlash > -1
	&& firstSlash < subPath.length() - 1)
	/*
	* Children of a folder (note that we'll include the folder
	* itself which ends in /)
	*/
	continue;
	content.put(subPath, new ResourceEntry(entry.getValue()));
	}
	return content;
	}

	public void removeResource(String path) {
	if (!odfPackage.contains(path))
	return;
	if (path.endsWith("/"))
	for (ResourceEntry childEntry : listResources(path).values())
	removeResource(childEntry.getPath());
	odfPackage.remove(path);
	}

	public class ResourceEntry {
	private final String path;
	private final long size;
	private String mediaType;
	private String version;

	protected ResourceEntry(OdfFileEntry odfEntry) {
	path = odfEntry.getPath();
	size = odfEntry.getSize();
	mediaType = odfEntry.getMediaType();
	version = odfEntry.getVersion();
	}

	public String getPath() {
	return path;
	}

	public long getSize() {
	return size;
	}

	public String getMediaType() {
	return mediaType;
	}

	public boolean isFolder() {
	return path.endsWith("/");
	}

	public UCFPackage getUcfPackage() {
	return UCFPackage.this;
	}

	@Override
	public boolean equals(Object obj) {
	if (!(obj instanceof ResourceEntry))
	return false;
	ResourceEntry other = (ResourceEntry) obj;

	if (!getUcfPackage().equals(other.getUcfPackage()))
	return false;
	return getPath().equals(other.getPath());
	}

	@Override
	public int hashCode() {
	final int prime = 31;
	int result = 1;
	result = prime * result + getUcfPackage().hashCode();
	result = prime * result + ((path == null) ? 0 : path.hashCode());
	return result;
	}

	public String getVersion() {
	return version;
	}
	}

	public Map<String, ResourceEntry> listAllResources() {
	return listResources("", true);
	}

	public void setRootFile(String path) {
	setRootFile(path, null);
	}

	@SuppressWarnings("rawtypes")
	public void setRootFile(String path, String version) {
	ResourceEntry rootFile = getResourceEntry(path);
	if (rootFile == null)
	throw new IllegalArgumentException("Unknown resource: " + path);
	odfPackage.getManifestEntries().get(path).setVersion(version);

	Container container = containerXml.getValue();

	RootFiles rootFiles = getRootFiles(container);
	String mediaType = rootFile.getMediaType();
	boolean foundExisting = false;
	// Check any existing files for matching path/mime type
	Iterator<Object> anyOrRootIt = rootFiles.getAnyOrRootFile().iterator();
	while (anyOrRootIt.hasNext()) {
	Object anyOrRoot = anyOrRootIt.next();
	if (anyOrRoot instanceof JAXBElement)
	anyOrRoot = ((JAXBElement) anyOrRoot).getValue();
	if (!(anyOrRoot instanceof RootFile))
	continue;
	RootFile rootFileElem = (RootFile) anyOrRoot;
	if (!rootFileElem.getFullPath().equals(path)
	&& !rootFileElem.getMediaType().equals(mediaType))
	// Different path and media type - ignore
	continue;
	if (foundExisting) {
	// Duplicate path/media type, we'll remove it
	anyOrRootIt.remove();
	continue;
	}
	rootFileElem.setFullPath(rootFile.getPath());
	if (mediaType != null)
	rootFileElem.setMediaType(mediaType);

	foundExisting = true;
	}
	if (!foundExisting) {
	RootFile rootFileElem = containerFactory.createRootFile();
	rootFileElem.setFullPath(rootFile.getPath());
	rootFileElem.setMediaType(mediaType);
	rootFiles.getAnyOrRootFile().add(
	containerFactory
	.createContainerRootFilesRootFile(rootFileElem));
	// rootFiles.getAnyOrRootFile().add(rootFileElem);
	}
	}

	protected RootFiles getRootFiles(Container container) {
	for (Object o : container.getRootFilesOrAny()) {
	if (o instanceof JAXBElement) {
	@SuppressWarnings("rawtypes")
	JAXBElement jaxbElement = (JAXBElement) o;
	o = jaxbElement.getValue();
	}
	if (o instanceof RootFiles)
	return (RootFiles) o;
	}
	// Not found - add it
	RootFiles rootFiles = containerFactory.createContainerRootFiles();
	container.getRootFilesOrAny().add(
	containerFactory.createContainerRootFiles(rootFiles));
	return rootFiles;
	}

	@SuppressWarnings("rawtypes")
	public List<ResourceEntry> getRootFiles() {
	ArrayList<UCFPackage.ResourceEntry> rootFiles = new ArrayList<>();
	if (containerXml == null)
	return rootFiles;

	RootFiles rootFilesElem = getRootFiles(containerXml.getValue());
	for (Object anyOrRoot : rootFilesElem.getAnyOrRootFile()) {
	if (anyOrRoot instanceof JAXBElement)
	anyOrRoot = ((JAXBElement) anyOrRoot).getValue();
	if (!(anyOrRoot instanceof RootFile))
	continue;
	RootFile rf = (RootFile) anyOrRoot;
	ResourceEntry entry = getResourceEntry(rf.getFullPath());
	if (rf.getMediaType() != null
	&& rf.getMediaType() != entry.mediaType)
	// Override the mime type in the returned entry
	entry.mediaType = rf.getMediaType();
	rootFiles.add(entry);
	}
	return rootFiles;
	}

	public ResourceEntry getResourceEntry(String path) {
	OdfFileEntry odfFileEntry = odfPackage.getManifestEntries().get(path);
	if (odfFileEntry == null)
	return null;
	return new ResourceEntry(odfFileEntry);
	}

	@SuppressWarnings("rawtypes")
	public void unsetRootFile(String path) {
	Container container = containerXml.getValue();
	RootFiles rootFiles = getRootFiles(container);
	Iterator<Object> anyOrRootIt = rootFiles.getAnyOrRootFile().iterator();
	while (anyOrRootIt.hasNext()) {
	Object anyOrRoot = anyOrRootIt.next();
	if (anyOrRoot instanceof JAXBElement)
	anyOrRoot = ((JAXBElement) anyOrRoot).getValue();
	if (!(anyOrRoot instanceof RootFile))
	continue;
	RootFile rootFileElem = (RootFile) anyOrRoot;
	if (rootFileElem.getFullPath().equals(path))
	anyOrRootIt.remove();
	}
	}

	protected JAXBElement<Container> getContainerXML() {
	return containerXml;
	}

	public void save(OutputStream output) throws IOException {
	File tempFile = createTempFile("ucfpackage", ".tmp");
	prepareAndSave(tempFile);

	// Copy file to the output

	// Note - Should use IOUtils, but we're trying to avoid external dependencies
	try (InputStream inStream = new FileInputStream(tempFile)) {
	byte[] buffer = new byte[8192];
	int n = 0;
	do {
	output.write(buffer, 0, n);
	n = inStream.read(buffer);
	} while (n > -1);
	} finally {
	tempFile.delete();
	}
	}

	public OutputStream addResourceUsingOutputStream(String path,
	String mediaType) throws IOException {
	if (path.equals(CONTAINER_XML))
	// as we need to parse it after insertion, this must fail
	throw new IllegalArgumentException("Can't add " + CONTAINER_XML
	+ " using OutputStream");
	try {
	return odfPackage.insertOutputStream(path, mediaType);
	} catch (IOException e) {
	throw e;
	} catch (Exception e) {
	throw new IOException("Could not add " + path, e);
	}
	}

	@Override
	public UCFPackage clone() {
	final PipedOutputStream outputStream = new PipedOutputStream();
	try {
	try (PipedInputStream inputStream = copyToOutputStream(outputStream)) {
	return new UCFPackage(inputStream);
	}
	} catch (IOException e) {
	throw new RuntimeException("Could not clone UCFPackage", e);
	}
	}

	private PipedInputStream copyToOutputStream(
	final PipedOutputStream outputStream) throws IOException {
	PipedInputStream inputStream = new PipedInputStream(outputStream);
	new Thread("Cloning " + this) {
	@Override
	public void run() {
	try {
	try {
	save(outputStream);
	} finally {
	outputStream.close();
	}
	} catch (IOException e) {
	logger.log(INFO,
	"Could not save/close UCF package while cloning", e);
	}
	}
	}.start();
	return inputStream;
	}

	public String getRootFileVersion(String rootFile) {
	return getResourceEntry(rootFile).getVersion();
	}
	}