Metacat

    /**

     * Creates a system metadata object for insertion into metacat

     *

     * @param localId  The local document identifier

     * @param user  The user submitting the system metadata document

     * @param groups  The groups the user belongs to

     *

     * @return sysMeta  The system metadata object created

     */

    public SystemMetadata createSystemMetadata(Identifier identifier,

      String username, String[] groups) 

      throws McdbException, McdbDocNotFoundException, SQLException, 

      IOException, AccessionNumberException, ClassNotFoundException,

      InsufficientKarmaException, ParseLSIDException, PropertyNotFoundException,

      BaseException, NoSuchAlgorithmException

    {

      logMetacat.debug("MetacatHandler.createSystemMetadata() called.");

      // create system metadata for the document

      IdentifierManager im = IdentifierManager.getInstance();

      Hashtable<String, Object> docInfo;

      SystemMetadata sysMeta = new SystemMetadata();

      String localId = "";

      InputStream inputStream;

      //set the id

      sysMeta.setIdentifier(identifier);

      // get the data or metadata object

      try {

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

        docInfo = im.getDocumentInfo(localId);

        inputStream = this.read(localId, username, groups);

      } catch ( McdbDocNotFoundException dnfe ) {

        logMetacat.debug("There was a problem getting the localId from " +

          "the given guid. The error message was: " + dnfe.getMessage());

        throw dnfe;

      } catch ( InsufficientKarmaException ike ) {

        logMetacat.debug("There was an access problem reading " +

          localId + ". The error message was: " + ike.getMessage());

        throw ike;

      } catch ( ParseLSIDException ple ) {

        logMetacat.debug("There was a problem parsing the LSID from " +

          localId + ". The error message was: " + ple.getMessage());

        throw ple;

      } catch ( PropertyNotFoundException pnfe ) {

        logMetacat.debug("There was a problem finding a property. " +

          "The error message was: " + pnfe.getMessage());

        throw pnfe;

      } catch ( McdbException me ) {

        logMetacat.debug("There was a Metacat problem. " +

          "The error message was: " + me.getMessage());

        throw me;

      } catch ( SQLException sqle ) {

        logMetacat.debug("There was a SQL problem. " +

          "The error message was: " + sqle.getMessage());

        throw sqle;

      } catch ( ClassNotFoundException cnfe ) {

        logMetacat.debug("There was a problem finding a class. " +

          "The error message was: " + cnfe.getMessage());

        throw cnfe;

      } catch ( IOException ioe ) {

        logMetacat.debug("There was an I/O exception. " +

          "The error message was: " + ioe.getMessage());

        throw ioe;

      } // end try()

      //set the default object format

      String doctype = (String) docInfo.get("doctype");

      ObjectFormat format = ObjectFormat.convert(doctype);

      if (format == null) {

          if (doctype.trim().equals("BIN")) {

              format = ObjectFormat.OCTET_STREAM;

          } else {

              format = ObjectFormat.convert("text/plain");

          }

      }

      sysMeta.setObjectFormat(format);

      logMetacat.debug("The ObjectFormat for " + localId + 

                       " is " + format.toString());

      // further parse EML documents to get data object format,

      // describes and describedBy information

      if ( format == ObjectFormat.EML_2_0_0 ||

           format == ObjectFormat.EML_2_0_1 ||

           format == ObjectFormat.EML_2_1_0 ) {

        try {

          DataoneEMLParser emlParser = DataoneEMLParser.getInstance();

          EMLDocument emlDocument = emlParser.parseDocument(inputStream);

          // iterate through the data objects in the EML doc and add sysmeta

          logMetacat.debug("In createSystemMetadata() the number of data " + 

            "entities is: " + emlDocument.distributionMetadata.size());

          // iterate through data objects described by the EML

          for( int j = 0; j < emlDocument.distributionMetadata.size(); j++ ) {

            DistributionMetadata distMetadata = 

              emlDocument.distributionMetadata.elementAt(j);

            String dataDocUrl = distMetadata.url;

            String dataDocMimeType = distMetadata.mimeType;

            String dataDocLocalId = "";

            logMetacat.debug("Data local ID: " + dataDocLocalId);

            logMetacat.debug("Data URL     : " + dataDocUrl);

            logMetacat.debug("Data mime    : " + dataDocMimeType);

            //we only handle ecogrid urls right now

            if ( dataDocUrl.trim().startsWith("ecogrid://knb/") ) {

              dataDocLocalId = 

                dataDocUrl.substring(dataDocUrl.indexOf("ecogrid://knb/") + 

                "ecogrid://knb/".length(), dataDocUrl.length());

              //set the id

              Identifier dataDocId = new Identifier();

              dataDocId.setValue(dataDocLocalId);

              // add describes into EML system metadata

              sysMeta.addDescribe(dataDocId);

              SystemMetadata dataSysMeta = new SystemMetadata();

              // check if data system metadata exists

              try {

                logMetacat.debug("Checking for existing system metadata for " + 

                  dataDocId.getValue());

                dataSysMeta = this.getSystemMetadata(dataDocId);

                // add describedBy sysmeta

                logMetacat.debug("Setting describedBy for " + dataDocId.getValue() +

                                 " to " + identifier.getValue());

                dataSysMeta.addDescribedBy(identifier);

                dataSysMeta.setObjectFormat(ObjectFormat.convert(dataDocMimeType));

                this.updateSystemMetadata(dataSysMeta, username, groups);

              } catch ( NotFound nf ) {

                // System metadata for data doesn't exist

                logMetacat.debug("There was not an existing system metadata " + 

                  "document for " + dataDocId.getValue());

                try {

                  logMetacat.debug("Creating a system metadata " + 

                    "document for " + dataDocId.getValue());

                  dataSysMeta = 

                    this.createSystemMetadata(dataDocId, username, groups);

                  logMetacat.debug("Setting describedBy for " + 

                    dataDocId.getValue() + " to " + identifier.getValue());

                  dataSysMeta.addDescribedBy(identifier);

                  logMetacat.debug("Setting mimeType for " + 

                    dataDocId.getValue() + " to " + dataDocMimeType);

                  dataSysMeta.setObjectFormat(ObjectFormat.convert(dataDocMimeType));

                  logMetacat.debug("Updating system metadata for " + 

                    dataDocId.getValue() + " to " + dataDocMimeType);

                  this.updateSystemMetadata(dataSysMeta, username, groups);

                } catch ( McdbDocNotFoundException mdnf) {

                  mdnf.printStackTrace();

                  throw mdnf;

                } catch ( NumberFormatException nfe) {

                  nfe.printStackTrace();

                  throw nfe;

                } catch ( AccessionNumberException ane) {

                  ane.printStackTrace();

                  throw ane;

                } catch ( SQLException sqle) {

                  sqle.printStackTrace();

                  throw sqle;

                } catch ( NoSuchAlgorithmException nsae) {

                  nsae.printStackTrace();

                  throw nsae;

                } catch ( IOException ioe) {

                  ioe.printStackTrace();

                  throw ioe;

                } catch ( PropertyNotFoundException pnfe) {

                  pnfe.printStackTrace();

                  throw pnfe;

                } catch ( BaseException be) {

                  be.printStackTrace();

                  throw be;

                }

              }

            } // end if()

          } // end for()

        } catch ( ParserConfigurationException pce ) {

          logMetacat.debug("There was a problem parsing the EML document. " +

                           "The error message was: " + pce.getMessage());

        } catch ( SAXException saxe ) {

          logMetacat.debug("There was a problem traversing the EML document. " +

                           "The error message was: " + saxe.getMessage());

        } catch ( XPathExpressionException xpee ) {

          logMetacat.debug("There was a problem searching the EML document. " +

                           "The error message was: " + xpee.getMessage());

        } // end try()

      } // end if()

      //create the checksum

      inputStream = this.read(localId, username, groups);

      ChecksumAlgorithm algorithm = ChecksumAlgorithm.convert("MD5");

      Checksum checksum = ServiceTypeUtil.checksum(inputStream, algorithm);

      sysMeta.setChecksum(checksum);

      //set the size

      inputStream = this.read(localId, username, groups);

      sysMeta.setSize(sizeOfStream(inputStream));

      //submitter

      Principal principal = new Principal();

      principal.setValue((String) docInfo.get("user_owner"));

      sysMeta.setSubmitter(principal);

      sysMeta.setRightsHolder(principal);

      try {

        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-DD");

        dateFormat.setTimeZone(TimeZone.getDefault());

        Date dateCreated = dateFormat.parse((String) docInfo.get("date_created"));

        sysMeta.setDateUploaded(dateCreated);

        Date dateUpdated = dateFormat.parse((String) docInfo.get("date_updated"));

        sysMeta.setDateSysMetadataModified(dateUpdated);

      } catch (ParseException pe) {

        logMetacat.debug("There was a problem parsing a Metacat date. The " + 

          "error message was: " + pe.getMessage());

        Date dateCreated = new Date();

        sysMeta.setDateUploaded(dateCreated);

        Date dateUpdated = new Date();

        sysMeta.setDateSysMetadataModified(dateUpdated);

      }

      NodeReference nr = new NodeReference();

      nr.setValue(PropertyService.getProperty("dataone.memberNodeId"));

      sysMeta.setOriginMemberNode(nr);

      sysMeta.setAuthoritativeMemberNode(nr);

      return sysMeta;

    }

    /*

     * Find the size (in bytes) of a stream. Note: This needs to refactored out

     * of MetacatHandler and into a utility when stream i/o in Metacat is

     * evaluated.

     *

     * @param is  The InputStream of bytes

     * @return size  The size in bytes of the input stream as a long

     * @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;

    }