Metacat

/**

 *  '$RCSfile$'

 *    Purpose: A Class that implements a URL for use in identifying metacat

 *             files. It also handles http urls

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

 *             National Center for Ecological Analysis and Synthesis

 *    Authors: Chad Berkley

 *    Release: @release@

 *

 *   '$Author$'

 *     '$Date$'

 * '$Revision$'

 */

package edu.ucsb.nceas.metacat;

import java.net.MalformedURLException;

import java.util.Hashtable;

import java.util.Enumeration;

public class metacatURL

{

  private String[][] params = new String[200][2];

  private Hashtable paramsHash = new Hashtable();

  private String urlType = null;

  private String host = null;

  private String url;

  /**

   * This constructor takes a string url and parses it according to the  

   * following rules.  

   * 1) The name of the url is the text before the "://" symbol.

   * 2) Parameter names are written first and are terminated with the # symbol

   * 3) Parameter values come 2nd and are terminated with an & except for the

   *    last value

   * The form of the url looks like: 

   * urltype://name1#value1&name2#value2&nameN#valueN

   * notice there is no & after the last param.  If one is there it is ignored.

   *

   * @param url the string to parse

   */

  public metacatURL(String url) throws MalformedURLException

  {

    this.url = url;

    parseURL(url);

  }

  /**

   * This method takes a string url and parses it according to the following 

   * rules.  

   * 1) The name of the url is the text before the "://" symbol.

   * 2) Parameter names are written first and are terminated with the # symbol

   * 3) Parameter values come 2nd and are terminated with an & except for the

   *    last value

   * The form of the url looks like: 

   * urltype://name1#value1&name2#value2&nameN#valueN

   * notice there is no & after the last param.  If one is there it is ignored.

   */

  private void parseURL(String url) throws MalformedURLException

  {

    String pname = null;

    String param = null;

    String temp = "";

    boolean ampflag = true;

    boolean poundflag = false;

    int arrcount = 0;

    int urlTypeIndex = url.indexOf("://"); //anything before this is the urltype

    this.urlType = url.substring(0, urlTypeIndex);

    paramsHash.put("urlType", this.urlType);

    if(this.urlType.equals("http"))

    {//if this is an http url

      params[0][0] = "httpurl";

      params[0][1] = url.substring(0, url.length());

      paramsHash.put(params[0][0], params[0][1]);

      for(int i=url.length()-1; i>0; i--)

      {

        if(url.charAt(i) == '/')

        {

          i=0;

        }

        else

        {

          String exchange = temp;

          temp = "";

          temp += url.charAt(i);

          temp += exchange;

        }

      }

      params[1][0] = "filename";

      params[1][1] = temp;

      paramsHash.put(params[1][0], params[1][1]);

    }

    else

    {//other urls that meet the metacat type url structure.

      int hostIndex = url.indexOf("?");

      this.host = url.substring(urlTypeIndex + 3, hostIndex);

      paramsHash.put("host", this.host);

      for(int i=hostIndex + 1; i<url.length(); i++)

      { //go throught the remainder of the url one character at a time.

        if(url.charAt(i) == '=')

        { //if the current char is a # then the preceding should be a parametet

          //name

          if(!poundflag && ampflag)

          {

            params[arrcount][0] = temp.trim();

            temp = "";

          }

          else

          { //if there are two #s or &s in a row throw an exception.

            throw new MalformedURLException("metacatURL: Two parameter names " +

                                            "not allowed in sequence");

          }

          poundflag = true;

          ampflag = false;

        }

        else if(url.charAt(i) == '&' || i == url.length()-1)

        { //the text preceding the & should be the param value.

          if(i == url.length() - 1)

          { //if we are at the end of the string grab the last value and append it.

            if(url.charAt(i) != '=')

            { //ignore an extra & on the end of the string

              temp += url.charAt(i);

            }

          }

          if(!ampflag && poundflag)

          {

            params[arrcount][1] = temp.trim();

            paramsHash.put(params[arrcount][0], params[arrcount][1]);

            temp = "";

            arrcount++; //increment the array to the next row.

          }

          else

          { //if there are two #s or &s in a row through an exception

            throw new MalformedURLException("metacatURL: Two parameter values " +

                                            "not allowed in sequence");

          }

          poundflag = false;

          ampflag = true;

        }

        else

        { //get the next character in the string

          temp += url.charAt(i); 

        }

      }

    }

  }

  /**

   * Returns the type of the url. This is defined by the text before the "://" 

   * symbol in the url.

   */

