databasecachecontrollerimpl.java.svn-base

监控整个SP系统的SMS信息通道的发送情况并且生成日志。 支持权限判断。

package com.infobank.superchannel.admin.controller.implementation;

import java.rmi.NoSuchObjectException;
import java.rmi.NotBoundException;
import java.rmi.RemoteException;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
import java.rmi.server.UnicastRemoteObject;
import java.util.Hashtable;
import java.util.UUID;
import java.util.concurrent.atomic.AtomicReference;

import org.apache.commons.configuration.Configuration;

import com.infobank.superchannel.admin.controller.DatabaseCacheController;
import com.infobank.superchannel.admin.controller.SuperChannelController;
import com.infobank.superchannel.admin.monitor.DatabaseCacheStatusMonitor;
import com.infobank.superchannel.admin.monitor.implementation.DatabaseCacheStatusMonitorImpl;
import com.infobank.superchannel.daemon.databasecache.DatabaseCache;
import com.infobank.superchannel.daemon.databasecache.DatabaseCacheDaemon;
import com.infobank.superchannel.pojo.ControllerUserToken;
import com.infobank.superchannel.util.DaemonConfiguration;

/**
 * @author Xiaoguang Sun
 * @version 类说明: 数据库缓冲服务器的控制器实现
 */
public class DatabaseCacheControllerImpl implements DatabaseCacheController {
  // 数据库缓冲服务器对象
  private AtomicReference<DatabaseCacheDaemon> daemon=new AtomicReference<DatabaseCacheDaemon>();

  // 数据库缓冲服务器状态监控器
  private DatabaseCacheStatusMonitor monitor=null;
  
  //super channel controller
  private SuperChannelController superChannelController=null;

    // keep a strong reference to DatabaseCache and DatabaseCacheController proxy
    private DatabaseCache databaseCacheProxy=null;
    private DatabaseCacheController databaseCacheControllerProxy=null;

  /**
   * 验证当前用户访问令牌的合法性
   * @param token 用户访问令牌
   * @return 是否合法 
   */
  private boolean verify(ControllerUserToken token){
    if(daemon.get()==null)
      return false;
    try{
      return superChannelController.isValidToken(token);
    }catch(RemoteException ex){
      return false;
    }
  }

  /**
   * 构造函数
   * @param daemon 数据库缓冲服务器对象
   */
  public DatabaseCacheControllerImpl(DatabaseCacheDaemon daemon){
    DaemonConfiguration config=DaemonConfiguration.getInstance();
    String superChannelControllerEndpoint=config.getString("/daemon[@type='SuperChannel']/endpoint/@name");

    this.daemon.set(daemon);

    try{
      Registry registry=LocateRegistry.getRegistry(null);
      superChannelController=(SuperChannelController) registry.lookup(superChannelControllerEndpoint);
      databaseCacheProxy=(DatabaseCache)UnicastRemoteObject.exportObject(daemon, 0);
      databaseCacheControllerProxy=(DatabaseCacheController)UnicastRemoteObject.exportObject(this, 0);
          
      monitor=new DatabaseCacheStatusMonitorImpl(daemon);

      superChannelController.setDatabaseCache(daemon.getInternalUserToken(),
                                              databaseCacheProxy,
                                              databaseCacheControllerProxy);

    }
    catch(NotBoundException ex){
      ex.printStackTrace();
      throw new RuntimeException("fatal error: could not locate super channel controller from registry");
    }
    catch(RemoteException ex){
      ex.printStackTrace();
      throw new RuntimeException("fatal error: could not bind controller to registry");
    }
  }

  /**
   * 获取数据库缓冲服务器的状态监控器对象
   * @param token 用户访问令牌
   * @return 状态监控器对象
   */
  public DatabaseCacheStatusMonitor getStatusMonitor(ControllerUserToken token) {
    if(!verify(token))
      return null;
    return monitor;
  }

  /**
   * 暂停数据库缓冲服务器
   * @param token 用户访问令牌
   * @return 操作是否成功
   */
  public boolean pause(ControllerUserToken token){
    if(!verify(token))
      return false;
    return daemon.get().pause();
  }

  /**
   * 重新读取数据库缓冲服务器配置
   * @param token 用户访问令牌
   * @return 操作是否成功
   */
  public boolean reload(ControllerUserToken token){
    if(!verify(token))
      return false;
    return daemon.get().reload();
  }

  /**
   * 重新启动数据库缓冲服务器
   * @param token 用户访问令牌
   * @return 操作是否成功
   */
  public boolean restart(ControllerUserToken token){
    if(!verify(token))
      return false;
    return daemon.get().restart();
  }

  /**
   * 继续暂停的数据库缓冲服务器
   * @param token 用户访问令牌
   * @return 操作是否成功
   */
  public boolean resume(ControllerUserToken token){
    if(!verify(token))
      return false;
    return daemon.get().resume();
  }

  /**
   * 停止数据库缓冲服务器
   * @param token 用户访问令牌
   * @return 操作是否成功
   */
  public boolean stop(ControllerUserToken token){
    if(!verify(token))
      return false;
    boolean result=daemon.get().stop();
    if(result){
      try{
          while(!UnicastRemoteObject.unexportObject(this, true)){
            Thread.sleep(1000);
          }
      }catch(NoSuchObjectException ex){
        return false;
      }
      catch(InterruptedException ex){
        return false;
      }

      System.exit(0);
    }
    return false;
  }
}