Metacat

  private Vector fileLocks = new Vector();

  private Thread lockThread = null;

  private static final AbstractDatabase dbAdapter = MetaCatUtil.dbAdapter;

  /**

   * Initialize the servlet by creating appropriate database connections

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

    }//finally

  }

  /**

   * when a forcereplication data file request comes in, local host sends a

   * readdata request to the requesting server (remote server) for the specified

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

      //the xml_documents

      {

        //conn = util.getConnection();

        DocumentImpl.delete(docid,user,null);

        //util.returnConnection(conn);

      //To data file insert or update is same

      {

        //Get data file and store it into local file system.

        // sending back readdata request to server

            try {

                try {

                    EventLog.getInstance().log(request.getRemoteAddr(),

                                               user, docid[0], "delete");

                    response.setContentType("text/xml");

    /**

     * Build the index records for this document.  For each node, all absolute

     * and relative paths to the root of the document are created and inserted

     * database.

     *

     * @throws McdbException on error getting the node records for the document

            Long nodeId = new Long(currentNode.getNodeId());

            nodeRecordMap.put(nodeId, currentNode);

        }

        // XML Index -- be sure that it is all in one db transaction

        int serialNumber = -1;

        DBConnection dbConn = null;

            dbConn.setAutoCommit(false);

            //make sure record is done

            //checkDocumentTable();

            // Delete the previous index entries for this document

            deleteNodeIndex(dbConn);

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

            // and build the new index and update the database

            it = nodeRecordLists.iterator();

                if (currentNode.nodetype.equals("ELEMENT") ||

                    currentNode.nodetype.equals("ATTRIBUTE") ) {

                        currentNode.getNodeName() + " (" +

                        currentNode.getNodeType() + ")");

                    if (atRootElement) {

                        rootNodeId = currentNode.getNodeId();

                        atRootElement = false;

                    }

                            currentNode.getNodeId(),

                            currentNode.getNodeId(), "", pathList);

                    updateNodeIndex(dbConn, pathList);

                }

            }

            dbConn.commit();

        } catch (SQLException e) {

            MetaCatUtil.debugMessage(

                "SQL Exception while inserting path index in " +

                "DocumentImpl.buildIndex for document " + docid, 10);

            e.printStackTrace();

            try {

                dbConn.rollback();

            } catch (SQLException sqle) {

                    + "\n" + sqle.getMessage(), 10);

            }

        } finally {

        }

    }

     * @param children the string representation of all child nodes of this id

     * @param pathList the hash to which paths are added

     */

            String children, HashMap pathList) {

        Long nodeId = new Long(id);

        NodeRecord current = (NodeRecord)records.get(nodeId);

            String path = current.getNodeName() + children;

            if (!children.equals("")) {

                System.err.print("B: " + path +"\n");

                    doctype, parentId));

            }

            if (id == rootNodeId) {

                System.err.print("C: " + fullPath +"\n");

                pathList.put(fullPath, new PathIndexEntry(leafNodeId, fullPath,

                    docid, doctype, parentId));

            }

        }

    }

    /**

     * of a subsequent update.

     *

     * @param conn the database connection to use, keeping a single transaction

        String sql = "DELETE FROM xml_index WHERE docid LIKE ?";

        MetaCatUtil.debugMessage(sql, 55);

        System.err.println("SQL is: " + sql);

        PreparedStatement pstmt = conn.prepareStatement(sql);

        // Increase usage count for the connection

        conn.increaseUsageCount(1);

        // Execute the delete and close the statement

        pstmt.setString(1, familyId);

        int rows = pstmt.executeUpdate();

        MetaCatUtil.debugMessage("Deleted " + rows + " rows from xml_index " +

            "for document " + docid, 55);

    }

    /**

     * database.

     *

     * @param conn the database connection to use, keeping a single transaction

     * @param pathList the hash of paths to insert

     * @throws SQLException if there is an error inserting into the db

     */

    {

        // Create an insert statement to reuse for all of the path

        // insertions

        String familyId = MetaCatUtil.getDocIdFromString(docid);

        pstmt.setString(3, familyId);

        pstmt.setString(4, doctype);

        // Step through the hashtable and insert each of the path values

        Iterator it = pathList.values().iterator();

        while (it.hasNext()) {

        // Close the database statement

        pstmt.close();

    }

    private boolean isRevisionOnly(DocumentIdentifier docid) throws Exception

    {

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

     * @param docid

     *            the ID of the document to be deleted from the database

     */

            throws Exception

    {

        DBConnection conn = null;

        int serialNumber = -1;

        PreparedStatement pstmt = null;

        try {

            //check out DBConnection

            conn = DBConnectionPool.getDBConnection("DocumentImpl.delete");

            // NEW - WHEN CLIENT ALWAYS PROVIDE ACCESSION NUMBER INCLUDING REV

            // IN IT

            MetaCatUtil.debugMessage("Start deleting doc " + docid + "...", 20);

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

            if (!hasAllPermission(user, groups, accnum)) { throw new Exception(

                DBConnectionPool.returnDBConnection(conn, serialNumber);

            }

        }

    }

    /**

     * Check for "WRITE" permission on @docid for @user and/or @groups

     * from DB connection

                    xmldoc.toXml(new PrintWriter(System.out), null, null, true);

                }

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

                System.out.println("Document deleted: " + docid);

            } else {

                /*

    ReplicationServer replServer = null; // Variable to store the

                                        // ReplicationServer got from

                                        // Server list

    String update;

    ReplMessageHandler message = new ReplMessageHandler();

    Vector responses = new Vector();

          String docId = (String)w.elementAt(0);

          try

          {

          }

          catch (Exception ee)

          {

  /* Handle delete single document*/

               throws Exception

  {

    MetaCatUtil.debugMessage("Try delete doc: "+docId, 40);

         //so we just add one for it. This rev number is no sence.

         String accnum=docId+util.getOption("accNumSeparator")+"1";

         //System.out.println("accnum: "+accnum);

         MetaCatUtil.debugMessage("Successfully deleted doc " + docId, 30);

         MetacatReplication.replLog("Doc " + docId + " deleted");

      }

/**

 *  '$RCSfile$'

 *             with a certain docid.

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

 *             National Center for Ecological Analysis and Synthesis

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 */

package edu.ucsb.nceas.metacat;

import java.util.*;

import java.text.*;

/**

 * with a certain docid.

 */

public class ForceReplicationHandler implements Runnable

  private String action;

  private boolean xmlDocument;

  private boolean dbactionFlag = true;

  private int homeServerCode = 0; // home server code for the docid

  // notification from B, then A will update its record. And A will notification

  // other metacat in its serverlist to update this docid if A is a hub. But we

  // don't want A to notify B again. B is nofitification of A

  private String notificationServer = null;

  /**

   * Constructor of ForceReplicationHandler

   * @param docid the docid to force replicate

   *        INSERT or UPDATE)

   * @param xml the docid is a xml document or not (data file)

   * notification from B, then A will update its record. And A will notification

   * other metacat in its serverlist to update this docid if A is a hub. But we

   * don't want A to notify B again. B is nofitification of A.

   */

                                                   String myNotificationServer)

  {

    this.docid = docid;

    }//catch

    // Get the notification server

    this.notificationServer = myNotificationServer;

    if(this.action.equals(""))

    {

      dbactionFlag = false;

    }

    btThread = new Thread(this);

    btThread.setPriority(Thread.MIN_PRIORITY);

    btThread.start();

  }

  /**

   * Use this constructor when the action is implied.

   */

                                                String myNotificationServer )

  {

    this.docid = docid;

    btThread.setPriority(Thread.MIN_PRIORITY);

    btThread.start();

  }

  /**

   * a new or updated docid

   */

  public void run()

  {

    try

    {

      // URL for notifcation

      {

        return;

      }

      // into the database before we send force replication request

      int sleepTime = Integer.parseInt

                         (MetaCatUtil.getOption("forcereplicationwaitingtime"));

        ReplicationServer replicationServer = serverLists.serverAt(i);

       // Get this ReplicationServer 's name

        String server = replicationServer.getServerName();

        // again, if server is null we don't replication it

        if (server!=null && !server.equals(notificationServer))

        {

          if(dbactionFlag)

          {

            // xml documents and server can replicate xml doucment

              // If this docid's homeserver is localhost, replicate it

              if (homeServerCode==1)

              {

                                                                    + server);

                                 util.getOption("replicationpath") +

                                 "&docid=" + docid + "&dbaction=" +

                                  action);

              }//if servercode==1

              else if (replicationServer.getHub()||

                   server.equals(MetacatReplication.

                // If the docid's home server is not local host, but local host

                // is a hub of this server, replicate the docid too.

                // If the server is homeserver of the docid, replication it too

                                                                    + server);

                                 util.getOption("replicationpath") +

                                 "&docid=" + docid + "&dbaction=" +

                                  action);

              }//else

            }//if xmlDocument

            //It is data file and configured to handle data replication

            else if (replicationServer.getDataReplication())

              // If the docid's home server is local host, replicate the docid

              if (homeServerCode==1)

              {

                                                                      + server);

                                 util.getOption("replicationpath") +

                                 "&docid=" + docid + "&dbaction=" +

                                  action);

              }//if serverCode==1

              else if (replicationServer.getHub()||

                server.equals(MetacatReplication.

                                    getServerNameForServerCode(homeServerCode)))

              {

                // is a hub of this server, replicate the docid too.

                // If the server is homeserver of the docid replication it too

                                                                      + server);

                                 util.getOption("replicationpath") +

                                 "&docid=" + docid + "&dbaction=" +

                                  action);

              }//else if servercode==1

            }//else if data file

          }//if has explicite action

          else

          { // has implicite action

            {

              // If homeserver of this doicd is local, replicate it

              if (homeServerCode ==1)

                                 util.getOption("replicationpath") +

                                 "&docid=" + docid);

              }//if homeserver ==1

              else if (replicationServer.getHub()||

                   server.equals(MetacatReplication.

                   getServerNameForServerCode(homeServerCode)))

              {

                // host is a hub for this server, replicate this doicd

                // If the server is homeserver of the docid, replication it too

                                 util.getOption("replicationpath") +

                                 "&docid=" + docid);

              }//else if

            }//if xmlDoucment

            { //It is datafile and server is configured to replicate data file

              //if home server is local host, replicate the data file

              if (homeServerCode ==1)

              {

                                 util.getOption("replicationpath") +

                                 "&docid=" + docid);

              }//if

                // If home server is not local host, but the local host is a hub

                // For this server, replicate the data file

                // If the server is homeserver of the docid, replication it too

                                 util.getOption("replicationpath") +

                                 "&docid=" + docid);

              }//else

            }//else if

          }//else has implicit action

          //Make sure comeAndGetIt is not empty

          if ( comeAndGetIt != null && !comeAndGetIt.equals(""))

          {

                                                + comeAndGetIt.toString(), 25);

            String message = MetacatReplication.getURLContent(comeAndGetIt);

          }

          //invoces a read request from the server to this local machine.

        }//if notification server

      }//for

    }//try

    catch(Exception e)

    {

                          e.getMessage());

      e.printStackTrace(System.out);

    }