Metacat

import org.xml.sax.*;

public class MetacatReplication extends HttpServlet implements Runnable

  private String deltaT;

  Timer replicationDaemon;

  private static MetaCatUtil util = new MetaCatUtil();

  private Vector fileLocks = new Vector();

  private Thread lockThread = null;

  private static final AbstractDatabase dbAdapter = MetaCatUtil.dbAdapter;

  /**

   * Initialize the servlet by creating appropriate database connections

   */

  {

     //initialize db connections to handle any update requests

    MetaCatUtil util = new MetaCatUtil();

          public java.net.URLStreamHandler createURLStreamHandler(

                        final String protocol)

          {

              {

                 {

                    URLStreamHandler urlsh = new HTTPClient.http.Handler();

                    MetaCatUtil.debugMessage("Using HttpClient Protocol Handler for http", 45);

                    return urlsh;

                  {

                     MetaCatUtil.debugMessage(

                          "Error setting URL StreamHandler!", 30);

                     return null;

                  }

               }//if

               {

                 {

                   URLStreamHandler urlsh = new HTTPClient.https.Handler();

                   MetaCatUtil.debugMessage("Using HttpClient Protocol Handler for https", 45);

                   return urlsh;

                 {

                   MetaCatUtil.debugMessage(

                              "Error setting URL StreamHandler!", 30);

              return null;

         }//createURLStreamHandler

     });*/

  }

  {

    replicationDaemon.cancel();

   // System.out.println("Replication daemon cancelled.");

  }

  public void doGet (HttpServletRequest request, HttpServletResponse response)

  {

    // Process the data and send back the response

    handleGetOrPost(request, response);

  }

  public void doPost(HttpServletRequest request, HttpServletResponse response)

  {

    // Process the data and send back the response

    handleGetOrPost(request, response);

  }

  {

    //PrintWriter out = response.getWriter();

    //ServletOutputStream outPut = response.getOutputStream();

    Hashtable params = new Hashtable();

    Enumeration paramlist = request.getParameterNames();

// NOT NEEDED - doesn't provide enough security because of possible IP spoofing

// REPLACED with running replication comminications over HTTPS

//    String requestingServerIP = request.getRemoteAddr();

//    InetAddress iaddr = InetAddress.getByName(requestingServerIP);

//    String requestingServer = iaddr.getHostName();

    while (paramlist.hasMoreElements()) {

      String name = (String)paramlist.nextElement();

      String[] value = request.getParameterValues(name);

    }

    String action = ((String[])params.get("action"))[0];

    String server = null;

    try {

      // check if the server is included in the list of replicated servers

           !action.equals("stop") &&

           !action.equals("start") &&

           !action.equals("getall") ) {

        server = ((String[])params.get("server"))[0];

        if ( getServerCodeForServerName(server) == 0 ) {

                             "\" rejected for server: " + server);

          return;

        } else {

                             "\" accepted for server: " + server);

        }

      }

                         e.getMessage() );

      return;

    }

    {

      OutputStream out=response.getOutputStream();

      //to get the data file.

      handleGetDataFileRequest(out, params, response);

      out.close();

    }

    {

      //read a specific docid from remote host, and store it into local host

      handleForceReplicateDataFileRequest(params);

    }

    else

    {

      replicationDaemon = new Timer(true);

      out.println("Replication Handler Stopped");

      MetacatReplication.replLog("deltaT handler stopped");

    } else if ( action.equals("start") ) {

      //start the replication server

      int rate;

      if ( params.containsKey("rate") ) {

      out.println("New rate is: " + rate + " seconds.");

      replicationDaemon.cancel();

      replicationDaemon = new Timer(true);

                                            rate * 1000);

      out.println("Replication Handler Started");

                                    rate + " seconds");

    } else if ( action.equals("getall") ) {

      //updates this server exactly once

      replicationDaemon.schedule(new ReplicationHandler(out), 0);

    } else if ( action.equals("forcereplicate") ) {

      //read a specific docid from remote host, and store it into local host

      handleForceReplicateRequest(out, params, response);

    } else if ( action.equals("update") ) {

      //request an update list from the server

      handleUpdateRequest(out, params, response);

      response.setContentType("text/html");

      out.println("<html><body>Test successfully</body></html>");

    }

    out.close();

    }//else

  }

   * This method can add, delete and list the servers currently included in

   * xml_replication.

   * action           subaction            other needed params

   * ---------------------------------------------------------

   * servercontrol    add                  server

   * servercontrol    delete               server

   */

  private void handleServerControlRequest(PrintWriter out, Hashtable params,

                                          HttpServletResponse response)

      dbConn=DBConnectionPool.

               getDBConnection("MetacatReplication.handleServerControlRequest");

      serialNumber=dbConn.getCheckOutSerialNumber();

      // add server to server list

      if ( subaction.equals("add") ) {

        replicate = ((String[])params.get("replicate"))[0];

        server = ((String[])params.get("server"))[0];

        //Get data replication value

        dataReplicate = ((String[])params.get("datareplicate"))[0];

        //Get hub value

        hub = ((String[])params.get("hub"))[0];

        /*pstmt = dbConn.prepareStatement("INSERT INTO xml_replication " +

                  "(server, last_checked, replicate, datareplicate, hub) " +

                                      "VALUES ('" + server + "', to_date(" +

                                      + hub +"')");*/

        pstmt = dbConn.prepareStatement("INSERT INTO xml_replication " +

                  "(server, last_checked, replicate, datareplicate, hub) " +

                                      + ", '" +

                                      replicate +"', '" +dataReplicate+"', '"

                                      + hub +"')");

        pstmt.execute();

        pstmt.close();

        dbConn.commit();

        response.setContentType("text/html");

        out.println("<html><body><table border=\"1\">");

        out.println("<tr><td><b>server</b></td><td><b>last_checked</b></td><td>");

        pstmt = dbConn.prepareStatement("SELECT * FROM xml_replication");

        //increase dbconnection usage

        dbConn.increaseUsageCount(1);

        pstmt.execute();

        ResultSet rs = pstmt.getResultSet();

        boolean tablehasrows = rs.next();

          out.println(rs.getString(4) + "</td><td>");

          out.println(rs.getString(5) + "</td><td>");

          out.println(rs.getString(6) + "</td></tr>");

          tablehasrows = rs.next();

        }

        out.println("</table></body></html>");

        // download certificate with the public key on this server

        // and import it as a trusted certificate

        String certURL = ((String[])params.get("certificate"))[0];

        downloadCertificate(certURL);

      // delete server from server list

      } else if ( subaction.equals("delete") ) {

        server = ((String[])params.get("server"))[0];

        out.println("<b>replicate</b></td>");

        out.println("<td><b>datareplicate</b></td>");

        out.println("<td><b>hub</b></td></tr>");

        pstmt = dbConn.prepareStatement("SELECT * FROM xml_replication");

        //increase dbconnection usage

        dbConn.increaseUsageCount(1);

          tablehasrows = rs.next();

        }

        out.println("</table></body></html>");

      else

      {

        out.println("<error>Unkonwn subaction</error>");

      }

      pstmt.close();

      //conn.close();

    } catch(Exception e) {

                         e.getMessage());

      e.printStackTrace(System.out);

    }

      }//try

      catch (SQLException ee)

      {

                "MetacatReplication.handleServerControlRequest to close pstmt "

                 + ee.getMessage(), 30);

      }//catch

        DBConnectionPool.returnDBConnection(dbConn, serialNumber);

      }//finally

    }//finally

  }

  private void downloadCertificate (String certURL)

                throws FileNotFoundException, IOException, MalformedURLException

  {

    MetaCatUtil util = new MetaCatUtil();

    String certPath = util.getOption("certPath"); //the path to be uploaded to

    // get filename from the URL of the certificate

    String filename = certURL;

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

    if ( slash > -1 ) {

      filename = filename.substring(slash + 1);

    }

    // open file output strem to write the input into it

    File f = new File(certPath, filename);

      try {

        if ( f.exists() ) {

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

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

        throw se;

      }

      // create a buffered byte output stream

      // that uses a default-sized output buffer

      FileOutputStream fos = new FileOutputStream(f);

      }

      // the input and the output streams must be closed

      bis.close();

    } // end of synchronized(f)

  }

  /**

   * when a forcereplication request comes in, local host sends a read request

   * to the requesting server (remote server) for the specified docid.

    int serverCode = 1;

    DBConnection dbConn = null;

    int serialNumber = -1;

    try {

      //if the url contains a dbaction then the default action is overridden

      if(params.containsKey("dbaction")) {

                +util.getLocalReplicationServerName()

                +"&action=read&docid=" + docid);

      String xmldoc = MetacatReplication.getURLContent(u);

      // get the document info from server

                               "?server="+util.getLocalReplicationServerName()

                               +"&action=getdocumentinfo&docid=" + docid);

      String docInfoStr = MetacatReplication.getURLContent(docinfourl);

      //dih is the parser for the docinfo xml format

      DocInfoHandler dih = new DocInfoHandler();

      XMLReader docinfoParser = ReplicationHandler.initParser(dih);

      docinfoParser.parse(new InputSource(new StringReader(docInfoStr)));

      Hashtable docinfoHash = dih.getDocInfo();

      // Get user owner of this docid

      String user = (String)docinfoHash.get("user_owner");

      // Get home server of this docid

      MetaCatUtil.debugMessage("docType: "+docType, 34);

      String parserBase = null;

      // this for eml2 and we need user eml2 parser

          (docType.trim()).equals(DocumentImpl.EML2_0_0NAMESPACE))

      {

         parserBase = DocumentImpl.EML200;

      }

      MetaCatUtil.debugMessage("The parserBase is: "+parserBase, 30);

      // Get DBConnection from pool

      dbConn=DBConnectionPool.

              getDBConnection("MetacatReplication.handleForceReplicateRequest");

      serialNumber=dbConn.getCheckOutSerialNumber();

      // write the document to local database

      DocumentImplWrapper wrapper = new DocumentImplWrapper(parserBase, false);

                               dbaction, docid, user, null, homeServer, server);

      MetacatReplication.replLog("document " + docid + " added to DB with " +

                                 "action " + dbaction);

    }//try

    {

                                      " failed to added to DB with " +

                                      "action " + dbaction + " because "+

                                       e.getMessage());

      MetaCatUtil.debugMessage("ERROR in MetacatReplication.handleForceReplicate" +

                         "Request(): " + e.getMessage(), 30);

    }//catch

    finally

    {

      DBConnectionPool.returnDBConnection(dbConn, serialNumber);

    }//finally

  }

  /**

   * docid. Then store it in local database and file system

   */

  private void handleForceReplicateDataFileRequest(Hashtable params)

  {

    //make sure there is some parameters

    if(params.isEmpty())

    {

      return;

    }

    // the docid should include rev number

    // Make sure there is a docid and server

    if (docid==null || server==null || server.equals(""))

    {

                              , 20);

      return;

    }

    // Overide or not

    boolean override = false;

    // dbaction - update or insert

    String dbaction=null;

    {

      //docid was switch to two parts uinque code and rev

      String uniqueCode=MetaCatUtil.getDocIdFromString(docid);

      int rev=MetaCatUtil.getVersionFromString(docid);

      {

        dbaction = ((String[])params.get("dbaction"))[0];

      }

      {

        dbaction = "update";

      }

      MetaCatUtil.debugMessage("Force replication request from: "+ server, 34);

      MetaCatUtil.debugMessage("Force replication docid: "+docid, 34);

      MetaCatUtil.debugMessage("Force replication action: "+dbaction, 34);

      // get the document info from server

                               "?server="+util.getLocalReplicationServerName()

                               +"&action=getdocumentinfo&docid=" + uniqueCode);

      String docInfoStr = MetacatReplication.getURLContent(docinfourl);

      //dih is the parser for the docinfo xml format

      docinfoParser.parse(new InputSource(new StringReader(docInfoStr)));

      Hashtable docinfoHash = dih.getDocInfo();

      String user = (String)docinfoHash.get("user_owner");

      String docName = (String)docinfoHash.get("docname");

      String docType = (String)docinfoHash.get("doctype");

      String docHomeServer= (String)docinfoHash.get("home_server");

      MetaCatUtil.debugMessage("docHomeServer of datafile: "+docHomeServer, 34);

      //if action is delete, we don't delete the data file. Just archieve

      //the xml_documents

      if (dbaction.equals("delete"))

        String datafilePath = util.getOption("datafilepath");

        //register data file into xml_documents table and wite data file

        //into file system

                            docName, docType, docid, user,docHomeServer,server);

     }

    MetacatReplication.replLog("datafile " + docid + " added to DB with " +

                                 "action " + dbaction);

    {

                                      " failed to added to DB with " +

                                      "action " + dbaction + " because "+

                                       e.getMessage());

   * The servlet parameters of interrest are:

   * docid: the docid of the file the lock is being requested for

   * currentdate: the timestamp of the document on the remote server

   */

  private void handleGetLockRequest(PrintWriter out, Hashtable params,

                                    HttpServletResponse response)

    try

    {

      String docid = ((String[])params.get("docid"))[0];

      String remoteRev = ((String[])params.get("updaterev"))[0];

      DocumentImpl requestDoc = new DocumentImpl(docid);

      MetacatReplication.replLog("lock request for " + docid);

      int localRevInt = requestDoc.getRev();

      int remoteRevInt = Integer.parseInt(remoteRev);

      if(remoteRevInt >= localRevInt)

      {

        if(!fileLocks.contains(docid))

        else

        { //deny the lock

          out.println("<filelocked><docid>" + docid + "</docid></filelocked>");

                                     "reason: file already locked");

        }

      }

      else

      {//deny the lock.

        out.println("<outdatedfile><docid>" + docid + "</docid></filelocked>");

                                   "reason: client has outdated file");

      }

      //conn.close();

      e.printStackTrace(System.out);

    }

  }

  /**

   * Sends all of the xml_documents information encoded in xml to a requestor

   * the format is:

   *                  user_updated, home_server, public_access, rev)/>

   * all of the subelements of document info are #PCDATA

   */

                                        HttpServletResponse response)

  {

    String docid = ((String[])(params.get("docid")))[0];

    StringBuffer sb = new StringBuffer();

    try

    {

      DocumentImpl doc = new DocumentImpl(docid);

      sb.append("<documentinfo><docid>").append(docid);

      sb.append("</docid><docname>").append(doc.getDocname());

      sb.append("</rev></documentinfo>");

      response.setContentType("text/xml");

      out.println(sb.toString());

    }

    catch (Exception e)

    {

      System.out.println("error in " +

                          e.getMessage());

    }

  }

  /**

   * Sends a datafile to a remote host

   */

                            Hashtable params, HttpServletResponse response)

  {

    String filepath = util.getOption("datafilepath");

    // Request docid

    String docId = ((String[])(params.get("docid")))[0];

      util.debugMessage("Didn't specify docid for replication", 20);

      return;

    }

    //try to open a https stream to test if the request server's public key

    //in the key store, this is security issue

    try

    {

      return;

    }//catch

    {

          filepath += "/";

    }

    // Get file aboslute file name

    //MIME type

    String contentType = null;

    {

        contentType="text/xml";

    {

        contentType="text/css";

    {

        contentType="text/plain";

    {

        contentType="text/xml";

    {

        contentType="text/html";

    {

        File f = new File(filename);

        {

           contentType="text/html";

        else

        {

           contentType="application/octet-stream";

        }

     }

   // Set the mime type

   response.setContentType(contentType);

   // Get the content of the file

   FileInputStream fin = null;

   {

      // FileInputStream to metacat

      fin = new FileInputStream(filename);

      // Read data from file input stream to byte array

      int b = fin.read(buf);

      // Write to outStream from byte array

      {

        outPut.write(buf, 0, b);

        b = fin.read(buf);

      }

      // close file input stream

      fin.close();

   }//try

   catch(Exception e)

   {

                         "handlGetDataFileRequest " + e.getMessage());

      e.printStackTrace(System.out);

   }//catch

}

  /**

   * Sends a document to a remote host

   */

                                        HttpServletResponse response)

  {

    try

    {

      //try to open a https stream to test if the request server's public key

        out.close();

        return;

      }

      String docid = ((String[])(params.get("docid")))[0];

      DocumentImpl di = new DocumentImpl(docid);

      response.setContentType("text/xml");

      out.print(di.toString(null, null, true));

      MetacatReplication.replLog("document " + docid + " sent");

    }

    catch(Exception e)

    {

      response.setContentType("text/xml");

      out.println("<error>"+e.getMessage()+"</error>");

    }

  }

  /**

   * Sends a list of all of the documents on this sever along with their

   * The format is:

   * <!ELEMENT replication (server, updates)>

   * <!ELEMENT server (#PCDATA)>

   * note that the rev in deletedDocument is always empty.  I just left

   * it in there to make the parser implementation easier.

   */

                                    HttpServletResponse response)

  {

    DBConnection dbConn = null;

    // DBConenction serial number when checked it out

    int serialNumber = -1;

    PreparedStatement pstmt = null;

    // Server list to store server info of xml_replication table

    ReplicationServerList serverList = null;

    try

    {

      // Check out a DBConnection from pool

      serialNumber=dbConn.getCheckOutSerialNumber();

      // Create a server list from xml_replication table

      serverList = new ReplicationServerList();

      // Get remote server name from param

      String server = ((String[])params.get("server"))[0];

      // If no servr name in param, return a error

        out.close();

        return;

      }//if

      //try to open a https stream to test if the request server's public key

      //in the key store, this is security issue

      URL u = new URL("https://" + server + "?server="

        out.close();

        return;

      }

      // Check if local host configure to replicate xml documents to remote

      // server. If not send back a error message

      if (!serverList.getReplicationValue(server))

        out.close();

        return;

      }//if

      // Store the sql command

      StringBuffer docsql = new StringBuffer();

      // Stroe the docid list

      StringBuffer delsql = new StringBuffer();

      // Store the data set file

      Vector packageFiles = new Vector();

      // Append local server's name and replication servlet to doclist

      doclist.append("<?xml version=\"1.0\"?><replication>");

      doclist.append("<server>").append(util.getOption("server"));

      doclist.append(util.getOption("replicationpath"));

      doclist.append("</server><updates>");

      // Get correct docid that reside on this server according the requesting

      // server's replicate and data replicate value in xml_replication table

      docsql.append("select docid, rev, doctype from xml_documents ");

        docsql.append("where server_location = 1");

      }

      MetaCatUtil.debugMessage("Doc sql: "+docsql.toString(), 30);

      // Get any deleted documents

      delsql.append("select distinct docid from ");

      delsql.append("xml_revisions where docid not in (select docid from ");

        delsql.append("and server_location = 1");

      }

      MetaCatUtil.debugMessage("Deleted sql: "+delsql.toString(), 30);

      // Get docid list of local host

      pstmt = dbConn.prepareStatement(docsql.toString());

      pstmt.execute();

          //because if a package file is read before all of the files it

          //refers to are loaded then there is an error

          if(recordDoctype != null && !packagedoctypes.contains(recordDoctype))

              //If this is not data file

              if (!recordDoctype.equals("BIN"))

              {

                doclist.append(MetaCatUtil.getOption("datafileflag"));

                doclist.append("</datafile>");

                doclist.append("</updatedDocument>");

          }//if packagedoctpes

          else

          { //the package files are saved to be put into the xml later.

        while(tablehasrows)

        {

          String recordDoctype = rs.getString(3);

          { //don't replicate data files

            Vector packagedoctypes = MetaCatUtil.getOptionList(

                                     MetaCatUtil.getOption("packagedoctype"));

         tablehasrows = rs.next();

        }//while

      }//else

      pstmt = dbConn.prepareStatement(delsql.toString());

      //usage count should increas 1

      dbConn.increaseUsageCount(1);

      pstmt.execute();

      rs = pstmt.getResultSet();

      tablehasrows = rs.next();

        //note that rev is always empty for deleted docs

        tablehasrows = rs.next();

      }

      //now we can put the package files into the xml results

      for(int i=0; i<packageFiles.size(); i++)

      {

        doclist.append("</rev>");

        doclist.append("</updatedDocument>");

      }

      doclist.append("</updates></replication>");

      MetaCatUtil.debugMessage("doclist: " + doclist.toString(), 40);

      pstmt.close();

      //conn.close();

      response.setContentType("text/xml");

      out.println(doclist.toString());

    }

    catch(Exception e)

    {

        DBConnectionPool.returnDBConnection(dbConn, serialNumber);

      }//finally

    }//finally

  }//handlUpdateRequest

  /**

   * Returns the xml_catalog table encoded in xml

   */

  {

    return handleGetCatalogRequest(null, null, null, false);

  }

  /**

   * Sends the contents of the xml_catalog table encoded in xml

   * The xml format is:

   * <!ELEMENT row (entry_type, source_doctype, target_doctype, public_id,

   *                system_id)>

   * All of the sub elements of row are #PCDATA

   * If printFlag == false then do not print to out.

   */

                                                Hashtable params,

                                                HttpServletResponse response,

                                                boolean printFlag)

    int serialNumber = -1;

    PreparedStatement pstmt = null;

    try

      /*conn = MetacatReplication.getDBConnection("MetacatReplication." +

                                                "handleGetCatalogRequest");*/

      dbConn=DBConnectionPool.

        sb.append("</target_doctype><public_id>").append(rs.getString(4));

        sb.append("</public_id><system_id>").append(rs.getString(5));

        sb.append("</system_id></row>");

        tablehasrows = rs.next();

      }

      sb.append("</xml_catalog>");

    }

    catch(Exception e)

    {

                          e.getMessage());

      e.printStackTrace(System.out);

      if(printFlag)

        DBConnectionPool.returnDBConnection(dbConn, serialNumber);

      }//finally

    }//finally

    return null;

  }

  /**

   * Sends the current system date to the remote server.  Using this action

   * because a time specific to a document is always kept on its home server.

   */

                                    HttpServletResponse response)

  {

    SimpleDateFormat formatter = new SimpleDateFormat ("MM/dd/yy HH:mm:ss");

    java.util.Date localtime = new java.util.Date();

    String dateString = formatter.format(localtime);

    response.setContentType("text/xml");

    out.println("<timestamp>" + dateString + "</timestamp>");

  }

  /**

   * granted it is granted for 30 seconds.  When this thread runs out

   * it deletes the docid from the queue, thus eliminating the lock.

   */

  {

    try

    {

                               (String)fileLocks.elementAt(0), 45);

      Thread.sleep(30000); //the lock will expire in 30 seconds

                              " exiting.", 45);

      fileLocks.remove(fileLocks.size() - 1);

      //fileLocks is treated as a FIFO queue.  If there are more than one lock

      //in the vector, the first one inserted will be removed.

    }

    catch(Exception e)

    {

                                "MetacatReplication.run: " + e.getMessage(), 30);

    }

  }

  /**

   * Returns the name of a server given a serverCode

   * @param serverCode the serverid of the server

                  getDBConnection("MetacatReplication.getServer");

      serialNumber=dbConn.getCheckOutSerialNumber();

      String sql = new String("select server from " +

                              serverCode);

      pstmt = dbConn.prepareStatement(sql);

      //System.out.println("getserver sql: " + sql);

        //System.out.println("server: " + rs.getString(1));

        return rs.getString(1);

      }

      //conn.close();

    }

    catch(Exception e)

    {

                          e.getMessage());

    }

    finally

        DBConnectionPool.returnDBConnection(dbConn, serialNumber);

      }//fianlly

    }//finally

    return null;

      //return null if the server does not exist

  }

  /**

   * Returns a server code given a server name

   * @param server the name of the server

      pstmt.execute();

      ResultSet rs = pstmt.getResultSet();

      boolean tablehasrows = rs.next();

        serverCode = rs.getInt(1);

        pstmt.close();

        //conn.close();

        return serverCode;

      }

    } catch(Exception e) {

      throw e;

    } finally {

      {

        pstmt.close();

        //conn.close();

       }//try

       {

         MetaCatUtil.debugMessage("Error in MetacatReplicatio.getServerCode: "

                                  +ee.getMessage(), 30);

       }//catch

       finally

       {

         DBConnectionPool.returnDBConnection(dbConn, serialNumber);

       }//finally

    }//finally

    return serverCode;

  }

  /**

   * Method to get a host server information for given docid

   * @param conn a connection to the database

      boolean tableHasRows = rs.next();

      if (tableHasRows)

      {

          String server = rs.getString(1);

          String last_checked = rs.getString(2);

          if(!server.equals("localhost"))

          {

            sl.put(server, last_checked);

          }

      }

      else

      {

      {

        DBConnectionPool.returnDBConnection(dbConn, serialNumber);

      }

    }//finally

    return sl;

  }

  /**

   * Returns a home server location  given a accnum

   * @param accNum , given accNum for a document

   */

  public static int getHomeServerCodeForDocId(String accNum) throws Exception

  {

    //MetaCatUtil ut = new MetaCatUtil();

    String docId=MetaCatUtil.getDocIdFromString(accNum);

    {

      // Get DBConnection

      dbConn=DBConnectionPool.

                  getDBConnection("ReplicationHandler.getServerLocation");

      serialNumber=dbConn.getCheckOutSerialNumber();

                              + "WHERE docid LIKE '" + docId + "'");

      pstmt.execute();

      ResultSet rs = pstmt.getResultSet();

      boolean tablehasrows = rs.next();

      //If a document is find, return the server location for it

        serverCode = rs.getInt(1);

        pstmt.close();

        //conn.close();

        //conn.close();

        return serverCode;

      }

    {

      throw e;

    {

      {

        pstmt.close();

        //conn.close();

      {

        MetaCatUtil.debugMessage("Erorr in Replication.getServerLocation "+

                     "to close pstmt"+ee.getMessage(), 30);

    }//finally

   //return serverCode;

  }

  /**

   * This method returns the content of a url

   * @param u the url to return the content from

    }

    istream.close();

    input.close();

    return serverResponse.toString();

  }

  /**

   * metacat.properties

   */

  public static void replLog(String message)

      //e.printStackTrace(System.out);

    }

  }

  /**

   * metacat.properties

   */

  public static void replErrorLog(String message)

      //e.printStackTrace(System.out);

    }

  }

  /**

   * Returns true if the replicate field for server in xml_replication is 1.

   * Returns false otherwise

      dbConn=DBConnectionPool.

                  getDBConnection("MetacatReplication.repltoServer");

      serialNumber=dbConn.getCheckOutSerialNumber();

                                    "xml_replication where server like '" +

                                     server + "'");

      pstmt.execute();

    }

    catch(Exception e)

    {

                         e.getMessage());

    }

    finally

    return false;

    //the default if this server does not exist is to not replicate to it.

  }

}

 * 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 edu.ucsb.nceas.dbadapter.AbstractDatabase;

import java.sql.*;

import java.util.*;

import java.io.*;

import java.net.*;

import java.text.*;

{

  int serverCheckCode = 1;

  MetaCatUtil util = new MetaCatUtil();

  PrintWriter out;

  private static final AbstractDatabase dbAdapter = MetaCatUtil.dbAdapter;