Metacat

/**

 *  '$RCSfile$'

 *    Purpose: Implements a service for managing object formats

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

 *             National Center for Ecological Analysis and Synthesis

 *    Authors: Christopher Jones

 * 

 *   '$Author: $'

 *     '$Date: $'

 * '$Revision: $'

 *

 * 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.service;

import java.io.ByteArrayInputStream;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.InputStream;

import java.sql.SQLException;

import java.util.HashMap;

import java.util.List;

import edu.ucsb.nceas.metacat.DBUtil;

import edu.ucsb.nceas.metacat.DocumentImpl;

import edu.ucsb.nceas.metacat.McdbException;

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

import edu.ucsb.nceas.metacat.McdbDocNotFoundException;

import edu.ucsb.nceas.metacat.shared.BaseService;

import edu.ucsb.nceas.metacat.shared.ServiceException;

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

import edu.ucsb.nceas.utilities.PropertyNotFoundException;

import org.apache.log4j.Logger;

import org.dataone.client.CNode;

import org.dataone.client.D1Client;

import org.dataone.client.ObjectFormatCache;

import org.dataone.service.exceptions.InsufficientResources;

import org.dataone.service.exceptions.InvalidRequest;

import org.dataone.service.exceptions.NotFound;

import org.dataone.service.exceptions.NotImplemented;

import org.dataone.service.exceptions.ServiceFailure;

import org.dataone.service.types.Identifier;

import org.dataone.service.types.ObjectFormat;

import org.dataone.service.types.ObjectFormatList;

//import org.dataone.service.types.ObjectFormatList;

import org.dataone.service.types.util.ServiceTypeUtil;

import org.jibx.runtime.JiBXException;

/**

 *  The ObjectFormatService manages the list of object formats registered

 *  within Metacat.  This includes schema types, mime types, and other

 *  information related to a particular format.  The service provides

 *  functionality for the DataONE MemberNode and CoordinatingNode components,

 *  with CoordinatingNodes providing the authoritative list of object formats.

 */

public class ObjectFormatService extends BaseService {

  /* The instance of the logging class */

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

  /* The singleton instance of the object format service */

  private static ObjectFormatService objectFormatService = null;

  /* The scope of the object formats docid used as the metacat identifier */

  private final String OBJECT_FORMAT_DOCID = "OBJECT_FORMAT_LIST.103";

  /* The revision of the object formats document */

  private int rev;

  /* The separator of the object formats document */

  private String separator = ".";

  /* The accession number of the object formats document */

  private String accNumber = null;

  /* The list of object formats */

  private static ObjectFormatList objectFormatList = null;

  /* the searchable map of object formats */

  private static HashMap<String, ObjectFormat> objectFormatMap = 

    new HashMap<String, ObjectFormat>();

  /* A hash map of object format identifiers

  /* The D1 coordinating node reference object used for object format lookups */

  private String coordinatingNodeBaseURL = null;

  /* The D1 coordinating node reference object used for object format lookups */

  private CNode cn = null;

  /* The D1 node type for this instance of metacat */

  private String nodeType;

  /*

   * Constructor: Creates an instance of the object format service. Since

   * this uses a singleton pattern, use getInstance() to gain the instance.

   */

