Metacat

/**

 *  '$RCSfile$'

 *    Purpose: A Class that implements org.xml.sax.EntityResolver interface

 *             for resolving external entities

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

 *             National Center for Ecological Analysis and Synthesis

 *    Authors: Jivka Bojilova, Matt Jones

 *    Release: @release@

 *

 *   '$Author: sgarg $'

 *     '$Date: 2005-10-10 11:06:55 -0700 (Mon, 10 Oct 2005) $'

 * '$Revision: 2663 $'

 *

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

import java.sql.*;

import java.io.File;

import java.io.Reader;

import java.io.BufferedReader;

import java.io.BufferedInputStream;

import java.io.FileWriter;

import java.io.BufferedWriter;

import java.io.InputStream;

import java.io.IOException;

import java.net.URL;

import java.net.URLConnection;

import java.net.MalformedURLException;

import java.util.Vector;

import org.apache.log4j.Logger;

/**

 * A database aware Class to handle schema location. If namespace is in the

 * xml_catalog table (public_id), the schema location specified in xml document

 * will be ignored by parser setting external schema location. If the

 * name space is not in the table, it will be download to metacat and register

 * in table

 */

public class SchemaLocationResolver

{

  private String nameSpace = null; //public id

  private String schemaLocation = null; // system id

  private Vector nameSpaceList = new Vector();// name space in the table

  private String nameSpaceAndLocationString = null; // the parameter will be set

                                              // in external property in parser

  //private String schemaFileName = null;

  // constant

  //private String SCHEMATYPE ="Schema"; 

  private String WHITESPACESTRING =" ";                                                         

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

  public SchemaLocationResolver()

  {

    createNameSpaceAndLocationStringFromDB();

  }

  /**

   * Construct an instance of the SchemaLocationResolver class

   *

   * @param  myNameSpaceAndLocation it is come from xsi:schemaLocation=

   *         "namespace location"

   */

  public SchemaLocationResolver(String myNameSpaceAndLocation)

  {

    parse(myNameSpaceAndLocation);

  }

  /**

   * A method to get nameSpaceAndLocationString

   */

  public String getNameSpaceAndLocationString()

  {

    logMetacat.info("namespace and location list is: " +

                             nameSpaceAndLocationString);

    return nameSpaceAndLocationString;

  }

  /**

   * When got a name space, check if it is in the database, if it is do nothing

   * else upload it to metacat to store it and register it in catalog table

   */

  public void resolveNameSpace ()

  {

    //get name space lists

    createNameSpaceListFromDB();

    // if name space is not in table

    if (nameSpace !=null && schemaLocation != null &&

        !nameSpaceList.contains(nameSpace))

    {

       try

       {

        // upload schema into metacat

        InputStream in = DBEntityResolver.checkURLConnection(schemaLocation);

        String newURLInMetacat = uploadSchemaFromURL(in);

        // reigister schema

        registerSchema(newURLInMetacat);

       }

       catch(Exception e)

       {

         logMetacat.error("Error in SchemaLocation.resolveNameSpace" +

                                  e.getMessage());

       }

    }//if

  }

  /* This method will take look xml_catalog table and create a string look like

   * "namespace1 location namespacke2 location". This string will be set as 

   * a extenalschemalocation in SAX parser. Then when parser check the 

   * it will ignore the schema location specified by xml document

   */

  private void createNameSpaceAndLocationStringFromDB()

