/src/edu/ucsb/nceas/metacat/dataone/CrudService.java - Annotate - Metacat - Ecoinformatics Redmine

metacat/src/edu/ucsb/nceas/metacat/dataone/CrudService.java @ 5427

-            jones
+/**
  *  '$RCSfile$'
  *  Copyright: 2000 Regents of the University of California and the
  *              National Center for Ecological Analysis and Synthesis
+ *
-            jones
+ *   '$Author: $'
-            jones
+ *     '$Date: 2009-06-13 15:28:13 +0300  $'
+ *
  * 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;
-            jones
+import java.io.ByteArrayOutputStream;
-            jones
+import java.io.File;
 import java.io.FileNotFoundException;
 import java.io.FileOutputStream;
-            jones
+import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
-            jones
+import java.io.PrintWriter;
-            berkley
+import java.io.StringBufferInputStream;
 import java.security.MessageDigest;
-            jones
+import java.sql.SQLException;
-            berkley
+import java.util.*;
-            berkley
+import java.text.DateFormat;
-            berkley
+import java.text.SimpleDateFormat;
             jones
 import javax.servlet.ServletContext;
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
-            jones
+import org.apache.commons.io.IOUtils;
 import org.apache.log4j.Logger;
-            jones
+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.mn.MemberNodeCrud;
-            berkley
+import org.dataone.service.types.*;
-            jones
+import org.jibx.runtime.BindingDirectory;
 import org.jibx.runtime.IBindingFactory;
 import org.jibx.runtime.IMarshallingContext;
-            jones
+import org.jibx.runtime.IUnmarshallingContext;
-            jones
+import org.jibx.runtime.JiBXException;
             jones
 import com.gc.iotools.stream.is.InputStreamFromOutputStream;
-            jones
+import edu.ucsb.nceas.metacat.AccessionNumberException;
-            berkley
+import edu.ucsb.nceas.metacat.MetacatResultSet;
 import edu.ucsb.nceas.metacat.MetacatResultSet.Document;
-            jones
+import edu.ucsb.nceas.metacat.DocumentImpl;
 import edu.ucsb.nceas.metacat.EventLog;
-            jones
+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;
-            berkley
+import edu.ucsb.nceas.metacat.client.rest.MetacatRestClient;
-            jones
+import edu.ucsb.nceas.metacat.properties.PropertyService;
 import edu.ucsb.nceas.metacat.replication.ForceReplicationHandler;
-            jones
+import edu.ucsb.nceas.metacat.service.SessionService;
-            jones
+import edu.ucsb.nceas.metacat.util.DocumentUtil;
-            jones
+import edu.ucsb.nceas.metacat.util.SessionData;
 import edu.ucsb.nceas.utilities.ParseLSIDException;
 import edu.ucsb.nceas.utilities.PropertyNotFoundException;
 /**
+ *
  * Implements DataONE MemberNode CRUD API for Metacat.
+ *
  * @author Matthew Jones
  */
