src/org/objectweb/cjdbc/console/jmx/RmiJmxClient.java

説明を見る。

package org.objectweb.cjdbc.console.jmx;

import java.io.IOException;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

import javax.management.InstanceNotFoundException;
import javax.management.MBeanServerConnection;
import javax.management.MBeanServerInvocationHandler;
import javax.management.NotificationListener;
import javax.management.ObjectName;
import javax.management.remote.JMXConnector;
import javax.management.remote.JMXConnectorFactory;
import javax.management.remote.JMXServiceURL;
import javax.naming.Context;
import javax.security.auth.Subject;

import org.objectweb.cjdbc.common.exceptions.VirtualDatabaseException;
import org.objectweb.cjdbc.common.jmx.JmxConstants;
import org.objectweb.cjdbc.common.jmx.mbeans.ControllerMBean;
import org.objectweb.cjdbc.common.jmx.mbeans.DataCollectorMBean;
import org.objectweb.cjdbc.common.jmx.mbeans.DatabaseBackendMBean;
import org.objectweb.cjdbc.common.jmx.mbeans.VirtualDatabaseMBean;
import org.objectweb.cjdbc.common.users.AdminUser;
import org.objectweb.cjdbc.controller.authentication.PasswordAuthenticator;

public class RmiJmxClient
{
  private JMXConnector         connector;
  private Object               credentials;
  private String               remoteHostAddress;
  private String               remoteHostPort;

  private NotificationListener notificationListener;

  // List of last used MBeans
  private ControllerMBean      controllerMBean;
  private VirtualDatabaseMBean virtualDbMBean;
  private DatabaseBackendMBean backendMBean;
  private DataCollectorMBean   dataMBean;

  public NotificationListener getNotificationListener()
  {
    return notificationListener;
  }

  public void setNotificationListener(NotificationListener notificationListener)
  {
    this.notificationListener = notificationListener;
  }

  public Object getCredentials()
  {
    return credentials;
  }

  public RmiJmxClient(String port, String host, String jmxUser,
      String jmxPassword) throws IOException
  {
    this(port, host, PasswordAuthenticator.createCredentials(jmxUser,
        jmxPassword));
  }

  public RmiJmxClient(String url, Object credentials) throws IOException
  {
    int index = url.indexOf(":");
    String ip = url.substring(0, index);
    String port = url.substring(index + 1);
    connect(port, ip, credentials);
  }

  public RmiJmxClient(String port, String host, Object credentials)
      throws IOException
  {
    connect(port, host, credentials);
  }

  public void connect(String port, String host, Object credentials)
      throws IOException
  {
    JMXServiceURL address = new JMXServiceURL("rmi", host, 0, "/jndi/jrmp");

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

    // use username and password for authentication of connections
    // with the controller, the values are compared to the ones
    // specified in the controller.xml config file.
    if (credentials != null)
    {
      // this line is not required if no username/password has been configered
      environment.put(JMXConnector.CREDENTIALS, credentials);
    }

    this.credentials = credentials;

    connector = JMXConnectorFactory.connect(address, environment);
    remoteHostAddress = host;
    remoteHostPort = port;
  }

