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

 *

 *   '$Author: daigle $'

 *     '$Date: 2008-10-10 17:10:00 -0700 (Fri, 10 Oct 2008) $'

 * '$Revision: 4439 $'

 *

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

import java.io.FileWriter;

import java.io.BufferedWriter;

import java.io.InputStream;

import java.io.IOException;

import org.apache.log4j.Logger;

import edu.ucsb.nceas.metacat.service.XMLSchemaService;

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

/**

 * 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 String WHITESPACESTRING =" ";   

  private boolean downloadNewSchema = false;

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

  public SchemaLocationResolver()

  {	  

  }

  /**

   * Construct an instance of the SchemaLocationResolver class

   *

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

   *         "namespace location"

   */

  public SchemaLocationResolver(String myNameSpaceAndLocation)

  {

	  parse(myNameSpaceAndLocation);

  }

  /**

   * Construct an instance of the SchemaLocationResolver class

   *

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

   *         "namespace location"

   */

  public SchemaLocationResolver(String myNameSpace, String myLocation)

  {

      nameSpace = myNameSpace;

      schemaLocation = myLocation;

  }

  /**

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

  {

    // if name space is not in table

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

        !XMLSchemaService.getNameSpaceList().contains(nameSpace))

    {

       try

       {

        // upload schema into metacat

        InputStream in = DBEntityResolver.checkURLConnection(schemaLocation);

        String newURLInMetacat = uploadSchemaFromURL(in);

        XMLSchemaService.getInstance().refresh();

        // check the name space list again.  It may not have appeared the first time 

        // because the schema was in the db but there was no file on disk.  If that's 

        // the case, it will show up in the name space list now.  If it doesn't we need

        // to register the schema in the database.

        if (!XMLSchemaService.getNameSpaceList().contains(nameSpace)) {

        	registerSchema(newURLInMetacat);

        	XMLSchemaService.getInstance().refresh();

        }

        downloadNewSchema = true;

       }

       catch(Exception e)

       {

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

                                  e.getMessage());

       }

    }//if

  }

  /**

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

   */

  private String uploadSchemaFromURL(InputStream istream) throws Exception

  {

	String relativeSchemaPath = XMLSchemaService.SCHEMA_DIR;

    String fullSchemaPath = SystemUtil.getContextDir() + relativeSchemaPath;

    String schemaURL = SystemUtil.getContextURL()  + relativeSchemaPath;

    // get filename from systemId

    String filename = XMLSchemaService.getSchemaFileNameFromUri(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(fullSchemaPath, 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  relativeSchemaPath + 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

    XMLSchemaService.populateRegisteredSchemaList();

  }

  /*

   * 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: "+ 

                                XMLSchemaService.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: "+ 

    		   XMLSchemaService.getNameSpaceAndLocationString());

     }

     catch(Exception e)

     {

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

                                e.getMessage());

     }

  }

  /**

   * Gets the downloadNewSchema's value.

   * @return

   */

 public boolean getDownloadNewSchema()

 {

	 return this.downloadNewSchema;

 }

}