  {

    DBConnection conn = null;

    int serialNumber = -1;

    PreparedStatement pstmt = null;

    ResultSet result = null;

    String sql = "SELECT public_id, system_id FROM xml_catalog where " +

                 "entry_type ='" + DocumentImpl.SCHEMA +"'";

    try 

    {

      //check out DBConnection

      conn=DBConnectionPool.getDBConnection("SchemaLocationResl.createName");

      serialNumber=conn.getCheckOutSerialNumber();

      pstmt = conn.prepareStatement(sql);

      pstmt.execute();

      result = pstmt.getResultSet();

      // Get string for namespace and location form DB

      boolean hasRow = result.next();

      StringBuffer buffer = new StringBuffer();

      boolean firstTime = true;

      while (hasRow)

      {

        String namespace = result.getString(1);

        String location  = result.getString(2);

        String pairOfNameSpaceAndLocation = namespace + WHITESPACESTRING 

                                            +location;

        if (!firstTime)

        {

          buffer.append(WHITESPACESTRING);

        }

        buffer.append(pairOfNameSpaceAndLocation);

        firstTime = false;

        hasRow = result.next();

      }

      // give the buffer to the string if buffer has something in it

      if (buffer.length() != 0)

      {

        nameSpaceAndLocationString = buffer.toString();

      }

      result.close();

      pstmt.close();

    } 

    catch (SQLException e) 

    {

      logMetacat.error("schemaLocation.createNameSpaceAndLocationString: " + 

                         e.getMessage());

    }

    finally

    {

      try

      {

        pstmt.close();

      }//try

      catch (SQLException sqlE)

      {

        logMetacat.error("Error in schema.createNameSpaceAndLocation "

                                    + sqlE.getMessage());

      }//catch

      DBConnectionPool.returnDBConnection(conn, serialNumber);

    }//finally

  }

  /* This method will take look xml_catalog table and create a name space

   * vector already in the table

   */

  private void createNameSpaceListFromDB()

  {

    DBConnection conn = null;

    int serialNumber = -1;

    PreparedStatement pstmt = null;

    ResultSet result = null;

    String sql = "SELECT public_id FROM xml_catalog where " +

                 "entry_type ='" + DocumentImpl.SCHEMA +"'";

    try 

    {

      //check out DBConnection

      conn=DBConnectionPool.getDBConnection("SchemaLocationResl.createNameList");

      serialNumber=conn.getCheckOutSerialNumber();

      pstmt = conn.prepareStatement(sql);

      pstmt.execute();

      result = pstmt.getResultSet();

      // Get string for namespace form DB and store in the vector

      boolean hasRow = result.next();

      while (hasRow)

      {

        String namespace = result.getString(1);

        nameSpaceList.addElement(namespace);

        hasRow = result.next();

      }

      pstmt.close();

      result.close();

    } 

    catch (SQLException e) 

    {

      logMetacat.error("schemaLocation.createNameSpaceList: " + 

                         e.getMessage());

    }

    finally

    {

      try

      {

        pstmt.close();

      }//try

      catch (SQLException sqlE)

      {

        logMetacat.error("Error in schemaLocation.createNameSpaceList: "

                                    +sqlE.getMessage());

      }//catch

      DBConnectionPool.returnDBConnection(conn, serialNumber);

    }//finally

  }

  /**

   * Upload new Schema located at outside URL to Metacat file system

   */

  private String uploadSchemaFromURL(InputStream istream) throws Exception

  {

    String schemaPath = MetaCatUtil.getOption("schemaPath");

    String schemaURL = MetaCatUtil.getOption("schemaURL");

    // get filename from systemId

    String filename = schemaLocation;

    if (filename != null && !(filename.trim()).equals(""))

    {

      int slash = Math.max(filename.lastIndexOf('/'), filename.lastIndexOf('\\'));

      if ( slash > -1 ) 

      {

        filename = filename.substring(slash + 1);

      }

    }

    else

    {

      return null;

    }

    // writing schema text on Metacat file system as filename

    try {

      // create a buffering character-input stream

      // that uses a default-sized input buffer

      BufferedInputStream in = new BufferedInputStream(istream);

      // open file writer to write the input into it

      File f = new File(schemaPath, filename);

      synchronized (f) 

      {

        try 

        {

          if ( f.exists() ) 

          {

           throw new IOException("File already exist: " + f.getCanonicalFile());

          }

        } 

        catch (SecurityException se) 

        {

         // if a security manager exists,

          throw se;

       }

      // create a buffered character-output stream

      // that uses a default-sized output buffer

      FileWriter fw = new FileWriter(f);

      BufferedWriter out = new BufferedWriter(fw);

      // read the input and write into the file writer

      int inputByte;

      while ( (inputByte = in.read()) != -1 ) 

      {

        out.write(inputByte);

        //out.newLine(); //instead of out.write('\r\n');

      }

      // the input and the output streams must be closed

      in.close();

      out.flush();

      out.close();

      fw.close();

     } // end of synchronized

    } 

    catch (Exception e) 

    {

      throw new Exception

      ("shemaLocationResolver.uploadSchemaFromURL(): " + e.getMessage());

    } 

    logMetacat.warn("new schema location is: " + schemaURL + 

                              filename);

    return  schemaURL + filename;

  }

