Metacat

/**

 *  '$RCSfile$'

 *  Copyright: 2000-2011 Regents of the University of California and the

 *              National Center for Ecological Analysis and Synthesis

 *

 *   '$Author: cjones $'

 *     '$Date: 2011-06-29 17:50:56 -0700 (Wed, 29 Jun 2011) $'

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 */

package edu.ucsb.nceas.metacat.dataone;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

import java.sql.SQLException;

import java.util.ArrayList;

import java.util.Calendar;

import java.util.Date;

import java.util.Enumeration;

import java.util.Hashtable;

import java.util.List;

import java.util.Timer;

import java.util.TimerTask;

import java.util.Vector;

import javax.servlet.http.HttpServletRequest;

import org.apache.commons.io.IOUtils;

import org.apache.log4j.Logger;

import org.dataone.client.ObjectFormatCache;

import org.dataone.service.exceptions.IdentifierNotUnique;

import org.dataone.service.exceptions.InsufficientResources;

import org.dataone.service.exceptions.InvalidRequest;

import org.dataone.service.exceptions.InvalidSystemMetadata;

import org.dataone.service.exceptions.InvalidToken;

import org.dataone.service.exceptions.NotAuthorized;

import org.dataone.service.exceptions.NotFound;

import org.dataone.service.exceptions.NotImplemented;

import org.dataone.service.exceptions.ServiceFailure;

import org.dataone.service.exceptions.UnsupportedType;

import org.dataone.service.types.AccessPolicy;

import org.dataone.service.types.AccessRule;

import org.dataone.service.types.Event;

import org.dataone.service.types.Identifier;

import org.dataone.service.types.Group;

import org.dataone.service.types.Log;

import org.dataone.service.types.LogEntry;

import org.dataone.service.types.NodeReference;

import org.dataone.service.types.ObjectFormat;

import org.dataone.service.types.Permission;

import org.dataone.service.types.Person;

import org.dataone.service.types.Session;

import org.dataone.service.types.Subject;

import org.dataone.service.types.SubjectList;

import org.dataone.service.types.SystemMetadata;

import edu.ucsb.nceas.metacat.AccessionNumberException;

import edu.ucsb.nceas.metacat.DocumentImpl;

import edu.ucsb.nceas.metacat.EventLog;

import edu.ucsb.nceas.metacat.IdentifierManager;

import edu.ucsb.nceas.metacat.McdbDocNotFoundException;

import edu.ucsb.nceas.metacat.McdbException;

import edu.ucsb.nceas.metacat.MetacatHandler;

import edu.ucsb.nceas.metacat.client.InsufficientKarmaException;

import edu.ucsb.nceas.metacat.properties.PropertyService;

import edu.ucsb.nceas.metacat.replication.ForceReplicationHandler;

import edu.ucsb.nceas.metacat.util.SessionData;

import edu.ucsb.nceas.metacat.util.SystemUtil;

import edu.ucsb.nceas.utilities.ParseLSIDException;

import edu.ucsb.nceas.utilities.PropertyNotFoundException;

public abstract class D1NodeService {

  private static Logger logMetacat = Logger.getLogger(D1NodeService.class);

  /* the metacat URL as a string (including ending /d1 service)*/

  protected String metacatUrl;

  /* reference to the metacat handler */

  private MetacatHandler handler;

  /* parameters set in the incoming request */

  private Hashtable<String, String[]> params;

  /**

   * Constructor - used to set the metacatUrl from a subclass extending D1NodeService

   * 

   * @param metacatUrl - the URL of the metacat service, including the ending /d1

   */

  public D1NodeService() {

  	this.metacatUrl = "";

    try {

	    this.metacatUrl = SystemUtil.getContextURL() + 

	    PropertyService.getProperty("dataone.serviceName");

    } catch (PropertyNotFoundException e) {

      throw new RuntimeException("Error getting the servlet url in D1NodeService: " + 

        	e.getMessage());

    }

  }

