Metacat

   public static final String SCHEMA                 = "Schema";

   public static final String DTD                    = "DTD";

   public static final String EML2                   = "eml2";

              "http://apache.org/xml/properties/schema/external-schemaLocation";

     "eml://ecoinformatics.org/eml-2.0.0 http://dev.nceas.ucsb.edu/tao/schema/eml.xsd"+

      " http://www.xml-cml.org/schema/stmml http://dev.nceas.ucsb.edu/tao/schema/stmml.xsd";*/

   public static final String DECLARATIONHANDLERPROPERTY =

                            "http://xml.org/sax/properties/declaration-handler";

   public static final String LEXICALPROPERTY =

                             "http://xml.org/sax/properties/lexical-handler";

                             "http://xml.org/sax/features/validation";

                             "http://apache.org/xml/features/validation/schema";

                              "http://xml.org/sax/features/namespaces";

                              "http://xml.org/sax/features/namespace-prefixes";

   public static final String EMLNAMESPACE =

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

  public static final String DOCNAME = "docname";

  public static final String PUBLICID = "publicid";

  public static final String SYSTEMID = "systemid";

  private int rev;

  private int serverlocation;

  private String docHomeServer;

  private long rootnodeid;

  private ElementNode rootNode = null;

  private TreeSet nodeRecordList = null;

  //ReplicationServerList serverList = new ReplicationServerList();

  /**

   * Constructor used to create a document and read the document information

   *

   * @param conn the database connection from which to read the document

   * @param docid the identifier of the document to be created

   * @param readNodes flag indicating whether the xmlnodes should be read

   */

  {

    try {

      //this.conn = conn;

      this.docid = docid;

      // Look up the document information

      getDocumentInfo(docid);

      if (readNodes) {

        // Download all of the document nodes using a single SQL query

        // The sort order of the records is determined by the NodeComparator

        // class, and needs to represent a depth-first traversal for the

        // toXml() method to work properly

        nodeRecordList = getNodeRecordList(rootnodeid);

      }

    } catch (McdbException ex) {

      throw ex;

    } catch (Throwable t) {

  }

  /**

   * for reading the document

   *

   * @param conn the database connection from which to read the document

   * @param docid the identifier of the document to be created

   */

  {

    this(docid, true);

  }

   * Construct a new document instance, writing the contents to the database.

   * This method is called from DBSAXHandler because we need to know the

   * root element name for documents without a DOCTYPE before creating it.

   *

   * specify the revision user want to upadate. The revion is only need to be

   * greater than current one. It is not need to be sequent number just after

   * current one. So it is only used in update action

   * @param conn the JDBC Connection to which all information is written

   * @param rootnodeid - sequence id of the root node in the document

   *        the DOCTYPE keyword ( should be the root element name ) or

   *        the root element name if no DOCTYPE declaration provided

   *        root element name)

   *                  following the PUBLIC keyword in DOCTYPE declaration or

   *                  the docname if no Public ID provided or

   *                  null if no DOCTYPE declaration provided

   *        resides.

   *

   */

                      String action, String user,

                      String pub, String catalogId, int serverCode)

                      throws SQLException, Exception

    this.updatedVersion = newRevision;

    writeDocumentToDB(action, user, pub, catalogId, serverCode);

  }

  /**

   * This method will be call in handleUploadRequest in MetacatServlet class

   */

                     String docname, String doctype, String accnum, String user)

                     throws SQLException, AccessionNumberException, Exception

  {

    try

    {

       // get server location for this doc

    {

      throw e;

    }

  }

  /**

   * Register a document that resides on the filesystem with the database.

   * Creates a reference to a filesystem document (used for non-xml data files).

   * This class only be called in MetaCatServerlet.

   * @param conn the JDBC Connection to which all information is written

   *        the DOCTYPE keyword ( should be the root element name ) or

   *        the root element name if no DOCTYPE declaration provided

   *        root element name)

   *                  following the PUBLIC keyword in DOCTYPE declaration or

   *                  the docname if no Public ID provided or

   *                  null if no DOCTYPE declaration provided

   *               (e.g., knb.1.1)

   * @param user the user that owns the document

   * @param serverCode the serverid from xml_replication on which this document

   *        resides.

   */

  public static void registerDocument(

                     String user, int serverCode)

                     throws SQLException, AccessionNumberException, Exception

  {

      // it is a updated data file

      else if (userSpecifyRev>revInDataBase && revInDataBase>0)

      {

        archiveDocRevision(docIdWithoutRev, user);

        //delete the old entry in xml_documents

        //deleteXMLDocuments(docIdWithoutRev);

      //other situation

      else

      {

        throw new Exception("Revision number couldn't be "

                    +userSpecifyRev);

      }

      String dateString = formatter.format(localtime);

      String sqlDateString=dbAdapter.toDate(dateString, "MM/DD/YY HH24:MI:SS");*/

      String  sqlDateString = dbAdapter.getDateTimeFunction();

      StringBuffer sql = new StringBuffer();

      if (action != null && action.equals("insert"))

      {

      pstmt.execute();

      pstmt.close();

      //dbconn.close();

    {

      try

      {

      {

        DBConnectionPool.returnDBConnection(dbconn, serialNumber);

      }

  }

    /**

   * Register a document that resides on the filesystem with the database.

   * (ie, just an entry in xml_documents, nothing in xml_nodes).

   * Creates a reference to a filesystem document (used for non-xml data files)

   * Replication.

   * This method is revised from registerDocument.

   *

   * @param conn the JDBC Connection to which all information is written

   *        the DOCTYPE keyword ( should be the root element name ) or

   *        the root element name if no DOCTYPE declaration provided

   *        root element name)

   *                  following the PUBLIC keyword in DOCTYPE declaration or

   *                  the docname if no Public ID provided or

   *                  null if no DOCTYPE declaration provided

   *               (e.g., knb.1.1)

   * @param user the user that owns the document

   * @param serverCode the serverid from xml_replication on which this document

   *        resides.

   */

  public static void registerDocumentInReplication(

                     String user, int serverCode)

                     throws SQLException, AccessionNumberException, Exception

  {

      //user specified rev should be great than 0

      if (revInDataBase==-1 && userSpecifyRev>=0 )

      {

        ac = new AccessionNumber(accnum, "insert");

        action = "insert";

      }

      // it is a updated data file

      else if (userSpecifyRev>revInDataBase && revInDataBase>=0)

      {

        archiveDocRevision(docIdWithoutRev, user);

        //delete the old entry in xml_documents

        //deleteXMLDocuments(docIdWithoutRev);

      //other situation

      else

      {

        throw new Exception("Revision number couldn't be "

                    +userSpecifyRev);

      }

      String dateString = formatter.format(localtime);

      String sqlDateString=dbAdapter.toDate(dateString, "MM/DD/YY HH24:MI:SS");*/

      String sqlDateString = dbAdapter.getDateTimeFunction();

      StringBuffer sql = new StringBuffer();

      if (action != null && action.equals("insert"))

      {

      // Set auto commit fasle

      dbconn.setAutoCommit(false);

      pstmt = dbconn.prepareStatement(sql.toString());

      pstmt.execute();

      // Commit the insert

      dbconn.commit();

      pstmt.close();

      //dbconn.close();

    {

      // Set DBConnection auto commit true

      dbconn.setAutoCommit(true);

      pstmt.close();

      DBConnectionPool.returnDBConnection(dbconn, serialNumber);

  }

 /**

   * This method will register a data file entry in xml_documents and save a

   * data file input Stream into file system.. It is only used in replication

   * @param  , the input stream which contain the file content

   * @param docname - the name of DTD, for data file, it is a docid number.

   * @param doctype - "BIN" for data file

   *               (e.g., knb.1.1)

   * @param user the user that owns the document

   * @param docHomeServer, the home server of the docid

   *                            local metacat

   */

                   String user, String docHomeServer, String notificationServer)

                     throws SQLException, AccessionNumberException, Exception

 {

    int serverCode=-2;

    if (filePath==null||filePath.equals(""))

    {

            Exception("Please specify the directory where file will be store");

    }

    if (accnum==null||accnum.equals(""))

    {

      throw new Exception("Please specify the stored file name");

    }

    // xml_replication table

    //serverList.addToServerListIfItIsNot(docHomeServer);

    insertServerIntoReplicationTable(docHomeServer);

    // Get server code again

    serverCode = getServerCode(docHomeServer);

    //register data file into xml_documents table

    registerDocumentInReplication(docname, doctype, accnum, user, serverCode);

    //write inputstream into file system.

    File dataDirectory = new File(filePath);

    // create a buffered byte output stream

    // that uses a default-sized output buffer

    FileOutputStream fos = new FileOutputStream(newFile);

    bis = new BufferedInputStream(input);

    byte[] buf = new byte[4 * 1024]; // 4K buffer

    int b = bis.read(buf);

    {

        outPut.write(buf, 0, b);

        b = bis.read(buf);

    }

    bis.close();

    // Force replicate data file

    ForceReplicationHandler forceReplication = new ForceReplicationHandler

                                    (accnum, false, notificationServer);

 }

                                                  throws Exception

    try

    {

      int serverLocation=getServerLocationNumber(accnum);

      return getDataFileLockGrant(accnum,serverLocation);

    }

    catch (Exception e)

    {

      throw e;

    }

  }

  /**

   * The method will check if metacat can get data file lock grant

   * If server code is 1, it get.

   * If server code is not 1 but call replication getlock successfully,

   * it get

   * else, it didn't get

   * @param action, the action to the document

   * @param serverCode, the server location code

   */

  public static boolean getDataFileLockGrant(String accnum, int serverCode)

  {

    boolean flag=true;

    //MetaCatUtil util = new MetaCatUtil();

    String docid = MetaCatUtil.getDocIdFromString(accnum);

    int rev = MetaCatUtil.getVersionFromString(accnum);

    if (serverCode == 1)

    {

      flag=true;

      return flag;

    }

    //if((serverCode != 1 && action.equals("UPDATE")) )

    if (serverCode != 1)

    { //if this document being written is not a resident of this server then

      //resident server will not give a lock then we send the user a message

      //saying that he/she needs to download a new copy of the file and

      //merge the differences manually.

      String server=MetacatReplication.getServerNameForServerCode(serverCode);

      MetacatReplication.replLog("attempting to lock " + accnum);

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

           +rev + "&docid=" + docid);

      //System.out.println("sending message: " + u.toString());

      String serverResStr = MetacatReplication.getURLContent(u);

        //System.out.println("In lockgranted");

        MetacatReplication.replLog("lock granted for " + accnum + " from " +

                                      server);

        return flag;

      }//if

                            "merge your changes and try again.");

      }//else if

    }//if

   return flag;

  }//getDataFileLockGrant

  /**

   * get the document name

   */

  public long getRootNodeID() {

    return rootnodeid;

  }

  /**

   * get the creation date

   */

  public String getCreateDate() {

    return createdate;

  }

  /**

   * get the update date

   */

    return updatedate;

  }

   * Get the document identifier (docid)

   */

  public String getDocID() {

    return docid;

  }

// DOCTITLE attr cleared from the db

//  /**

//   *get the document title

//  public String getDocTitle() {

//    return doctitle;

//  }

  public String getUserowner() {

    return userowner;

  }

  public String getUserupdated() {

    return userupdated;

  }

  public int getServerlocation() {

    return serverlocation;

  }

  public String getDocHomeServer() {

    return docHomeServer;

  }

  public String getPublicaccess() {

    return publicaccess;

  }

  public int getRev() {

    return rev;

  }

  public String getValidateType()

  {

    return validateType;

  }

  /**

   * Print a string representation of the XML document

   */

  public String toString(String user, String[] groups, boolean withInlinedata)

  {

    StringWriter docwriter = new StringWriter();

    {

      this.toXml(docwriter, user, groups, withInlinedata);

    {

      return null;

    }

    String document = docwriter.toString();

    return document;

  }

   /**

   * Print a string representation of the XML document

   */

    String userName = null;

    String[] groupNames = null;

    boolean withInlineData = false;

    {

      this.toXml(docwriter, userName, groupNames, withInlineData);

    {

      return null;

    }

  /**

   * Get a text representation of the XML document as a string

   * This older algorithm uses a recursive tree of Objects to represent the

   * and searches all of the document data to find its children nodes and

   * recursively build.  Thus, because each node reads the whole document,

   * this algorithm is extremely slow for larger documents, and the time

    // Append the resulting document to the StringBuffer and return it

    doc.append("<?xml version=\"1.0\"?>\n");

    if (docname != null) {

      if ((doctype != null) && (system_id != null)) {

                   "\" \"" + system_id + "\">\n");

      } else {

        doc.append("<!DOCTYPE " + docname + ">\n");

      }

    }

    doc.append(rootNode.toString());

    return (doc.toString());

  }

   *

   * @param pw the Writer to which we print the document

   */

                                                          throws McdbException

  {

    // flag for process  eml2

    boolean proccessEml2 = false;

                              // id stored in db or not

    boolean firstElement = true;

    String dbDocName = null;

    String dbPublicID = null;

    String dbSystemID = null;

    if (doctype != null && doctype.equals(EMLNAMESPACE))

    {

      proccessEml2 = true;

    }

    // flag for process inline data

    boolean prcocessInlineData = false;

    TreeSet nodeRecordLists = null;

    PrintWriter out = null;

    if (pw instanceof PrintWriter) {

    }

    MetaCatUtil util = new MetaCatUtil();

    // Here add code to handle subtree access control

    PermissionController control = new PermissionController(docid);

                                             AccessControlInterface.READSTRING);

    if (!unaccessableSubTree.isEmpty())

    {

      nodeRecordLists = getPartNodeRecordList(rootnodeid, unaccessableSubTree);

    }

    {

      nodeRecordLists = getNodeRecordList(rootnodeid);

    }

    boolean previousNodeWasElement = false;

    // Step through all of the node records we were given

    Iterator it = nodeRecordLists.iterator();

    {

      NodeRecord currentNode = (NodeRecord)it.next();

      util.debugMessage("[Got Node ID: " + currentNode.nodeid +

                          " (" + currentNode.parentnodeid +

                          ", " + currentNode.nodedata + ")]", 50);

      // Print the end tag for the previous node if needed

      //

            if (previousNodeWasElement) {

              out.print(">");

              previousNodeWasElement = false;

            if ( currentElement.nodeprefix != null ) {

                        currentElement.nodename + ">" );

            } else {

              out.print("</" + currentElement.nodename + ">" );

      // Handle the DOCUMENT node

      if (currentNode.nodetype.equals("DOCUMENT")) {

        out.print("<?xml version=\"1.0\"?>");

      // Handle the ELEMENT nodes

      } else if (currentNode.nodetype.equals("ELEMENT")) {

        if (atRootElement) {

            out.print(">");

          }

        }

        // if publicid or system is not stored into db send it out by default

        if ( !storedDTD & firstElement )

        {

           {

              {

                       "\" \"" + system_id + "\">");

               {

                  out.print("<!DOCTYPE " + docname + ">");

               }

           }

        } else {

          out.print("<" + currentNode.nodename);

        }

        // if currentNode is inline and handle eml2, set flag proccess in

            currentNode.nodename.equals(EmlSAXHandler.INLINE) && proccessEml2)

        {

          prcocessInlineData = true;

        }

        else

        {

          // file system and output it

          // for inline data, the data base only store the file name, so we

          // can combine the file name and inline data file path, to get it

          String fileName = currentNode.nodedata;

                          EmlSAXHandler.readInlineDataFromFileSystem(fileName);

          char [] characterArray = new char [4*1024];

          try

            throw new McdbException(e.getMessage());

          }

        }

        // reset proccess inline data false

        prcocessInlineData =false;

        previousNodeWasElement = false;

        out.print("<?" + currentNode.nodename + " " +

                        currentNode.nodedata + "?>");

        previousNodeWasElement = false;

     } else if (currentNode.nodetype.equals(DTD)) {

         storedDTD = true;

         if (currentNode.getNodeName().equals(DOCNAME))

         {

           dbSystemID = currentNode.getNodeData();

           // send out <!doctype .../>

           {

              {

                       "\" \"" + dbSystemID + "\">");

              {

                out.print("<!DOCTYPE " + dbDocName + ">");

              }

           }

           //reset these variable

           dbDocName = null;

           dbPublicID = null;

           dbSystemID = null;

         }

      // Handle any other node type (do nothing)

      } else {

        // Any other types of nodes are not handled.

      }

      out.flush();

    }

    // Print the final end tag for the root element

    while(!openElements.empty())

    {

      NodeRecord currentElement = (NodeRecord)openElements.pop();

      util.debugMessage("\n POPPED: " + currentElement.nodename, 50);

      if ( currentElement.nodeprefix != null ) {

                  currentElement.nodename + ">" );

      } else {

        out.print("</" + currentElement.nodename + ">" );

    }

    out.flush();

  }

  private boolean isRevisionOnly(DocumentIdentifier docid) throws Exception

  {

    //System.out.println("inRevisionOnly");

      {

        return false;

      }

      if(tablehasrows)

      {

        int r = rs.getInt(1);

      }

      // Get miss docid and rev, throw to McdDocNotFoundException

      String missDocId = MetaCatUtil.getDocIdFromString(docid.toString());

                  MetaCatUtil.getRevisionStringFromString(docid.toString());

                docid.toString() + "' does not exist", missDocId, missRevision);

    }//try

    finally

    }//finally

  }

                                        AccessionNumberException, Exception

  {

    getDocumentInfo(new DocumentIdentifier(docid));

  }

  /**

   * Look up the document type information from the database

   *

    int serialNumber = -1;

    PreparedStatement pstmt = null;

    String table = "xml_documents";

    try

    {

      if(isRevisionOnly(docid))

    }

    catch(Exception e)

    {

                          e.getMessage(), 30);

      throw e;

    }

    {

      dbconn=DBConnectionPool.getDBConnection("DocumentImpl.getDocumentInfo");

      serialNumber=dbconn.getCheckOutSerialNumber();

        this.serverlocation = rs.getInt(8);

        this.publicaccess   = rs.getString(9);

        this.rev            = rs.getInt(10);

      pstmt.close();

      //get doc  home server name

      pstmt = dbconn.prepareStatement("select server " +

                        "from xml_replication where serverid = ?");

      //because connection use twise here, so we need to increase one

      tableHasRows = rs.next();

      if (tableHasRows)

      {

          String server = rs.getString(1);

          //get homeserver name

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

            this.docHomeServer=MetaCatUtil.getLocalReplicationServerName();

          }

          MetaCatUtil.debugMessage("server: "+docHomeServer, 50);

      }

      pstmt.close();

      if (this.doctype != null) {

        dbconn.increaseUsageCount(1);

        // Bind the values to the query

        pstmt.setString(1, doctype);

        pstmt.execute();

        rs = pstmt.getResultSet();

        tableHasRows = rs.next();

        if (tableHasRows) {

          this.system_id  = rs.getString(1);

          this.validateType = rs.getString(2);

        pstmt.close();

      }

    } catch (SQLException e) {

                          e.getMessage());

      e.printStackTrace(System.out);

      throw new McdbException("Error accessing database connection in " +

                                 docid.getIdentifier(), docid.getRev());

    }

  }

  /**

   * Look up the node data from the database, but some node would be shown

   * because of access control

   * @param rootnodeid the id of the root node of the node tree to look up

   * @param accessControl  the hashtable has control info

   */

                                        throws McdbException

  {

    PreparedStatement pstmt = null;

    String nodedata = null;

    String quotechar = dbAdapter.getStringDelimiter();

    String sql = "SELECT nodeid,parentnodeid,nodeindex, " +

                  "FROM xml_nodes WHERE rootnodeid = ?";

    // go through the access control for some nodes

     Enumeration en = accessControl.elements();

     while (en.hasMoreElements())

         long startId = tree.getStartNodeId();

         long endId  = tree.getEndNodeId();

         sql = sql +" AND(nodeid < " + startId + " OR nodeid > " +endId +")";

     }

     MetaCatUtil.debugMessage("The final query to select part node tree: " +

                              sql, 25);

    {

      dbconn=DBConnectionPool.

                    getDBConnection("DocumentImpl.getPartNodeRecordList");

      pstmt.execute();

      ResultSet rs = pstmt.getResultSet();

      boolean tableHasRows = rs.next();

      {

        nodeid = rs.getLong(1);

        parentnodeid = rs.getLong(2);

        // Advance to the next node

        tableHasRows = rs.next();

      pstmt.close();

    {

      throw new McdbException("Error in DocumentImpl.getPartNodeRecordList " +

                              e.getMessage());

        DBConnectionPool.returnDBConnection(dbconn, serialNumber);

      }

    }

    {

      return nodeRecordList;

    {

      throw new McdbException("Error getting node data: " + docid);

    }

  }

  /**

   * Look up the node data from the database

   *

      serialNumber=dbconn.getCheckOutSerialNumber();

      pstmt =

      dbconn.prepareStatement("SELECT nodeid,parentnodeid,nodeindex, " +

           "FROM xml_nodes WHERE rootnodeid = ?");

      // Bind the values to the query

        // Advance to the next node

        tableHasRows = rs.next();

      pstmt.close();

    } catch (SQLException e) {

        DBConnectionPool.returnDBConnection(dbconn, serialNumber);

      }

    }

    return nodeRecordList;

  }

// NOT USED ANY MORE

//   default serverCode of 1*/

//  private void writeDocumentToDB(String action, String user)

//               throws SQLException, Exception

//  }

 /** creates SQL code and inserts new document into DB connection */

               throws SQLException, Exception {

    String sysdate = dbAdapter.getDateTimeFunction();

      if (action.equals("INSERT")) {

        //AccessionNumber ac = new AccessionNumber();

        //this.docid = ac.generate(docid, "INSERT");

        pstmt = connection.prepareStatement(

                "INSERT INTO xml_documents " +

                "public_access, catalog_id, server_location, rev) " +

                ", ?, ?, ?, ?)");

        // Increase dbconnection usage count

        connection.increaseUsageCount(1);

        //this means that "localhost" in the xml_replication table must

        //always be the first entry!!!!!

        // Bind the values to the query

        pstmt.setString(1, this.docid);

        pstmt.setLong(2, rootnodeid);

        }*/

        pstmt.setString(8, catalogid);

        pstmt.setInt(9, serverCode);

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

        // Save the old document publicaccessentry in a backup table

        }

        else

        {

          thisrev=Integer.parseInt(updatedVersion);

        }

        MetaCatUtil.debugMessage("final revsion is: "+thisrev, 40);

            (new Boolean(MetaCatUtil.getOption("usexmlindex"))).booleanValue();

        if (useXMLIndex) {

            MetaCatUtil.debugMessage("before delete", 40);

            MetaCatUtil.debugMessage("after delete", 40);

            // Increase dbconnection usage count

            connection.increaseUsageCount(1);

            pstmt.execute();

        }

        // Update the new document to reflect the new node tree

        pstmt = connection.prepareStatement(

            "UPDATE xml_documents " +

      // Do the insertion

      pstmt.execute();

      pstmt.close();

    } catch (SQLException sqle) {

                             String action, String docid, String user,

                             String[] groups )

                throws Exception {

    Reader dtd = null;

    if ( dtdfilename != null ) {

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

  public static String write(DBConnection conn,Reader xml,String pub,Reader dtd,

                             String action, String docid, String user,

                             boolean needValidation)

                throws Exception {

    //in MetacatServlet class and now is wrapper into documentImple

    // get server location for this doc

    int serverLocation=getServerLocationNumber(docid);

                 ruleBase, needValidation);

  }

  /**

   * Write an XML file to the database, given a Reader

   *

   * @param override flag to stop insert replication checking.

   *        if override = true then a document not belonging to the local server

   *        will not be checked upon update for a file lock.

   *        update will be locked and version checked.

   */

    AccessionNumber ac = new AccessionNumber(accnum, action);

    String docid = ac.getDocid();

    String rev = ac.getRev();

                             serverCode + " override: " + override, 10);

    if((serverCode != 1 && action.equals("UPDATE")) && !override)

    { //if this document being written is not a resident of this server then

      //we need to try to get a lock from it's resident server.  If the

      //resident server will not give a lock then we send the user a message

      //saying that he/she needs to download a new copy of the file and

      //merge the differences manually.

      char istreamChar;

      // check for 'write' permission for 'user' to update this document

      if ( !hasWritePermission(user, groups, accnum) ) {

              " does not have permission to update XML Document #" + accnum);

      DocumentIdentifier id = new DocumentIdentifier(accnum);

      String updaterev = id.getRev();

      String server=MetacatReplication.getServerNameForServerCode(serverCode);

      MetacatReplication.replLog("attempting to lock " + accnum);

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

           +updaterev + "&docid=" + docid);

      //System.out.println("sending message: " + u.toString());

      String serverResStr = MetacatReplication.getURLContent(u);

      if(openingtag.equals("<lockgranted>"))

      {//the lock was granted go ahead with the insert

        XMLReader parser = null;

        {

          //System.out.println("In lockgranted");

          MetacatReplication.replLog("lock granted for " + accnum + " from " +

          /*XMLReader parser = initializeParser(conn, action, docid, updaterev,

                               validate, user, groups, pub, serverCode, dtd);*/

          parser = initializeParser(conn, action, docid, updaterev,

          conn.setAutoCommit(false);

          conn.commit();

          conn.setAutoCommit(true);

        {

          conn.rollback();

          conn.setAutoCommit(true);

          }

          throw e;

        }

        runRelationAndAccessHandler(accnum, user, groups, serverCode);

        // Force replication the docid

        ForceReplicationHandler frh = new ForceReplicationHandler

                                                          (accnum, true, null);

        return(accnum);

      }

      else if(openingtag.equals("<filelocked>"))

                            "merge your changes and try again.");

      }

    }

    if ( action.equals("UPDATE") ) {

      // check for 'write' permission for 'user' to update this document

      if ( !hasWritePermission(user, groups, accnum) ) {

              " does not have permission to update XML Document #" + accnum);

    }

    XMLReader parser = null;

                                          dtd, ruleBase, needValidation);

      conn.setAutoCommit(false);

      parser.parse(new InputSource(xml));

      conn.commit();

      conn.setAutoCommit(true);

    {

      conn.rollback();

      conn.setAutoCommit(true);

       }

      throw e;

    }

    runRelationAndAccessHandler(accnum, user, groups, serverCode);

    // Force replicate out the new document to each server in our server list.

    // Start the thread to replicate this new document out to the other servers

    // true mean it is xml document

    // null is because no metacat notify the force replication.

    ForceReplicationHandler frh = new ForceReplicationHandler

                                                  (accnum, action, true, null);

    MetaCatUtil.debugMessage("Conn Usage count after writting: "