src/org/objectweb/cjdbc/controller/monitoring/datacollector/DataCollector.java

説明を見る。

package org.objectweb.cjdbc.controller.monitoring.datacollector;

import java.util.ArrayList;

import javax.management.NotCompliantMBeanException;
import javax.management.ObjectName;

import org.objectweb.cjdbc.common.exceptions.DataCollectorException;
import org.objectweb.cjdbc.common.exceptions.ExceptionTypes;
import org.objectweb.cjdbc.common.i18n.Translate;
import org.objectweb.cjdbc.common.jmx.JmxConstants;
import org.objectweb.cjdbc.common.jmx.JmxException;
import org.objectweb.cjdbc.common.jmx.mbeans.DataCollectorMBean;
import org.objectweb.cjdbc.common.log.Trace;
import org.objectweb.cjdbc.common.monitor.AbstractDataCollector;
import org.objectweb.cjdbc.common.monitor.DataCollection;
import org.objectweb.cjdbc.common.monitor.backend.ActiveConnectionsCollector;
import org.objectweb.cjdbc.common.monitor.backend.ActiveTransactionCollector;
import org.objectweb.cjdbc.common.monitor.backend.PendingRequestsCollector;
import org.objectweb.cjdbc.common.monitor.backend.ReadRequestsCollector;
import org.objectweb.cjdbc.common.monitor.backend.RequestsCollector;
import org.objectweb.cjdbc.common.monitor.backend.TransactionsCollector;
import org.objectweb.cjdbc.common.monitor.backend.WriteRequestsCollector;
import org.objectweb.cjdbc.common.monitor.cache.CacheEntriesCollector;
import org.objectweb.cjdbc.common.monitor.cache.CountHitsCollector;
import org.objectweb.cjdbc.common.monitor.cache.CountInsertCollector;
import org.objectweb.cjdbc.common.monitor.cache.CountSelectCollector;
import org.objectweb.cjdbc.common.monitor.cache.HitsRatioCollector;
import org.objectweb.cjdbc.common.monitor.client.ClientActiveTimeCollector;
import org.objectweb.cjdbc.common.monitor.client.ClientBytesReadCollector;
import org.objectweb.cjdbc.common.monitor.client.ClientBytesWrittenCollector;
import org.objectweb.cjdbc.common.monitor.client.ClientReadingSpeedCollector;
import org.objectweb.cjdbc.common.monitor.client.ClientWritingSpeedCollector;
import org.objectweb.cjdbc.common.monitor.controller.ControllerIdleThreadsCollector;
import org.objectweb.cjdbc.common.monitor.controller.ControllerWorkerPendingQueueCollector;
import org.objectweb.cjdbc.common.monitor.controller.ThreadsCountCollector;
import org.objectweb.cjdbc.common.monitor.controller.TotalMemoryCollector;
import org.objectweb.cjdbc.common.monitor.controller.UsedMemoryCollector;
import org.objectweb.cjdbc.common.monitor.scheduler.NumberReadCollector;
import org.objectweb.cjdbc.common.monitor.scheduler.NumberRequestsCollector;
import org.objectweb.cjdbc.common.monitor.scheduler.NumberWriteCollector;
import org.objectweb.cjdbc.common.monitor.scheduler.PendingTransactionsCollector;
import org.objectweb.cjdbc.common.monitor.scheduler.PendingWritesCollector;
import org.objectweb.cjdbc.common.monitor.virtualdatabase.ActiveDatabaseThreadCollector;
import org.objectweb.cjdbc.common.monitor.virtualdatabase.DatabaseThreadsCollector;
import org.objectweb.cjdbc.common.monitor.virtualdatabase.PendingDatabaseConnectionCollector;
import org.objectweb.cjdbc.controller.backend.DatabaseBackend;
import org.objectweb.cjdbc.controller.cache.result.AbstractResultCache;
import org.objectweb.cjdbc.controller.core.Controller;
import org.objectweb.cjdbc.controller.jmx.AbstractStandardMBean;
import org.objectweb.cjdbc.controller.jmx.MBeanServerManager;
import org.objectweb.cjdbc.controller.recoverylog.AbstractRecoveryLog;
import org.objectweb.cjdbc.controller.scheduler.AbstractScheduler;
import org.objectweb.cjdbc.controller.virtualdatabase.VirtualDatabase;
import org.objectweb.cjdbc.controller.virtualdatabase.VirtualDatabaseWorkerThread;