  /**

   * Adds a new object to the Node, where the object is either a data 

   * object or a science metadata object. This method is called by clients 

   * to create new data objects on Member Nodes or internally for Coordinating

   * Nodes

   * 

   * @param session - the Session object containing the credentials for the Subject

   * @param pid - The object identifier to be created

   * @param object - the object bytes

   * @param sysmeta - the system metadata that describes the object  

   * 

   * @return pid - the object identifier created

   * 

   * @throws InvalidToken

   * @throws ServiceFailure

   * @throws NotAuthorized

   * @throws IdentifierNotUnique

   * @throws UnsupportedType

   * @throws InsufficientResources

   * @throws InvalidSystemMetadata

   * @throws NotImplemented

   * @throws InvalidRequest

   */

  public Identifier create(Session session, Identifier pid, InputStream object,

    SystemMetadata sysmeta) 

    throws InvalidToken, ServiceFailure, NotAuthorized, IdentifierNotUnique, 

    UnsupportedType, InsufficientResources, InvalidSystemMetadata, 

    NotImplemented, InvalidRequest {

    Identifier resultPid = null;

    String localId = null;

    Subject subject = session.getSubject();

    boolean allowed = false;

    // be sure the user is authenticated for create()

    if (subject.getValue() == null || 

        subject.getValue().toLowerCase().equals("public") ) {

      throw new NotAuthorized("1100", "The provided identity does not have " +

        "permission to WRITE to the Member Node.");

    }

    // verify that pid == SystemMetadata.getIdentifier()

    logMetacat.debug("Comparing pid|sysmeta_pid: " + 

      pid.getValue() + "|" + sysmeta.getIdentifier().getValue());

    if (!pid.getValue().equals(sysmeta.getIdentifier().getValue())) {

        throw new InvalidSystemMetadata("1180", 

            "The supplied system metadata is invalid. " +

            "The identifier " + pid.getValue() + " does not match identifier" +

            "in the system metadata identified by " +

            sysmeta.getIdentifier().getValue() + ".");

    }

    logMetacat.debug("Checking if identifier exists...");

    // Check that the identifier does not already exist

    IdentifierManager im = IdentifierManager.getInstance();

    if (im.identifierExists(pid.getValue())) {

        throw new IdentifierNotUnique("1120", 

          "The requested identifier " + pid.getValue() +

          " is already used by another object and" +

          "therefore can not be used for this object. Clients should choose" +

          "a new identifier that is unique and retry the operation or " +

          "use CN_crud.reserveIdentifier() to reserve one.");

    }

    // check for permission

    try {

      allowed = isAuthorized(session, pid, Permission.WRITE);

    } catch (NotFound e) {

      // The identifier doesn't exist, writing should be fine.

      allowed = true;

    }

    // we have the go ahead

    if ( allowed ) {

      // Science metadata (XML) or science data object?

      // TODO: there are cases where certain object formats are science metadata

      // but are not XML (netCDF ...).  Handle this.

      if ( isScienceMetadata(sysmeta) ) {

        // CASE METADATA:

      	String objectAsXML = "";

        try {

	        objectAsXML = IOUtils.toString(object, "UTF-8");

	        localId = insertOrUpdateDocument(objectAsXML, pid, session, "insert");

	        //localId = im.getLocalId(pid.getValue());

        } catch (IOException e) {

        	String msg = "The Node is unable to create the object. " +

          "There was a problem converting the object to XML";

        	logMetacat.info(msg);

          throw new ServiceFailure("1190", msg + ": " + e.getMessage());

        }

      }

    } else {

      // DEFAULT CASE: DATA (needs to be checked and completed)

      //localId = insertDataObject(object, pid, session);

    }

    // setting the resulting identifier failed

    if (resultPid == null ) {

      throw new ServiceFailure("1190", "The Node is unable to create the object. " +

        "The resulting identifier was null.");

    }

    return resultPid;

  }

  /**

   * Return the log records associated with a given event between the start and 

   * end dates listed given a particular Subject listed in the Session

   * 

   * @param session - the Session object containing the credentials for the Subject

   * @param fromDate - the start date of the desired log records

   * @param toDate - the end date of the desired log records

   * @param event - restrict log records of a specific event type

   * @param start - zero based offset from the first record in the 

   *                set of matching log records. Used to assist with 

   *                paging the response.

   * @param count - maximum number of log records to return in the response. 

   *                Used to assist with paging the response.

   * 

   * @return the desired log records

   * 

   * @throws InvalidToken

   * @throws ServiceFailure

   * @throws NotAuthorized

   * @throws InvalidRequest

   * @throws NotImplemented

   */

