Metacat

	        AuthToken token = getToken();

	        cs.generateMissingSystemMetadata(token);

import java.io.StringBufferInputStream;

import java.security.MessageDigest;

     * 

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

    public void generateMissingSystemMetadata(AuthToken token)

        IdentifierManager im = IdentifierManager.getInstance();

        List<String> l = im.getLocalIdsWithNoSystemMetadata();

            String localId = l.get(i);

            System.out.println("Creating SystemMetadata for localId " + localId);

            //get the document

            try

            {

                //generate required system metadata fields from the document

                SystemMetadata sm = createSystemMetadata(localId, token);

                System.out.println("sm: " + sm.toString());

                //insert the systemmetadata object

                //associate the systemmetadata with the original id

            }

            catch(Exception e)

            {

                System.out.println("Exception generating missing system metadata: " + e.getMessage());

                logMetacat.error("Could not generate missing system metadata: " + e.getMessage());

            }

    /**

     * 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

        ObjectFormat format = ObjectFormat.convert(docInfo.get("doctype"));

        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;

    }

    /**

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

        Calendar c = Calendar.getInstance();

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

              new Integer(month).intValue(), 

              new Integer(day).intValue());

        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;

    }

     * return information on the document with localId.  These are the fields

     * from the xml_documents table.  They can be used to contstruct metadata 

     * about the object that is stored.

     * @param localId

     * @return

     * @throws McdbDocNotFoundException

     */

    public Hashtable<String, String> getDocumentInfo(String localId)

        throws McdbDocNotFoundException

    {

        Hashtable<String, String> h = new Hashtable<String, String>();

        String sql = "select docname, doctype, user_owner, user_updated, " +

            "server_location, rev, date_created, date_updated from " + 

            "xml_documents where docid like '" + localId + "'";

        DBConnection dbConn = null;

        int serialNumber = -1;

        try 

        {

            // Get a database connection from the pool

            dbConn = DBConnectionPool.getDBConnection("IdentifierManager.getDocumentInfo");

            serialNumber = dbConn.getCheckOutSerialNumber();

            // Execute the insert statement

            PreparedStatement stmt = dbConn.prepareStatement(sql);

            ResultSet rs = stmt.executeQuery();

            if (rs.next()) 

            {

                String docname = rs.getString(1);

                String doctype = rs.getString(2);

                String user_owner = rs.getString(3);

                String user_updated = rs.getString(4);

                String server_location = rs.getString(5);

                int rev = rs.getInt(6);

                String date_created = rs.getString(7);

                String date_updated = rs.getString(8);

                h.put("docname", docname);

                h.put("doctype", doctype);

                h.put("user_owner", user_owner);

                h.put("user_updated", user_updated);

                h.put("server_location", server_location);

                h.put("rev", new Integer(rev).toString());

                h.put("date_created", date_created);

                h.put("date_updated", date_updated);

                stmt.close();

            } 

            else

            {

                stmt.close();

                DBConnectionPool.returnDBConnection(dbConn, serialNumber);

                throw new McdbDocNotFoundException("Could not find document " + localId);

            }

        } 

        catch (SQLException e) 

        {

            logMetacat.error("Error while getting document info for localid " + localId + " : "  

                    + e.getMessage());

        } 

        finally 

        {

            // Return database connection to the pool

            DBConnectionPool.returnDBConnection(dbConn, serialNumber);

        }

        return h;

    }

    /**

     * return the newest rev for a given localId

     * @param localId

     * @return

     */

    public int getLatestRevForLocalId(String localId)

        throws McdbDocNotFoundException

    {

        int rev = 0;

        String sql = "select rev from xml_documents where docid like '" + localId + "'";

        DBConnection dbConn = null;

        int serialNumber = -1;

        try 

        {

            // Get a database connection from the pool

            dbConn = DBConnectionPool.getDBConnection("IdentifierManager.getLatestRevForLocalId");

            serialNumber = dbConn.getCheckOutSerialNumber();

            // Execute the insert statement

            PreparedStatement stmt = dbConn.prepareStatement(sql);

            ResultSet rs = stmt.executeQuery();

            if (rs.next()) 

            {

                rev = rs.getInt(1);

                stmt.close();

            } 

            else

            {

                stmt.close();

                DBConnectionPool.returnDBConnection(dbConn, serialNumber);

                throw new McdbDocNotFoundException("Could not find document " + localId);

            }

        } 

        catch (SQLException e) 

        {

            logMetacat.error("Error while looking up the guid: " 

                    + e.getMessage());

        } 

        finally 

        {

            // Return database connection to the pool

            DBConnectionPool.returnDBConnection(dbConn, serialNumber);

        }

        return rev;

    }

    /**