  /*

   * Register new schema identified by @systemId in Metacat XML Catalog

   */

  private void registerSchema(String systemId )

  {

    // check systemid is not null

    if (systemId == null || nameSpace == null || (nameSpace.trim()).equals(""))

    {

      return;

    }

    DBConnection conn = null;

    int serialNumber = -1;

    PreparedStatement pstmt = null;

    String sql = "INSERT INTO xml_catalog " +

             "(entry_type, public_id, system_id) " +

             "VALUES ('" + DocumentImpl.SCHEMA + "', ?, ?)";

    try 

    {

      //check out DBConnection

      conn=DBConnectionPool.getDBConnection("schemaLocation.registerSchema");

      serialNumber=conn.getCheckOutSerialNumber();

      pstmt = conn.prepareStatement(sql);

      // Bind the values to the query

      pstmt.setString(1, nameSpace);

      pstmt.setString(2, systemId);

      // Do the insertion

      pstmt.execute();

      pstmt.close();

    } 

    catch (SQLException e) 

    {

      logMetacat.error("SchemaLocation.egisterSchema(): " + e.getMessage());

    }

    finally

    {

      try

      {

        pstmt.close();

      }//try

      catch (SQLException sqlE)

      {

        logMetacat.error("Error in SchemaLocation.egisterSchema(): "

                                    +sqlE.getMessage());

      }//catch

      DBConnectionPool.returnDBConnection(conn, serialNumber);

    }//finally

  }

  /*

   * A method to parse the value for xis:schemaLocation="namespace location"

   * and store the namespace in nameSpace and location in schemaLocaion

   */

  private void parse(String nameSpaceAndLocation)

  {

    // check the parameter

    if (nameSpaceAndLocation == null||(nameSpaceAndLocation.trim()).equals(""))

    {

      return;

    }

    //Get white space index (delimiter)

    int indexOfWhiteSpace = nameSpaceAndLocation.lastIndexOf(WHITESPACESTRING);

    if (indexOfWhiteSpace != -1)

    {

      // before white space is namespace

      nameSpace = nameSpaceAndLocation.substring(0,indexOfWhiteSpace);

      // after white sapce is schema location

      schemaLocation = nameSpaceAndLocation.substring(indexOfWhiteSpace+1);

      // Gebug message

      logMetacat.info("Namespace after parsing: " + nameSpace);

      logMetacat.info("Location after parsing: " + schemaLocation);

    } 

  }

  public static void main(String[] argus)

  {

     try

     {

       DBConnectionPool pool = DBConnectionPool.getInstance();

       // Print out a empty schema list

       SchemaLocationResolver schema = new SchemaLocationResolver();

       logMetacat.warn("Namespace and Location String: "+ 

                                schema.getNameSpaceAndLocationString());

       // input a schemalocation

       SchemaLocationResolver schema2 = new SchemaLocationResolver(

                                        "eml://ecoinformatics.org/eml-2.0.0 " +

                                "http://dev.nceas.ucsb.edu/tao/schema/eml.xsd");

       schema2.resolveNameSpace();

       // input a wrong name space location

       SchemaLocationResolver schema3 = new SchemaLocationResolver(

                                        "http://www.xm.org/schema/stmml " +

                              "http://dev.nceas.ucsb.edu/tao/schema/stmml.xsd");

       schema3.resolveNameSpace();

       // print out new schema list in db

       SchemaLocationResolver schema4 = new SchemaLocationResolver();

       logMetacat.warn("Namespace and Location String: "+ 

                                schema4.getNameSpaceAndLocationString());

     }

     catch(Exception e)

     {

       logMetacat.error("erorr in Schemalocation.main: " + 

                                e.getMessage());

     }

  }

}