  public String getURLType()

  {

    return this.urlType; 

  }

  /**

   * Returns the parameters as a 2D string array.

   */

  public String[][] getParams()

  {

    return this.params;

  }

  /** 

   * Returns the parameters in a hashtable.

   */

  public Hashtable getHashParams()

  {

    return this.paramsHash;

  }

  /**

   * returns a single parameter from the hash by name

   * @param paramname the name of the parameter to return.

   */

  public Object getHashParam(String paramname)

  {

    return this.paramsHash.get(paramname);

  }

  /**

   * returns a string representation of this metacatURL

   */

  public String toString()

  {

    return this.url;

  }

  public void printHashParams()

  {

    Enumeration e = this.paramsHash.keys();

    System.out.println("name          value");

    System.out.println("-------------------");

    while(e.hasMoreElements())

    {

      String key = (String)e.nextElement();

      System.out.print(key);

      System.out.print("          ");

      System.out.println((String)this.paramsHash.get(key));

    }

  }

  /**

   * Prints the parameters neatly to system.out

   */

  public void printParams()

  {

    String[][] p = null;

    System.out.println("url type: " + this.getURLType());

    System.out.println("parameters: ");

    p = this.getParams();

    System.out.println("name          value");

    System.out.println("-------------------");

    for(int i=0; i<p.length; i++)

    {

      if(p[i][0] != null)

      {

        System.out.print(p[i][0]);

        System.out.print("          ");

        System.out.print(p[i][1]);

        System.out.println();

      }

    }

  }

  /**

   * Returns a single parameter and value as a 1D string array.

   *

   * @param index the index of the parameter, value array that you want.

   */

  public String[] getParam(int index)

  {

    String[] s = new String[2];

    s[0] = this.params[index][0].trim();

    s[1] = this.params[index][1].trim();

    //System.out.println("0: " + s[0]);

    //System.out.println("1: " + s[1]);

    return s;

  }

  /**

   * Test method for this class.

   */

  public static void main(String args[])

  {

    String testurl =  "metacat://dev.nceas.ucsb.edu?docid=NCEAS:10&username=chad&pasword=xyz";

    String testurl2 = "http://dev.nceas.ucsb.edu/berkley/testdata.dat";

    try

    {

      metacatURL murl = new metacatURL(testurl);

      metacatURL murl2 = new metacatURL(testurl2);

      String[][] p = null;

      System.out.println("url type: " + murl.getURLType());

      System.out.println("parameters: ");

      p = murl.getParams();

      Hashtable h = murl.getHashParams();

      murl.printParams();

      murl2.printParams();

      System.out.println("hash params: " );

      murl.printHashParams();

      murl2.printHashParams();

    }

    catch(MalformedURLException murle)

    {

      System.out.println("bad url " + murle.getMessage()); 

    }

  }

}

/**

 *  '$RCSfile$'

 *    Purpose: A class to asyncronously build the package relation index

 *             in the database table xml_relation.

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

 *             National Center for Ecological Analysis and Synthesis

 *    Authors: Chad Berkley

 *    Release: @release@

 *

 *   '$Author$'

 *     '$Date$'

 * '$Revision$'

 */

package edu.ucsb.nceas.metacat;

import java.sql.*;

import java.util.*;

import java.lang.Thread; 

public class relationHandler implements Runnable

{

  private Thread btThread = null;

  private Connection conn = null;

  private DocumentImpl xmldoc = null;

  MetaCatUtil util = new MetaCatUtil();

  /** 

   * Constructor for this class.  finds all of the relations to a single xml

   * document and writes them to the database.  This includes transitive

   * relations.

   * @param xmldoc the xml document to index.

   */

  public relationHandler(DocumentImpl xmldoc, Connection conn)

  {

    this.conn = conn;    

    this.xmldoc = xmldoc;

    if(xmldoc.getDoctype().equals(util.getOption("packagedoctype")))

    { //make sure this doctype is a package document then run the thread

      btThread = new Thread(this);

      btThread.setPriority(Thread.MIN_PRIORITY);

      btThread.start();

    }

  }

  /**

   * The thread handler

   */

  public void run()