  public Log getLogRecords(Session session, Date fromDate, Date toDate, 

      Event event, Integer start, Integer count) throws InvalidToken, ServiceFailure,

      NotAuthorized, InvalidRequest, NotImplemented {

    Log log = new Log();

    Vector<LogEntry> logs = new Vector<LogEntry>();

    IdentifierManager im = IdentifierManager.getInstance();

    EventLog el = EventLog.getInstance();

    if (fromDate == null) {

      logMetacat.debug("setting fromdate from null");

      fromDate = new Date(1);

    }

    if (toDate == null) {

      logMetacat.debug("setting todate from null");

      toDate = new Date();

    }

    logMetacat.debug("fromDate: " + fromDate);

    logMetacat.debug("toDate: " + toDate);

    String report = el.getReport(null, null, null, null,

        new java.sql.Timestamp(fromDate.getTime()),

        new java.sql.Timestamp(toDate.getTime()), false);

    logMetacat.debug("report: " + report);

    String logEntry = "<logEntry>";

    String endLogEntry = "</logEntry>";

    int startIndex = 0;

    int foundIndex = report.indexOf(logEntry, startIndex);

    while (foundIndex != -1) {

      // parse out each entry

      int endEntryIndex = report.indexOf(endLogEntry, foundIndex);

      String entry = report.substring(foundIndex, endEntryIndex);

      logMetacat.debug("entry: " + entry);

      startIndex = endEntryIndex + endLogEntry.length();

      foundIndex = report.indexOf(logEntry, startIndex);

      String entryId = getLogEntryField("entryid", entry);

      String ipAddress = getLogEntryField("ipAddress", entry);

      String principal = getLogEntryField("principal", entry);

      String docid = getLogEntryField("docid", entry);

      String eventS = getLogEntryField("event", entry);

      String dateLogged = getLogEntryField("dateLogged", entry);

      LogEntry le = new LogEntry();

      Event e = Event.convert(eventS);

      if (e == null) { // skip any events that are not Dataone Crud events

        continue;

      }

      le.setEvent(e);

      Identifier entryid = new Identifier();

      entryid.setValue(entryId);

      le.setEntryId(entryid);

      Identifier identifier = new Identifier();

      try {

        logMetacat.debug("converting docid '" + docid + "' to a pid.");

        if (docid == null || docid.trim().equals("") || docid.trim().equals("null")) {

          continue;

        }

        docid = docid.substring(0, docid.lastIndexOf("."));

        identifier.setValue(im.getGUID(docid, im.getLatestRevForLocalId(docid)));

      } catch (Exception ex) { 

        // try to get the pid, if that doesn't

        // work, just use the local id

        // throw new ServiceFailure("1030",

        // "Error getting pid for localId " +

        // docid + ": " + ex.getMessage());\

        // skip it if the pid can't be found

        continue;

      }

      le.setIdentifier(identifier);

      le.setIpAddress(ipAddress);

      Calendar c = Calendar.getInstance();

      String year = dateLogged.substring(0, 4);

      String month = dateLogged.substring(5, 7);

      String date = dateLogged.substring(8, 10);

      logMetacat.debug("year: " + year + " month: " + month + " day: " + date);

      c.set(new Integer(year).intValue(), new Integer(month).intValue(),

          new Integer(date).intValue());

      Date logDate = c.getTime();

      le.setDateLogged(logDate);

      NodeReference memberNode = new NodeReference();

      memberNode.setValue(ipAddress);

      le.setMemberNode(memberNode);

      Subject princ = new Subject();

      princ.setValue(principal);

      le.setSubject(princ);

      le.setUserAgent("metacat/RESTService");

      if (event == null) {

        logs.add(le);

      }

      if (event != null

          && e.toString().toLowerCase().trim().equals(

              event.toString().toLowerCase().trim())) {

        logs.add(le);

      }

    }

    log.setLogEntryList(logs);

    logMetacat.info("getLogRecords");

    return log;

  }

