Metacat

import org.dataone.service.types.v1.NodeReference;

import org.dataone.service.types.v1.Replica;

import org.dataone.service.types.v1.ReplicationPolicy;

import org.dataone.service.types.v1.ReplicationStatus;

import org.dataone.service.types.v1.Session;

		setReplicationStatus() - PUT /replicationNotifications/PID

		updateReplicationMetadata() - PUT /replicationMetadata/PID

		setReplicationPolicy() - PUT /replicationPolicies/PID

		isNodeAuthorized() - GET /replicationAuthorizations/PID

    protected static final String RESOURCE_REPLICATION_POLICY = "replicaPolicies";

    protected static final String RESOURCE_REPLICATION_META = "replicaMetadata";

    protected static final String RESOURCE_REPLICATION_AUTHORIZED = "replicaAuthorizations";

    protected static final String RESOURCE_REPLICATION_NOTIFY = "replicaNotifications";

                } else if ( resource.startsWith(RESOURCE_REPLICATION_POLICY) && 

                        httpVerb == PUT) {

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

                    // get the trailing pid

                    extra = parseTrailing(resource, RESOURCE_REPLICATION_POLICY);

                    setReplicationPolicy(extra);

                    status = true;

                } else if ( resource.startsWith(RESOURCE_REPLICATION_META) && 

                        httpVerb == PUT) {

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

                    // get the trailing pid

                    extra = parseTrailing(resource, RESOURCE_REPLICATION_META);

                    updateReplicationMetadata(extra);

                    status = true;

                } else if ( resource.startsWith(RESOURCE_REPLICATION_NOTIFY) && 

                        httpVerb == PUT ) {

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

                    // get the trailing pid

                    extra = parseTrailing(resource, RESOURCE_REPLICATION_NOTIFY);

                    setReplicationStatus(extra);

                    status = true;

                } else if ( resource.startsWith(RESOURCE_REPLICATION_AUTHORIZED) 

                        && httpVerb == GET) {

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

                    // get the trailing pid

                    extra = parseTrailing(resource, RESOURCE_REPLICATION_AUTHORIZED);

                    isNodeAuthorized(extra);

                    status = true;

    private void owner(String id) 

        throws JiBXException, InvalidToken, ServiceFailure, 

        NotFound, NotAuthorized, NotImplemented, InvalidRequest, IOException, 

        InstantiationException, IllegalAccessException {

        Identifier pid = new Identifier();

		    pid.setValue(id);

        long serialVersion = 0L;

        String serialVersionStr = null;

        // get the serialVersion

        try {

            serialVersionStr = params.get("serialVersion")[0];

            serialVersion = new Long(serialVersionStr).longValue();

        } catch (NullPointerException e) {

            String msg = "The 'serialVersion' must be provided as a parameter and was not.";

            logMetacat.error(msg);

            throw new InvalidRequest("4442", msg);

        }		    

		    // get the subject

		    String subjectStr = params.get("subject")[0];

		    Subject subject = TypeMarshaller.unmarshalTypeFromStream(Subject.class, new ByteArrayInputStream(subjectStr.getBytes("UTF-8")));

		    Identifier retPid = CNodeService.getInstance(request).setOwner(session, pid, subject, serialVersion);

		    OutputStream out = response.getOutputStream();

		    response.setStatus(200);

		    response.setContentType("text/xml");

		    TypeMarshaller.marshalTypeToOutputStream(retPid, out);		

    protected void setAccess(String pid) 

        throws JiBXException, InvalidToken, ServiceFailure, NotFound, 

        NotAuthorized, NotImplemented, InvalidRequest, IOException, 

        InstantiationException, IllegalAccessException, ParserConfigurationException, 

        SAXException {

        long serialVersion = 0L;

        String serialVersionStr = null;

        // get the serialVersion

        try {

            serialVersionStr = params.get("serialVersion")[0];

            serialVersion = new Long(serialVersionStr).longValue();

        } catch (NullPointerException e) {

            String msg = "The 'serialVersion' must be provided as a parameter and was not.";

            logMetacat.error(msg);

            throw new InvalidRequest("4402", msg);

        }

        CNodeService.getInstance(request).setAccessPolicy(session, id, accessPolicy, serialVersion);

    private void query() 

        throws InvalidToken, ServiceFailure, NotAuthorized, InvalidRequest, NotImplemented {

    	  String query = null;

		    String queryType = null;

		    try {

		    	query = params.get("query")[0];

		    } catch (Exception e) {

		    	logMetacat.warn("query not specified");

		    }

		    try {

		    	String qt = params.get("queryType")[0];

		    	queryType = qt;

		    } catch (Exception e) {

		    	logMetacat.warn("queryType not specified");

		    }

        	// expecting to throw NotImplemented

		    CNodeService.getInstance(request).search(session, queryType, query);

    /**

     * Pass the request to get node replication authorization to CNodeService

     * 

     * @param pid  the identifier of the object to get authorization to replicate

     * 

     * @throws NotImplemented

     * @throws NotAuthorized

     * @throws InvalidToken

     * @throws ServiceFailure

     * @throws NotFound

     * @throws InvalidRequest

     */

    public boolean isNodeAuthorized(String pid) 

        throws NotImplemented, NotAuthorized, InvalidToken, ServiceFailure, 

        NotFound, InvalidRequest {

        boolean result = false;

        Subject targetNodeSubject = new Subject();

        String nodeSubject = null;

        Permission permission = null;

        String replPermission = null;

        // get the pid

        Identifier identifier = new Identifier();

        identifier.setValue(pid);

        // get the target node subject

        try {

            nodeSubject = params.get("targetNodeSubject")[0];

            targetNodeSubject.setValue(nodeSubject);

        } catch (NullPointerException e) {

            String msg = "The 'targetNodeSubject' must be provided as a parameter and was not.";

            logMetacat.error(msg);

            throw new InvalidRequest("4873", msg);

        }

        // get the permission

        try {

            replPermission = params.get("replicatePermission")[0];

            permission = Permission.convert(replPermission);

        } catch (NullPointerException e) {

            String msg = "The 'replicatePermission' must be provided as a parameter and was not.";

            logMetacat.error(msg);

            throw new InvalidRequest("4873", msg);

        }

        result =

            CNodeService.getInstance(request).isNodeAuthorized(session, targetNodeSubject, identifier, permission);

        response.setStatus(200);

        response.setContentType("text/xml");

        return result;

    }

    /**

     * Pass the request to set the replication policy to CNodeService

     * 

     * @param pid  the identifier of the object to set the replication policy on

     * 

     * @throws NotImplemented

     * @throws NotFound

     * @throws NotAuthorized

     * @throws ServiceFailure

     * @throws InvalidRequest

     * @throws InvalidToken

     * @throws IOException

     * @throws InstantiationException

     * @throws IllegalAccessException

     * @throws JiBXException

     */

    public boolean setReplicationPolicy(String pid) 

        throws NotImplemented, NotFound, NotAuthorized, ServiceFailure, 

        InvalidRequest, InvalidToken, IOException, InstantiationException, 

        IllegalAccessException, JiBXException {

        boolean result = false;

        ReplicationPolicy policy = null;

        long serialVersion = 0L;

        String serialVersionStr = null;

        Identifier identifier = new Identifier();

        identifier.setValue(pid);

        // get the serialVersion

        try {

            serialVersionStr = params.get("serialVersion")[0];

            serialVersion = new Long(serialVersionStr).longValue();

        } catch (NullPointerException e) {

            String msg = "The 'serialVersion' must be provided as a parameter and was not.";

            logMetacat.error(msg);

            throw new InvalidRequest("4883", msg);

        }

        policy = collectReplicationPolicy();

        result = 

            CNodeService.getInstance(request).setReplicationPolicy(session, identifier, policy, serialVersion);

        response.setStatus(200);

        response.setContentType("text/xml");

        return result;

    }

    /**

     * Pass the request to set the replication status to CNodeService

     * 

     * @param pid  the identifier of the object to set the replication status on

     * 

     * @throws ServiceFailure

     * @throws NotImplemented

     * @throws InvalidToken

     * @throws NotAuthorized

     * @throws InvalidRequest

     * @throws NotFound

     */

    public boolean setReplicationStatus(String pid) 

        throws ServiceFailure, NotImplemented, InvalidToken, NotAuthorized, 

        InvalidRequest, NotFound {

        boolean result = false;

        Identifier identifier = new Identifier();

        identifier.setValue(pid);

        long serialVersion = 0L;

        String serialVersionStr = null;

        ReplicationStatus status = null;

        String replicationStatus = null;

        NodeReference targetNodeRef = null;

        String targetNode = null;

        // get the serialVersion

        try {

            serialVersionStr = params.get("serialVersion")[0];

            serialVersion = new Long(serialVersionStr).longValue();

        } catch (NullPointerException e) {

            String msg = "The 'serialVersion' must be provided as a parameter and was not.";

            logMetacat.error(msg);

            throw new InvalidRequest("4730", msg);

        }

        // get the replication status param

        try {

            replicationStatus = params.get("status")[0];

            status = ReplicationStatus.convert(replicationStatus);

        } catch (Exception e) {

            // TODO Auto-generated catch block

            e.printStackTrace();

        }

        // get the target node reference param

        targetNode = params.get("nodeRef")[0];

        targetNodeRef = new NodeReference();

        targetNodeRef.setValue(targetNode);

        result = 

            CNodeService.getInstance(request).setReplicationStatus(session, identifier, targetNodeRef, status, serialVersion);       

        response.setStatus(200);

        response.setContentType("text/xml");

        return result;

    }

    /**

     * Pass the request to update the replication metadata to CNodeService

     * 

     * @param pid  the identifier of the object to update the replication metadata on

     * 

     * @throws ServiceFailure

     * @throws NotImplemented

     * @throws InvalidToken

     * @throws NotAuthorized

     * @throws InvalidRequest

     * @throws NotFound

     */

    public boolean updateReplicationMetadata(String pid) 

        throws ServiceFailure, NotImplemented, InvalidToken, NotAuthorized, 

        InvalidRequest, NotFound {

        boolean result = false;

        long serialVersion = 0L;

        String serialVersionStr = null;

        Replica replica = null;

        Identifier identifier = new Identifier();

        identifier.setValue(pid);

        // get the serialVersion

        try {

            serialVersionStr = params.get("serialVersion")[0];

            serialVersion = new Long(serialVersionStr).longValue();

        } catch (NullPointerException e) {

            String msg = "The 'serialVersion' must be provided as a parameter and was not.";

            logMetacat.error(msg);

            throw new InvalidRequest("4853", msg);

        }

        replica = collectReplicaMetadata();

        result = 

            CNodeService.getInstance(request).updateReplicationMetadata(session, identifier, replica, serialVersion);

        response.setStatus(200);

        response.setContentType("text/xml");

        return result;

    }