Metacat

import gov.loc.repository.bagit.Bag;

import gov.loc.repository.bagit.BagFactory;

import java.io.File;

import java.io.FileOutputStream;

    // MN packaging tests

    suite.addTest(new MNodeServiceTest("testGetPackage"));

	/**

	 * Test getting a known object

	 */

	public void testGetPackage() {

		printTestHeader("testGetPackage");

		try {

			Session session = getTestSession();

			Identifier guid = new Identifier();

			guid.setValue("testGetPackage." + System.currentTimeMillis());

			InputStream object = new ByteArrayInputStream("test".getBytes("UTF-8"));

			SystemMetadata sysmeta = createSystemMetadata(guid, session.getSubject(), object);

			Identifier pid = MNodeService.getInstance(request).create(session, guid, object, sysmeta);

			InputStream bagStream = MNodeService.getInstance(request).getPackage(session, pid);

			File bagFile = File.createTempFile("bagit", ".zip");

			IOUtils.copy(bagStream, new FileOutputStream(bagFile));

			BagFactory bagFactory = new BagFactory();

			Bag bag = bagFactory.createBag(bagFile);

			InputStream result = bag.getPayload().iterator().next().newInputStream();

			// go back to beginning of original stream

			object.reset();

			// check

			assertTrue(object.available() > 0);

			assertTrue(result.available() > 0);

			assertTrue(IOUtils.contentEquals(result, object));

			// clean up

			bagFile.delete();

		} catch (Exception e) {

			e.printStackTrace();

			fail("Unexpected error: " + e.getMessage());

		}

	}

import java.io.File;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import org.dataone.client.formats.ObjectFormatInfo;

import gov.loc.repository.bagit.Bag;

import gov.loc.repository.bagit.BagFactory;

import gov.loc.repository.bagit.writer.Writer;

import gov.loc.repository.bagit.writer.impl.ZipWriter;

	/**

	 * Packages the given package in a Bagit collection for download

	 * @param pid

	 * @throws IOException 

	 * @throws NotImplemented 

	 * @throws NotFound 

	 * @throws NotAuthorized 

	 * @throws ServiceFailure 

	 * @throws InvalidToken 

	 * @throws OREParserException 

	 * @throws URISyntaxException 

	 * @throws OREException 

	 */

	public InputStream getPackage(Session session, Identifier pid) throws IOException, InvalidToken, ServiceFailure, NotAuthorized, NotFound, NotImplemented, OREException, URISyntaxException, OREParserException {

		InputStream bagInputStream = null;

		BagFactory bagFactory = new BagFactory();

		Bag bag = bagFactory.createBag();

		// track the temp files we use so we can delete them when finished

		List<File> tempFiles = new ArrayList<File>();

		// the pids to include in the package

		List<Identifier> packagePids = new ArrayList<Identifier>();

		// find the package contents

		SystemMetadata sysMeta = this.getSystemMetadata(session, pid);

		if (ObjectFormatService.getInstance().getFormat(sysMeta.getFormatId()).getFormatType().equals("RESOURCE")) {

			InputStream oreInputStream = this.get(session, pid);

			Map<Identifier, Map<Identifier, List<Identifier>>> resourceMapStructure = ResourceMapFactory.getInstance().parseResourceMap(oreInputStream);

			packagePids.addAll(resourceMapStructure.keySet());

			for (Map<Identifier, List<Identifier>> entries: resourceMapStructure.values()) {

				packagePids.addAll(entries.keySet());

				for (List<Identifier> dataPids: entries.values()) {

					packagePids.addAll(dataPids);

				}

			}

		} else {

			// just the lone pid in this package

			packagePids.add(pid);

		}

		// loop through the package contents

		for (Identifier entryPid: packagePids) {

			SystemMetadata entrySysMeta = this.getSystemMetadata(session, entryPid);

			String extension = ObjectFormatInfo.instance().getExtension(entrySysMeta.getFormatId().getValue());

	        String prefix = entryPid.getValue();

			File tempFile = File.createTempFile(prefix + "_bagit", extension);

			tempFiles.add(tempFile);

			InputStream entryInputStream = this.get(session, entryPid);

			IOUtils.copy(entryInputStream, new FileOutputStream(tempFile));

			bag.addFileToPayload(tempFile);

		}

		bag = bag.makeComplete();

		File bagFile = File.createTempFile("bagit", ".zip");

		// TODO: delete more confidently

		bagFile.deleteOnExit();

		bag.setFile(bagFile);

		Writer zipWriter = new ZipWriter(bagFactory);

		bag.write(zipWriter, bagFile);

		bagFile = bag.getFile();

		bagInputStream = new FileInputStream(bagFile);

		// clean up temp entry files

		for (File tf: tempFiles) {

			tf.delete();

		}

		return bagInputStream;

	}

    		<groupId>gov.loc</groupId>

			<artifactId>bagit</artifactId>

			<version>4.4</version>

			<type>jar</type>

			<exclusions>

				<exclusion>

					<groupId>xml-apis</groupId>

					<artifactId>xml-apis</artifactId>

		        </exclusion>

		        <exclusion>

					<groupId>org.apache.httpcomponents</groupId>

					<artifactId>httpclient</artifactId>

		        </exclusion>

		        <exclusion>

		        	<groupId>org.apache.httpcomponents</groupId>

    				<artifactId>httpmime</artifactId>

		        </exclusion>

		        <exclusion>

					<groupId>commons-codec</groupId>

					<artifactId>commons-codec</artifactId>

		        </exclusion>

			</exclusions>

    	</dependency>

    	<dependency>