  /**

   * Return the object identified by the given object identifier

   * 

   * @param session - the Session object containing the credentials for the Subject

   * @param pid - the object identifier for the given object

   * 

   * TODO: The D1 Authorization API doesn't provide information on which 

   * authentication system the Subject belongs to, and so it's not possible to

   * discern which Person or Group is a valid KNB LDAP DN.  Fix this.

   * 

   * @return inputStream - the input stream of the given object

   * 

   * @throws InvalidToken

   * @throws ServiceFailure

   * @throws NotAuthorized

   * @throws InvalidRequest

   * @throws NotImplemented

   */

  public InputStream get(Session session, Identifier pid) 

    throws InvalidToken, ServiceFailure, NotAuthorized, NotFound, 

    NotImplemented, InvalidRequest {

    InputStream inputStream = null; // bytes to be returned

    handler = new MetacatHandler(new Timer());

    boolean allowed = false;

    String localId; // the metacat docid for the pid

    // get the local docid from Metacat

    try {

      localId = IdentifierManager.getInstance().getLocalId(pid.getValue());

    } catch (McdbDocNotFoundException e) {

      throw new NotFound("1020", "The object specified by " + 

                         pid.getValue() +

                         "does not exist at this node.");

    }

    // check for authorization

    allowed = isAuthorized(session, pid, Permission.READ);

    // if the person is authorized, perform the read

    if ( allowed ) {

      // get the object bytes

      // TODO: stream to file to stream conversion throughout Metacat needs to

      // be resolved

      File tmpDir;

      try

      {

          tmpDir = new File(PropertyService.getProperty("application.tempDir"));

      }

      catch(PropertyNotFoundException pnfe)

      {

          logMetacat.error("D1NodeService.get(): " +

                  "application.tmpDir not found.  Using /tmp instead.");

          tmpDir = new File("/tmp");

      }

      Date d = new Date();

      final File outputFile = new File(tmpDir, "metacat.output." + d.getTime());

      FileOutputStream dataSink;

      try {

        dataSink = new FileOutputStream(outputFile);

        handler.read(localId);

      } catch (FileNotFoundException e) {

        throw new ServiceFailure("1020", "The object specified by " + 

            pid.getValue() +

            "could not be returned due to a file read error: " +

            e.getMessage());

      } catch (PropertyNotFoundException e) {

        throw new ServiceFailure("1020", "The object specified by " + 

            pid.getValue() +

            "could not be returned due to an internal error: " +

            e.getMessage());

      } catch (ClassNotFoundException e) {

        throw new ServiceFailure("1020", "The object specified by " + 

            pid.getValue() +

            "could not be returned due to an internal error: " +

            e.getMessage());

      } catch (IOException e) {

        throw new ServiceFailure("1020", "The object specified by " + 

            pid.getValue() +

            "could not be returned due to a file read error: " +

            e.getMessage());

      } catch (SQLException e) {

        throw new ServiceFailure("1020", "The object specified by " + 

            pid.getValue() +

            "could not be returned due to a database error: " +

            e.getMessage());

      } catch (McdbException e) {

        throw new ServiceFailure("1020", "The object specified by " + 

            pid.getValue() +

            "could not be returned due to database error: " +

            e.getMessage());

      } catch (ParseLSIDException e) {

        throw new ServiceFailure("1020", "The object specified by " + 

            pid.getValue() +

            "could not be returned due to a parse error: " +

            e.getMessage());

      }

      //set a timer to clean up the temp files

      Timer t = new Timer();

      TimerTask tt = new TimerTask() {

          @Override

          public void run()

          {

              outputFile.delete();

          }

      };

      t.schedule(tt, 20000); //schedule after 20 secs

      try {

        inputStream = new FileInputStream(outputFile);

      } catch (FileNotFoundException e) {

        throw new ServiceFailure("1020", "The object specified by " + 

          pid.getValue() +

          "could not be returned due to a file read error: " +

          e.getMessage());

      }      

    }

    // if we fail to set the input stream

    if ( inputStream == null ) {

      throw new NotFound("1020", "The object specified by " + 

                         pid.getValue() +

                         "does not exist at this node.");

    }

    return inputStream;

  }

