superchannelcontrollerimpl.java.svn-base

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

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

import java.io.IOException;
import java.rmi.RemoteException;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
import java.rmi.server.UnicastRemoteObject;
import java.util.Collection;
import java.util.Date;
import java.util.Hashtable;
import java.util.LinkedList;
import java.util.List;
import java.util.Set;
import java.util.UUID;
import java.util.concurrent.atomic.AtomicReference;

import org.apache.commons.configuration.Configuration;
import org.apache.log4j.Logger;

import com.infobank.superchannel.admin.controller.DatabaseCacheController;
import com.infobank.superchannel.admin.controller.MessageLauncherController;
import com.infobank.superchannel.admin.controller.SuperChannelController;
import com.infobank.superchannel.admin.monitor.ChannelStatusMonitor;
import com.infobank.superchannel.admin.monitor.DatabaseCacheStatusMonitor;
import com.infobank.superchannel.admin.monitor.MessageLauncherStatusMonitor;
import com.infobank.superchannel.admin.monitor.implementation.DatabaseCacheStatusMonitorImpl;
import com.infobank.superchannel.daemon.controller.SuperChannelControllerDaemon;
import com.infobank.superchannel.daemon.databasecache.DatabaseCacheDaemon;
import com.infobank.superchannel.daemon.databasecache.DatabaseCache;
import com.infobank.superchannel.daemon.messagelauncher.MessageLauncherDaemon;
import com.infobank.superchannel.pojo.ControllerUserToken;
import com.infobank.superchannel.util.DaemonConfiguration;

public class SuperChannelControllerImpl implements SuperChannelController {
  //当前已登陆用户
  private Hashtable<UUID,ControllerUserToken> currentUsers=new Hashtable<UUID,ControllerUserToken>();

  private ControllerUserToken internalUserToken;

  private String internalUserTokenString;
  
  private long timeout=0;

  private Object controllerMutex=new Object();

  private String preprocessString(String value){
    return value.replace('\n',' ').replace('\r',' ').replaceAll(" +"," ");
  }

  public DebugSetting loadDebugSetting(String basePath, DaemonConfiguration config){
    StringBuilder sb=new StringBuilder();
    sb.append(basePath);
    sb.append("/@enabled");
    boolean debugEnabled=config.getBoolean(sb.toString());
    if(debugEnabled){
      sb=new StringBuilder();
      sb.append(basePath);
      sb.append("/agent");
      String agent=config.getString(sb.toString());

      sb=new StringBuilder();
      sb.append(basePath);
      sb.append("/transport");
      String transport=config.getString(sb.toString());

      sb=new StringBuilder();
      sb.append(basePath);
      sb.append("/address");
      String address=config.getString(sb.toString());

      sb=new StringBuilder();
      sb.append(basePath);
      sb.append("/server");
      boolean server=config.getBoolean(sb.toString());

      sb=new StringBuilder();
      sb.append(basePath);
      sb.append("/suspend");
      boolean suspend=config.getBoolean(sb.toString());
      return new DebugSetting(agent,transport,address,server,suspend);
    }else{
      return new DebugSetting();
    }
  }


  private class DebugSetting{
    private boolean enabled=true;
    private String agent;
    private String transport;
    private String address;
    private boolean server;
    private boolean suspend;

    private DebugSetting(){
      enabled=false;
    }
    
    private DebugSetting(String agent, String transport, String address,
        boolean server, boolean suspend){
      enabled=true;
      this.agent=agent;
      this.transport=transport;
      this.address=address;
      this.server=server;
      this.suspend=suspend;
    }

    public String toString(){
      if(!enabled){
        return "";
      }

      StringBuilder sb=new StringBuilder();
      sb.append("-agentlib:");
      sb.append(agent); 
      sb.append("=transport=");
      sb.append(transport);
      sb.append(",address=");
      sb.append(address);
      sb.append(",server=");
      if(server){
        sb.append("y");
      }else{
        sb.append("n");
      }
      sb.append(",suspend=");
      if(suspend){
        sb.append("y");
      }else{
        sb.append("n");
      }
      sb.append(" ");
      return sb.toString(); 
    }
  }

  private class DatabaseCacheSet{
    private DatabaseCacheSet(String jvmHome,
                             String jvmArgs,
                             String appArgs,
                             String cp,
                             String mc,
                             DebugSetting debug){
      this.daemon=null;
      this.controller=null;
      this.monitor=null;
      this.process=null;
      this.jvmHome=preprocessString(jvmHome);
      this.jvmArguments=preprocessString(jvmArgs);
      this.applicationArguments=preprocessString(appArgs);
      this.classPath=preprocessString(cp);
      this.mainClass=preprocessString(mc);
      this.debug=debug;
    }

