Name:      ReplManagerPlugin.java

Project:   xmlBlaster.org

Copyright: xmlBlaster.org, see xmlBlaster-LICENSE file

Switch on finer logging in xmlBlaster.properties:

trace[org.xmlBlaster.contrib.dbwatcher.convert.ResultSetToXmlConverter]=true

trace[org.xmlBlaster.contrib.db.DbPool]=true

trace[org.xmlBlaster.contrib.dbwatcher.detector.MD5ChangeDetector]=true

trace[org.xmlBlaster.contrib.dbwatcher.detector.AlertScheduler]=true

trace[org.xmlBlaster.contrib.dbwatcher.detector.TimestampChangeDetector]=true

trace[org.xmlBlaster.contrib.dbwatcher.plugin.ReplManagerPlugin]=true

trace[org.xmlBlaster.contrib.dbwatcher.mom.XmlBlasterPublisher]=true

trace[org.xmlBlaster.contrib.dbwatcher.DbWatcher]=true

------------------------------------------------------------------------------*/

* ReplManagerPlugin is a plugin wrapper if you want to run DbWatcher inside xmlBlaster.

* <p />

* DbWatcher checks a database for changes and publishes these to the MoM

* <p />

* This plugin needs to be registered in <tt>xmlBlasterPlugins.xml</tt>

* to be available on xmlBlaster server startup.

*

* <p>

* This plugin uses <tt>java.util.logging</tt> and redirects the logging to xmlBlasters default

* logging framework. You can switch this off by setting the attribute <tt>xmlBlaster/jdk14loggingCapture</tt> to false.

* </p>

*

* @author <a href="mailto:michele@laghi.eu">Michele Laghi</a>

