Metacat

 * acltext -- XML access text for a document to load into the database<br>

 * dtdtext -- XML DTD text for a new DTD to load into Metacat XML Catalog<br>

//      try {

//        // Open a pool of db connections

//        connectionPool = util.getConnectionPool();

//      } catch (Exception e) {

//        System.err.println("Error creating pool of database connections");

//        System.err.println(e.getMessage());

//      }

    if ( connectionPool.isEmpty() ) {

    //out.println(((String[])params.get("docid"))[0]);

      if(params.contains("acltext"))

        String[] acltext = (String[])params.get("acltext");

      StringReader dtd = null;

      if(params.contains("dtdtext"))

      {

        String[] dtdtext = (String[])params.get("dtdtext");

        try {

          dtd = new StringReader(dtdtext[0]);

        } catch (NullPointerException npe) {}

      }

                newdocid = DocumentImpl.write(conn, xml, acl, dtd, doAction,

              newdocid = DocumentImpl.write(conn, xml, acl, dtd, doAction,

  public static String write(Connection conn,String filename,

                             String aclfilename,String dtdfilename,

                             String action, String docid, String user,

                             String group )

    Reader acl = null;

    if ( aclfilename != null ) {

      acl = new FileReader(new File(aclfilename).toString());

    }

    Reader dtd = null;

    if ( dtdfilename != null ) {

      dtd = new FileReader(new File(dtdfilename).toString());

    }

                   acl, dtd, action, docid, user, group);

  public static String write(Connection conn,Reader xml,Reader acl,Reader dtd,

                             String action, String docid, String user,

                             String group )

    return write ( conn, xml, acl, dtd, action, docid, user, group, 1, false);

  }

  public static String write(Connection conn,Reader xml,Reader acl,

                             String action, String docid, String user,

                             String group )

                throws Exception {

      return write(conn,xml,acl,action,docid,user,group,servercode);

                throws Exception

    return write(conn,xml,null,action,docid,user,group,serverCode);

  public static String write( Connection conn,Reader xml,Reader acl,

                              String group, int serverCode) 

                throws Exception

    return write(conn,xml,acl,null,action,docid,user,group,serverCode,false);

  public static String write( Connection conn,Reader xml,Reader acl,Reader dtd,

                throws Exception

          XMLReader parser = initializeParser(conn, action, newdocid, user,

                                              serverCode, dtd);

      XMLReader parser=initializeParser(conn,action,newdocid,user,serverCode,dtd);

  private static XMLReader initializeParser(Connection conn, String action,

                                            String docid, String user,

                                            int serverCode, Reader dtd) 

                           throws Exception 

  {

      ContentHandler chandler = new DBSAXHandler(conn,action,docid,user,serverCode);

      EntityResolver eresolver= new DBEntityResolver(conn,(DBSAXHandler)chandler,dtd);

      DTDHandler dtdhandler   = new DBDTDHandler(conn);

      parser.setEntityResolver((EntityResolver)eresolver);

      String dtdfilename = null;

        } else if ( args[i].equals( "-r" ) ) {

          dtdfilename =  args[++i];

          "USAGE: java DocumentImpl [-t] <-a INSERT> [-d docid] <-f filename> "+

          "[-c aclfilename] [-r dtdfilename]");

          "   OR: java DocumentImpl [-t] <-a UPDATE -d docid -f filename> " +

          "[-c aclfilename] [-r dtdfilename]");

                                             dtdfilename, action, docid,

                                             null, null);

import org.xml.sax.helpers.DefaultHandler;

import java.io.Reader;

import java.io.BufferedReader;

import java.io.FileWriter;

import java.io.BufferedWriter;

  private Connection conn = null;

  private DefaultHandler handler = null;

  private String docname = null;

  private String doctype = null;

  private String systemid = null;

  private Reader dtdtext = null;

  /** 

   * Construct an instance of the DBEntityResolver class

   *

   * @param conn the JDBC connection to which information is written

   * @param handler the SAX handler to determine parsing context

   * @param dtd Reader of new dtd to be uploaded on server's file system

   */

  public DBEntityResolver(Connection conn, DefaultHandler handler, Reader dtd)

  {

    this.conn = conn;

    this.handler = handler;

    this.dtdtext = dtd;

  }

  /** 

   * The Parser call this method before opening any external entity 

   * except the top-level document entity (including the external DTD subset,

   * external entities referenced within the DTD, and external entities 

   * referenced within the document element)

   */

  public InputSource resolveEntity (String publicId, String systemId)

                     throws SAXException

  {

    String dbSystemID;

    String doctype = null;

    // Won't have a handler under all cases

    if ( handler != null ) {

      if ( handler instanceof DBSAXHandler ) {

        DBSAXHandler dhandler = null;

        dhandler = (DBSAXHandler)handler;

        if ( dhandler.processingDTD() ) {

          // public ID is doctype

          if (publicId != null) {   

            doctype = publicId;

          // assume public ID (doctype) is docname

          } else if (systemId != null) {

            doctype = dhandler.getDocname();

      } else if ( handler instanceof AccessControlList ) {

        AccessControlList ahandler = null;

        ahandler = (AccessControlList)handler;

        //if ( ahandler.processingDTD() ) {

          // public ID is doctype

          if (publicId != null) {   

            doctype = publicId;

          // assume public ID (doctype) is docname

          } else if (systemId != null) {

            doctype = ahandler.getDocname();

          }

        //}

      }

    }

    // get System ID for doctype

    if (doctype != null) {

      // look at db XML Catalog for System ID 

      dbSystemID = getDTDSystemID(doctype);

      boolean doctypeIsInDB = true;

      // no System ID found in db XML Catalog

      if (dbSystemID == null) {

        doctypeIsInDB = false;

        // use the provided System ID

        if (systemId != null) {

          dbSystemID = systemId;

        }

      }

      // there are dtd text provided; try to upload on Metacat

      if ( dtdtext != null ) {

        dbSystemID = uploadDTD(dbSystemID);

      }

      // check URLConnection first

      InputStream istream = checkURLConnection(dbSystemID);

      // need to register System ID in db XML Catalog if not yet

      if ( !doctypeIsInDB ) {

        registerDTD(doctype, dbSystemID);

      }

      // return a byte-input stream for use

      InputSource is = new InputSource(dbSystemID); 

      //is.setPublicId(doctype);

      //is.setSystemId(dbSystemID);

      is.setByteStream(istream);

      return is;

    } else {

      // use the provided systemId for other cases

      InputStream istream = checkURLConnection(systemId);

      return null;

    }

  }

  /** 

   * Look at db XML Catalog to get System ID (if any) for @doctype.

   * Return null if there are no System ID found for @doctype

   */

  private String getDTDSystemID( String doctype )

                 throws SAXException

  {

    String systemid = null;

    Statement stmt;

    try {

      stmt = conn.createStatement();

      stmt.execute("SELECT system_id FROM xml_catalog " + 

                   "WHERE entry_type = 'DTD' AND public_id = '" +

                   doctype + "'");

      ResultSet rs = stmt.getResultSet();

      boolean tableHasRows = rs.next();

      if (tableHasRows) {

        systemid = rs.getString(1);

      }

      stmt.close();

    } catch (SQLException e) {

      throw new SAXException

      ("DBEntityResolver.getDTDSystemID(): " + e.getMessage());

    }

    // return the selected System ID

    return systemid;

  }

  /** 

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

   * . make a reference with @systemId for @doctype in Metacat DB

   */

  private void registerDTD ( String doctype, String systemId )

                 throws SAXException

  {

    // make a reference in db catalog table with @systemId for @doctype

    try {

      PreparedStatement pstmt;

      pstmt = conn.prepareStatement(

             "(catalog_id, entry_type, public_id, system_id) " +

             "VALUES (null, 'DTD', ?, ?)");

      // Bind the values to the query

      pstmt.setString(1, doctype);

      pstmt.setString(2, systemId);

      // Do the insertion

      pstmt.execute();

      pstmt.close();

    } catch (SQLException e) {

      throw new SAXException

      ("DBEntityResolver.registerDTD(): " + e.getMessage());

    }

  }

  /** 

   * Upload new DTD text identified by @systemId on Metacat file system

   */

  private String uploadDTD ( String systemId )

                 throws SAXException

  {

    MetaCatUtil util = new MetaCatUtil();

    String dtdPath = util.getOption("dtdPath");

    String dtdURL = util.getOption("dtdURL");

    // get filename from systemId

    String filename = systemId;

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

    if ( slash > -1 ) {

      filename = filename.substring(slash + 1);

    }

    // writing dtd text on Metacat file system as filename

    try {

      // create a buffering character-input stream

      // that uses a default-sized input buffer

      BufferedReader in = new BufferedReader(dtdtext);

      // open file writer to write the input into it

      //String dtdPath = "/opt/tomcat/webapps/bojilova/dtd/";

      File f = new File(dtdPath, filename);

      try {

        if ( f.exists() && !f.canWrite() ) {

          throw new IOException("Not writable: " + f.getCanonicalFile());

        }

      } catch (SecurityException se) {

        // if a security manager exists,

        // its checkRead method is called for f.exist()

        // or checkWrite method is called for f.canWrite()

        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

	    String inputLine;

	    while ( (inputLine = in.readLine()) != null ) {

	      out.write(inputLine, 0, inputLine.length());

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

    } catch (MalformedURLException e) {

      throw new SAXException

      ("DBEntityResolver.uploadDTD(): " + e.getMessage());

    } catch (IOException e) {

      throw new SAXException

      ("DBEntityResolver.uploadDTD(): " + e.getMessage());

    } catch (SecurityException e) {

      throw new SAXException

      ("DBEntityResolver.uploadDTD(): " + e.getMessage());

    }

    //String dtdURL = "http://dev.nceas.ucsb.edu/bojilova/dtd/";

    return  dtdURL + filename;

  }

  /** 

   * Check URL Connection for @systemId, and return an InputStream

   * that can be used to read from the systemId URL.  The parser ends

   * up using this via the InputSource to read the DTD.

   *

   * @param systemId a URI (in practice URL) to be checked and opened

   */

  private InputStream checkURLConnection (String systemId)

                      throws SAXException

  {

    try {

      return (new URL(systemId).openStream());

    } catch (MalformedURLException e) {

      throw new SAXException

      ("DBEntityResolver.checkURLConnection(): " + e.getMessage());

    } catch (IOException e) {

      throw new SAXException

      ("DBEntityResolver.checkURLConnection(): " + e.getMessage());

    }    

  }   

 * 'Revision 1.15  2000/08/14 20:53:33  jones

 * 'Added "release" keyword to all metacat source files so that the release

 * 'number will be evident in software distributions.

 * '

import org.xml.sax.ContentHandler;

import org.xml.sax.EntityResolver;

import org.xml.sax.ErrorHandler;

  private boolean	processingDTD;

  private String 	docname;

  private String 	doctype;

  private String 	systemid;

    this.processingDTD = false;

    // Turn off validation

    parser.setFeature("http://xml.org/sax/features/validation", false);

    // Set Handlers in the parser

    parser.setContentHandler((ContentHandler)this);

    // make a DBEntityResolver instance

    // Set the EntityReslover to DBEntityResolver instance

    EntityResolver eresolver = new DBEntityResolver(conn,this,null);

    parser.setEntityResolver((EntityResolver)eresolver);

    parser.setErrorHandler((ErrorHandler)this);

  /** SAX Handler that receives notification of DOCTYPE. Sets the DTD */

  public void startDTD(String name, String publicId, String systemId) 

              throws SAXException {

    docname = name;

    doctype = publicId;

    systemid = systemId;

//    processingDTD = true;

  }

  /** 

   * SAX Handler that receives notification of the start of entities

   */

  public void startEntity(String name) throws SAXException {

    if (name.equals("[dtd]")) {

      processingDTD = true;

    }

  }

  /** 

   * SAX Handler that receives notification of the end of entities

   */

  public void endEntity(String name) throws SAXException {

    if (name.equals("[dtd]")) {

      processingDTD = false;

    }

  }

  /**

   * get the document name

   */

  public String getDocname() {

    return docname;

  }

  /**

   * get the document processing state

   */

  public boolean processingDTD() {

    return processingDTD;

  }