Metacat

    protected static final String RESOURCE_PUBLISH = "publish";

                } else if (resource.startsWith(RESOURCE_PUBLISH)) {

                    logMetacat.debug("Using resource: " + RESOURCE_PUBLISH);

                    // PUT

                    if (httpVerb == PUT) {

                    	// after the command

                        extra = parseTrailing(resource, RESOURCE_PUBLISH);

                        publish(extra);

                        status = true;

                    }  

                        extra = parseTrailing(resource, RESOURCE_PACKAGE);

	protected void publish(String pid) throws InvalidToken, ServiceFailure,

			NotAuthorized, NotFound, NotImplemented, IOException,

			JiBXException, InvalidRequest, IdentifierNotUnique,

			UnsupportedType, InsufficientResources, InvalidSystemMetadata {

		// publish the object

		Identifier originalIdentifier = new Identifier();

		originalIdentifier.setValue(pid);

		Identifier newIdentifier = MNodeService.getInstance(request).publish(session, originalIdentifier);

		response.setStatus(200);

		response.setContentType("text/xml");

		OutputStream out = response.getOutputStream();

		// write new identifier to the output stream

		TypeMarshaller.marshalTypeToOutputStream(newIdentifier, out);

	}

	 * @throws InvalidRequest 

	 * @throws NotImplemented 

	 * @throws NotAuthorized 

	 * @throws ServiceFailure 

	 * @throws InvalidToken 

	 * @throws InvalidSystemMetadata 

	 * @throws InsufficientResources 

	 * @throws UnsupportedType 

	 * @throws IdentifierNotUnique 

	public Identifier publish(Session session, Identifier originalIdentifier) throws InvalidToken, ServiceFailure, NotAuthorized, NotImplemented, InvalidRequest, NotFound, IdentifierNotUnique, UnsupportedType, InsufficientResources, InvalidSystemMetadata {

		this.update(session, originalIdentifier, inputStream, newIdentifier, sysmeta);

		// update ORE that references the scimeta

		// TODO: better ORE location algorithm -- this is just convention for generated resource maps and is fragile

			String localId = IdentifierManager.getInstance().getLocalId(originalIdentifier.getValue());

			Identifier potentialOreIdentifier = new Identifier();

			potentialOreIdentifier.setValue(SystemMetadataFactory.RESOURCE_MAP_PREFIX + localId);

			InputStream oreInputStream = null;

			try {

				oreInputStream = this.get(session, potentialOreIdentifier);

			} catch (NotFound nf) {

				// this is probably okay for many sci meta data docs

				logMetacat.warn("No potential ORE map found for: " + potentialOreIdentifier.getValue());

			}

			if (oreInputStream != null) {

				Identifier newOreIdentifier = MNodeService.getInstance(request).generateIdentifier(session, MNodeService.UUID_SCHEME, null);

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

				Map<Identifier, List<Identifier>> sciMetaMap = resourceMapStructure.get(potentialOreIdentifier);

				List<Identifier> dataIdentifiers = sciMetaMap.get(originalIdentifier);

				// TODO: ensure all data package objects allow public read

				// reconstruct the ORE with the new identifiers

				sciMetaMap.remove(originalIdentifier);

				sciMetaMap.put(newIdentifier, dataIdentifiers);

				ResourceMap resourceMap = ResourceMapFactory.getInstance().createResourceMap(newOreIdentifier, sciMetaMap);

				String resourceMapString = ResourceMapFactory.getInstance().serializeResourceMap(resourceMap);

				// get the original ORE SM and update the values

				SystemMetadata oreSysMeta = this.getSystemMetadata(session, potentialOreIdentifier);

				oreSysMeta.setIdentifier(newOreIdentifier);

				oreSysMeta.setObsoletes(potentialOreIdentifier);

				oreSysMeta.setObsoletedBy(null);

				oreSysMeta.setSize(BigInteger.valueOf(resourceMapString.getBytes("UTF-8").length));

				oreSysMeta.setChecksum(ChecksumUtil.checksum(resourceMapString.getBytes("UTF-8"), oreSysMeta.getChecksum().getAlgorithm()));

				// save the updated ORE

				this.update(

						session, 

						potentialOreIdentifier, 

						new ByteArrayInputStream(resourceMapString.getBytes("UTF-8")), 

						newOreIdentifier, 

						oreSysMeta);

			}

		} catch (McdbDocNotFoundException e) {

			// report as service failure

			ServiceFailure sf = new ServiceFailure("1030", e.getMessage());

			sf.initCause(e);

			throw sf;

		} catch (UnsupportedEncodingException e) {

			// report as service failure

			ServiceFailure sf = new ServiceFailure("1030", e.getMessage());

			sf.initCause(e);

			throw sf;

		} catch (OREException e) {

			// report as service failure

			ServiceFailure sf = new ServiceFailure("1030", e.getMessage());

			sf.initCause(e);

			throw sf;

		} catch (URISyntaxException e) {

			// report as service failure

			ServiceFailure sf = new ServiceFailure("1030", e.getMessage());

			sf.initCause(e);

			throw sf;

		} catch (OREParserException e) {

			// report as service failure

			ServiceFailure sf = new ServiceFailure("1030", e.getMessage());

			sf.initCause(e);

			throw sf;

		} catch (ORESerialiserException e) {

			// report as service failure

			ServiceFailure sf = new ServiceFailure("1030", e.getMessage());

			sf.initCause(e);

			throw sf;

		} catch (NoSuchAlgorithmException e) {

			// report as service failure

			ServiceFailure sf = new ServiceFailure("1030", e.getMessage());

			sf.initCause(e);

			throw sf;