*/

   implements ReplManagerPluginMBean,

              I_Callback,

              I_MsgDispatchInterceptor,

              I_ClientListener,

              I_SubscriptionListener,

              I_Timeout,

              ReplicationConstants,

              I_Plugin,

              I_PublishFilter {

      long msg;

      long[] trans;

     

      /**

       * @deprecated

       * @param data

       */

      public Counter(long[] data) {

         boolean oldStyle = data.length < 5;

         if (oldStyle) { // TODO remove this once no more old data around

            this.msg = data[2];

            this.trans = new long[10];

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

               this.trans[i] = data[1];

         }

         else {

            this.msg = data[2];

            this.trans = new long[10];

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

               this.trans[i] = data[i+4];

         }

      }

   }

  

   public final static String SESSION_ID = "replManager/1";

   private final static String SENDER_SESSION = "_senderSession";

   private final static String ME = ReplManagerPlugin.class.getName();

   private static Logger log = Logger.getLogger(ME);

   private Object mbeanHandle;

   private String user = "replManager";

   private String password = "secret";

   private Map replications;

   private Map replSlaveMap;

 

   /** Keys are requestId Strings, and values are SqlStatement objects */

   private Map sqlStatementMap;

   private boolean shutdown;

   private volatile boolean initialized;

  

   private String instanceName;

   private long maxSize = 999999L;

   private String sqlTopic;

   private long maxResponseEntries;

   private I_DbPool pool;

   private VersionTransformerCache transformerCache;

   private String cachedListOfReplications;

   private String initialFilesLocation;

   private Timestamp timeoutHandle;

   private Timeout timeout = new Timeout("ReplManagerPlugin-StatusPoller");

   private final static long STATUS_POLLER_INTERVAL_DEFAULT = 5000L;

   private long statusPollerInterval = STATUS_POLLER_INTERVAL_DEFAULT;

   private long statusProcessingTime;

   private long numRefresh;

   private int maxNumOfEntries = REPLICATION_MAX_ENTRIES_DEFAULT;

   private I_Info persistentInfo;

   private Map topicToPrefixMap;

   private Map counterMap;

   private Set initialDataTopicSet;

   /**

    * Default constructor, you need to call <tt>init()<tt> thereafter.

    */

   public ReplManagerPlugin() {

      super(new String[] {});

      this.replications = new TreeMap();

      this.topicToPrefixMap = new HashMap();

      this.counterMap = new HashMap();

      this.replSlaveMap = new TreeMap();

      this.sqlStatementMap = new TreeMap();

      this.transformerCache = new VersionTransformerCache();

      this.initialDataTopicSet = new HashSet();

   }

   public byte[] transformVersion(String replPrefix, String srcVersion, String destVersion, String destination, byte[] srcData) throws Exception {

      if (destVersion == null)

         return srcData;

      if (destVersion.equalsIgnoreCase(srcVersion))

         return srcData;

      return this.transformerCache.transform(replPrefix, srcVersion, destVersion, destination, srcData, null);

   }

  

   public byte[] transformVersion(String replPrefix, String destVersion, String destination, byte[] content) throws Exception {

      I_Info tmpInfo = (I_Info)this.replications.get(replPrefix);

      if (tmpInfo == null)

         throw new Exception("The replication with replication.prefix='" + replPrefix + "' was not found");

      String srcVersion = tmpInfo.get("replication.version", "0.0").trim();

      if (srcVersion.length() < 1)

         throw new Exception("The replication '" + replPrefix + "' has no version defined");

      return transformVersion(replPrefix, srcVersion, destVersion, destination, content);

   }

  

   public String transformVersion(String replPrefix, String destVersion, String destination, String is) throws Exception {

      I_Info tmpInfo = (I_Info)this.replications.get(replPrefix);

      if (tmpInfo == null)

         throw new Exception("The replication with replication.prefix='" + replPrefix + "' was not found");

      String srcVersion = tmpInfo.get("replication.version", "0.0").trim();

      if (srcVersion.length() < 1)

         throw new Exception("The replication '" + replPrefix + "' has no version defined");

      return new String(transformVersion(replPrefix, srcVersion, destVersion, destination, is.getBytes()));

   }

  

   public void clearVersionCache() {

      this.transformerCache.clearCache();

      this.cachedListOfReplications = null;

   }

   /**

    *

    * @param name the slave associated with this name or null if none found.

    * @return

    */

   public I_ReplSlave getSlave(String name) {

      if (name == null || name.length() < 1)

         return null;

      synchronized(this.replSlaveMap) {

         return (I_ReplSlave)this.replSlaveMap.get(name);

      }

   }

  

   public String reInitiate(String replPrefix) {

      I_Info info = (I_Info)this.replications.get(replPrefix);

      I_ReplSlave[] slaves = (I_ReplSlave[])this.replSlaveMap.values().toArray(new I_ReplSlave[this.replSlaveMap.size()]);

      StringBuffer buf = new StringBuffer();

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

         String thisReplPrefix = slaves[i].getReplPrefix();

         if (thisReplPrefix != null && thisReplPrefix.equals(replPrefix)) {

            try {

               slaves[i].reInitiate(info);

            }

            catch (Exception ex) {

               buf.append(slaves[i].toString());

               ex.printStackTrace();

            }

         }

      }

      String ret = buf.toString();

      if (buf.length() > 0)

         return "FAILED: the slaves " + ret + " did fail";

      return "Success: " + slaves.length + " slaves re-initiated";

   }

  

   /**

    * Never returns null. It returns a list of keys identifying the slaves using the replication

    * manager.

    * @return

    */

   public String getSlaves() {

      return InfoHelper.getIteratorAsString(this.replSlaveMap.keySet().iterator());

   }

  

   /**

    * Never returns null. It returns a list of keys identifying the ongoing replications.

    * @return

    */

   public String getReplications() {

      if (this.cachedListOfReplications != null)

         return this.cachedListOfReplications;

      // rebuild the cache

      Iterator iter = this.replications.values().iterator();

      boolean isFirst = true;

      StringBuffer buf = new StringBuffer();

      while (iter.hasNext()) {

         I_Info tmpInfo = (I_Info)iter.next();

         String tmp = tmpInfo.get(SUPPORTED_VERSIONS, null);

         log.info("replications : '" + tmp + "'");

         if (tmp != null) {

            if (!isFirst)

               buf.append(",");

            isFirst = false;

            buf.append(tmp);

         }

         else {

            String replPrefix = SpecificDefault.getReplPrefix(tmpInfo);

            log.warning("Property '" + SUPPORTED_VERSIONS + "' not found for '" + replPrefix + "'");

            if (!isFirst)

               buf.append(",");

            isFirst = false;

            buf.append(replPrefix);

         }

      }

      // return InfoHelper.getIteratorAsString(this.replications.keySet().iterator());

      this.cachedListOfReplications = buf.toString();

      return this.cachedListOfReplications;

   }

  

  

   public static String getPluginName() {

      return "ReplManager,1.0";

   }

  

   public String getType() {

      return "ReplManager";

   }

  

   public String getVersion() {

      return "1.0";

   }

   private void addIfNotSet(String key, String defValue) {

      String tmp = get(key, null);

      if (tmp == null) {

         if (defValue == null)

            log.warning("The property '" + key + "' is not set");

         put(key, defValue);

      }

   }

   /**

    * Creates a I_DbPool object using the defaults out of the JDBC,1.0 Queue Properties and initializes

    * the pool.

    * @return

    * @throws Exception

    */

   private I_DbPool initializePersistentInfo() throws Exception {

      QueuePluginManager pluginManager = new QueuePluginManager(this.global);

      PluginInfo queuePluginInfo = new PluginInfo(this.global, pluginManager, "JDBC", "1.0");

      Properties prop = (Properties)queuePluginInfo.getParameters();

     

      String dbUrl = this.global.get("db.url", prop.getProperty("url", null), null, queuePluginInfo);

      String dbUser = this.global.get("db.user", prop.getProperty("user", null), null, queuePluginInfo);

      String dbPassword = this.global.get("db.passwordr", prop.getProperty("password", null), null, queuePluginInfo);

     

      String dbDrivers = this.global.get("JdbcDriver.drivers", prop.getProperty("Jdbc.drivers", null), null, queuePluginInfo);

      dbDrivers = this.global.get("jdbc.drivers", dbDrivers, null, queuePluginInfo);

      log.info("db.url='" + dbUrl + "' db.user='" + dbUser + "'");

     

      addIfNotSet("db.url", dbUrl);

      addIfNotSet("db.user", dbUser);

      addIfNotSet("db.password", dbPassword);

      addIfNotSet("db.drivers", dbDrivers);

     

      I_DbPool newPool = new DbPool();

     

      newPool.init(this);

      this.persistentInfo = new DbInfo(newPool, "replication", this);

      return newPool;

   }

  

   /**

    * Intiates the replication for the given slave.

    * TODO Specify that the replicationKey (dbmasterid) must be short and DB conform.

    * Usually called by Humans via JMX Console.

    *

    * The cascaded replication is the replication which will be automatically started once the initial update of the first replication is finished. This is

    * used to concatenate replications. A typical usecase is in two way replication, then the initial update of the back replication can be automatically triggered

    * once the initial update of the main replication is finished.

    *

    * @param slaveSessionName

    * @param replicationKey This is the dbWatcher replication.prefix attribute.

    * @param cascadeSlaveSessionName The Name of the session of the dbWriter to be used for the cascaded replication. Can be null.

    * @param cascadedReplicationPrefix the prefix identifing the DbWatcher for the cascaded replication. Can be null. 

    * @param realInitialFilesLocation the file location where the initial dump is stored. If null or an empty String, then it

    * is assumed to be transfered the "normal" way, that is over the choosen communication protocol.

    */

   public String initiateReplication(String slaveSessionName, String prefixWithVersion, String cascadeSlaveSessionName, String cascadeReplicationPrefix, String realInitialFilesLocation) {

      try {

         return initiateReplicationNonMBean(slaveSessionName, prefixWithVersion, cascadeSlaveSessionName, cascadeReplicationPrefix, realInitialFilesLocation);

      }

      catch (Exception ex) {

         return "error: " + ex.getMessage();

      }

   }

   /**

    * Intiates the replication for the given slave.

    * TODO Specify that the replicationKey (dbmasterid) must be short and DB conform.

    * The cascaded replication is the replication which will be automatically started once the initial update of the first replication is finished. This is

    * used to concatenate replications. A typical usecase is in two way replication, then the initial update of the back replication can be automatically triggered

    * once the initial update of the main replication is finished.

    *

    * @param slaveSessionName

    * @param replicationKey This is the dbWatcher replication.prefix attribute.

    * @param cascadeSlaveSessionName The Name of the session of the dbWriter to be used for the cascaded replication. Can be null.

    * @param cascadedReplicationPrefix the prefix identifing the DbWatcher for the cascaded replication. Can be null. 

    * @param realInitialFilesLocation the file location where the initial dump is stored. If null or an empty String, then it

    * is assumed to be transfered the "normal" way, that is over the choosen communication protocol.

    * @throws Exception

    */

   public String initiateReplicationNonMBean(String slaveSessionName, String prefixWithVersion, String cascadeSlaveSessionName, String cascadeReplicationPrefix, String realInitialFilesLocation) throws Exception {

      try {

         if (slaveSessionName == null || slaveSessionName.trim().length() < 1)

            throw new Exception("ReplManagerPlugin.initiateReplication: The slave session name is null, please provide one");

         if (prefixWithVersion == null || prefixWithVersion.length() < 1)

            throw new Exception("ReplManagerPlugin.initiateReplication: The replication.prefix is null, please provide one");

         slaveSessionName = slaveSessionName.trim();

         String ret = "initiateReplication invoked for slave '" + slaveSessionName + "' and on replication '" + prefixWithVersion + "' store location : '" + realInitialFilesLocation + "'";

         log.info(ret);

        

         String replicationPrefix = VersionTransformerCache.stripReplicationPrefix(prefixWithVersion);

         String requestedVersion = VersionTransformerCache.stripReplicationVersion(prefixWithVersion);

        

         I_Info individualInfo = (I_Info)this.replications.get(replicationPrefix);

         if (individualInfo != null) {

           

            if (realInitialFilesLocation != null && realInitialFilesLocation.trim().length() > 0) {

               checkExistance(realInitialFilesLocation.trim());

               this.initialFilesLocation = realInitialFilesLocation.trim();

               individualInfo.put(INITIAL_FILES_LOCATION, this.initialFilesLocation);

            }

            else {

               // individualInfo.putObject(INITIAL_FILES_LOCATION, null);

               individualInfo.put(INITIAL_FILES_LOCATION, null);

            }

            individualInfo.put(REPL_VERSION, requestedVersion);

            individualInfo.putObject("org.xmlBlaster.engine.Global", this.global);

            I_ReplSlave slave = null;

            synchronized (this.replSlaveMap) {

               slave = (I_ReplSlave)this.replSlaveMap.get(slaveSessionName);

            }

            if (slave != null) {

               individualInfo.put("_replName", replicationPrefix);

               String dbWatcherSessionId = individualInfo.get(SENDER_SESSION, null);

               if (dbWatcherSessionId == null)

                  throw new Exception("ReplSlave '" + slave + "' constructor: the master Session Id (which is passed in the properties as '" + SENDER_SESSION + "' are not found. Can not continue with initial update");

               if (cascadeSlaveSessionName != null) {

                  // check to avoid loops

                  cascadeSlaveSessionName = cascadeSlaveSessionName.trim();

                  if (slaveSessionName.equals(cascadeSlaveSessionName))

                     throw new Exception(ret + " did fail since having the same slave '" + slaveSessionName + "' for both replications would result in a loop");

                     // return "error: " + ret + " did fail since having the same slave '" + slaveSessionName + "' for both replications would result in a loop";

               }

              

               boolean isOkToStart = slave.run(individualInfo, dbWatcherSessionId, cascadeReplicationPrefix, cascadeSlaveSessionName, false);

               if (isOkToStart == false) {

                  ret += " did fail since your status is '" + slave.getStatus() + "'. Please invoke first 'Cancel Update'";

                  throw new Exception(ret);

                  // return "error: " + ret; // don't throw an exception here since MX4J seems to loose exception msg.

               }

            }

            else

               throw new Exception("the replication slave '" + slaveSessionName + "' was not found among the list of slaves which is '" + getSlaves() + "'");

         }

         else

            throw new Exception("initiateReplication failed for '" + slaveSessionName + "' with replication key '" + replicationPrefix + "' since not known. Known are '" + getReplications() + "'");

         return ret;

      }

      catch (Exception ex) {

         ex.printStackTrace();

         throw ex;

      }

   }

   /**

    * @see org.xmlBlaster.util.plugin.I_Plugin#init(org.xmlBlaster.util.Global, org.xmlBlaster.util.plugin.PluginInfo)

    */

   protected synchronized void doInit(Global global, PluginInfo pluginInfo) throws XmlBlasterException {

      // if (this.initialized)

      //   return;

      try {

         // String momClass = get("mom.class", "org.xmlBlaster.contrib.MomEventEngine").trim();

         // String registryName = "mom.publisher";

         synchronized (ReplManagerPlugin.class) {

            this.instanceName = "replication";

         }

        

         ContextNode contextNode = new ContextNode(ContextNode.CONTRIB_MARKER_TAG, instanceName,

               this.global.getContextNode());

         if (!this.global.isRegisteredMBean(contextNode))

            this.mbeanHandle = this.global.registerMBean(contextNode, this);

        

         if (this.pool == null)

            this.pool = initializePersistentInfo();

        

         I_XmlBlasterAccess conn = this.global.getXmlBlasterAccess();

         this.user = get("mom.user", this.user);

         this.password = get("mom.password", this.password);

         ConnectQos connectQos = new ConnectQos(this.global, this.user, this.password);

         boolean persistentConnection = true;

         boolean persistentSubscription = true;

         connectQos.setPersistent(persistentConnection);

         connectQos.setMaxSessions(1);

         connectQos.setPtpAllowed(true);

         connectQos.setSessionTimeout(0L);

         String sessionName = REPL_MANAGER_SESSION;

         connectQos.setSessionName(new SessionName(this.global, sessionName));

         conn.connect(connectQos, this);

        

         // this is the instance passed from the outside, not a clone, otherwise

         // it will not find the plugin registry for the MIME plugin

         putObject("org.xmlBlaster.engine.Global", global);

         getEngineGlobal(this.global).getPluginRegistry().register(getType() + "," + getVersion(), this);

         this.sqlTopic = this.get("replication.sqlTopic", "sqlTopic");

         if (this.sqlTopic != null) {

            SubscribeKey subKey = new SubscribeKey(this.global, this.sqlTopic);

            SubscribeQos subQos = new SubscribeQos(this.global);

            subQos.setPersistent(persistentSubscription);

            subQos.setMultiSubscribe(false);

            conn.subscribe(subKey, subQos);

         }

        

         boolean wantsDeadLetters = true;

         if (wantsDeadLetters) {

            SubscribeKey subKey = new SubscribeKey(this.global, Constants.OID_DEAD_LETTER);

            SubscribeQos subQos = new SubscribeQos(this.global);

            // we probably need this to avoid missing messages when changing runlevels

            subQos.setPersistent(persistentSubscription);

            subQos.setMultiSubscribe(false);

            conn.subscribe(subKey, subQos);

         }

         this.maxResponseEntries = this.getLong("replication.sqlMaxEntries", 10L);

         RequestBroker rb = getEngineGlobal(this.global).getRequestBroker();

        

         rb.getAuthenticate(null).addClientListener(this);

         SessionInfo[] sessionInfos = rb.getAuthenticate(null).getSessionInfoArr();

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

            SessionInfo sessionInfo = sessionInfos[i];

            ClientEvent event = new ClientEvent(sessionInfo);

            sessionAdded(event);

           

            I_SubscriptionListener oldListener = rb.getSubscriptionListener(getPriority());

            if (oldListener == null)

               rb.addSubscriptionListener(this);

           

            SubscriptionInfo[] subInfos = rb.getClientSubscriptions().getSubscriptions(sessionInfo);

            for (int j=0; j < subInfos.length; j++) {

               SubscriptionEvent subEvent = new SubscriptionEvent(subInfos[j]);

               subscriptionAdd(subEvent);

            }

         }

         this.initialFilesLocation = this.get("replication.initialFilesLocation", "${user.home}/tmp");

         this.statusPollerInterval = this.getLong("replication.monitor.statusPollerInterval", STATUS_POLLER_INTERVAL_DEFAULT);

        

         if (this.statusPollerInterval > 0)

            this.timeoutHandle = timeout.addTimeoutListener(this, this.statusPollerInterval, null);

         else

            log.warning("The 'replication.monitor.statusPollerInterval' is set to '" + this.statusPollerInterval + "' which is lower than 1 ms, I will not activate it");

        

         this.maxNumOfEntries = this.getInt(REPLICATION_MAX_ENTRIES_KEY, REPLICATION_MAX_ENTRIES_DEFAULT);

         log.info("Will send a maximum of '" + this.maxNumOfEntries + "' on each sweep");

         this.initialized = true;

      }

      catch (Throwable e) {

         throw new XmlBlasterException(this.global, ErrorCode.RESOURCE_CONFIGURATION, "ReplManagerPlugin", "init failed", e);

      }

      log.info("Loaded ReplManagerPlugin '" + getType() + "'");

   }

   private org.xmlBlaster.engine.ServerScope getEngineGlobal(Global glob) {

      return (org.xmlBlaster.engine.ServerScope)glob.getObjectEntry(ORIGINAL_ENGINE_GLOBAL);

   }

  

  

   /**

    * @see org.xmlBlaster.util.plugin.I_Plugin#shutdown()

    */

   public synchronized void shutdown() {

      if (this.shutdown)

         return;

      try {

         super.shutdown();

         if (this.timeoutHandle != null) {

            this.timeout.removeTimeoutListener(this.timeoutHandle);

            this.timeoutHandle = null;

         }

        

         this.global.unregisterMBean(this.mbeanHandle);

         getEngineGlobal(this.global).getRequestBroker().getAuthenticate(null).removeClientListener(this);

         getEngineGlobal(this.global).getRequestBroker().removeSubscriptionListener(this);

         I_XmlBlasterAccess conn = this.global.getXmlBlasterAccess();

         if (this.sqlTopic != null) {

            UnSubscribeKey key = new UnSubscribeKey(this.global, this.sqlTopic);

            conn.unSubscribe(key, new UnSubscribeQos(this.global));

         }

         conn.disconnect(new DisconnectQos(this.global));

         this.replications.clear();

         this.replSlaveMap.clear();

         this.topicToPrefixMap.clear();

         this.counterMap.clear();

        

         synchronized(this.sqlStatementMap) {

            String[] keys = (String[])this.sqlStatementMap.keySet().toArray(new String[this.sqlStatementMap.size()]);

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

               unregisterSqlStatement(keys[i]);

         }

        

         getEngineGlobal(this.global).getPluginRegistry().unRegister(getType() + "," + getVersion());

         this.pool.shutdown();

      }

      catch (Throwable e) {

         log.warning("Ignoring shutdown problem: " + e.toString());

      }

      this.shutdown = true;

      log.info("Stopped DbWatcher plugin '" + getType() + "'");

   }

  

   /**

    * Gets the properties associated to this replication. Note that the info is this of the last

    * registration. This method can return null if no object is found or if the replicationPrefix

    * was null.

    *

    * @param replicationPrefix

    * @return

    */

   public I_Info getReplicationInfo(String replicationPrefix) {

      if (replicationPrefix == null)

         return null;

      synchronized (this.replications) {

         return (I_Info)this.replications.get(replicationPrefix);

      }

   }

  

   /**

    * Used to register a dbWatcher. This is a request coming directly from the

    * DbWatcher which registeres himself to this plugin.

    * Note that if you are using the same id for the replication on several DbWatcher

    * (several writers) only the first dbWatcher will pass the configuration. You are

    * responsible of ensuring that the relevant configuration parameters are the same

    * for all such DbWatcher instances.

    *

    * @param senderSession The session requesting this registration. This is needed

    * to reply to the right requestor.

    *

    * @param replId

    * @param info These are the Configuration of the DbWatcher, for example Table Names and so forth.

    */

   public synchronized void register(String senderSession, String replicationPrefix, I_Info info) {

      I_Info oldInfo = (I_Info)this.replications.get(replicationPrefix);

      info.put(SENDER_SESSION, senderSession);

      String topicName = info.get("mom.topicName", null);

      if (topicName == null)

         log.severe("Topic name not found for '" + replicationPrefix + "' can not map the topic to the replication prefix");

      else {

         this.topicToPrefixMap.put(topicName, replicationPrefix);

         String name = "replication." + replicationPrefix + ".replData";

         long[] replData = readOldReplData(this.persistentInfo, name);

         this.counterMap.put(replicationPrefix, new Counter(replData));

      }

     

      if (oldInfo != null) {

         log.info("register '" + replicationPrefix + "' by senderSession='" + senderSession + "'");

         String oldSenderSession = oldInfo.get(SENDER_SESSION, senderSession);

         if (oldSenderSession.equals(senderSession)) {

            log.info("register '" + replicationPrefix + "' by senderSession='" + senderSession + "' will overwrite old registration done previously");

            this.replications.put(replicationPrefix, info);

         }

         else {

            log.info("register '" + replicationPrefix + "' by senderSession='" + senderSession + "' was not done since there is a registration done by '" + oldSenderSession + "'. Will ignore the new one.");

         }

      }

      else

         this.replications.put(replicationPrefix, info);

     

      String initialDataTopic = info.get("replication.initialDataTopic", "replication.initialData");

      if (initialDataTopic != null)

         this.initialDataTopicSet.add(initialDataTopic);

      else

         log.severe("The initialDataTopic for replication '" + replicationPrefix + "' was null"); // should never happen

      this.cachedListOfReplications = null; // clear the cache

   }

  

   public synchronized void unregister(String senderSession, String replicationPrefix) {

      I_Info oldInfo = (I_Info)this.replications.get(replicationPrefix);

      if (oldInfo == null)

         log.info("unregister '" + replicationPrefix + "' by senderSession='" + senderSession + "' is ignored since there is no such registration done");

      else {

         log.info("unregister '" + replicationPrefix + "' by senderSession='" + senderSession + "'");

         /*

         if (log.isLoggable(Level.FINE)) {

            log.fine("unregister '" + replId + "' by senderSession='" + senderSession + "' the stack trace is:");

            Thread.dumpStack();

         }

         */

         String oldSenderSession = oldInfo.get(SENDER_SESSION, senderSession);

         if (oldSenderSession.equals(senderSession)) {

            this.replications.remove(replicationPrefix);

         }

         else {

            log.warning("unregister '" + replicationPrefix + "' by senderSession='" + senderSession + "' was not done since there is a registration done by '" + oldSenderSession + "'. Please do it with the correct Session");

         }

         String topicName = oldInfo.get("mom.topicName", null);

         if (topicName != null) {

            this.topicToPrefixMap.remove(topicName);

            this.counterMap.remove(replicationPrefix);

         }

      }

      String initialDataTopic = oldInfo.get("replication.initialDataTopic", "replication.initialData");

      if (initialDataTopic != null)

         this.initialDataTopicSet.remove(initialDataTopic);

      else

         log.severe("The initialDataTopic for replication '" + replicationPrefix + "' was null"); // should never happen

      this.cachedListOfReplications = null; // clear the cache

   }

  

   public static byte[] getContent(InputStream is) throws IOException, ClassNotFoundException {

      int ret = 0;

      byte[] buf = new byte[1024];

      ByteArrayOutputStream baos = new ByteArrayOutputStream();

      try {

         while ( (ret=is.read(buf)) > -1) {

            baos.write(buf, 0, ret);

         }

      }

      catch (IOException ex) {

         ex.printStackTrace();

         return new byte[0];

      }

      return baos.toByteArray();

   }

  

   private String processDeadLetter(UpdateQos qos) {

      String receiver = qos.getClientProperty(Constants.CLIENTPROPERTY_DEADMSGRECEIVER, (String)null);

      // the receiver is the absolute name so we need to cut it since the keys are the relative name:

      if (receiver == null)

         return "OK";

      int pos = receiver.indexOf("client/");

      if (pos < 0)

         return "OK";

      String key = receiver.substring(pos).trim();

      I_ReplSlave slave = null;

      synchronized(this.replSlaveMap) {

         slave = (I_ReplSlave)this.replSlaveMap.get(key);

      }

      slave.onDeadLetter(qos.getClientProperties());

      return "OK";

   }

  

   /**

    * It receives events from all ReplicationConverter instances which want to register themselves for

    * administration of initial updates.

    *

    * @see org.xmlBlaster.client.I_Callback#update(java.lang.String, org.xmlBlaster.client.key.UpdateKey, byte[], org.xmlBlaster.client.qos.UpdateQos)

    */

   public String update(String cbSessionId, UpdateKey updateKey, byte[] content, UpdateQos updateQos) throws XmlBlasterException {

      try {

         // check first if deadLetter ...

         if (Constants.OID_DEAD_LETTER.equals(updateKey.getOid()))

            return processDeadLetter(updateQos);

        

         InputStream is = MomEventEngine.decompress(new ByteArrayInputStream(content), updateQos.getClientProperties());

         content = getContent(is);

         SessionName senderSession = updateQos.getSender();

         String request = updateQos.getClientProperty("_command", "");

         log.info("The master Replicator with session '" + senderSession.getRelativeName() + "' is sending '" + request + "'");

         if ("broadcastSql".equalsIgnoreCase(request)) {

            try {

               final boolean highPrio = true;

               String requestId = updateQos.getClientProperty("requestId", (String)null);

               if (requestId == null)

                  throw new Exception("The requestId has not been defined");

               String repl =  updateQos.getClientProperty(REPL_PREFIX_KEY, REPL_PREFIX_DEFAULT);

               String sql =  new String(content);

               sendBroadcastRequest(repl, sql, highPrio, requestId);

               return "OK";

            }

            catch (Throwable ex) {

               ex.printStackTrace();

               log.severe("An exception occured during an sql broadcast message:" + ex.getMessage() + "' will continue anyway to avoid stopping dispatcher");

               return "OK"; // we don't want to stop the dispatcher

            }

         }

         else if ("removeBroadcast".equalsIgnoreCase(request)) {

            try {

               removeSqlStatement(new String(content));

               return "OK";

            }

            catch (Throwable ex) {

               ex.printStackTrace();

               log.severe("An exception occured when removing an sql broadcast:" + ex.getMessage() + "' will continue anyway to avoid stopping dispatcher");

               return "OK"; // we don't want to stop the dispatcher

            }

         }

         // 1. This is a response from an sql statement which has been previously sent to the slaves.

         else if (this.sqlTopic != null && updateKey.getOid().equals(this.sqlTopic)) {

            ClientProperty prop = (ClientProperty)updateQos.getClientProperties().get(STATEMENT_ID_ATTR);

            if (prop == null) {

               log.severe("The statement id is not specified, can not process it");

               return "OK"; // we don't want to stop the dispatcher

            }

            String reqId = prop.getStringValue();

            SqlStatement sqlStatement = (SqlStatement)this.sqlStatementMap.get(reqId);

            if (sqlStatement == null) {

               log.severe("The statement with id '" + reqId + "' has not been found");

               return "OK"; // we don't want to stop the dispatcher

            }

            prop = (ClientProperty)updateQos.getClientProperties().get(EXCEPTION_ATTR);

            String response = null;

            boolean isException = false;

            if (prop != null) {

               response = prop.getStringValue();

               isException = true;

            }

            prop = (ClientProperty)updateQos.getClientProperties().get(MASTER_ATTR);

            if (prop != null) { // then it is the response from the master

               String replPrefix = prop.getStringValue();

               if (response == null)

                  response = new String(content);

               sqlStatement.setResponse(replPrefix, response, isException);

            }

            else {

               if (response == null)

                  response = new String(content);

               sqlStatement.setResponse(senderSession.getRelativeName(), response, isException);

            }

         }

         // 2. This is the response coming from a DbWatcher on a request for initial update which one of the ReplSlaves has previously requested.

         else if ("INITIAL_DATA_RESPONSE".equals(request)) {

            long minReplKey = updateQos.getClientProperty("_minReplKey", 0L);

            long maxReplKey = updateQos.getClientProperty("_maxReplKey", 0L);

            try {

               String completeSlaveName = updateQos.getClientProperty("_slaveName", (String)null);

               if (completeSlaveName == null)

                  log.severe("on initial data response the slave name was not specified. Can not perform operation");

               else {

                  String[] slaveNames = StringPairTokenizer.parseLine(completeSlaveName, ',');

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

                     I_ReplSlave slave = null;

                     synchronized (this.replSlaveMap) {

                        slave = (I_ReplSlave)this.replSlaveMap.get(slaveNames[i]);

                     }

                     if (slave == null)

                        log.severe("on initial data response the slave name '" + slaveNames[i] + "' was not registered (could have already logged out)");

                     else

                        slave.reactivateDestination(minReplKey, maxReplKey);

                  }

               }

            }

            catch (Exception ex) {

               log.warning("reactivateDestination encountered an exception '" + ex.getMessage());

            }

         }

         else if ("INITIATE_REPLICATION".equals(request)) {

            String slaveSessionName = updateQos.getClientProperty("_slaveSessionName", (String)null);

            String prefixWithVersion = updateQos.getClientProperty("_prefixWithVersion", (String)null);

            String cascadeSlaveSessionName = updateQos.getClientProperty("_cascadeSlaveSessionName", (String)null);

            String cascadeReplicationPrefix = updateQos.getClientProperty("_cascadeReplicationPrefix", (String)null);

            String realInitialFilesLocation = updateQos.getClientProperty("_realInitialFilesLocation", (String)null);

            boolean force = updateQos.getClientProperty("_force", false);

            if (force) {

               I_ReplSlave slave = null;

               try {

                  synchronized (this.replSlaveMap) {

                     slave = (I_ReplSlave)this.replSlaveMap.get(slaveSessionName);

                  }

                  if (slave != null)

                     slave.cancelInitialUpdate(false);

               }

               catch (Throwable ex) {

                  log.severe("Could not cancel initial update for slave '" + slave.getSessionName() + "'");

                  ex.printStackTrace();

               }

            }

            String ret = initiateReplication(slaveSessionName, prefixWithVersion, cascadeSlaveSessionName, cascadeReplicationPrefix, realInitialFilesLocation);

            log.info(ret);

         }

         return "OK";

      }

      catch (Throwable ex) {

         ex.printStackTrace();

         log.severe("Throwable occured in the update method of ReplManagerPlugin");

         // throw new XmlBlasterException(this.global, ErrorCode.USER_UPDATE_HOLDBACK, "XmlBlasterPublisher.update", "user exception", ex);

         return "OK"; // we don't want to stop the dispatcher

      }

   }

  

  

   // enforced by I_MsgDispatchInterceptor

  

   /**

    * This method is invoked always so see sessionAdded javadoc.

    * @see org.xmlBlaster.util.dispatch.plugins.I_MsgDispatchInterceptor#addDispatchManager(org.xmlBlaster.util.dispatch.DispatchManager)

    */

   public void addDispatchManager(DispatchManager dispatchManager) {

      /*

      try {

         SessionName sessionName = dispatchManager.getSessionName();

         if (sessionName == null) {

            log.severe("The sessionName is null: "   + dispatchManager.toXml(""));

            Thread.dumpStack();

         }

         else {

            log.info("Adding dispatch Manager for '" + sessionName + "'");

            String relativeSessionName = sessionName.getRelativeName();

            I_ReplSlave slave = new ReplSlave(this.global, this.pool, this, relativeSessionName);

            synchronized (this.replSlaveMap) {

               this.replSlaveMap.put(relativeSessionName, slave);

            }

         }

      }

      catch (XmlBlasterException ex) {

         ex.printStackTrace();

      }

      */

   }

   public String getInstanceName() {

      return this.instanceName;

   }

  

   /**

    * @see org.xmlBlaster.util.dispatch.plugins.I_MsgDispatchInterceptor#doActivate(org.xmlBlaster.util.dispatch.DispatchManager)

    */

   public boolean doActivate(DispatchManager dispatchManager) {

      if (dispatchManager.getDispatchConnectionsHandler().isPolling()) {

         log.fine("Can't send message as connection is lost and we are polling");

         return false;

      }

      return true;

   }

   /**

    * TODO implement this

    * @param slave

    */

   private final int getMaxNumOfEntries(I_ReplSlave slave) {

      if (slave == null)

         return this.maxNumOfEntries;

      int max = slave.getMaxNumOfEntries();

      if (max < 1)

         return this.maxNumOfEntries;

      else