-            berkley
+public class CrudService implements MemberNodeCrud
+{
-            berkley
+    private static CrudService crudService = null;
             jones
     private MetacatHandler handler;
     private Hashtable<String, String[]> params;
-            berkley
+    private Logger logMetacat = null;
     private Logger logCrud = null;
             berkley
     private String metacatUrl;
             berkley
     private static final DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd'T'hh:mm:ss'Z'");
             jones
     /**
-            berkley
+     * singleton accessor
      */
     public static CrudService getInstance()
+    {
       if(crudService == null)
+      {
         crudService = new CrudService();
+      }
       return crudService;
+    }
     /**
-            jones
+     * Initializes new instance by setting servlet context,request and response.
      */
-            berkley
+    public CrudService() {
-            berkley
+    //change crud service into a singleton.  dont pass servlet data structures here
-            berkley
+        logMetacat = Logger.getLogger(CrudService.class);
-            berkley
+        logCrud = Logger.getLogger("DataOneLogger");
-            berkley
+        try
+        {
             String server = PropertyService.getProperty("server.name");
             String port = PropertyService.getProperty("server.httpPort");
             String context = PropertyService.getProperty("application.context");
             metacatUrl = "http://" + server + ":" + port + "/" + context;
             logMetacat.debug("Initializing CrudService with url " + metacatUrl);
+        }
         catch(Exception e)
+        {
             logMetacat.error("Could not find servlet url in CrudService: " + e.getMessage());
             e.printStackTrace();
             throw new RuntimeException("Error getting servlet url in CrudService: " + e.getMessage());
+        }
         /*this.servletContext = servletContext;
-            jones
+        this.request = request;
-            berkley
+        this.response = response;*/
         params = new Hashtable<String, String[]>();
             jones
-            berkley
+        handler = new MetacatHandler(new Timer());
             jones
             berkley
-            jones
+    /**
-            berkley
+     * return the context url CrudService is using.
-            jones
+     */
-            berkley
+    public String getContextUrl()
+    {
         return metacatUrl;
+    }
     /**
-            berkley
+     * Set the context url that this service uses.  It is normally not necessary
      * to call this method unless you are trying to connect to a server other
      * than the one in which this service is installed.  Otherwise, this value is
      * taken from the metacat.properties file (server.name, server.port, application.context).
      */
     public void setContextUrl(String url)
+    {
         metacatUrl = url;
+    }
     /**
-            berkley
+     * set the params for this service from an HttpServletRequest param list
      */
     public void setParamsFromRequest(HttpServletRequest request)
+    {
-            jones
+        Enumeration paramlist = request.getParameterNames();
         while (paramlist.hasMoreElements()) {
-            berkley
+            String name = (String) paramlist.nextElement();
             String[] value = (String[])request.getParameterValues(name);
-            jones
+            params.put(name, value);
+        }
+    }
-            berkley
+    /**
-            berkley
+     * Authenticate against metacat and get a token.
      * @param username
      * @param password
      * @return
      * @throws ServiceFailure
      */
     public AuthToken authenticate(String username, String password)
       throws ServiceFailure
+    {
         try
+        {
             MetacatRestClient restClient = new MetacatRestClient(getContextUrl());
             String response = restClient.login(username, password);
             String sessionid = restClient.getSessionId();
             SessionService sessionService = SessionService.getInstance();
             sessionService.registerSession(new SessionData(sessionid, username, new String[0], password, "CrudServiceLogin"));
             AuthToken token = new AuthToken(sessionid);
-            berkley
+            EventLog.getInstance().log(metacatUrl,
-            berkley
+                    username, null, "authenticate");
-            berkley
+            logCrud.info("authenticate");
-            berkley
+            return token;
+        }
         catch(Exception e)
+        {
             throw new ServiceFailure("1000", "Error authenticating with metacat: " + e.getMessage());
+        }
+    }
     /**
-            berkley
+     * set the parameter values needed for this request
      */
     public void setParameter(String name, String[] value)
+    {
         params.put(name, value);
+    }
-            berkley
+    /**
      * Generate SystemMetadata for any object in the object store that does
      * not already have it.  SystemMetadata documents themselves, are, of course,
      * exempt.  This is a utility method for migration of existing object
      * stores to DataONE where SystemMetadata is required for all objects.  See
      * https://trac.dataone.org/ticket/591
             berkley
      * @param token an authtoken with appropriate permissions to read all
      * documents in the object store.  To work correctly, this should probably
      * be an adminstrative credential.
-            berkley
+     */
-            berkley
+    public void generateMissingSystemMetadata(AuthToken token)
             berkley
-            berkley
+        IdentifierManager im = IdentifierManager.getInstance();
-            berkley
+        //get the list of ids with no SM
-            berkley
+        List<String> l = im.getLocalIdsWithNoSystemMetadata();
-            berkley
+        for(int i=0; i<l.size(); i++)
         { //for each id, add a system metadata doc
-            berkley
+            String localId = l.get(i);
-            berkley
+            //System.out.println("Creating SystemMetadata for localId " + localId);
-            berkley
+            //get the document
             try
+            {
                 //generate required system metadata fields from the document
                 SystemMetadata sm = createSystemMetadata(localId, token);
                 //insert the systemmetadata object
-            berkley
+                SessionData sessionData = getSessionData(token);
                 insertSystemMetadata(sm, sessionData);
             berkley
                 String username = sessionData.getUserName();
                 EventLog.getInstance().log(metacatUrl,
-            berkley
+                        username, localId, "generateMissingSystemMetadata");
             berkley
             catch(Exception e)
+            {
-            berkley
+                //e.printStackTrace();
-            berkley
+                System.out.println("Exception generating missing system metadata: " + e.getMessage());
                 logMetacat.error("Could not generate missing system metadata: " + e.getMessage());
+            }
             berkley
-            berkley
+        logCrud.info("generateMissingSystemMetadata");
             berkley
-            berkley
+    /**
-            berkley
+     * create an object via the crud interface
-            berkley
+     */
-            jones
+    public Identifier create(AuthToken token, Identifier guid,
-            jones
+            InputStream object, SystemMetadata sysmeta) throws InvalidToken,
             ServiceFailure, NotAuthorized, IdentifierNotUnique, UnsupportedType,
             InsufficientResources, InvalidSystemMetadata, NotImplemented {
             jones
         logMetacat.debug("Starting CrudService.create()...");
-            jones
+        // authenticate & get user info
         SessionData sessionData = getSessionData(token);
         String username = sessionData.getUserName();
         String[] groups = sessionData.getGroupNames();
-            berkley
+        String localId = null;
             jones
-            berkley
+        if (username == null || username.equals("public"))
+        {
             throw new NotAuthorized("1000", "User " + username + " is not authorized to create content." +
                     "  If you are not logged in, please do so and retry the request.");
+        }
-            jones
+        // verify that guid == SystemMetadata.getIdentifier()
-            jones
+        logMetacat.debug("Comparing guid|sysmeta_guid: " + guid.getValue() + "|" + sysmeta.getIdentifier().getValue());
-            jones
+        if (!guid.getValue().equals(sysmeta.getIdentifier().getValue())) {
-            berkley
+            throw new InvalidSystemMetadata("1180",
-            jones
+                "GUID in method call does not match GUID in system metadata.");
+        }
             jones
         logMetacat.debug("Checking if identifier exists...");
         // Check that the identifier does not already exist
         IdentifierManager im = IdentifierManager.getInstance();
-            jones
+        if (im.identifierExists(guid.getValue())) {
-            berkley
+            throw new IdentifierNotUnique("1120",
-            jones
+                "GUID is already in use by an existing object.");
+        }
-            jones
+        // Check if we are handling metadata or data
         boolean isScienceMetadata = isScienceMetadata(sysmeta);
             jones
-            jones
+        if (isScienceMetadata) {
-            jones
+            // CASE METADATA:
             try {
-            berkley
+                this.insertDocument(object, guid, sessionData);
-            berkley
+                localId = im.getLocalId(guid.getValue());
-            jones
+            } catch (IOException e) {
                 String msg = "Could not create string from XML stream: " +
                     " " + e.getMessage();
                 logMetacat.debug(msg);
-            berkley
+                throw new ServiceFailure("1190", msg);
-            berkley
+            } catch(Exception e) {
                 String msg = "Unexpected error in CrudService.create: " + e.getMessage();
                 logMetacat.debug(msg);
                 throw new ServiceFailure("1190", msg);
             jones
             berkley
             jones
-            jones
+        } else {
-            jones
+            // DEFAULT CASE: DATA (needs to be checked and completed)
             insertDataObject(object, guid, sessionData);
+        }
             jones
-            jones
+        // For Metadata and Data, insert the system metadata into the object store too
         insertSystemMetadata(sysmeta, sessionData);
-            jones
+        logMetacat.debug("Returning from CrudService.create()");
-            berkley
+        EventLog.getInstance().log(metacatUrl,
-            berkley
+                username, localId, "create");
-            berkley
+        logCrud.info("create localId:" + localId + " guid:" + guid.getValue());
-            jones
+        return guid;
             jones
             berkley
     /**
      * update an existing object with a new object.  Change the system metadata
      * to reflect the changes and update it as well.
      */
     public Identifier update(AuthToken token, Identifier guid,
             InputStream object, Identifier obsoletedGuid, SystemMetadata sysmeta)
             throws InvalidToken, ServiceFailure, NotAuthorized, IdentifierNotUnique,
             UnsupportedType, InsufficientResources, NotFound, InvalidSystemMetadata,
             NotImplemented {
         try
+        {
             SessionData sessionData = getSessionData(token);
             //find the old systemmetadata (sm.old) document id (the one linked to obsoletedGuid)
             SystemMetadata sm = getSystemMetadata(token, obsoletedGuid);
             //change sm.old's obsoletedBy field
             List l = sm.getObsoletedByList();
             l.add(guid);
             sm.setObsoletedByList(l);
             //update sm.old
             updateSystemMetadata(sm, sessionData);
             //change the obsoletes field of the new systemMetadata (sm.new) to point to the id of the old one
             sysmeta.addObsolete(obsoletedGuid);
             //insert sm.new
             insertSystemMetadata(sysmeta, sessionData);
             boolean isScienceMetadata = isScienceMetadata(sysmeta);
             if(isScienceMetadata)
+            {
                 //update the doc
                 updateDocument(object, obsoletedGuid, guid, sessionData);
+            }
             else
+            {
                 //update a data file, not xml
                 insertDataObject(object, guid, sessionData);
+            }
             berkley
             IdentifierManager im = IdentifierManager.getInstance();
             String username = sessionData.getUserName();
             EventLog.getInstance().log(metacatUrl,
-            berkley
+                    username, im.getLocalId(guid.getValue()), "update");
-            berkley
+            logCrud.info("update localId:" + im.getLocalId(guid.getValue()) + " guid:" + guid.getValue());
-            berkley
+            return guid;
+        }
         catch(Exception e)
+        {
-            berkley
+            throw new ServiceFailure("1030", "Error updating document in CrudService: " + e.getMessage());
             berkley
+    }
             berkley
     /**
-            berkley
+     * set the permission on the document
      * @param token
      * @param principal
      * @param permission
      * @param permissionType
      * @param permissionOrder
      * @return
      */
     public void setAccess(AuthToken token, Identifier id, String principal, String permission,
-            berkley
+            String permissionType, String permissionOrder, boolean setSystemMetadata)
-            berkley
+      throws ServiceFailure
+    {
         try
+        {
             IdentifierManager im = IdentifierManager.getInstance();
             String docid = im.getLocalId(id.getValue());
             final SessionData sessionData = getSessionData(token);
             String permNum = "0";
-            berkley
+            if(permission.equals("read"))
             berkley
                 permNum = "4";
+            }
-            berkley
+            else if(permission.equals("write"))
             berkley
                 permNum = "6";
+            }
-            berkley
+            System.out.println("user " + sessionData.getUserName() +
                     " is setting access level " + permNum + " for permission " +
                     permissionType + " on doc with localid " + docid);
-            berkley
+            handler.setAccess(metacatUrl, sessionData.getUserName(), docid,
                     principal, permNum, permissionType, permissionOrder);
-            berkley
+            if(setSystemMetadata)
+            {
                 //set the same perms on the system metadata doc
                 String smlocalid = im.getSystemMetadataLocalId(id.getValue());
                 System.out.println("setting access on SM doc with localid " + smlocalid);
                 //cs.setAccess(token, smid, principal, permission, permissionType, permissionOrder);
                 handler.setAccess(metacatUrl, sessionData.getUserName(), smlocalid,
                         principal, permNum, permissionType, permissionOrder);
+            }
-            berkley
+            String username = sessionData.getUserName();
             EventLog.getInstance().log(metacatUrl,
-            berkley
+                    username, im.getLocalId(id.getValue()), "setAccess");
-            berkley
+            logCrud.info("setAccess");
             berkley
         catch(Exception e)
+        {
-            berkley
+            e.printStackTrace();
-            berkley
+            throw new ServiceFailure("1000", "Could not set access on the document with id " + id.getValue());
+        }
+    }
     /**
-            berkley
+     *  Retrieve the list of objects present on the MN that match the calling
      *  parameters. This method is required to support the process of Member
      *  Node synchronization. At a minimum, this method should be able to
      *  return a list of objects that match:
      *  startTime <= SystemMetadata.dateSysMetadataModified
      *  but is expected to also support date range (by also specifying endTime),
      *  and should also support slicing of the matching set of records by
      *  indicating the starting index of the response (where 0 is the index
      *  of the first item) and the count of elements to be returned.
+     *
-            berkley
+     *  If startTime or endTime is null, the query is not restricted by that parameter.
+     *
-            berkley
+     * @see http://mule1.dataone.org/ArchitectureDocs/mn_api_replication.html#MN_replication.listObjects
      * @param token
      * @param startTime
      * @param endTime
      * @param objectFormat
      * @param replicaStatus
      * @param start
      * @param count
      * @return ObjectList
      * @throws NotAuthorized
      * @throws InvalidRequest
      * @throws NotImplemented
      * @throws ServiceFailure
      * @throws InvalidToken
      */
     public ObjectList listObjects(AuthToken token, Date startTime, Date endTime,
         ObjectFormat objectFormat, boolean replicaStatus, int start, int count)
       throws NotAuthorized, InvalidRequest, NotImplemented, ServiceFailure, InvalidToken
+    {
       ObjectList ol = new ObjectList();
-            berkley
+      final SessionData sessionData = getSessionData(token);
-            berkley
+      int totalAfterQuery = 0;
-            berkley
+      try
+      {
             berkley
-            berkley
+          params.clear();
           params.put("returndoctype", new String[] {"http://dataone.org/service/types/SystemMetadata/0.1"});
           params.put("qformat", new String[] {"xml"});
-            berkley
+          params.put("returnfield", new String[] {"size", "originMemberNode",
-            berkley
+                  "identifier", "objectFormat", "dateSysMetadataModified", "checksum", "checksum/@algorithm"});
-            berkley
+          params.put("anyfield", new String[] {"%"});
             berkley
-            berkley
+          //System.out.println("query is: metacatUrl: " + metacatUrl + " user: " + sessionData.getUserName() +
           //    " sessionid: " + sessionData.getId() + " params: " + params.toString());
-            berkley
+          String username = "public";
           String[] groups = null;
           String sessionid = "";
           if(sessionData != null)
+          {
               username = sessionData.getUserName();
               groups = sessionData.getGroupNames();
               sessionid = sessionData.getId();
+          }
             berkley
-            berkley
+          MetacatResultSet rs = handler.query(metacatUrl, params, username,
                   groups, sessionid);
-            berkley
+          List docs = rs.getDocuments();
-            berkley
+          if(count == 1000)
             berkley
-            berkley
+              count = docs.size();
+          }
             berkley
-            berkley
+          //System.out.println("query returned " + docs.size() + " documents.");
           Vector<Document> docCopy = new Vector<Document>();
             berkley
-            berkley
+          //preparse the list to remove any that don't match the query params
           for(int i=0; i<docs.size(); i++)
             berkley
-            berkley
+              Document d = (Document)docs.get(i);
-            berkley
+              ObjectFormat returnedObjectFormat = ObjectFormat.convert(d.getField("objectFormat"));
             berkley
               if(returnedObjectFormat != null &&
                  objectFormat != null &&
                  !objectFormat.toString().trim().equals(returnedObjectFormat.toString().trim()))
-            berkley
+              { //make sure the objectFormat is the one specified
                   continue;
+              }
             berkley
               String dateSMM = d.getField("dateSysMetadataModified");
-            berkley
+              if((startTime != null || endTime != null) && dateSMM == null)
               {  //if startTime or endTime are not null, we need a date to compare to
-            berkley
+                  continue;
+              }
             berkley
               //date parse
               Date dateSysMetadataModified = null;
               if(dateSMM != null)
+              {
-            berkley
+                  //dateSysMetadataModified = parseDate(dateSMM);
                   if(dateSMM.indexOf(".") != -1)
                   {  //strip the milliseconds
                       dateSMM = dateSMM.substring(0, dateSMM.indexOf(".")) + 'Z';
+                  }
                   //System.out.println("dateSMM: " + dateSMM);
                   dateFormat.setTimeZone(TimeZone.getTimeZone("GMT-0"));
                   dateSysMetadataModified = dateFormat.parse(dateSMM);
                   //System.out.println("dateSysMetadataModified: " + dateSysMetadataModified);
                   //dateSysMetadataModified = getDateInTimeZone(dateSysMetadataModified, TimeZone.getDefault().getID());
                   //System.out.println("dateSysMetadataModified after convertion to default timezone: " + dateSysMetadataModified);
             berkley
-            berkley
+              /*System.out.println("docid: " + d.docid);
               System.out.println("dateSysMetadataModified: " + dateSysMetadataModified);
               System.out.println("startTime: " + startTime);
               System.out.println("endtime: " + endTime);*/
             berkley
-            berkley
+              int startDateComparison = 0;
               int endDateComparison = 0;
               if(startTime != null)
+              {
-            berkley
+                  Calendar zTime = Calendar.getInstance(TimeZone.getTimeZone("GMT-0"));
                   zTime.setTime(startTime);
                   startTime = zTime.getTime();
-            berkley
+                  if(dateSysMetadataModified == null)
+                  {
                       startDateComparison = -1;
+                  }
                   else
+                  {
                       startDateComparison = dateSysMetadataModified.compareTo(startTime);
+                  }
                   //System.out.println("startDateCom: " + startDateComparison);
             berkley
-            berkley
+              else
+              {
                   startDateComparison = 1;
+              }
             berkley
               if(endTime != null)
+              {
-            berkley
+                  Calendar zTime = Calendar.getInstance(TimeZone.getTimeZone("GMT-0"));
                   zTime.setTime(endTime);
                   endTime = zTime.getTime();
-            berkley
+                  if(dateSysMetadataModified == null)
+                  {
                       endDateComparison = 1;
+                  }
                   else
+                  {
                       endDateComparison = dateSysMetadataModified.compareTo(endTime);
+                  }
                   //System.out.println("endDateCom: " + endDateComparison);
             berkley
-            berkley
+              else
+              {
                   endDateComparison = -1;
+              }
             berkley
             berkley
-            berkley
+              if(startDateComparison < 0 || endDateComparison > 0)
             berkley
-            berkley
+                  continue;
+              }
-            berkley
+              docCopy.add((Document)docs.get(i));
           } //end pre-parse
           docs = docCopy;
           totalAfterQuery = docs.size();
-            berkley
+          System.out.println("total after subquery: " + totalAfterQuery);
             berkley
           //make sure we don't run over the end
           int end = start + count;
           if(end > docs.size())
+          {
               end = docs.size();
+          }
           for(int i=start; i<end; i++)
+          {
               //get the document from the result
               Document d = (Document)docs.get(i);
               //System.out.println("processing doc " + d.docid);
               String dateSMM = d.getField("dateSysMetadataModified");
               Date dateSysMetadataModified = null;
               if(dateSMM != null)
+              {
                   try
+                  {
                       dateSysMetadataModified = parseDate(dateSMM);
+                  }
                   catch(Exception e)
                   { //if we fail to parse the date, just ignore the value
                       dateSysMetadataModified = null;
+                  }
+              }
               ObjectFormat returnedObjectFormat = ObjectFormat.convert(d.getField("objectFormat"));
-            berkley
+              ObjectInfo info = new ObjectInfo();
               //add the fields to the info object
               Checksum cs = new Checksum();
               cs.setValue(d.getField("checksum"));
-            berkley
+              String csalg = d.getField("algorithm");
               if(csalg == null)
+              {
                   csalg = "MD5";
+              }
               ChecksumAlgorithm ca = ChecksumAlgorithm.convert(csalg);
               cs.setAlgorithm(ca);
-            berkley
+              info.setChecksum(cs);
               info.setDateSysMetadataModified(dateSysMetadataModified);
               Identifier id = new Identifier();
               id.setValue(d.getField("identifier"));
               info.setIdentifier(id);
               info.setObjectFormat(returnedObjectFormat);
-            berkley
+              String size = d.getField("size");
               if(size != null)
+              {
                   info.setSize(new Long(size.trim()).longValue());
+              }
-            berkley
+              //add the ObjectInfo to the ObjectList
-            berkley
+              if(info.getIdentifier().getValue() != null)
               { //id can be null from tests.  should not happen in production.
                   ol.addObjectInfo(info);
+              }
             berkley
             berkley
             berkley
       catch(Exception e)
+      {
           e.printStackTrace();
           throw new ServiceFailure("1580", "Error retrieving ObjectList: " + e.getMessage());
+      }
-            berkley
+      String username = sessionData.getUserName();
       EventLog.getInstance().log(metacatUrl,
-            berkley
+              username, null, "read");
-            berkley
+      logCrud.info("listObjects");
-            berkley
+      //System.out.println("ol.size: " + ol.sizeObjectInfoList());
-            berkley
+      ol.setCount(count);
       ol.setStart(start);
       ol.setTotal(totalAfterQuery);
-            berkley
+      System.out.println("returning " + ol.sizeObjectInfoList() + " items in the object list");
-            berkley
+      return ol;
+    }
     /**
      * Call listObjects with the default values for replicaStatus (true), start (0),
      * and count (1000).
      * @param token
      * @param startTime
      * @param endTime
      * @param objectFormat
      * @return
      * @throws NotAuthorized
      * @throws InvalidRequest
      * @throws NotImplemented
      * @throws ServiceFailure
      * @throws InvalidToken
      */
     public ObjectList listObjects(AuthToken token, Date startTime, Date endTime,
         ObjectFormat objectFormat)
       throws NotAuthorized, InvalidRequest, NotImplemented, ServiceFailure, InvalidToken
+    {
        return listObjects(token, startTime, endTime, objectFormat, true, 0, 1000);
+    }
             jones
-            berkley
+    /**
      * Delete a document.  NOT IMPLEMENTED
      */
-            jones
+    public Identifier delete(AuthToken token, Identifier guid)
-            jones
+            throws InvalidToken, ServiceFailure, NotAuthorized, NotFound,
             NotImplemented {
-            berkley
+        logCrud.info("delete");
-            berkley
+        throw new NotImplemented("1000", "This method not yet implemented.");
             jones
-            berkley
+    /**
      * describe a document.  NOT IMPLEMENTED
      */
-            jones
+    public DescribeResponse describe(AuthToken token, Identifier guid)
-            jones
+            throws InvalidToken, ServiceFailure, NotAuthorized, NotFound,
             NotImplemented {
-            berkley
+        logCrud.info("describe");
-            berkley
+        throw new NotImplemented("1000", "This method not yet implemented.");
             jones
-            berkley
+    /**
      * get a document with a specified guid.
      */
-            jones
+    public InputStream get(AuthToken token, Identifier guid)
-            jones
+            throws InvalidToken, ServiceFailure, NotAuthorized, NotFound,
             NotImplemented {
         // Retrieve the session information from the AuthToken
         // If the session is expired, then the user is 'public'
         final SessionData sessionData = getSessionData(token);
         // Look up the localId for this global identifier
         IdentifierManager im = IdentifierManager.getInstance();
         try {
-            jones
+            final String localId = im.getLocalId(guid.getValue());
             jones
             final InputStreamFromOutputStream<String> objectStream =
                 new InputStreamFromOutputStream<String>() {
                 @Override
                 public String produce(final OutputStream dataSink) throws Exception {
                     try {
-            berkley
+                        handler.readFromMetacat(metacatUrl, null,
-            jones
+                                dataSink, localId, "xml",
                                 sessionData.getUserName(),
                                 sessionData.getGroupNames(), true, params);
                     } catch (PropertyNotFoundException e) {
-            berkley
+                        e.printStackTrace();
                         throw new ServiceFailure("1030", "Error getting property from metacat: " + e.getMessage());
-            jones
+                    } catch (ClassNotFoundException e) {
-            berkley
+                        e.printStackTrace();
                         throw new ServiceFailure("1030", "Class not found error when reading from metacat: " + e.getMessage());
-            jones
+                    } catch (IOException e) {
-            berkley
+                        e.printStackTrace();
                         throw new ServiceFailure("1030", "IOException while reading from metacat: " + e.getMessage());
-            jones
+                    } catch (SQLException e) {
-            berkley
+                        e.printStackTrace();
                         throw new ServiceFailure("1030", "SQLException while reading from metacat: " + e.getMessage());
-            jones
+                    } catch (McdbException e) {
-            berkley
+                        e.printStackTrace();
                         throw new ServiceFailure("1030", "Metacat DB exception while reading from metacat: " + e.getMessage());
-            jones
+                    } catch (ParseLSIDException e) {
-            berkley
+                        e.printStackTrace();
                         throw new NotFound("1020", "LSID parsing exception while reading from metacat: " + e.getMessage());
-            jones
+                    } catch (InsufficientKarmaException e) {
-            berkley
+                        e.printStackTrace();
                         throw new NotAuthorized("1000", "User not authorized for get(): " + e.getMessage());
             jones
                     return "Completed";
+                }
             };
-            berkley
+            System.out.println("1");
-            berkley
+            String username = sessionData.getUserName();
             EventLog.getInstance().log(metacatUrl,
-            berkley
+                    username, im.getLocalId(guid.getValue()), "read");
-            berkley
+            logCrud.info("get localId:" + localId + " guid:" + guid.getValue());
-            jones
+            return objectStream;
         } catch (McdbDocNotFoundException e) {
-            berkley
+            throw new NotFound("1020", e.getMessage());
             jones
+    }
-            berkley
+    /**
      * get the checksum for a document.  NOT IMPLEMENTED
      */
-            jones
+    public Checksum getChecksum(AuthToken token, Identifier guid)
-            jones
+            throws InvalidToken, ServiceFailure, NotAuthorized, NotFound,
             InvalidRequest, NotImplemented {
-            berkley
+        logCrud.info("getChecksum");
-            berkley
+        throw new NotImplemented("1000", "This method not yet implemented.");
             jones
-            berkley
+    /**
      * get the checksum for a document.  NOT IMPLEMENTED
      */
-            jones
+    public Checksum getChecksum(AuthToken token, Identifier guid,
-            jones
+            String checksumAlgorithm) throws InvalidToken, ServiceFailure,
             NotAuthorized, NotFound, InvalidRequest, NotImplemented {
-            berkley
+        logCrud.info("getChecksum");
-            berkley
+        throw new NotImplemented("1000", "This method not yet implemented.");
             jones
-            berkley
+    /**
-            berkley
+     * get log records.
-            berkley
+     */
-            berkley
+    public Log getLogRecords(AuthToken token, Date fromDate, Date toDate, Event event)
-            jones
+            throws InvalidToken, ServiceFailure, NotAuthorized, InvalidRequest,
-            berkley
+            NotImplemented
+    {
-            berkley
+        Log log = new Log();
         Vector<LogEntry> logs = new Vector<LogEntry>();
-            berkley
+        IdentifierManager im = IdentifierManager.getInstance();
         EventLog el = EventLog.getInstance();
-            berkley
+        if(fromDate == null)
+        {
-            berkley
+            System.out.println("setting fromdate from null");
-            berkley
+            fromDate = new Date(1);
+        }
         if(toDate == null)
+        {
-            berkley
+            System.out.println("setting todate from null");
-            berkley
+            toDate = new Date();
+        }
             berkley
         System.out.println("fromDate: " + fromDate);
         System.out.println("toDate: " + toDate);
-            berkley
+        String report = el.getReport(null, null, null, null,
                 new java.sql.Timestamp(fromDate.getTime()),
                 new java.sql.Timestamp(toDate.getTime()));
-            berkley
+        //System.out.println("report: " + report);
-            berkley
+        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);
             //System.out.println("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);
-            berkley
+            String eventS = getLogEntryField("event", entry);
-            berkley
+            String dateLogged = getLogEntryField("dateLogged", entry);
-            berkley
+            LogEntry le = new LogEntry();
             berkley
-            berkley
+            Event e = Event.convert(eventS);
-            berkley
+            if(e == null)
             { //skip any events that are not Dataone Crud events
                 continue;
+            }
-            berkley
+            le.setEvent(e);
-            berkley
+            Identifier entryid = new Identifier();
             entryid.setValue(entryId);
-            berkley
+            le.setEntryId(entryid);
-            berkley
+            Identifier identifier = new Identifier();
             try
+            {
-            berkley
+                System.out.println("converting docid '" + docid + "' to a guid.");
-            berkley
+                if(docid == null || docid.trim().equals("") || docid.trim().equals("null"))
+                {
                     continue;
+                }
-            berkley
+                docid = docid.substring(0, docid.lastIndexOf("."));
-            berkley
+                identifier.setValue(im.getGUID(docid, im.getLatestRevForLocalId(docid)));
+            }
             catch(Exception ex)
             { //try to get the guid, if that doesn't work, just use the local id
-            berkley
+                //throw new ServiceFailure("1030", "Error getting guid for localId " +
-            berkley
+                //        docid + ": " + ex.getMessage());\
                 //skip it if the guid can't be found
-            berkley
+                continue;
             berkley
-            berkley
+            le.setIdentifier(identifier);
             le.setIpAddress(ipAddress);
-            berkley
+            Calendar c = Calendar.getInstance();
             String year = dateLogged.substring(0, 4);
             String month = dateLogged.substring(5, 7);
             String date = dateLogged.substring(8, 10);
             //System.out.println("year: " + year + " month: " + month + " day: " + date);
             c.set(new Integer(year).intValue(), new Integer(month).intValue(), new Integer(date).intValue());
             Date logDate = c.getTime();
-            berkley
+            le.setDateLogged(logDate);
-            berkley
+            NodeReference memberNode = new NodeReference();
             memberNode.setValue(ipAddress);
-            berkley
+            le.setMemberNode(memberNode);
-            berkley
+            Principal princ = new Principal();
             princ.setValue(principal);
-            berkley
+            le.setPrincipal(princ);
             le.setUserAgent("metacat/RESTService");
             berkley
             if(event == null)
+            {
                 logs.add(le);
+            }
             if(event != null &&
                e.toString().toLowerCase().trim().equals(event.toString().toLowerCase().trim()))
+            {
               logs.add(le);
+            }
             berkley
-            berkley
+        log.setLogEntryList(logs);
-            berkley
+        logCrud.info("getLogRecords");
-            berkley
+        return log;
             jones
             berkley
     /**
      * parse a logEntry and get the relavent field from it
      * @param fieldname
      * @param entry
      * @return
      */
     private String getLogEntryField(String fieldname, String entry)
+    {
         String begin = "<" + fieldname + ">";
         String end = "</" + fieldname + ">";
         //System.out.println("looking for " + begin + " and " + end + " in entry " + entry);
         String s = entry.substring(entry.indexOf(begin) + begin.length(), entry.indexOf(end));
         //System.out.println("entry " + fieldname + " : " + s);
         return s;
+    }
             jones
-            berkley
+    /**
      * get the system metadata for a document with a specified guid.
      */
-            jones
+    public SystemMetadata getSystemMetadata(AuthToken token, Identifier guid)
-            jones
+            throws InvalidToken, ServiceFailure, NotAuthorized, NotFound,
             InvalidRequest, NotImplemented {
             jones
-            jones
+        logMetacat.debug("CrudService.getSystemMetadata - for guid: " + guid.getValue());
         // Retrieve the session information from the AuthToken
         // If the session is expired, then the user is 'public'
         final SessionData sessionData = getSessionData(token);
         try {
             IdentifierManager im = IdentifierManager.getInstance();
-            berkley
+            final String localId = im.getSystemMetadataLocalId(guid.getValue());
             jones
             // Read system metadata from metacat's db
             final InputStreamFromOutputStream<String> objectStream =
                 new InputStreamFromOutputStream<String>() {
                 @Override
                 public String produce(final OutputStream dataSink) throws Exception {
                     try {
-            berkley
+                        handler.readFromMetacat(metacatUrl, null,
-            jones
+                                dataSink, localId, "xml",
                                 sessionData.getUserName(),
                                 sessionData.getGroupNames(), true, params);
                     } catch (PropertyNotFoundException e) {
-            berkley
+                        e.printStackTrace();
                         throw new ServiceFailure("1030", "Property not found while reading system metadata from metacat: " + e.getMessage());
-            jones
+                    } catch (ClassNotFoundException e) {
-            berkley
+                        e.printStackTrace();
                         throw new ServiceFailure("1030", "Class not found while reading system metadata from metacat: " + e.getMessage());
-            jones
+                    } catch (IOException e) {
-            berkley
+                        e.printStackTrace();
                         throw new ServiceFailure("1030", "IOException while reading system metadata from metacat: " + e.getMessage());
-            jones
+                    } catch (SQLException e) {
-            berkley
+                        e.printStackTrace();
                         throw new ServiceFailure("1030", "SQLException while reading system metadata from metacat: " + e.getMessage());
-            jones
+                    } catch (McdbException e) {
-            berkley
+                        e.printStackTrace();
                         throw new ServiceFailure("1030", "Metacat DB Exception while reading system metadata from metacat: " + e.getMessage());
-            jones
+                    } catch (ParseLSIDException e) {
-            berkley
+                        e.printStackTrace();
                         throw new NotFound("1020", "Error parsing LSID while reading system metadata from metacat: " + e.getMessage());
-            jones
+                    } catch (InsufficientKarmaException e) {
-            berkley
+                        e.printStackTrace();
                         throw new NotAuthorized("1000", "User not authorized for get() on system metadata: " + e.getMessage());
             jones
                     return "Completed";
+                }
             };
             // Deserialize the xml to create a SystemMetadata object
             SystemMetadata sysmeta = deserializeSystemMetadata(objectStream);
-            berkley
+            String username = sessionData.getUserName();
             EventLog.getInstance().log(metacatUrl,
-            berkley
+                    username, im.getLocalId(guid.getValue()), "read");
-            berkley
+            logCrud.info("getSystemMetadata localId: " + localId + " guid:" + guid.getValue());
-            jones
+            return sysmeta;
         } catch (McdbDocNotFoundException e) {
-            berkley
+            //e.printStackTrace();
-            berkley
+            throw new NotFound("1000", e.getMessage());
             jones
             jones
             berkley
     /**
      * parse the date in the systemMetadata
      * @param s
      * @return
      * @throws Exception
      */
-            berkley
+    public Date parseDate(String s)
-            berkley
+      throws Exception
+    {
         Date d = null;
         int tIndex = s.indexOf("T");
         int zIndex = s.indexOf("Z");
         if(tIndex != -1 && zIndex != -1)
         { //parse a date that looks like 2010-05-18T21:12:54.362Z
             //System.out.println("original date: " + s);
             String date = s.substring(0, tIndex);
             String year = date.substring(0, date.indexOf("-"));
             String month = date.substring(date.indexOf("-") + 1, date.lastIndexOf("-"));
             String day = date.substring(date.lastIndexOf("-") + 1, date.length());
             /*System.out.println("date: " + "year: " + new Integer(year).intValue() +
                     " month: " + new Integer(month).intValue() + " day: " +
                     new Integer(day).intValue());
             */
             String time = s.substring(tIndex + 1, zIndex);
             String hour = time.substring(0, time.indexOf(":"));
             String minute = time.substring(time.indexOf(":") + 1, time.lastIndexOf(":"));
             String seconds = "00";
             String milliseconds = "00";
             if(time.indexOf(".") != -1)
+            {
                 seconds = time.substring(time.lastIndexOf(":") + 1, time.indexOf("."));
                 milliseconds = time.substring(time.indexOf(".") + 1, time.length());
+            }
-            berkley
+            else
+            {
                 seconds = time.substring(time.lastIndexOf(":") + 1, time.length());
+            }
-            berkley
+            /*System.out.println("time: " + "hour: " + new Integer(hour).intValue() +
                     " minute: " + new Integer(minute).intValue() + " seconds: " +
                     new Integer(seconds).intValue() + " milli: " +
                     new Integer(milliseconds).intValue());*/
             //d = DateFormat.getDateTimeInstance().parse(date + " " + time);
-            berkley
+            Calendar c = Calendar.getInstance(/*TimeZone.getTimeZone("GMT-0")*/TimeZone.getDefault());
-            berkley
+            c.set(new Integer(year).intValue(), new Integer(month).intValue() - 1,
                   new Integer(day).intValue(), new Integer(hour).intValue(),
                   new Integer(minute).intValue(), new Integer(seconds).intValue());
             c.set(Calendar.MILLISECOND, new Integer(milliseconds).intValue());
             d = new Date(c.getTimeInMillis());
             //System.out.println("d: " + d);
             return d;
+        }
         else
         {  //if it's not in the expected format, try the formatter
             return DateFormat.getDateTimeInstance().parse(s);
+        }
+    }
             jones
-            jones
+    /*
      * Look up the information on the session using the token provided in
      * the AuthToken.  The Session should have all relevant user information.
      * If the session has expired or is invalid, the 'public' session will
      * be returned, giving the user anonymous access.
      */
-            berkley
+    public static SessionData getSessionData(AuthToken token) {
-            jones
+        SessionData sessionData = null;
         String sessionId = "PUBLIC";
         if (token != null) {
             sessionId = token.getToken();
+        }
         // if the session id is registered in SessionService, get the
         // SessionData for it. Otherwise, use the public session.
-            berkley
+        //System.out.println("sessionid: " + sessionId);
-            berkley
+        if (sessionId != null &&
-            berkley
+            !sessionId.toLowerCase().equals("public") &&
-            berkley
+            SessionService.getInstance().isSessionRegistered(sessionId))
+        {
-            berkley
+            sessionData = SessionService.getInstance().getRegisteredSession(sessionId);
-            jones
+        } else {
-            berkley
+            sessionData = SessionService.getInstance().getPublicSession();
             jones
             berkley
-            jones
+        return sessionData;
+    }
     /**
      * Determine if a given object should be treated as an XML science metadata
      * object.
+     *
      * TODO: This test should be externalized in a configuration dictionary rather than being hardcoded.
+     *
      * @param sysmeta the SystemMetadata describig the object
      * @return true if the object should be treated as science metadata
      */
     private boolean isScienceMetadata(SystemMetadata sysmeta) {
         boolean scimeta = false;
         switch (sysmeta.getObjectFormat()) {
             case EML_2_1_0: scimeta = true; break;
             case EML_2_0_1: scimeta = true; break;
             case EML_2_0_0: scimeta = true; break;
             case FGDC_STD_001_1_1999: scimeta = true; break;
             case FGDC_STD_001_1998: scimeta = true; break;
             case NCML_2_2: scimeta = true; break;
+        }
         return scimeta;
+    }
-            berkley
+    /**
      * insert a data doc
      * @param object
      * @param guid
      * @param sessionData
      * @throws ServiceFailure
      */
-            jones
+    private void insertDataObject(InputStream object, Identifier guid,
             SessionData sessionData) throws ServiceFailure {
         String username = sessionData.getUserName();
         String[] groups = sessionData.getGroupNames();
         // generate guid/localId pair for object
         logMetacat.debug("Generating a guid/localId mapping");
         IdentifierManager im = IdentifierManager.getInstance();
         String localId = im.generateLocalId(guid.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, groups);
                         logMetacat.debug("Registration step completed.");
                     } catch (SQLException e) {
                         //newFile.delete();
                         logMetacat.debug("SQLE: " + e.getMessage());
                         e.printStackTrace(System.out);
-            berkley
+                        throw new ServiceFailure("1190", "Registration failed: " + e.getMessage());
-            jones
+                    } catch (AccessionNumberException e) {
                         //newFile.delete();
                         logMetacat.debug("ANE: " + e.getMessage());
                         e.printStackTrace(System.out);
-            berkley
+                        throw new ServiceFailure("1190", "Registration failed: " + e.getMessage());
-            jones
+                    } catch (Exception e) {
                         //newFile.delete();
                         logMetacat.debug("Exception: " + e.getMessage());
                         e.printStackTrace(System.out);
-            berkley
+                        throw new ServiceFailure("1190", "Registration failed: " + e.getMessage());
             jones
                     logMetacat.debug("Logging the creation event.");
-            berkley
+                    EventLog.getInstance().log(metacatUrl,
-            berkley
+                            username, localId, "create");
             jones
                     // Schedule replication for this data file
                     logMetacat.debug("Scheduling replication.");
                     ForceReplicationHandler frh = new ForceReplicationHandler(
-            berkley
+                            localId, "create", false, null);
             jones
                 } catch (PropertyNotFoundException e) {
-            berkley
+                    throw new ServiceFailure("1190", "Could not lock file for writing:" + e.getMessage());
             jones
+            }
         } catch (Exception e) {
             // Could not get a lock on the document, so we can not update the file now
-            berkley
+            throw new ServiceFailure("1190", "Failed to lock file: " + e.getMessage());
             jones
+    }
-            berkley
+    /**
      * write a file to a stream
      * @param dir
      * @param fileName
      * @param data
      * @return
      * @throws ServiceFailure
      */
-            jones
+    private File writeStreamToFile(File dir, String fileName, InputStream data)
         throws ServiceFailure {
         File newFile = new File(dir, fileName);
         logMetacat.debug("Filename for write is: " + newFile.getAbsolutePath());
         try {
             if (newFile.createNewFile()) {
                 // write data stream to desired file
                 OutputStream os = new FileOutputStream(newFile);
                 long length = IOUtils.copyLarge(data, os);
                 os.flush();
                 os.close();
             } else {
                 logMetacat.debug("File creation failed, or file already exists.");
-            berkley
+                throw new ServiceFailure("1190", "File already exists: " + fileName);
             jones
         } catch (FileNotFoundException e) {
             logMetacat.debug("FNF: " + e.getMessage());
-            berkley
+            throw new ServiceFailure("1190", "File not found: " + fileName + " "
-            jones
+                    + e.getMessage());
         } catch (IOException e) {
             logMetacat.debug("IOE: " + e.getMessage());
-            berkley
+            throw new ServiceFailure("1190", "File was not written: " + fileName
-            jones
+                    + " " + e.getMessage());
+        }
         return newFile;
             jones
             berkley
     private static Date getDateInTimeZone(Date currentDate, String timeZoneId)
+    {
         TimeZone tz = TimeZone.getTimeZone(timeZoneId);
         Calendar mbCal = new GregorianCalendar(TimeZone.getTimeZone(timeZoneId));
         mbCal.setTimeInMillis(currentDate.getTime());
             jones
-            berkley
+        Calendar cal = Calendar.getInstance();
         cal.set(Calendar.YEAR, mbCal.get(Calendar.YEAR));
         cal.set(Calendar.MONTH, mbCal.get(Calendar.MONTH));
         cal.set(Calendar.DAY_OF_MONTH, mbCal.get(Calendar.DAY_OF_MONTH));
         cal.set(Calendar.HOUR_OF_DAY, mbCal.get(Calendar.HOUR_OF_DAY));
         cal.set(Calendar.MINUTE, mbCal.get(Calendar.MINUTE));
         cal.set(Calendar.SECOND, mbCal.get(Calendar.SECOND));
         cal.set(Calendar.MILLISECOND, mbCal.get(Calendar.MILLISECOND));
         return cal.getTime();
+    }
-            berkley
+    /**
      * insert a systemMetadata doc
      */
-            jones
+    private void insertSystemMetadata(SystemMetadata sysmeta, SessionData sessionData)
-            berkley
+        throws ServiceFailure
+    {
-            jones
+        logMetacat.debug("Starting to insert SystemMetadata...");
         // generate guid/localId pair for sysmeta
-            jones
+        Identifier sysMetaGuid = new Identifier();
         sysMetaGuid.setValue(DocumentUtil.generateDocumentId(1));
-            jones
+        sysmeta.setDateSysMetadataModified(new Date());
-            berkley
+        System.out.println("****inserting new system metadata with modified date " + sysmeta.getDateSysMetadataModified());
             jones
         String xml = new String(serializeSystemMetadata(sysmeta).toByteArray());
-            berkley
+        String localId = insertDocument(xml, sysMetaGuid, sessionData);
-            berkley
+        System.out.println("sysmeta inserted with localId " + localId);
-            berkley
+        //insert the system metadata doc id into the identifiers table to
         //link it to the data or metadata document
-            berkley
+        IdentifierManager.getInstance().createSystemMetadataMapping(
                 sysmeta.getIdentifier().getValue(), sysMetaGuid.getValue());
             jones
-            berkley
+    /**
-            berkley
+     * update a systemMetadata doc
      */
     private void updateSystemMetadata(SystemMetadata sm, SessionData sessionData)
       throws ServiceFailure
+    {
         try
+        {
-            berkley
+            String smId = IdentifierManager.getInstance().getSystemMetadataLocalId(sm.getIdentifier().getValue());
-            berkley
+            sm.setDateSysMetadataModified(new Date());
             String xml = new String(serializeSystemMetadata(sm).toByteArray());
             Identifier id = new Identifier();
             id.setValue(smId);
             String localId = updateDocument(xml, id, null, sessionData);
             IdentifierManager.getInstance().updateSystemMetadataMapping(sm.getIdentifier().getValue(), localId);
+        }
         catch(Exception e)
+        {
-            berkley
+            throw new ServiceFailure("1030", "Error updating system metadata: " + e.getMessage());
             berkley
+    }
     /**
      * insert a document
      * NOTE: this method shouldn't be used from the update or create() methods.
      * we shouldn't be putting the science metadata or data objects into memory.
      */
     private String insertDocument(String xml, Identifier guid, SessionData sessionData)
         throws ServiceFailure
+    {
         return insertOrUpdateDocument(xml, guid, sessionData, "insert");
+    }
     /**
      * insert a document from a stream
      */
     private String insertDocument(InputStream is, Identifier guid, SessionData sessionData)
       throws IOException, ServiceFailure
+    {
         //HACK: change this eventually.  we should not be converting the stream to a string
         String xml = IOUtils.toString(is);
         return insertDocument(xml, guid, sessionData);
+    }
     /**
      * update a document
      * NOTE: this method shouldn't be used from the update or create() methods.
      * we shouldn't be putting the science metadata or data objects into memory.
      */
     private String updateDocument(String xml, Identifier obsoleteGuid, Identifier guid, SessionData sessionData)
         throws ServiceFailure
+    {
         return insertOrUpdateDocument(xml, obsoleteGuid, sessionData, "update");
+    }
     /**
      * update a document from a stream
      */
     private String updateDocument(InputStream is, Identifier obsoleteGuid, Identifier guid, SessionData sessionData)
       throws IOException, ServiceFailure
+    {
         //HACK: change this eventually.  we should not be converting the stream to a string
         String xml = IOUtils.toString(is);
         String localId = updateDocument(xml, obsoleteGuid, guid, sessionData);
         IdentifierManager im = IdentifierManager.getInstance();
         if(guid != null)
+        {
           im.createMapping(guid.getValue(), localId);
+        }
         return localId;
+    }
     /**
-            berkley
+     * insert a document, return the id of the document that was inserted
      */
-            berkley
+    protected String insertOrUpdateDocument(String xml, Identifier guid, SessionData sessionData, String insertOrUpdate)
-            jones
+        throws ServiceFailure {
         logMetacat.debug("Starting to insert xml document...");
         IdentifierManager im = IdentifierManager.getInstance();
         // generate guid/localId pair for sysmeta
-            berkley
+        String localId = null;
         if(insertOrUpdate.equals("insert"))
+        {
             localId = im.generateLocalId(guid.getValue(), 1);
+        }
         else
+        {
             //localid should already exist in the identifier table, so just find it
             try
+            {
                 localId = im.getLocalId(guid.getValue());
                 //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;
+            }
             catch(McdbDocNotFoundException e)
+            {
-            berkley
+                throw new ServiceFailure("1030", "CrudService.insertOrUpdateDocument(): " +
-            berkley
+                    "guid " + guid.getValue() + " should have been in the identifier table, but it wasn't: " + e.getMessage());
+            }
+        }
-            jones
+        logMetacat.debug("Metadata guid|localId: " + guid.getValue() + "|" +
-            jones
+                localId);
         String[] action = new String[1];
-            berkley
+        action[0] = insertOrUpdate;
-            jones
+        params.put("action", action);
         String[] docid = new String[1];
         docid[0] = localId;
         params.put("docid", docid);
         String[] doctext = new String[1];
         doctext[0] = xml;
         logMetacat.debug(doctext[0]);
         params.put("doctext", doctext);
             jones
         // TODO: refactor handleInsertOrUpdateAction() to not output XML directly
         // onto output stream, or alternatively, capture that and parse it to
         // generate the right exceptions
-            berkley
+        //ByteArrayOutputStream output = new ByteArrayOutputStream();
         //PrintWriter pw = new PrintWriter(output);
-            berkley
+        String result = handler.handleInsertOrUpdateAction(metacatUrl, null,
-            berkley
+                            null, params, sessionData.getUserName(), sessionData.getGroupNames());
         //String outputS = new String(output.toByteArray());
         logMetacat.debug("CrudService.insertDocument - Metacat returned: " + result);
-            berkley
+        logMetacat.debug("Finsished inserting xml document with id " + localId);
         return localId;
             jones
-            berkley
+    /**
      * serialize a system metadata doc
      * @param sysmeta
      * @return
      * @throws ServiceFailure
      */
-            jones
+    public static ByteArrayOutputStream serializeSystemMetadata(SystemMetadata sysmeta)
-            jones
+        throws ServiceFailure {
         IBindingFactory bfact;
         ByteArrayOutputStream sysmetaOut = null;
         try {
             bfact = BindingDirectory.getFactory(SystemMetadata.class);
             IMarshallingContext mctx = bfact.createMarshallingContext();
             sysmetaOut = new ByteArrayOutputStream();
             mctx.marshalDocument(sysmeta, "UTF-8", null, sysmetaOut);
         } catch (JiBXException e) {
-            berkley
+            e.printStackTrace();
-            berkley
+            throw new ServiceFailure("1190", "Failed to serialize and insert SystemMetadata: " + e.getMessage());
             jones
         return sysmetaOut;
+    }
             jones
-            berkley
+    /**
      * deserialize a system metadata doc
      * @param xml
      * @return
      * @throws ServiceFailure
      */
-            jones
+    public static SystemMetadata deserializeSystemMetadata(InputStream xml)
         throws ServiceFailure {
         try {
             IBindingFactory bfact = BindingDirectory.getFactory(SystemMetadata.class);
             IUnmarshallingContext uctx = bfact.createUnmarshallingContext();
             SystemMetadata sysmeta = (SystemMetadata) uctx.unmarshalDocument(xml, null);
             return sysmeta;
         } catch (JiBXException e) {
-            berkley
+            e.printStackTrace();
             throw new ServiceFailure("1190", "Failed to deserialize and insert SystemMetadata: " + e.getMessage());
             jones
+    }
             berkley
     /**
      * produce an md5 checksum for item
      */
     private String checksum(InputStream is)
       throws Exception
+    {
         byte[] buffer = new byte[1024];
         MessageDigest complete = MessageDigest.getInstance("MD5");
         int numRead;
         do
+        {
           numRead = is.read(buffer);
           if (numRead > 0)
+          {
             complete.update(buffer, 0, numRead);
+          }
         } while (numRead != -1);
         return getHex(complete.digest());
+    }
     /**
      * convert a byte array to a hex string
      */
     private static String getHex( byte [] raw )
+    {
         final String HEXES = "0123456789ABCDEF";
         if ( raw == null ) {
           return null;
+        }
         final StringBuilder hex = new StringBuilder( 2 * raw.length );
         for ( final byte b : raw ) {
           hex.append(HEXES.charAt((b & 0xF0) >> 4))
              .append(HEXES.charAt((b & 0x0F)));
+        }
         return hex.toString();
+    }
     /**
      * parse the metacat date which looks like 2010-06-08 (YYYY-MM-DD) into
      * a proper date object
      * @param date
      * @return
      */
     private Date parseMetacatDate(String date)
+    {
         String year = date.substring(0, 4);
         String month = date.substring(5, 7);
         String day = date.substring(8, 10);
-            berkley
+        Calendar c = Calendar.getInstance(TimeZone.getDefault());
-            berkley
+        c.set(new Integer(year).intValue(),
               new Integer(month).intValue(),
               new Integer(day).intValue());
-            berkley
+        System.out.println("time in parseMetacatDate: " + c.getTime());
-            berkley
+        return c.getTime();
+    }
     /**
      * find the size (in bytes) of a stream
      * @param is
      * @return
      * @throws IOException
      */
     private long sizeOfStream(InputStream is)
         throws IOException
+    {
         long size = 0;
         byte[] b = new byte[1024];
         int numread = is.read(b, 0, 1024);
         while(numread != -1)
+        {
             size += numread;
             numread = is.read(b, 0, 1024);
+        }
         return size;
+    }
             berkley
     /**
      * create system metadata with a specified id, doc and format
      */
     private SystemMetadata createSystemMetadata(String localId, AuthToken token)
       throws Exception
+    {
         IdentifierManager im = IdentifierManager.getInstance();
         Hashtable<String, String> docInfo = im.getDocumentInfo(localId);
         //get the document text
         int rev = im.getLatestRevForLocalId(localId);
         Identifier identifier = new Identifier();
         identifier.setValue(im.getGUID(localId, rev));
         InputStream is = this.get(token, identifier);
         SystemMetadata sm = new SystemMetadata();
         //set the id
         sm.setIdentifier(identifier);
         //set the object format
         String doctype = docInfo.get("doctype");
         ObjectFormat format = ObjectFormat.convert(docInfo.get("doctype"));
         if(format == null)
+        {
             if(doctype.trim().equals("BIN"))
+            {
                 format = ObjectFormat.APPLICATIONOCTETSTREAM;
+            }
             else
+            {
                 format = ObjectFormat.convert("text/plain");
+            }
+        }
         sm.setObjectFormat(format);
         //create the checksum
         String checksumS = checksum(is);
         ChecksumAlgorithm ca = ChecksumAlgorithm.convert("MD5");
         Checksum checksum = new Checksum();
         checksum.setValue(checksumS);
         checksum.setAlgorithm(ca);
         sm.setChecksum(checksum);
         //set the size
         is = this.get(token, identifier);
         sm.setSize(sizeOfStream(is));
         //submitter
         Principal p = new Principal();
         p.setValue(docInfo.get("user_owner"));
         sm.setSubmitter(p);
         sm.setRightsHolder(p);
         try
+        {
             Date dateCreated = parseMetacatDate(docInfo.get("date_created"));
             sm.setDateUploaded(dateCreated);
             Date dateUpdated = parseMetacatDate(docInfo.get("date_updated"));
             sm.setDateSysMetadataModified(dateUpdated);
+        }
         catch(Exception e)
+        {
             System.out.println("couldn't parse a date: " + e.getMessage());
             Date dateCreated = new Date();
             sm.setDateUploaded(dateCreated);
             Date dateUpdated = new Date();
             sm.setDateSysMetadataModified(dateUpdated);
+        }
         NodeReference nr = new NodeReference();
         nr.setValue("metacat");
         sm.setOriginMemberNode(nr);
         sm.setAuthoritativeMemberNode(nr);
         return sm;
+    }
             jones

Project

General

Profile

Metacat