    private DatabaseCache daemon;
    private DatabaseCacheController controller;
    private DatabaseCacheStatusMonitor monitor;
    private Process process;
    private String jvmHome;
    private String jvmArguments;
    private String applicationArguments;
    private String classPath;
    private String mainClass;
    private DebugSetting debug;
  }

  private AtomicReference<DatabaseCacheSet> databaseCache=new AtomicReference<DatabaseCacheSet>(null);

  private class MessageLauncherSet{
    private MessageLauncherSet(String jvmHome,
                               String jvmArgs,
                               String appArgs,
                               String cp,
                               String mc,
                               String tag,
                               DebugSetting debug){
      this.controller=null;
      this.monitor=null;
      this.channelMonitor=null;
      this.process=null;
      this.jvmHome=preprocessString(jvmHome);
      this.jvmArguments=preprocessString(jvmArgs);
      this.applicationArguments=preprocessString(appArgs);
      this.classPath=preprocessString(cp);
      this.mainClass=preprocessString(mc);
      this.tag=tag;
      this.debug=debug;
    }
    private MessageLauncherController controller;
    private MessageLauncherStatusMonitor monitor;
    private ChannelStatusMonitor channelMonitor;
    private Process process;
    private String jvmHome;
    private String jvmArguments;
    private String applicationArguments;
    private String classPath;
    private String mainClass;
    private String tag;
    private DebugSetting debug;
  }
  private Hashtable<String, MessageLauncherSet> messageLauncherMap=new Hashtable<String, MessageLauncherSet> ();
  
  private Logger logger=Logger.getLogger(SuperChannelControllerDaemon.class);

  private void evictTimeoutUser(){
    Collection<ControllerUserToken> tokens=currentUsers.values();
    long now=(new Date()).getTime();
    for(ControllerUserToken token:tokens){
      if((token.heartbeatTime.getTime()+timeout)<now){
        // timeout user
        currentUsers.remove(token.sid);
        try{
          synchronized(controllerMutex){
            databaseCache.get().monitor.detach(token);
            Collection<MessageLauncherSet> mls=messageLauncherMap.values();
            for(MessageLauncherSet ml:mls){
              ml.monitor.detach(token);
              ml.channelMonitor.detach(token);
            }
          }
        }
        catch(RemoteException ex){
        }
      }
    }
  }

  private String classPath=null;
  
  private class Evictor extends Thread{
    private SuperChannelControllerImpl impl=null;
    private int interval=0;
    public Evictor(SuperChannelControllerImpl impl){
      this.impl=impl;
      DaemonConfiguration config=DaemonConfiguration.getInstance();
      interval=config.getInt("/daemon[@type='SuperChannel']/security/evictor/interval");
      start();
    }

    public void run(){
      while(true){
        try{
          sleep(interval);
        }catch(InterruptedException ex){
          return;
        }
        
        impl.evictTimeoutUser();
      }
    }
  }
  
