Metacat

import java.util.Iterator;

    Vector<InputStream> responses = new Vector<InputStream>();

    try {

        _xmlDocQueryCount = 0;

        _xmlRevQueryCount = 0;

        _xmlDocQueryTime = 0;

        _xmlRevQueryTime = 0;

        /*

         */

        ReplicationServer replServer = null; // Variable to store the

        // ReplicationServer got from

        // Server list

        String server = null; // Variable to store server name

        //    String update;

        URL u;

        long replicationStartTime = System.currentTimeMillis();

        long timeToGetServerList = 0;

        //Check for every server in server list to get updated list and put

        // them in to response

        long startTimeToGetServers = System.currentTimeMillis();

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

            // Get ReplicationServer object from server list

            replServer = serverList.serverAt(i);

            // Get server name from ReplicationServer object

            server = replServer.getServerName().trim();

            InputStream result = null;

            logReplication.info("ReplicationHandler.update - full update started to: " + server);

            // Send command to that server to get updated docid information

            try

            {

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

                        +MetacatUtil.getLocalReplicationServerName()+"&action=update");

                logReplication.info("ReplicationHandler.update - Sending infomation " +u.toString());

                result = ReplicationService.getURLStream(u);

            }

            catch (Exception e)

            {

                logMetacat.error("ReplicationHandler.update - " + ReplicationService.METACAT_REPL_ERROR_MSG);

                logReplication.error( "ReplicationHandler.update - Failed to get updated doc list "+

                        "for server " + server + " because "+e.getMessage());

                continue;

            }

            //logReplication.info("ReplicationHandler.update - docid: "+server+" "+result);

            //check if result have error or not, if has skip it.

            // TODO: check for error in stream

            //if (result.indexOf("<error>") != -1 && result.indexOf("</error>") != -1) {

            if (result == null) {

                logMetacat.error("ReplicationHandler.update - " + ReplicationService.METACAT_REPL_ERROR_MSG);

                logReplication.error( "ReplicationHandler.update - Failed to get updated doc list "+

                        "for server " + server + " because "+result);

                continue;

            }

            //Add result to vector

            responses.add(result);

        timeToGetServerList = System.currentTimeMillis() - startTimeToGetServers;

        //make sure that there is updated file list

        //If response is null, metacat don't need do anything

        if (responses==null || responses.isEmpty())

            logMetacat.error("ReplicationHandler.update - " + ReplicationService.METACAT_REPL_ERROR_MSG);

            logReplication.info( "ReplicationHandler.update - No updated doc list for "+

                    "every server and failed to replicate");

            return;

        //logReplication.info("ReplicationHandler.update - Responses from remote metacat about updated "+

        //               "document information: "+ responses.toString());

        long totalServerListParseTime = 0;

        // go through response vector(it contains updated vector and delete vector

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

        {

            long startServerListParseTime = System.currentTimeMillis();

            XMLReader parser;

            ReplMessageHandler message = new ReplMessageHandler();

            try

            {

                parser = initParser(message);

            }

            catch (Exception e)

            {

                logMetacat.error("ReplicationHandler.update - " + ReplicationService.METACAT_REPL_ERROR_MSG);

                logReplication.error("ReplicationHandler.update - Failed to replicate becaue couldn't " +

                        " initParser for message and " +e.getMessage());

                // stop replication

                return;

            }

            try

            {

                parser.parse(new InputSource(responses.elementAt(i)));

            }

            catch(Exception e)

            {

                logMetacat.error("ReplicationHandler.update - " + ReplicationService.METACAT_REPL_ERROR_MSG);

                logReplication.error("ReplicationHandler.update - Couldn't parse one responses "+

                        "because "+ e.getMessage());

                continue;

            }

            finally 

            {

                IOUtils.closeQuietly(responses.elementAt(i));

            }

            //v is the list of updated documents

            Vector<Vector<String>> updateList = new Vector<Vector<String>>(message.getUpdatesVect());

            logReplication.info("ReplicationHandler.update - The document list size is "+updateList.size()+ " from "+message.getServerName());

            //d is the list of deleted documents

            Vector<Vector<String>> deleteList = new Vector<Vector<String>>(message.getDeletesVect());

            logReplication.info("ReplicationHandler.update - Update vector size: "+ updateList.size()+" from "+message.getServerName());

            logReplication.info("ReplicationHandler.update - Delete vector size: "+ deleteList.size()+" from "+message.getServerName());

            logReplication.info("ReplicationHandler.update - The delete document list size is "+deleteList.size()+" from "+message.getServerName());

            // go though every element in updated document vector

            handleDocList(updateList, DocumentImpl.DOCUMENTTABLE);

            //handle deleted docs

            for(int k=0; k<deleteList.size(); k++)

            { //delete the deleted documents;

                Vector<String> w = new Vector<String>(deleteList.elementAt(k));

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

                try

                {

                    handleDeleteSingleDocument(docId, server);

                }

                catch (Exception ee)

                {

                    continue;

                }

            }//for delete docs

            // handle replicate doc in xml_revision

            Vector<Vector<String>> revisionList = new Vector<Vector<String>>(message.getRevisionsVect());

            logReplication.info("ReplicationHandler.update - The revision document list size is "+revisionList.size()+ " from "+message.getServerName());

            handleDocList(revisionList, DocumentImpl.REVISIONTABLE);

            DOCINSERTNUMBER = 1;

            DOCERRORNUMBER  = 1;

            REVINSERTNUMBER = 1;

            REVERRORNUMBER  = 1;

            // handle system metadata

            Vector<Vector<String>> systemMetadataList = message.getSystemMetadataVect();

            for(int k = 0; k < systemMetadataList.size(); k++) { 

                Vector<String> w = systemMetadataList.elementAt(k);

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

                String remoteserver = (String) w.elementAt(1);

                try {

                    handleSystemMetadata(remoteserver, guid);

                }

                catch (Exception ee) {

                    logMetacat.error("Error replicating system metedata for guid: " + guid, ee);

                    continue;

                }

            }

            totalServerListParseTime += (System.currentTimeMillis() - startServerListParseTime);

        }//for response

        //updated last_checked

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

            // Get ReplicationServer object from server list

            replServer = serverList.serverAt(i);

            try

            {

                updateLastCheckTimeForSingleServer(replServer);

            }

            catch(Exception e)

            {

                continue;

            }

        }//for

        long replicationEndTime = System.currentTimeMillis();

        logMetacat.debug("ReplicationHandler.update - Total replication time: " + 

                (replicationEndTime - replicationStartTime));

        logMetacat.debug("ReplicationHandler.update - time to get server list: " + 

                timeToGetServerList);

        logMetacat.debug("ReplicationHandler.update - server list parse time: " + 

                totalServerListParseTime);

        logMetacat.debug("ReplicationHandler.update - 'in xml_documents' total query count: " + 

                _xmlDocQueryCount);

        logMetacat.debug("ReplicationHandler.update - 'in xml_documents' total query time: " + 

                _xmlDocQueryTime + " ms");

        logMetacat.debug("ReplicationHandler.update - 'in xml_revisions' total query count: " + 

                _xmlRevQueryCount);

        logMetacat.debug("ReplicationHandler.update - 'in xml_revisions' total query time: " + 

                _xmlRevQueryTime + " ms");;

    } finally { // need to close all inputstreams unconditionally

        Iterator<InputStream> isit = responses.iterator();

        while (isit.hasNext()) {

            IOUtils.closeQuietly(isit.next());

        }

    }

    }//update