Name:      EventPlugin.java

Project:   xmlBlaster.org

Copyright: xmlBlaster.org, see xmlBlaster-LICENSE file

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

* Registers for events from the xmlBlaster core and forwards them as

* configured.

* <p>

* This is useful for clients or administrators to be notified on certain core

* events.

* </p>

* <p>

* This <tt>EventPlugin</tt> plugin is started with the run level manager as

* configured in <code>xmlBlasterPlugins.xml</code>, for example:

* </p>

*

* <pre>

* lt;plugin id='EventPlugin' className='org.xmlBlaster.engine.EventPlugin'&gt;

*   &lt;action do='LOAD' onStartupRunlevel='7' sequence='11'

*                        onFail='resource.configuration.pluginFailed'/&gt;

*   &lt;action do='STOP' onShutdownRunlevel='6' sequence='11'/&gt;

*   &lt;attribute id='eventTypes'&gt;

*      logging/severe/*,

*      logging/warning/*,

*      service/RunlevelManager/event/startupRunlevel8,

*      client/joe/session/1/event/connect

*   &lt;/attribute&gt;

*   &lt;attribute id='destination.smtp'&gt;

*      mail.smtp.from=xmlBlaster@localhost,

*      mail.smtp.to=demo@localhost,

*      mail.collectMillis=10000

*   &lt;/attribute&gt;

*   &lt;attribute id='destination.jmx'/&gt;

* lt;/plugin&gt;

* </pre>

*

* <p>

* In the above example an email is send if any logging/severe/* (==log/error)

* or logging/warning/* occurs. Further an event is emitted on xmlBlaster

* startup in run level 8 and if a new client logs in. Those events are send as

* JMX notifications as well. Adding <code>&lt;attribute id='destination.publish'/></code> would send the

* event as a xmlBlaster message as well, but take care to not send logging

* events as such messages will most certainly loop (if they log something they

* will trigger another message and so forth)!

* </p>

* <p>

* List of supported event sources, note that this plugin must be active on a

* runlevel early enough depending on the event you want to capture:

* </p>

* <table border="1">

* <tr>

* <td>logging/severe/*</td>

* <td>Captures all errors logged</td>

* </tr>

* <tr>

* <td>logging/warning/*</td>

* <td>Captures all warnings logged</td>

* </tr>

* <tr>

* <td>service/RunlevelManager/event/startupRunlevel9</td>

* <td>Captures event when startup run level reaches 9 (RUNNING), any other

* runlevel is possible as well (note that this plugin must be active

* beforehand)</td>

* </tr>

* <tr>

* <td>service/RunlevelManager/event/shutdownRunlevel8</td>

* <td>Captures event when shutdown runlevel reaches 8 (RUNNING_RPE), any other

* run level is possible as well (note that this plugin must be active

* beforehand)</td>

* </tr>

* <tr>

* <td>client/* /session/* /event/connect</td>

* <td>Captures event on client login (all clients)</td>

* </tr>

* <tr>

* <td>client/[subjectId]/session/[publicSessionId]/event/connect</td>

* <td>Captures event on given client login, e.g.

* "client/joe/session/1/event/connect"</td>

* </tr>

* <tr>

* <td>client/* /session/* /event/disconnect</td>

* <td>Captures event on client logout (all clients)</td>

* </tr>

* <tr>

* <td>client/[subjectId]/session/[publicSessionId]/event/disconnect</td>

* <td>Captures event on given client logout, e.g.

* "client/joe/session/1/event/disconnect"</td>

* </tr>

* <tr>

* <td>topic/* /event/subscribe</td>

* <td>Captures if subscribe() is invoked (on all topics)</td>

* </tr>

* <tr>

* <td>topic/[topicId]/event/subscribe</td>

* <td>Captures if subscribe() on the specified topic is invoked</td>

* </tr>

* <tr>

* <td>client/[subjectId]/session/[publicSessionId]/event/subscribe</td>

* <td>Captures if the given client has invoked subscribe(), e.g.

* "client/joe/session/1/event/subscribe". The publicSessionId can be a wildcard

* "*".</td>

* </tr>

* <tr>

* <td>topic/* /event/unSubscribe</td>

* <td>Captures if unSubscribe() is invoked (on all topics)</td>

* </tr>

* <tr>

* <td>topic/[topicId]/event/unSubscribe</td>

* <td>Captures if unSubscribe() on the specified topic is invoked</td>

* </tr>

* <tr>

* <td>client/[subjectId]/session/[publicSessionId]/event/unSubscribe</td>

* <td>Captures if the given client has invoked unSubscribe(), e.g.

* "client/joe/session/1/event/unSubscribe". The publicSessionId can be a

* wildcard "*".</td>

* </tr>

* <tr>

* <td>topic/* /event/alive</td>

* <td>Captures if a topic is created (on all topics)</td>

* </tr>

* <tr>

* <td>topic/hello/event/alive</td>

* <td>Captures event if the topic 'hello' is created</td>

* </tr>

* <tr>

* <td>topic/* /event/dead</td>

* <td>Captures if a topic is destroyed (on all topics)</td>

* </tr>

* <tr>

* <td>topic/hello/event/dead</td>

* <td>Captures event if the topic 'hello' is destroyed</td>

* </tr>

* <tr>

* <td>client/[subjectId]/session/[publicSessionId]/event/connectionState</td>

* <td>Captures event if the cluster client connection chages between ALIVE |

* POLLING | DEAD. Wildcards are supported.</td>

* </tr>

* <tr>

* <td>client/[subjectId]/session/[publicSessionId]/event/callbackState</td>

* <td>Captures event if the client callback server goes to ALIVE or POLLING.

* Note that the status change to DEAD is currently not implemented (it is

* reported as POLLING). Wildcards are not supported.</td>

* </tr>

* <tr>

* <td>heartbeat.360000</td>

* <td>Sends a heartbeat notification every given milli seconds. Setting

* <code>heartbeat</code> defaults to one notification per day (86400000

* millis).</td>

* </tr>

* </table>

* <p>

* List of supported event sinks:

* </p>

* <table border="1">

* <tr>

* <td>destination.smtp</td>

* <td>Sends an email about the occurred event. Collects multiple events to one

* mail depending on configuration. You need to configure at least the email

* address parameters <code>mail.stmp.from</code> and <code>mail.smtp.to</code>

* and activate the <code>SmtpClient</code> plugin in

* <code>xmlBlasterPlugins.xml</code>. If you have a reasonable email provider

* you can configure it to forward the mail as an SMS (mine offers this

* feature).</td>

* </tr>

* <tr>

* <td>destination.publish</td>

* <td>Publishes an xmlBlaster message which contains the occurred event,

* currently all messages are published into a topic named '__sys__Event'</td>

* </tr>

* <tr>

* <td>destination.jmx</td>

* <td>Emits an JMX notification for the occurred event. Open 'jconsole' and

* 'MBeans->org.xmlBlaster->node->xxx->service->EventPlugin[yyy]' there choose

* the 'Notifications[0]' tabulator and click the 'Subscribe' button. Now you

* receive the configured events.</td>

* </tr>

* </table>

*

* <p>

* We access the xmlBlaster core directly to register the supported internal

* events, hence this plugin works only if it is in the same virtual machine

* (JVM) as the xmlBlaster server.

* </p>

* <p>

* All events don't throw any exceptions as this plugin should have no influence

* on the regular work-flow of xmlBlaster.

* </p>

*

* @author <a href="mailto:xmlblast@marcelruff.info">Marcel Ruff</a>

* @see <a

*      href="http://www.xmlBlaster.org/xmlBlaster/doc/requirements/admin.events.html">The

*      admin.events requirement</a>

*/

      I_Plugin, EventPluginMBean, I_ClientListener, I_RunlevelListener,

      I_LogListener, I_SubscriptionListener, I_TopicListener,

      I_ConnectionStatusListener, I_RemotePropertiesListener, I_EventDispatcher, I_ConnectionStateListener, Comparable {

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

   private static Logger log = Logger.getLogger(EventPlugin.class.getName());

   /** My JMX registration */

   private Object mbeanHandle;

   private ContextNode contextNode;

   protected Global glob;

   protected I_PluginConfig pluginConfig;

   protected org.xmlBlaster.engine.ServerScope engineGlob;

   protected RequestBroker requestBroker;

   protected SessionInfo sessionInfo;

   protected boolean isActive;

   protected boolean isShutdown;

   protected String eventTypes;

   protected Set loggingSet;

   protected Set runlevelSet;

   protected Set clientSet;

   protected Set topicSet;

   protected Set pendingCallbackSessionInfoSet;

   protected Set callbackSessionStateSet;

   protected static int staticInstanceCounter;

   protected int instanceCounter;

   private String uniqueInstanceName;

  

   /**

    * Helper class to send emails

    */

   class SmtpDestinationHelper {

      private SmtpClient smtpClient;

      String to, from, subjectTemplate, cc, bcc, contentTemplate, contentSeparator;

      long collectIntervall = Constants.DAY_IN_MILLIS / 2;

     

      private boolean sendAsync = true;

     

      //private boolean blockOnOverflow = false;

      public SmtpDestinationHelper(SmtpClient smtpClient, String destination)

            throws XmlBlasterException {

         this.smtpClient = smtpClient;

         Map map = StringPairTokenizer.parseLineToProperties(destination);

         if (map.containsKey("mail.smtp.to"))

            this.to = (String) map.get("mail.smtp.to");

         verifyInternetAddress(this.to);

         if (map.containsKey("mail.smtp.from"))

            this.from = (String) map.get("mail.smtp.from");

         if (this.from == null)

            this.from = "xmlBlaster@localhost";

         verifyInternetAddress(this.from);

         // Each line of characters MUST be no more than 998 characters,

         // and SHOULD be no more than 78 characters, excluding the CRLF

         if (map.containsKey("mail.subject"))

            this.subjectTemplate = (String) map.get("mail.subject");

         else

            this.subjectTemplate = "[XmlBlaster event: $_{eventType}] $_{nodeId}";

            //this.subjectTemplate = "[XmlBlaster generated email] $_{nodeId} $_{summary}";

         if (map.containsKey("mail.content"))

            this.contentTemplate = (String) map.get("mail.content");

         else

            this.contentTemplate = "eventType:   $_{eventType}\ninstanceId:  $_{instanceId}\n\nsummary:     $_{summary}\ndescription: $_{description}\n\neventDate:   $_{datetime}\nversionInfo: $_{versionInfo}\n\n--\nhttp://www.xmlblaster.org/xmlBlaster/doc/requirements/admin.events.html";

         if (map.containsKey("mail.contentSeparator"))

            this.contentSeparator = (String) map.get("mail.contentSeparator");

         else

            this.contentSeparator = "\n\n========== NEXT ============\n\n";

         if (map.containsKey("mail.smtp.cc"))

            this.cc = (String) map.get("mail.smtp.cc");

         if (this.cc != null && this.cc.trim().length() > 0)

            verifyInternetAddress(this.cc);

         if (map.containsKey("mail.smtp.bcc"))

            this.bcc = (String) map.get("mail.smtp.bcc");

         if (this.bcc != null && this.bcc.trim().length() > 0)

            verifyInternetAddress(this.bcc);

         if (map.containsKey("mail.sendAsync")) {

            String tmp = (String) map.get("mail.sendAsync");

            this.sendAsync = Boolean.valueOf(tmp.trim()).booleanValue();

         }

         //if (map.containsKey("mail.blockOnOverflow")) {

         //   String tmp = (String) map.get("mail.blockOnOverflow");

         //   this.blockOnOverflow = Boolean.valueOf(tmp.trim()).booleanValue();

         //}

         if (map.containsKey("mail.collectMillis")) {

            String tmp = (String) map.get("mail.collectMillis");

            this.collectIntervall = Long.valueOf(tmp.trim()).longValue();

         }

         if (this.collectIntervall < 0) this.collectIntervall = 0;

      }

      EmailData createEmailData() {

         EmailData emailData = new EmailData(this.to, this.from,

               "", "");

         emailData.setCc(this.cc);

         emailData.setBcc(this.bcc);

         emailData.setSendAsync(this.sendAsync);

         // emailData.setExpiryTime(expiryTimestamp);

         // emailData.addAttachment(new AttachmentHolder(payloadFileName,

         // payloadMimetype, payload));

         return emailData;

      }

   } // end of helper class SmtpDestination

   protected SmtpClient smtpClient;

   protected final Object smtpDestinationMonitor = new Object();

   protected SmtpDestinationHelper smtpDestinationHelper;

   protected String smtpDestinationConfiguration;

   protected Timeout smtpTimeout;

   protected Timestamp smtpTimeoutHandle;

   protected EmailData currentEmailData;

   protected long heartbeatInterval;

   protected Timeout heartbeatTimeout;

   protected Timestamp heartbeatTimeoutHandle;

   /**

    * Helper class to publish messages.

    */

   class PublishDestinationHelper {

      String destination;

      String key, qos, keyOid;

      String contentTemplate;

      public PublishDestinationHelper(String destination) throws XmlBlasterException {

         Map map = StringPairTokenizer.parseLineToProperties(destination);

         if (map.containsKey("publish.key")) {

            this.key = (String) map.get("publish.key");

            MsgKeyData msgKey = engineGlob.getMsgKeyFactory().readObject(this.key);

            this.keyOid = msgKey.getOid();

         }

         if (map.containsKey("publish.qos"))

            this.qos = (String) map.get("publish.qos");

         if (map.containsKey("publish.content"))

            this.contentTemplate = (String) map.get("publish.content");

         else

            this.contentTemplate = "$_{eventType}";

      }

      String getKeyOid() {

         return this.keyOid;

      }

      MsgKeyData getPublishKey(String summary, String description,

            String eventType, String errorCode) throws XmlBlasterException {

         if (this.key != null) {

            return engineGlob.getMsgKeyFactory().readObject(this.key);

         }

         //PublishKey publishKey = new PublishKey(engineGlob, Constants.EVENT_OID_LOGIN/*"__sys__Login"*/, "text/plain");

         // TODO: invent an oid depending on the eventType:

         PublishKey publishKey = new PublishKey(engineGlob, "__sys__Event", "text/plain", "1.0");

         publishKey.setClientTags("<org.xmlBlaster><event/></org.xmlBlaster>");

         return publishKey.getData();

      }

      MsgQosData getPublishQos(String summary, String description,

            String eventType, String errorCode, SessionName sessionName) throws XmlBlasterException {

         MsgQosData msgQosData = null;

         if (this.qos != null) {

            msgQosData = engineGlob.getMsgQosFactory().readObject(this.qos);

         }

         else {

            PublishQos publishQos = new PublishQos(engineGlob);

            publishQos.setLifeTime(-1L);

            publishQos.setForceUpdate(true);

            // TODO: Configure history depth to 0 only on first publish

            TopicProperty topicProperty = new TopicProperty(engineGlob);

            HistoryQueueProperty historyQueueProperty = new HistoryQueueProperty(engineGlob, engineGlob.getId());

            historyQueueProperty.setMaxEntriesCache(2);

            historyQueueProperty.setMaxEntries(2);

            topicProperty.setHistoryQueueProperty(historyQueueProperty);

            publishQos.setTopicProperty(topicProperty);

            msgQosData = publishQos.getData();

         }

         if (summary != null && summary.length() > 0)

            msgQosData.addClientProperty(Constants.EVENTPLUGIN_PROP_SUMMARY, summary); // "_summary"

         if (description != null && description.length() > 0)

            msgQosData.addClientProperty(Constants.EVENTPLUGIN_PROP_DESCRIPTION, description);

         if (eventType != null && eventType.length() > 0)

            msgQosData.addClientProperty(Constants.EVENTPLUGIN_PROP_EVENTTYPE, eventType);

         if (errorCode != null && errorCode.length() > 0)

            msgQosData.addClientProperty(Constants.EVENTPLUGIN_PROP_ERRORCODE, errorCode);

         if (sessionName != null) {

            msgQosData.addClientProperty(Constants.EVENTPLUGIN_PROP_PUBSESSIONID,

                  sessionName.getPublicSessionId());

            msgQosData.addClientProperty(Constants.EVENTPLUGIN_PROP_SUBJECTID,

                  sessionName.getLoginName());

            msgQosData.addClientProperty(Constants.EVENTPLUGIN_PROP_ABSOLUTENAME,

                  sessionName.getAbsoluteName());

            /*

            // To be backwards compatible with loginEvent=true setting:

            // deprecated:

            msgQosData.addClientProperty("__publicSessionId",

                  sessionName.getPublicSessionId());

            msgQosData.addClientProperty("__subjectId",

                  sessionName.getLoginName());

            msgQosData.addClientProperty("__absoluteName",

                  sessionName.getAbsoluteName());

            // TODO: backwards compatible?

            //msgUnit.setContent(sessionName.getLoginName().getBytes());

            // To be backwards compatible with loginEvent=true setting:

            */

         }

         msgQosData.addClientProperty(Constants.EVENTPLUGIN_PROP_NODEID, engineGlob.getId());

         return msgQosData;

      }

      MsgUnit getMsgUnit(String summary, String description,

            String eventType, String errorCode, SessionName sessionName) throws XmlBlasterException {

         String content = replaceTokens(

            this.contentTemplate, summary, description, eventType, errorCode, sessionName);

         return new MsgUnit(

               getPublishKey(summary, description, eventType, errorCode),

               content.getBytes(),

               getPublishQos(summary, description, eventType, errorCode, sessionName));

      }

   }

   protected PublishDestinationHelper publishDestinationHelper;

   protected String publishDestinationConfiguration;

   /**

    * Helper class to send a JMX notification.

    */

   class JmxDestinationHelper {

      String destination;

      String contentTemplate;

      public JmxDestinationHelper(String destination) throws XmlBlasterException {

         Map map = StringPairTokenizer.parseLineToProperties(destination);

         if (map.containsKey("jmx.content"))

            this.contentTemplate = (String) map.get("jmx.content");

         else

            this.contentTemplate = "$_{eventType}: $_{summary}";

      }

      String getMessage(String summary, String description,

            String eventType, String errorCode, SessionName sessionName) throws XmlBlasterException {

         String content = replaceTokens(

            this.contentTemplate, summary, description, eventType, errorCode, sessionName);

         return content;

      }

   }

   protected JmxDestinationHelper jmxDestinationHelper;

   protected String jmxDestinationConfiguration;

   public EventPlugin() {

      synchronized (EventPlugin.class) {

         staticInstanceCounter++;

         this.instanceCounter = staticInstanceCounter;

         log.fine("instance #" + instanceCounter + " created");

      }

   }

   /**

    * Initializes the plugin

    *

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

    *      org.xmlBlaster.util.plugin.PluginInfo)

    */

   public void init(org.xmlBlaster.util.Global utilGlob, PluginInfo pluginInfo)

         throws XmlBlasterException {

      this.pluginConfig = pluginInfo;

      this.uniqueInstanceName = pluginInfo.getId() + "-" + instanceCounter;

      this.glob = utilGlob.getClone(utilGlob.getNativeConnectArgs());

      this.glob.addObjectEntry(Constants.OBJECT_ENTRY_ServerScope, utilGlob // "ServerNodeScope"

            .getObjectEntry(Constants.OBJECT_ENTRY_ServerScope));

      this.engineGlob = (org.xmlBlaster.engine.ServerScope) utilGlob

            .getObjectEntry(Constants.OBJECT_ENTRY_ServerScope);

      this.requestBroker = engineGlob.getRequestBroker();

      this.sessionInfo = requestBroker.getInternalSessionInfo();

      // For JMX instanceName may not contain ","

      this.contextNode = new ContextNode(ContextNode.SERVICE_MARKER_TAG,

            "EventPlugin[" + getType() + "]", this.engineGlob.getScopeContextNode());

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

      this.eventTypes = this.glob.get("eventTypes", "", null,

            this.pluginConfig);

      if (this.eventTypes == null || this.eventTypes.trim().length() == 0) {

         log.warning("Please configure an attribute 'eventTypes', there is nothing to do for us.");

         return;

      }

      this.eventTypes = this.eventTypes.trim();

      StringBuffer destLogStr = new StringBuffer(1024);

      // Sending the events with email?

      this.smtpDestinationConfiguration = this.glob.get("destination.smtp", "", null,

            this.pluginConfig);

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

         this.smtpDestinationConfiguration = this.smtpDestinationConfiguration.trim();

         setupSmtpSink(this.smtpDestinationConfiguration);

         if (destLogStr.length() > 0) destLogStr.append(",");

         destLogStr.append("destination.smtp");

         if (this.smtpDestinationConfiguration.length() > 0)

            destLogStr.append("(").append(this.smtpDestinationConfiguration).append(")");

      }

      // Sending the events with publish()?

      this.publishDestinationConfiguration = this.glob.get("destination.publish", (String)null, null,

            this.pluginConfig);

      if (this.publishDestinationConfiguration != null) {

         this.publishDestinationConfiguration = this.publishDestinationConfiguration.trim();

         this.publishDestinationHelper = new PublishDestinationHelper(this.publishDestinationConfiguration);

         if (destLogStr.length() > 0) destLogStr.append(",");

         destLogStr.append("destination.publish");

         if (this.publishDestinationConfiguration.length() > 0)

            destLogStr.append("(").append(this.publishDestinationConfiguration).append(")");

         if (this.eventTypes.indexOf("logging/severe/*") != -1 || this.eventTypes.indexOf("log/error/*") != -1)

            log.warning("The combination of 'destination.publish' with 'logging/severe/*' is dangerous as it could loop forever, it is supressed.");

         else if (this.eventTypes.indexOf("logging/severe/") != -1 || this.eventTypes.indexOf("log/error/") != -1)

            log.warning("The combination of 'destination.publish' with 'logging/severe/xyz' is dangerous as it could loop forever.");

         if (this.eventTypes.indexOf("logging/warning") != -1 || this.eventTypes.indexOf("logging/warn") != -1)

            log.warning("The combination of 'destination.publish' with 'logging/warning' is very dangerous as it could loop forever, it is supressed.");

      }

      // Sending the events as a JMX notification?

      this.jmxDestinationConfiguration = this.glob.get("destination.jmx", (String)null, null,

            this.pluginConfig);

      if (this.jmxDestinationConfiguration != null) {

         this.jmxDestinationConfiguration = this.jmxDestinationConfiguration.trim();

         this.jmxDestinationHelper = new JmxDestinationHelper(this.jmxDestinationConfiguration);

         if (destLogStr.length() > 0) destLogStr.append(",");

         destLogStr.append("destination.jmx");

         if (this.jmxDestinationConfiguration.length() > 0)

            destLogStr.append("(").append(this.jmxDestinationConfiguration).append(")");

      }

      if (destLogStr.length() < 1) {

         log.warning("Please configure a data sink attribute 'destination.*', there is nothing to do for us.");

         return;

      }

      this.isActive = true;

      registerEventTypes(this.eventTypes);

      log.info("Configured to send core events of type '" + this.eventTypes.trim()

            + "' to '" + destLogStr.toString() + "'");

   } // init()

   /**

    * Find out which events to listen.

    * @param eventTypes A commas seperated list of supported events, e.g. <code>logging/severe/*,logging/warning/*</code>

    */

   private void registerEventTypes(String eventTypes) throws XmlBlasterException {

      String[] eventTypeArr = StringPairTokenizer.parseLine(eventTypes);

      ServerScope serverScope = requestBroker.getServerScope();

      QueueEventHandler queueEventHandler = null;

      MapEventHandler mapEventHandler = null;

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

         String event = eventTypeArr[i].trim();

         if (event.length() < 1) continue; // Allow ',' at end

         try {

            // "logging/severe/*"

            // TODO: support specific channels as "logging/severe/*" -> "logging/severe/core"

            if (event.startsWith(ContextNode.LOGGING_MARKER_TAG+"/severe/")

                  || event.startsWith("logging/error/")) {

               // We want to be notified if a log.error() is called, this will

               // notify our LogableDevice.log() method

               XbNotifyHandler.instance().register(Level.SEVERE.intValue(), this);

               if (this.loggingSet == null) this.loggingSet = new TreeSet();

               this.loggingSet.add(event);

            }

            // "logging/warning/*"

            else if (event.startsWith(ContextNode.LOGGING_MARKER_TAG+"/warning/")

                  || event.startsWith("logging/warn/")) {

               XbNotifyHandler.instance().register(Level.WARNING.intValue(), this);

               if (this.loggingSet == null) this.loggingSet = new TreeSet();

               this.loggingSet.add(event);

            }

            // "service/RunlevelManager/event/startupRunlevel8", "service/RunlevelManager/event/shutdownRunlevel7"

            else if (event.startsWith(this.engineGlob.getRunlevelManager().getContextNode().getRelativeName()+"/event/")) {

               log.fine("Register event = " + event);

               this.engineGlob.getRunlevelManager().addRunlevelListener(this);

               if (this.runlevelSet == null) this.runlevelSet = new TreeSet();

               this.runlevelSet.add(event);

            }

            else if (isConnectionStateEvent(event)) {

               // client/[subjectId]/session/[publicSessionId]/event/connectionState

               ClusterManager clusterManager = requestBroker.getServerScope().getClusterManager();

               if (clusterManager == null) {

                  log.warning("Configuration of '" + event + "' is ignored, no cluster manager available");

                  continue;

               }

               if (!clusterManager.isReady()) {

                  log.warning("Configuration of '" + event + "' is ignored, cluster manager is not ready");

                  continue;

               }

               int index = event.lastIndexOf("/event/");

               if (index == -1) {

                  log.warning("Configuration of '" + event + "' is ignored, wrong syntax");

                  continue;

               }

               // strip "event/connectionState"

               String name = event.substring(0, index);

               ClusterNode[] nodes = clusterManager.getClusterNodes();

               for (int ic=0; ic<nodes.length; ic++) {

                  ClusterNode node = nodes[ic];

                  SessionName destination = node.getSessionName();

                  if (destination != null && destination.matchRelativeName(name)) {

                     node.registerConnectionListener(this);

                  }

               }

            }

            else if (isCallbackStateEvent(event)) {

            //else if (event.endsWith("/event/callbackState") || event.endsWith("/event/callbackAlive") || event.endsWith("/event/callbackPolling") || event.endsWith("/event/callbackDead")) {

               // OK: "client/joe/session/1/event/callbackState"

               // Not yet supported: "client/joe/session/1/event/callbackAlive", "client/joe/session/1/event/callbackPolling"

               int index = event.lastIndexOf("/event/");

               if (index == -1) {

                  log.warning("Configuration of '" + event + "' is ignored, wrong syntax");

                  continue;

               }

               String name = event.substring(0, index);

               SessionName sessionName = new SessionName(this.engineGlob, name);

               this.requestBroker.getAuthenticate().addClientListener(this);

               if (this.callbackSessionStateSet == null) this.callbackSessionStateSet = new TreeSet();

               if (event.startsWith(ContextNode.SUBJECT_MARKER_TAG+ContextNode.SEP+"*"+ContextNode.SEP) ||

                   event.endsWith(ContextNode.SESSION_MARKER_TAG+ContextNode.SEP+"*"+"/event/callbackState")) {