  /**

   * Return the system metadata for a given object

   * 

   * @param session - the Session object containing the credentials for the Subject

   * @param pid - the object identifier for the given object

   * 

   * @return inputStream - the input stream of the given system metadata object

   * 

   * @throws InvalidToken

   * @throws ServiceFailure

   * @throws NotAuthorized

   * @throws NotFound

   * @throws InvalidRequest

   * @throws NotImplemented

   */

  public SystemMetadata getSystemMetadata(Session session, Identifier pid)

    throws InvalidToken, ServiceFailure, NotAuthorized, NotFound,

    InvalidRequest, NotImplemented {

    if (!isAuthorized(session, pid, Permission.READ)) {

      throw new NotAuthorized("1400", Permission.READ + " not allowed on " + pid.getValue());  

    }

    SystemMetadata systemMetadata = null;

    try {

      systemMetadata = IdentifierManager.getInstance().getSystemMetadata(pid.getValue());

    } catch (McdbDocNotFoundException e) {

      throw new NotFound("1420", "No record found for: " + pid.getValue());

    }

    return systemMetadata;

  }

  /**

   * Set access for a given object using the object identifier and a Subject

   * under a given Session.

   * 

   * @param session - the Session object containing the credentials for the Subject

   * @param pid - the object identifier for the given object to apply the policy

   * @param policy - the access policy to be applied

   * 

   * @return true if the application of the policy succeeds

   * @throws InvalidToken

   * @throws ServiceFailure

   * @throws NotFound

   * @throws NotAuthorized

   * @throws NotImplemented

   * @throws InvalidRequest

   */

  public boolean setAccessPolicy(Session session, Identifier pid, 

    AccessPolicy accessPolicy) 

    throws InvalidToken, ServiceFailure, NotFound, NotAuthorized, 

    NotImplemented, InvalidRequest {

    boolean success = false;

    // get the subject

    Subject subject = session.getSubject();

    // get the system metadata

    String pidStr = pid.getValue();

    // are we allowed to do this?

    if (!isAuthorized(session, pid, Permission.CHANGE_PERMISSION)) {

      throw new NotAuthorized("4420", "not allowed by " + subject.getValue() + " on " + pidStr);  

    }

    SystemMetadata systemMetadata = null;

    try {

      systemMetadata = IdentifierManager.getInstance().getSystemMetadata(pidStr);

    } catch (McdbDocNotFoundException e) {

      throw new NotFound("4400", "No record found for: " + pid);

    }

    // set the access policy

    systemMetadata.setAccessPolicy(accessPolicy);

    // update the metadata

    try {

      IdentifierManager.getInstance().updateSystemMetadata(systemMetadata);

      success = true;

    } catch (McdbDocNotFoundException e) {

      throw new ServiceFailure("4430", e.getMessage());

    }

    return success;

  }

  /**

   * Test if the user identified by the provided token has authorization 

   * for operation on the specified object.

   * 

   * @param session - the Session object containing the credentials for the Subject

   * @param pid - The identifer of the resource for which access is being checked

   * @param operation - The type of operation which is being requested for the given pid

   *

   * @return true if the operation is allowed

   * 

   * @throws ServiceFailure

   * @throws InvalidToken

   * @throws NotFound

   * @throws NotAuthorized

   * @throws NotImplemented

   * @throws InvalidRequest

   */

  public boolean isAuthorized(Session session, Identifier pid, Permission permission)

    throws ServiceFailure, InvalidToken, NotFound, NotAuthorized,