  public VirtualDatabaseMBean getVirtualDatabaseProxy(String database,
      String user, String password) throws InstanceNotFoundException,
      IOException, VirtualDatabaseException
  {
    if (virtualDbMBean != null && isValidConnection()
        && virtualDbMBean.getName().equals(database))
    {
      return virtualDbMBean;
    }
    else
    {
      ObjectName db = JmxConstants.getVirtualDbObjectName(database);

      // we build a subject for authentication
      AdminUser dbUser = new AdminUser(user, password);
      Set principals = new HashSet();
      principals.add(dbUser);
      Subject subj = new Subject(true, principals, new HashSet(), new HashSet());

      // we open a connection for this subject, all subsequent calls with this
      // connection will be executed on the behalf of our subject.
      MBeanServerConnection delegateConnection = connector
          .getMBeanServerConnection(subj);

      // we create a proxy to the virtual database
      VirtualDatabaseMBean local = (VirtualDatabaseMBean) MBeanServerInvocationHandler
          .newProxyInstance(delegateConnection, db, VirtualDatabaseMBean.class,
              false);

      // Check authentication
      boolean authenticated = false;
      try
      {
        authenticated = local.checkAdminAuthentication(user, password);
      }
      catch (Exception e)
      {
        throw new VirtualDatabaseException(
            "Could not check authentication. MBean is not accessible.");
      }
      if (!authenticated)
        throw new VirtualDatabaseException("Authentication Failed");

      // Add notification listener
      if (notificationListener != null)
      {
        delegateConnection.addNotificationListener(db, notificationListener,
            null, null);
      }

      this.virtualDbMBean = local;

      return virtualDbMBean;
    }
  }

  public ControllerMBean getControllerProxy() throws InstanceNotFoundException,
      IOException
  {

    if (controllerMBean != null && isValidConnection())
    {
      return controllerMBean;
    }
    else
    {
      ObjectName db = JmxConstants.getControllerObjectName();

      // we create a new proxy to the controller
      controllerMBean = (ControllerMBean) MBeanServerInvocationHandler
          .newProxyInstance(connector.getMBeanServerConnection(), db,
              ControllerMBean.class, false);

      // Add notification listener
      if (notificationListener != null)
      {
        connector.getMBeanServerConnection().addNotificationListener(db,
            notificationListener, null, null);
      }

      return controllerMBean;
    }
  }

  public DataCollectorMBean getDataCollectorProxy() throws IOException
  {

    if (dataMBean != null && isValidConnection())
    {
      return dataMBean;
    }
    else
    {
      ObjectName db = JmxConstants.getDataCollectorObjectName();

      // we create a new proxy to the data collector
      dataMBean = (DataCollectorMBean) MBeanServerInvocationHandler
          .newProxyInstance(connector.getMBeanServerConnection(), db,
              DataCollectorMBean.class, false);
      return dataMBean;
    }
  }

  public DatabaseBackendMBean getDatabaseBackendProxy(String vdb,
      String backend, String user, String password)
      throws InstanceNotFoundException, IOException
  {
    if (backendMBean != null && isValidConnection())
    {
      try
      {
        if (backendMBean.getName().equals(backend))
          return backendMBean;
      }
      catch (Exception e)
      {
        // backend is no more there
      }
    }

    // we build a subject for authentication
    AdminUser dbUser = new AdminUser(user, password);
    Set principals = new HashSet();
    principals.add(dbUser);
    Subject subj = new Subject(true, principals, new HashSet(), new HashSet());

    ObjectName db = JmxConstants.getDatabaseBackendObjectName(vdb, backend);
    MBeanServerConnection delegateConnection = connector
        .getMBeanServerConnection(subj);

    if (notificationListener != null)
    {
      delegateConnection.addNotificationListener(db, notificationListener,
          null, null);
    }

    // we create a proxy to the database backend
    backendMBean = (DatabaseBackendMBean) MBeanServerInvocationHandler
        .newProxyInstance(delegateConnection, db, DatabaseBackendMBean.class,
            false);
    return backendMBean;
  }

  public String getRemoteName()
  {
    return remoteHostAddress + ":" + remoteHostPort;
  }

  public String getRemoteHostAddress()
  {
    return remoteHostAddress;
  }

  public String getRemoteHostPort()
  {
    return remoteHostPort;
  }

  public void reconnect() throws Exception
  {
    connect(remoteHostPort, remoteHostAddress, credentials);
  }

  public boolean isValidConnection()
  {
    try
    {
      connector.getMBeanServerConnection().getMBeanCount();
      return true;
    }
    catch (Exception e)
    {
      controllerMBean = null;
      backendMBean = null;
      virtualDbMBean = null;
      dataMBean = null;
      return false;
    }
  }
}

---