  public SuperChannelControllerImpl(ControllerUserToken internalUserToken, 
      long timeout,String classPath){
    this.internalUserToken=internalUserToken;
    this.internalUserTokenString=internalUserToken.sid.toString();
    this.timeout=timeout;
    this.classPath=classPath;

    DaemonConfiguration config=DaemonConfiguration.getInstance();

    String pathSeparator=System.getProperty("path.separator");

    String basePath="/daemon[@type='DatabaseCache']/jvm/";
    StringBuilder sb=new StringBuilder();

    // create DatabaseCacheSet and MessageLauncherSet
    sb.append(basePath);
    sb.append("@home");
    String jvmHome=config.getString(sb.toString());

    sb=new StringBuilder();
    sb.append(basePath);
    sb.append("debug");
    DebugSetting debug=loadDebugSetting(sb.toString(),config);

    sb=new StringBuilder();
    sb.append(basePath);
    sb.append("main");
    String mc=config.getString(sb.toString());

    sb=new StringBuilder();
    sb.append(basePath);
    sb.append("classpath");
    String cp=config.getString(sb.toString());
    if(cp==null)
      cp="";

    sb=new StringBuilder();
    sb.append(basePath);
    sb.append("arguments[@type='JVM']");
    String jvmArgs=config.getString(sb.toString());
    if(jvmArgs==null)
      jvmArgs="";

    sb=new StringBuilder();
    sb.append(basePath);
    sb.append("arguments[@type='Application']");
    String appArgs=config.getString(sb.toString());
    if(appArgs==null)
      appArgs="";

    cp=cp.trim();
    if(!cp.isEmpty()){
      sb=new StringBuilder();
      sb.append(classPath);
      sb.append(pathSeparator);
      sb.append(cp);
      cp=sb.toString();
    }else{
      cp=classPath;
    }
    databaseCache.set(new DatabaseCacheSet(jvmHome,jvmArgs,appArgs,cp,mc,debug));

    int numberOfMessageLaunchers=config.getMaxIndex("/daemon[@type='MessageLauncher']/jvm")+1;
    for(int idx=1; idx<=numberOfMessageLaunchers; ++idx){
      sb=new StringBuilder();
      sb.append("/daemon[@type='MessageLauncher'][");
      sb.append(idx);
      sb.append("]/@tag");
      String tag=config.getString(sb.toString());

      sb=new StringBuilder();
      sb.append("/daemon[@type='MessageLauncher' and @tag='");
      sb.append(tag);
      sb.append("']/jvm/");
      basePath=sb.toString();

      sb.append("@home");
      jvmHome=config.getString(sb.toString());
      if(jvmHome==null)
        jvmHome="";

      sb=new StringBuilder();
      sb.append(basePath);
      sb.append("debug");
      debug=loadDebugSetting(sb.toString(),config);

      sb=new StringBuilder();
      sb.append(basePath);
      sb.append("main");
      mc=config.getString(sb.toString());
      if(mc==null)
        mc="";

      sb=new StringBuilder();
      sb.append(basePath);
      sb.append("classpath");
      cp=config.getString(sb.toString());
      if(cp==null)
        cp="";

      sb=new StringBuilder();
      sb.append(basePath);
      sb.append("arguments[@type='JVM']");
      jvmArgs=config.getString(sb.toString());
      if(jvmArgs==null)
        jvmArgs="";
      
      sb=new StringBuilder();
      sb.append(basePath);
      sb.append("arguments[@type='Application']");
      appArgs=config.getString(sb.toString());
      if(appArgs==null)
        appArgs="";

      cp=cp.trim();
      if(cp.isEmpty()){
        sb=new StringBuilder();
        sb.append(classPath);
        sb.append(pathSeparator);
        sb.append(cp);
        cp=sb.toString();
      }else{
        cp=classPath;
      }
      MessageLauncherSet mls=new MessageLauncherSet(jvmHome,jvmArgs,appArgs,cp,mc,tag,debug);

      messageLauncherMap.put(tag,mls); 
    }
  }

  public DatabaseCacheController getDatabaseCacheController(
      ControllerUserToken token){
      if(!isValidToken(token))
        throw new RuntimeException("invalid user token");
    synchronized(controllerMutex){
      return databaseCache.get().controller;
    }
  }

  public MessageLauncherController getMessageLauncherController(
      ControllerUserToken token,String tag){
      if(!isValidToken(token))
        throw new RuntimeException("invalid user token");

      synchronized(controllerMutex){
    MessageLauncherSet mls=messageLauncherMap.get(tag);
    if(mls!=null)
      return mls.controller;
    return null;
    }
  }

  public List<MessageLauncherController> getAllMessageLauncherController(
      ControllerUserToken token){
    if(!isValidToken(token))
        throw new RuntimeException("invalid user token");

    List<MessageLauncherController> result=null;
    synchronized(controllerMutex){
    if(messageLauncherMap.isEmpty())
      return null;
    result=new LinkedList<MessageLauncherController>();
    Collection<MessageLauncherSet> mls=messageLauncherMap.values();
    for(MessageLauncherSet ml:mls){
      result.add(ml.controller);
    }
    return result;
    }
  }

  public ControllerUserToken logon(String username, String password){
      ControllerUserToken token=new ControllerUserToken(username);
      synchronized(controllerMutex){
        if(databaseCache.get().controller!=null){
          try{
            databaseCache.get().monitor.attach(token);
          }catch(RemoteException ex){
            return null;
          }
        }

        if(!messageLauncherMap.isEmpty()){
          try{
            Collection<MessageLauncherSet> mls=messageLauncherMap.values();
            for(MessageLauncherSet ml:mls){
              if(ml.controller==null)
                continue;
              ml.channelMonitor.attach(token);
              ml.monitor.attach(token);
            }
          }
          catch(RemoteException ex){
            try{
              databaseCache.get().monitor.detach(token);
            }
            catch(RemoteException rex){
            }
            return null;
          }
      }
      
      synchronized(currentUsers){
        currentUsers.put(token.sid, token);
      }
      
      return token;
    }
  }

  public boolean logout(ControllerUserToken token){
    synchronized(currentUsers){
      if(!currentUsers.contains(token))
        return false;
    }
      
    synchronized(controllerMutex){
      if(databaseCache.get()!=null){
        try{
          databaseCache.get().monitor.detach(token);
        }catch(RemoteException ex){
          return false;
        }
      }
      
      if(!messageLauncherMap.isEmpty()){
        try{
          Collection<MessageLauncherSet> mls=messageLauncherMap.values();
          for(MessageLauncherSet ml:mls){
            ml.channelMonitor.detach(token);
            ml.monitor.detach(token);