  private ObjectFormatService() {

    super();

    _serviceName="ObjectFormatService";

    try {

      doRefresh();

    } catch (ServiceException se) {

      logMetacat.debug("There was a problem creating the ObjectFormatService. " +

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

    }

  }

  /**

   *  Get the instance of the ObjectFormatService that has been instantiated,

   *  or instantiate one if it has not been already.

   *

   * @return objectFormatService - The instance of the object format service

   */

  public static ObjectFormatService getInstance(){

    if ( objectFormatService == null ) {

      objectFormatService = new ObjectFormatService();

    }

    return objectFormatService;

  }

  /**

   * Refreshes the object format service by manually updating the object

   * format document.

   */

  public void doRefresh() throws ServiceException {

    logMetacat.debug("ObjectFormatService.doRefresh() called.");

    logMetacat.info("Refreshing the object format list.");

    // create the in-memory list of object formats

    populateObjectFormatList();

    return;

  }

  /**

   * Populate the ObjectFormatService's objectFormatList. If this metacat

   * installation is a D1 Coordinating Node, object formats are populated

   * from a cached document in the Metacat database. Otherwise, if it is 

   * a Member Node, it attempts to get the authoritative list from the

   * defined Coordinating Node, failing back to a cached version.

   * 

   * @throws ServiceException

   */

  private void populateObjectFormatList() throws ServiceException {

    try {

      coordinatingNodeBaseURL = 

        PropertyService.getProperty("dataone.coordinatingNodeBaseURL");

      nodeType = 

        PropertyService.getProperty("dataone.nodeType");

    } catch ( PropertyNotFoundException pnfe ) {

      String message = "There was a problem finding the coordinating node " +

                       "URL in the properties file.  The message was: "     +

                       pnfe.getMessage();

      logMetacat.error(message);

      throw new ServiceException(message);

    }

    this.getCachedList();  

  }

  /**

   * Indicate whether or not this service is refreshable.  In this case it is,

   * where the ObjectFormatService can manually get the latest object format

   * document from Metacat.

   *

   * @return refreshable - the boolean refreshable status

   */

  public boolean refreshable() {

    return true;

  }

  /**

   * Stop the ObjectFormatService. When stopped, the service will no longer

   * respond to requests. Not implemented yet.

   */

  public void stop() throws ServiceException {

    // stub only 

    return;

  }

  /**

   * List the object formats registered with the object format service.

   * 

   * @return objectFormatList - the list of object formats

   */

  public ObjectFormatList listFormats() {

    return ObjectFormatService.objectFormatList;

  }

  /**

   * Get the object format based on the given identifier as a string.

   * 

   * @param format - the object format as a string

   * @return objectFormat - the ObjectFormat represented by the format string

   */

  public static ObjectFormat getFormat(String format) {

    ObjectFormat objectFormat = null;

    objectFormat = ObjectFormatService.objectFormatMap.get(format);

    return objectFormat;

  }

  /**

   * Get the object format list cached in Metacat, or on failure, via a

   * cached file on disk

   * 

   * @return objectFormatList - the cached object format list

   */

  private void getCachedList()

    throws ServiceException {

    try {

      // reset the accession number separator in case it is 

      // different than the default

      try {

        this.separator = PropertyService.getProperty("document.accNumSeparator");

      } catch ( PropertyNotFoundException pnfe ) {

        // use the default separator, but log the issue

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

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

      }

      // get the latest accession number if it is in Metacat

      this.rev = 

        DBUtil.getLatestRevisionInDocumentTable(this.OBJECT_FORMAT_DOCID);

      if ( this.rev != -1 ) {

        this.accNumber = this.OBJECT_FORMAT_DOCID + 

                         this.separator + 

                         this.rev;

        DocumentImpl objectFormatsDocument = new DocumentImpl(accNumber, false);

        ByteArrayInputStream bais = 

          new ByteArrayInputStream(objectFormatsDocument.toString().getBytes());

        ObjectFormatService.objectFormatList = 

          this.deserializeObjectFormatList(bais);

      } else {

        logMetacat.info("The latest revision number of "   + 

          this.OBJECT_FORMAT_DOCID                         +

          " could not be found. Reverting to the on-disk " +

          "object format list");

        ObjectFormatService.objectFormatList = ObjectFormatCache.listFormats();

      }

    } catch ( SQLException sqle ) {

      // we either have a metacat error or the docid was not inserted yet

      logMetacat.info("The latest revision number of "   + 

        this.OBJECT_FORMAT_DOCID                         +

        " could not be found. Reverting to the on-disk " +

        "object format list");

      ObjectFormatService.objectFormatList = ObjectFormatCache.listFormats();

    } catch (McdbException mcdbe) {

      // we have a metacat doc not found error

      logMetacat.info( this.OBJECT_FORMAT_DOCID          +

        " could not be found. Reverting to the on-disk " +

        "object format list");

      ObjectFormatService.objectFormatList = ObjectFormatCache.listFormats();

    }

    return;

  }

  /**

   * Deserialize the object format list file to an object format list object

   * 

   * @param fileInputStream - the file input stream of the XML object format list file

   * @return objectFormatList - the ObjectFormatList object from the XML stream

   * @throws ServiceException

   */

  private ObjectFormatList deserializeObjectFormatList(InputStream inputStream) 

    throws ServiceException {

    ObjectFormatList objectFormatList;

    try {

      objectFormatList = (ObjectFormatList)

      ServiceTypeUtil.deserializeServiceType(ObjectFormatList.class, inputStream);

    } catch ( JiBXException jbxe ) {

      logMetacat.debug("There was an error deserializing the input stream. " +

        "The error was: " + jbxe.getMessage());

      jbxe.printStackTrace();

      throw new ServiceException(jbxe.getMessage());

    }

    return objectFormatList;

  }

}