/*
    *  Copyright 2010 Felix Roethenbacher
    *
    *  Licensed under the Apache License, Version 2.0 (the "License");
    *  you may not use this file except in compliance with the License.
    *  You may obtain a copy of the License at
    *
    *      http://www.apache.org/licenses/LICENSE-2.0
    *
   *  Unless required by applicable law or agreed to in writing, software
   *  distributed under the License is distributed on an "AS IS" BASIS,
   *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   *  See the License for the specific language governing permissions and
   *  limitations under the License.
   */
  package ch.syabru.nagios.broker.jmx;
  
  import java.io.IOException;
  
  import javax.management.ListenerNotFoundException;
  import javax.management.MBeanServerConnection;
  import javax.management.Notification;
  import javax.management.NotificationListener;
  import javax.management.ObjectName;
  import javax.management.remote.JMXConnectionNotification;
  import javax.management.remote.JMXConnector;
  import javax.management.remote.JMXConnectorFactory;
  import javax.management.remote.JMXServiceURL;
  
  import org.apache.commons.lang.Validate;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  import ch.syabru.nagios.broker.Message;
  import ch.syabru.nagios.broker.MessageHandler;
  import ch.syabru.nagios.broker.MessageListener;
  import ch.syabru.nagios.broker.MessageListenerManager;
  
  /**
   * JMX message listener implementation.
   *
   * @author Felix Roethenbacher
   *
   */
  public class JmxMessageListener
  implements MessageListener, NotificationListener
  {
      private final Logger logger = LoggerFactory.getLogger(this.getClass());
  
      private MessageListenerManager messageListenerManager;
      private MessageHandler messageHandler;
      private JMXServiceURL jmxServiceUrl;
      private ObjectName objectName;
  
      private JMXConnector connector;
      private String id;
  
      /**
       * C'tor.
       * @param messageListenerManager Message listener manager.
       * @param messageHandler Message handler.
       * @param jmxServiceUrl JMX service URL.
       * @param objectName Object name.
       */
      public JmxMessageListener(MessageListenerManager messageListenerManager,
              MessageHandler messageHandler, JMXServiceURL jmxServiceUrl,
              ObjectName objectName)
      {
          Validate.notNull(messageListenerManager,
                  "messageListenerManager must not be null");
          Validate.notNull(messageHandler, "messageHandler must not be null");
          Validate.notNull(jmxServiceUrl, "jmxServiceUrl must not be null");
          Validate.notNull(objectName, "objectName must not be null");
          this.messageListenerManager = messageListenerManager;
          this.messageHandler = messageHandler;
          this.jmxServiceUrl = jmxServiceUrl;
          this.objectName = objectName;
          this.id = "JMX listener " + jmxServiceUrl + ", " +
                  objectName.toString();
      }
  
      @Override
      public String getId() {
          return id;
      }
  
      @Override
      public void registerListener()
      {
          try {
              connector = JMXConnectorFactory.connect(jmxServiceUrl);
              connector.addConnectionNotificationListener(this, null, null);
              MBeanServerConnection con = connector.getMBeanServerConnection();
              con.addNotificationListener(objectName, this, null, null);
              logger.info("Registered JMX notification listener [{}]", getId());
          } catch (Exception e) {
              logger.warn("Failed to register JMX notification listener. " +
                      "Will retry later. [{}] [{}]", new Object[] {getId(),
                      e.getMessage()});
             messageListenerManager.addForReconnect(this);
         }
     }
 
     /**
      * Remove notification listeners.
      */
     @Override
     public void unregisterListener() {
         if (connector != null) {
             try {
                 connector.removeConnectionNotificationListener(this);
             } catch (ListenerNotFoundException e) {
                 logger.debug("Error removing connection notification " +
                         "listener", e);
             }
             try {
                 MBeanServerConnection con =
                     connector.getMBeanServerConnection();
                 con.removeNotificationListener(objectName, this);
                 logger.debug("Unregistered notification listener [{}]",
                         getId());
             } catch (ListenerNotFoundException e) {
                 // Do nothing. MBean probably already unregistered.
             } catch (Exception e) {
                 logger.debug("Error removing notification listener", e);
             }
             try {
                 connector.close();
             } catch (IOException e) {
                 logger.debug("Error closing JMX connection", e);
             }
         }
     }
 
     @Override
     public void handleNotification(Notification notification, Object handback)
     {
         // Connection notifications.
         if (notification instanceof JMXConnectionNotification) {
             JMXConnectionNotification connNotification =
                 (JMXConnectionNotification) notification;
             if (connNotification.getType().equals(
                     JMXConnectionNotification.CLOSED))
             {
                 logger.warn("Connection closed. Will retry later to " +
                         "re-register listener. [{}]", getId());
                 messageListenerManager.addForReconnect(this);
             } else if (connNotification.getType().equals(
                     JMXConnectionNotification.FAILED))
             {
                 logger.warn("Connection failed. Will retry later to " +
                         "re-register listener. [{}]", getId());
                 messageListenerManager.addForReconnect(this);
             }
         } else {
             try {
                 Message message = new JmxMessage(notification);
                 // TODO Move this to separate thread as call should end as
                 // quick as possible.
                 messageHandler.messageReceived(message);
             } catch (Exception e) {
                 logger.error("Error handling JMX notification", e);
             }
         }
     }
 }