  {

    //pseudo-code algorithm

    //for each new relation r in xml_nodes

    //  put r into xml_relation

    //  compare r to each relation already in xml_relation

    //  if r isrelatedto a row in xml_relation

    //    add a new row to xml_relation that represents this new relation

    try

    {

      String docid = xmldoc.getDocID();

      PreparedStatement pstmt = conn.prepareStatement(

                                QuerySpecification.printPackageSQL(docid));

      pstmt.execute();

      //get the new relations out of xml_nodes

      ResultSet rs = pstmt.getResultSet();

      boolean hasmorerows = rs.next();

      while(hasmorerows)

      {

        String subject = rs.getString(1);

        metacatURL subjectMurl = new metacatURL(subject);

        String subjectDoctype = null;

        if(subjectMurl.getURLType().equals("metacat"))

        {

          DocumentImpl subDoc = new DocumentImpl(conn, 

                                                 subjectMurl.getParam(0)[1]);

          subjectDoctype = subDoc.getDoctype();

        }

        String relationship = rs.getString(2);

        String object = rs.getString(3);

        //compare r to each relation in xml_relation

        pstmt = conn.prepareStatement("select subject, subdoctype, " +

                                      "relationship, object, objdoctype " +

                                      "from xml_relation");

        pstmt.execute();

        //get each relation in xml_relation for comparison

        ResultSet relations = pstmt.getResultSet();

        boolean hasmorerelations = relations.next();

        while(hasmorerelations)

        {

          String currentSub = relations.getString(1);

          String currentSubDoctype = relations.getString(2);

          String currentRelationship = relations.getString(3);

          String currentObj = relations.getString(4);

          String currentObjDoctype = relations.getString(5);

          if(object.equals(currentObj))

          {//there is a transitive relation so add a new relation to the table

            StringBuffer insertTransRelation = new StringBuffer();

            insertTransRelation.append("insert into xml_relation (subject, ");

            insertTransRelation.append("subdoctype, relationship, object, ");

            insertTransRelation.append("objdoctype) values ('");

            insertTransRelation.append(currentSub).append("', '");

            insertTransRelation.append(currentSubDoctype).append("', ");

            insertTransRelation.append("'hasTransitiveRelationTo', '");

            insertTransRelation.append(subject).append("', '");

            insertTransRelation.append(subjectDoctype).append("')");

            pstmt = conn.prepareStatement(insertTransRelation.toString());

            pstmt.execute();

            insertTransRelation = new StringBuffer();

            //put the same relation in with the subject and object switched

            insertTransRelation.append("insert into xml_relation (subject, ");

            insertTransRelation.append("subdoctype, relationship, object, ");

            insertTransRelation.append("objdoctype) values ('");

            insertTransRelation.append(subject).append("', '");

            insertTransRelation.append(subjectDoctype).append("', ");

            insertTransRelation.append("'hasTransitiveRelationTo', '");

            insertTransRelation.append(currentSub).append("', '");

            insertTransRelation.append(currentSubDoctype).append("')");

            pstmt = conn.prepareStatement(insertTransRelation.toString());

            pstmt.execute();

          }

          hasmorerelations = relations.next();

        }

        //get the current relations information

        metacatURL subMurl = new metacatURL(subject);

        metacatURL objMurl = new metacatURL(object);

        String subDoctype = null;

        String objDoctype = null;

        if(subMurl.getURLType().equals("metacat"))

        {

          DocumentImpl subDoc = new DocumentImpl(conn, subMurl.getParam(0)[1]);

          subDoctype = subDoc.getDoctype();

        }

        if(objMurl.getURLType().equals("metacat"))

        {

          DocumentImpl objDoc = new DocumentImpl(conn, objMurl.getParam(0)[1]);

          objDoc.getDoctype();

        }

        //now that the comparisons are done, the new relation can be put

        //into xml_relation

        StringBuffer insertStmt = new StringBuffer();

        insertStmt.append("insert into xml_relation (subject, subdoctype, ");

        insertStmt.append("relationship, object, objdoctype) values ('");

        insertStmt.append(subject).append("', '");

        insertStmt.append(subDoctype).append("', '");

        insertStmt.append(relationship).append("', '");

        insertStmt.append(object).append("', '");

        insertStmt.append(objDoctype).append("')");

        pstmt = conn.prepareStatement(insertStmt.toString());

        pstmt.execute(); 

        hasmorerows = rs.next();

      }

      conn.commit();

      btThread = null;

    } catch(Exception e) { 

      try { 

        conn.rollback();

      } catch (SQLException sqle) {}

      System.out.println("Error in relationHandler: " + e.getMessage());

      util.debugMessage("Error in relationHandler: " + e.getMessage());

      e.printStackTrace(System.out);

      btThread = null;

    }

  }

}