    NotImplemented, InvalidRequest {

    boolean allowed = false;

    // get the subjects from the session

    List<Subject> subjects = new ArrayList<Subject>();

    Subject subject = session.getSubject();

    if (subject != null) {

    	subjects.add(subject);

    }

    SubjectList subjectList = session.getSubjectList();

    if (subjectList != null) {

    	List<Person> personList = subjectList.getPersonList();

    	if (personList != null) {

		    for (Person p: personList) {

		      subjects.add(p.getSubject());

		    }

    	}

    	List<Group> groupList = subjectList.getGroupList();

    	if (groupList != null) {

		    for (Group g: groupList) {

		      subjects.add(g.getSubject());

		    }

    	}

    }

    // get the system metadata

    String pidStr = pid.getValue();

    SystemMetadata systemMetadata = null;

    try {

      systemMetadata = IdentifierManager.getInstance().getSystemMetadata(pidStr);

    } catch (McdbDocNotFoundException e) {

      throw new NotFound("1800", "No record found for " + pidStr);

    }

    try {

	    List<AccessRule> allows = systemMetadata.getAccessPolicy().getAllowList();

	    for (AccessRule accessRule: allows) {

	      for (Subject s: subjects) {

	        if (accessRule.getSubjectList().contains(s)) {

	          allowed = accessRule.getPermissionList().contains(permission);

	          if (allowed) {

	        	  break;

	          }

	        }

	      }

	    }

    } catch (Exception e) {

    	// catch all for errors - safe side should be to deny the access

    	logMetacat.error("Problem checking authorization - defaulting to deny", e);

		allowed = false;

	}

    // throw or return?

    if (!allowed) {

      throw new NotAuthorized("1820", permission + " not allowed on " + pidStr);

    }

    return allowed;

  }

  /**

   * parse a logEntry and get the relevant field from it

   * 

   * @param fieldname

   * @param entry

   * @return

   */

  private String getLogEntryField(String fieldname, String entry) {

    String begin = "<" + fieldname + ">";

    String end = "</" + fieldname + ">";

    // logMetacat.debug("looking for " + begin + " and " + end +

    // " in entry " + entry);

    String s = entry.substring(entry.indexOf(begin) + begin.length(), entry

        .indexOf(end));

    logMetacat.debug("entry " + fieldname + " : " + s);

    return s;

  }

  /** 

   * Determine if a given object should be treated as an XML science metadata

   * object. 

   * 

   * @param sysmeta - the SystemMetadata describing the object

   * @return true if the object should be treated as science metadata

   */

  private boolean isScienceMetadata(SystemMetadata sysmeta) {

    ObjectFormat objectFormat = null;

    boolean isScienceMetadata = false;

    try {

      objectFormat = ObjectFormatCache.getInstance().getFormat(sysmeta.getObjectFormat().getFmtid());

      isScienceMetadata = objectFormat.isScienceMetadata();

    } catch (InvalidRequest e) {

       logMetacat.debug("There was a problem determining if the object identified by" + 

         sysmeta.getIdentifier().getValue() + 

         " is science metadata: " + e.getMessage());

    } catch (ServiceFailure e) {

      logMetacat.debug("There was a problem determining if the object identified by" + 

          sysmeta.getIdentifier().getValue() + 

          " is science metadata: " + e.getMessage());

    } catch (NotFound e) {

      logMetacat.debug("There was a problem determining if the object identified by" + 

          sysmeta.getIdentifier().getValue() + 

          " is science metadata: " + e.getMessage());

    } catch (InsufficientResources e) {

      logMetacat.debug("There was a problem determining if the object identified by" + 

          sysmeta.getIdentifier().getValue() + 

          " is science metadata: " + e.getMessage());

    } catch (NotImplemented e) {

      logMetacat.debug("There was a problem determining if the object identified by" + 

          sysmeta.getIdentifier().getValue() + 

          " is science metadata: " + e.getMessage());

    }

    return isScienceMetadata;

  }

  /**

   * Insert or update an XML document into Metacat

   * 

   * @param xml - the XML document to insert or update

   * @param pid - the identifier to be used for the resulting object

   * 

   * @return localId - the resulting docid of the document created or updated

   * 

   */

  protected String insertOrUpdateDocument(String xml, Identifier pid, 

    Session session, String insertOrUpdate) 

