src/org/objectweb/cjdbc/controller/jmx/RmiConnector.java

説明を見る。

package org.objectweb.cjdbc.controller.jmx;

import java.net.InetAddress;
import java.net.UnknownHostException;
import java.rmi.Remote;
import java.rmi.registry.LocateRegistry;
import java.rmi.server.UnicastRemoteObject;
import java.util.ArrayList;
import java.util.Date;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.List;

import javax.management.Notification;
import javax.management.remote.JMXAuthenticator;
import javax.management.remote.JMXConnectorServer;
import javax.management.remote.rmi.RMIConnectorServer;
import javax.naming.Context;

import org.objectweb.cjdbc.common.i18n.Translate;
import org.objectweb.cjdbc.common.jmx.JmxException;
import org.objectweb.cjdbc.common.jmx.notifications.JmxNotification;
import org.objectweb.cjdbc.common.log.Trace;
import org.objectweb.cjdbc.common.net.RMISSLClientSocketFactory;
import org.objectweb.cjdbc.common.net.RMISSLServerSocketFactory;
import org.objectweb.cjdbc.common.net.SSLConfiguration;
import org.objectweb.cjdbc.common.net.SocketFactoryFactory;
import org.objectweb.cjdbc.controller.authentication.PasswordAuthenticator;

public class RmiConnector
{
  static Trace               logger        = Trace
                                               .getLogger("org.objectweb.cjdbc.controller.jmx");

  private String             controllerName;
  private String             hostName;
  private int                port;
  private JMXAuthenticator   authenticator;
  private SSLConfiguration   sslConfig;

  private JMXConnectorServer connection;
  private Remote             rmiRegistry;

  private static List        rmiConnectors = new ArrayList();

  public RmiConnector(String controllerName, String hostName, int port,
      JMXAuthenticator authenticator, SSLConfiguration sslConfig)
      throws JmxException
  {
    if (hostName != null)
    {
      this.hostName = hostName;
    }
    else
    {
      try
      {
        this.hostName = InetAddress.getLocalHost().getHostName();
      }
      catch (UnknownHostException ex)
      {
        throw new JmxException(ex);
      }
    }
    this.controllerName = controllerName;
    this.port = port;
    this.authenticator = authenticator;
    this.sslConfig = sslConfig;

    addRmiConnector(this);
  }

  public JMXAuthenticator getAuthenticator()
  {
    return authenticator;
  }

  public void setAuthenticator(JMXAuthenticator authenticator)
  {
    this.authenticator = authenticator;
  }

  public int getPort()
  {
    return port;
  }

  public void setPort(int port)
  {
    this.port = port;
  }

  public SSLConfiguration getSslConfig()
  {
    return sslConfig;
  }

  public void setSslConfig(SSLConfiguration sslConfig)
  {
    this.sslConfig = sslConfig;
  }

  public JMXConnectorServer getConnection()
  {
    return connection;
  }

  public void start() throws JmxException
  {
    createNamingService();
    createJRMPAdaptor();
  }

  public void stop() throws JmxException
  {
    try
    {
      if (connection != null)
        connection.stop();
      if (rmiRegistry != null)
        UnicastRemoteObject.unexportObject(rmiRegistry, true);
    }
    catch (Exception e)
    {
      throw new JmxException(e);
    }
    finally
    {
      connection = null;
      rmiRegistry = null;
    }
  }

  private void createNamingService() throws JmxException
  {
    try
    {
      // create and start the naming service
      logger.info(Translate.get("jmx.create.naming.service", new String[]{""
          + port}));
      rmiRegistry = LocateRegistry.createRegistry(port);
    }
    catch (Exception e)
    {
      throw new JmxException(e);
    }
  }

  private void createJRMPAdaptor() throws JmxException
  {
    try
    {
      // create the JRMP adaptator
      logger.info(Translate.get("jmx.create.jrmp.adaptor", "" + port));

      // Set the jndi name with which it will be registered
      // JNDI properties
      logger.debug(Translate.get("jmx.prepare.jndi"));

      javax.management.remote.JMXServiceURL address = new javax.management.remote.JMXServiceURL(
          "rmi", hostName, 0, "/jndi/jrmp");

      java.util.Map environment = new java.util.HashMap();
      environment.put(Context.INITIAL_CONTEXT_FACTORY,
          "com.sun.jndi.rmi.registry.RegistryContextFactory");
      environment.put(Context.PROVIDER_URL, "rmi://" + hostName + ":" + port);

      if (authenticator == null)
      {
        authenticator = PasswordAuthenticator.NO_AUTHENICATION;
      }

      if (authenticator != null)
      {
        environment.put(JMXConnectorServer.AUTHENTICATOR, authenticator);
      }

      // ssl enabled ?
      if (sslConfig != null)
      {
        logger.info(Translate.get("jmx.create.jrmp.ssl.enabled"));

        RMISSLClientSocketFactory csf = new RMISSLClientSocketFactory();
        RMISSLServerSocketFactory ssf = new RMISSLServerSocketFactory(
            SocketFactoryFactory.createServerFactory(sslConfig));
        environment.put(RMIConnectorServer.RMI_CLIENT_SOCKET_FACTORY_ATTRIBUTE,
            csf);
        environment.put(RMIConnectorServer.RMI_SERVER_SOCKET_FACTORY_ATTRIBUTE,
            ssf);
      }

      connection = javax.management.remote.JMXConnectorServerFactory
          .newJMXConnectorServer(address, environment, MBeanServerManager
              .getInstance());

      connection.start();
    }
    catch (Exception e)
    {
      throw new JmxException(e);
    }
  }

  public static List getRmiConnectors()
  {
    return rmiConnectors;
  }

  private static synchronized void addRmiConnector(RmiConnector pRmiConnector)
  {
    rmiConnectors.add(pRmiConnector);
  }

  public String getControllerName()
  {
    return controllerName;
  }

  public String getHostName()
  {
    return hostName;
  }

  private Date            myDate;
  private long            time;
  private JmxNotification cjdbcNotification;
  private Notification    notification;
  private static long     sequence = 0;

  public synchronized void sendNotification(AbstractStandardMBean mbean,
      String type, String priority, String description, Hashtable data)
  {

    myDate = new Date();
    time = myDate.getTime();

    cjdbcNotification = new JmxNotification(priority, "" + sequence, type,
        description, "" + time, controllerName, mbean.getClass().getName(),
        "mbeanName", hostName, "" + port, data);
    notification = new Notification(type, mbean, sequence, myDate.getTime(),
        description);
    notification.setUserData(cjdbcNotification.toString());
    mbean.sendNotification(notification);
  }

  public static void broadcastNotification(AbstractStandardMBean mbean,
      String type, String priority, String description, Hashtable data)
  {
    sequence++;
    logger.info("Sending notification:" + description + "(Message No:"
        + sequence + ")");
    Iterator iter = rmiConnectors.iterator();
    RmiConnector rmi;
    while (iter.hasNext())
    {
      rmi = ((RmiConnector) iter.next());
      rmi.sendNotification(mbean, type, priority, description, data);
    }
  }
}

---