public class DataCollector extends AbstractStandardMBean
    implements
      DataCollectorMBean,
      DataCollection
{
  static Trace logger = Trace.getLogger("org.objectweb.cjdbc.controller.jmx");
  Controller   controller;

  public DataCollector(Controller controller)
      throws NotCompliantMBeanException, JmxException
  {
    super(DataCollectorMBean.class);
    this.controller = controller;
    ObjectName objectName = JmxConstants.getDataCollectorObjectName();
    MBeanServerManager.registerMBean(this, objectName);

  }

  public String getAssociatedString()
  {
    return "datacollector";
  }

  private VirtualDatabase getVirtualDatabase(String name)
      throws DataCollectorException
  {
    VirtualDatabase vd = controller.getVirtualDatabase(name);
    if (vd == null)
      throw new DataCollectorException("Unknown Database");
    return vd;
  }

  public String[][] retrieveBackendsData() throws DataCollectorException
  {
    throw new DataCollectorException("Not Implemented");
  }

  public String[][] retrieveBackendsData(String virtualDatabasename)
      throws DataCollectorException
  {
    VirtualDatabase vdb = getVirtualDatabase(virtualDatabasename);
    try
    {
      vdb.acquireReadLockBackendLists();
    }
    catch (InterruptedException e)
    {
      String msg = Translate.get("virtualdatabase.fail.read.lock", e);
      throw new DataCollectorException(msg);
    }
    ArrayList backends = vdb.getBackends();
    int backendListSize = backends.size();
    String[][] data = new String[backendListSize][];
    for (int i = 0; i < backendListSize; i++)
    {
      data[i] = ((DatabaseBackend) backends.get(i)).getBackendData();
    }
    vdb.releaseReadLockBackendLists();
    return data;
  }

  public String[][] retrieveCacheData() throws DataCollectorException
  {
    throw new DataCollectorException(ExceptionTypes.NOT_IMPLEMENTED);

  }

  public String[][] retrieveRecoveryLogData(String databaseName)
      throws DataCollectorException
  {
    VirtualDatabase vdb = getVirtualDatabase(databaseName);
    AbstractRecoveryLog log = vdb.getRequestManager().getRecoveryLog();
    if (log == null)
      throw new DataCollectorException(ExceptionTypes.NO_RECOVERY_LOG);
    return log.getData();
  }

  public String[][] retrieveCacheData(String virtualDatabasename)
      throws DataCollectorException
  {
    VirtualDatabase vdb = getVirtualDatabase(virtualDatabasename);
    AbstractResultCache cache = vdb.getRequestManager().getResultCache();
    if (cache == null)
      throw new DataCollectorException(ExceptionTypes.NO_CACHE_ENABLED);
    else
    {
      try
      {
        return cache.getCacheData();
      }
      catch (Exception e)
      {
        throw new DataCollectorException(e.getMessage());
      }
    }
  }

  public String[][] retrieveCacheStatsData() throws DataCollectorException
  {
    throw new DataCollectorException(ExceptionTypes.NOT_IMPLEMENTED);
  }

  public String[][] retrieveCacheStatsData(String virtualDatabasename)
      throws DataCollectorException
  {
    VirtualDatabase vdb = getVirtualDatabase(virtualDatabasename);
    AbstractResultCache cache = vdb.getRequestManager().getResultCache();
    if (cache == null)
      throw new DataCollectorException("No Cache enabled.");
    else
    {
      try
      {
        return cache.getCacheStatsData();
      }
      catch (Exception e)
      {
        throw new DataCollectorException(e.getMessage());
      }
    }
  }

  public String[][] retrieveClientsData() throws DataCollectorException
  {
    throw new DataCollectorException("Not Implemented");
  }

  public String[][] retrieveClientsData(String virtualDatabasename)
      throws DataCollectorException
  {
    VirtualDatabase vdb = getVirtualDatabase(virtualDatabasename);
    ArrayList activeThreads = vdb.getActiveThreads();
    int size = activeThreads.size();
    String[][] data = new String[size][];
    for (int i = 0; i < size; i++)
    {
      data[i] = ((VirtualDatabaseWorkerThread) activeThreads.get(i))
          .retrieveClientData();
    }
    return data;
  }

  public String[][] retrieveControllerLoadData()
  {
    long total = Runtime.getRuntime().totalMemory();
    long free = Runtime.getRuntime().freeMemory();
    String[][] data = new String[1][6];
    data[0][0] = controller.getIPAddress();
    data[0][1] = "" + total / 1024 / 1024;
    data[0][2] = "" + (total - free) / 1024 / 1024;
    data[0][3] = "" + Thread.activeCount();
    data[0][4] = ""
        + controller.getConnectionThread()
            .getControllerServerThreadPendingQueueSize();
    data[0][5] = "" + controller.getConnectionThread().getIdleWorkerThreads();
    return data;
  }

  public String[][] retrieveSQLStats() throws DataCollectorException
  {
    throw new DataCollectorException("Not Implemented");
  }

  public String[][] retrieveSQLStats(String virtualDatabasename)
      throws DataCollectorException
  {
    VirtualDatabase vdb = getVirtualDatabase(virtualDatabasename);
    if (vdb.getSQLMonitor() == null)
      throw new DataCollectorException("No SQL monitoring enabled.");
    else
      return vdb.getSQLMonitor().getAllStatsInformation();
  }

  public String[][] retrieveVirtualDatabasesData()
  {
    ArrayList dbs = controller.getVirtualDatabases();
    int size = dbs.size();
    String[][] data = new String[size][4];
    VirtualDatabase db;
    for (int i = 0; i < size; i++)
    {
      db = (VirtualDatabase) dbs.get(i);
      data[i][0] = db.getName();
      data[i][1] = "" + db.getActiveThreads().size();
      data[i][2] = "" + db.getPendingConnections().size();
      data[i][3] = "" + db.getCurrentNbOfThreads();
    }
    return data;
  }

  public Controller getController()
  {
    return controller;
  }

  public String[][] retrieveSchedulerData(String virtualDatabasename)
      throws DataCollectorException
  {
    VirtualDatabase vdb = getVirtualDatabase(virtualDatabasename);
    AbstractScheduler scheduler = vdb.getRequestManager().getScheduler();
    String[][] data = new String[1][];
    data[0] = scheduler.getSchedulerData();
    return data;
  }

  public AbstractDataCollector retrieveDataCollectorInstance(int dataType,
      String targetName, String virtualDbName) throws DataCollectorException
  {
    switch (dataType)
    {
      /*
       * Controller Collectors
       */
      case CONTROLLER_TOTAL_MEMORY :
        return new TotalMemoryCollector(controller);
      case CONTROLLER_USED_MEMORY :
        return new UsedMemoryCollector(controller);
      case CONTROLLER_WORKER_PENDING_QUEUE :
        return new ControllerWorkerPendingQueueCollector(controller);
      case CONTROLLER_THREADS_NUMBER :
        return new ThreadsCountCollector(controller);
      case CONTROLLER_IDLE_WORKER_THREADS :
        return new ControllerIdleThreadsCollector(controller);
      /*
       * Backend collectors
       */
      case BACKEND_ACTIVE_TRANSACTION :
        return new ActiveTransactionCollector(targetName, virtualDbName);
      case BACKEND_PENDING_REQUESTS :
        return new PendingRequestsCollector(targetName, virtualDbName);
      case BACKEND_TOTAL_ACTIVE_CONNECTIONS :
        return new ActiveConnectionsCollector(targetName, virtualDbName);
      case BACKEND_TOTAL_REQUEST :
        return new RequestsCollector(targetName, virtualDbName);
      case BACKEND_TOTAL_READ_REQUEST :
        return new ReadRequestsCollector(targetName, virtualDbName);
      case BACKEND_TOTAL_WRITE_REQUEST :
        return new WriteRequestsCollector(targetName, virtualDbName);
      case BACKEND_TOTAL_TRANSACTIONS :
        return new TransactionsCollector(targetName, virtualDbName);
      /*
       * VirtualDatabase collectors
       */
      case DATABASES_ACTIVE_THREADS :
        return new ActiveDatabaseThreadCollector(virtualDbName);
      case DATABASES_PENDING_CONNECTIONS :
        return new PendingDatabaseConnectionCollector(virtualDbName);
      case DATABASES_NUMBER_OF_THREADS :
        return new DatabaseThreadsCollector(virtualDbName);
      /*
       * Cache stats collectors
       */
      case CACHE_STATS_COUNT_HITS :
        return new CountHitsCollector(virtualDbName);
      case CACHE_STATS_COUNT_INSERT :
        return new CountInsertCollector(virtualDbName);
      case CACHE_STATS_COUNT_SELECT :
        return new CountSelectCollector(virtualDbName);
      case CACHE_STATS_HITS_PERCENTAGE :
        return new HitsRatioCollector(virtualDbName);
      case CACHE_STATS_NUMBER_ENTRIES :
        return new CacheEntriesCollector(virtualDbName);
      /*
       * Scheduler collectors
       */
      case SCHEDULER_NUMBER_READ :
        return new NumberReadCollector(virtualDbName);
      case SCHEDULER_NUMBER_REQUESTS :
        return new NumberRequestsCollector(virtualDbName);
      case SCHEDULER_NUMBER_WRITES :
        return new NumberWriteCollector(virtualDbName);
      case SCHEDULER_PENDING_TRANSACTIONS :
        return new PendingTransactionsCollector(virtualDbName);
      case SCHEDULER_PENDING_WRITES :
        return new PendingWritesCollector(virtualDbName);
      /*
       * Client collectors
       */
      case CLIENT_BYTES_READ :
        return new ClientBytesReadCollector(virtualDbName, targetName);
      case CLIENT_BYTES_WRITTEN :
        return new ClientBytesWrittenCollector(virtualDbName, targetName);
      case CLIENT_TIME_ACTIVE :
        return new ClientActiveTimeCollector(virtualDbName, targetName);
      case CLIENT_READING_SPEED :
        return new ClientReadingSpeedCollector(virtualDbName, targetName);
      case CLIENT_WRITING_SPEED :
        return new ClientWritingSpeedCollector(virtualDbName, targetName);
      /*
       * Unknown collector
       */
      default :
        throw new DataCollectorException(ExceptionTypes.INVALID_COLLECTOR_TYPE);
    }
  }

  public long retrieveData(AbstractDataCollector collector)
      throws DataCollectorException
  {
    // Get the new value and return it
    // recall reference to controller (is transient in collector)
    collector.setController(controller);
    return collector.collectValue();
  }

  public boolean hasVirtualDatabase(String name)
  {
    return controller.hasVirtualDatabase(name);
  }
}

---