    throws ServiceFailure {

  	logMetacat.debug("Starting to insert xml document...");

    IdentifierManager im = IdentifierManager.getInstance();

    // generate pid/localId pair for sysmeta

    String localId = null;

    if(insertOrUpdate.equals("insert")) {

      localId = im.generateLocalId(pid.getValue(), 1);

    } else {

      //localid should already exist in the identifier table, so just find it

      try {

        logMetacat.debug("Updating pid " + pid.getValue());

        logMetacat.debug("looking in identifier table for pid " + pid.getValue());

        localId = im.getLocalId(pid.getValue());

        logMetacat.debug("localId: " + localId);

        //increment the revision

        String docid = localId.substring(0, localId.lastIndexOf("."));

        String revS = localId.substring(localId.lastIndexOf(".") + 1, localId.length());

        int rev = new Integer(revS).intValue();

        rev++;

        docid = docid + "." + rev;

        localId = docid;

        logMetacat.debug("incremented localId: " + localId);

      } catch(McdbDocNotFoundException e) {

        throw new ServiceFailure("1030", "D1NodeService.insertOrUpdateDocument(): " +

            "pid " + pid.getValue() + 

            " should have been in the identifier table, but it wasn't: " + 

            e.getMessage());

      }

    }

    String[] action = new String[1];

    action[0] = insertOrUpdate;

    params.put("action", action);

    String[] docid = new String[1];

    docid[0] = localId;

    params.put("docid", docid);

    String[] doctext = new String[1];

    doctext[0] = xml;

    params.put("doctext", doctext);

    String username = "public";

    String[] groupnames = null;

    if( session != null ) {

      username = session.getSubject().getValue();

      List<Group> groupList = session.getSubjectList().getGroupList();

      for ( int i = 0; i > groupList.size(); i++ ) {

      	groupnames[i] = groupList.get(i).getGroupName();

      }

    }

    // do the insert or update action

    String result = handler.handleInsertOrUpdateAction(metacatUrl, null, 

                        null, params, username, groupnames);

    if(result.indexOf("<error>") != -1) {

    	String detailCode = "";

    	if ( insertOrUpdate.equals("insert") ) {

    		detailCode = "1190";

    	} else if ( insertOrUpdate.equals("update") ) {

    		detailCode = "1310";

    	}

        throw new ServiceFailure(detailCode, 

          "Error inserting or updating document: " + result);

    }

    logMetacat.debug("Finsished inserting xml document with id " + localId);

    return localId;

  }

  /**

   * Insert a data document

   * 

   * @param object

   * @param pid

   * @param sessionData

   * @throws ServiceFailure

   * @returns localId of the data object inserted

   */

  private String insertDataObject(InputStream object, Identifier pid, 

          Session session) throws ServiceFailure {

    String username = "public";

    String[] groupnames = null;

    if( session != null ) {

      username = session.getSubject().getValue();

      List<Group> groupList = session.getSubjectList().getGroupList();

      for ( int i = 0; i > groupList.size(); i++ ) {

      	groupnames[i] = groupList.get(i).getGroupName();

      }

    }

    // generate pid/localId pair for object

    logMetacat.debug("Generating a pid/localId mapping");

    IdentifierManager im = IdentifierManager.getInstance();

    String localId = im.generateLocalId(pid.getValue(), 1);

    try {

      logMetacat.debug("Case DATA: starting to write to disk.");

      if (DocumentImpl.getDataFileLockGrant(localId)) {

        // Save the data file to disk using "localId" as the name

        try {

          String datafilepath = PropertyService.getProperty("application.datafilepath");

          File dataDirectory = new File(datafilepath);

          dataDirectory.mkdirs();

          File newFile = writeStreamToFile(dataDirectory, localId, object);

          // TODO: Check that the file size matches SystemMetadata

          // long size = newFile.length();

          // if (size == 0) {

          //     throw new IOException("Uploaded file is 0 bytes!");

          // }

          // Register the file in the database (which generates an exception

          // if the localId is not acceptable or other untoward things happen

          try {

            logMetacat.debug("Registering document...");

            DocumentImpl.registerDocument(localId, "BIN", localId,

                    username, groupnames);

            logMetacat.debug("Registration step completed.");

          } catch (SQLException e) {

            //newFile.delete();

            logMetacat.debug("SQLE: " + e.getMessage());

            e.printStackTrace(System.out);

            throw new ServiceFailure("1190", "Registration failed: " + 

            		e.getMessage());

          } catch (AccessionNumberException e) {