superchannelcontrollerimpl.java.svn-base

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

          }
        }
        catch(RemoteException ex){
          return false;
        }
      }
    }

    synchronized(currentUsers){
      currentUsers.remove(token.sid);
      return true;
    }
  }

  public boolean pause(ControllerUserToken token){
    if(!isValidToken(token))
        throw new RuntimeException("invalid user token");
    try{
    synchronized(controllerMutex){
        DatabaseCacheController dcc=databaseCache.get().controller;
      if(dcc!=null){
      if(!dcc.pause(token))
        return false;
      }
        
      if(!messageLauncherMap.isEmpty()){
      Collection<MessageLauncherSet> mls=messageLauncherMap.values();
      for(MessageLauncherSet ml:mls){
        if(!ml.controller.pause(token)){
        return false;
        }
      }
      }
      return true;
    }
    }catch(RemoteException ex){
    return false;
    }
  }

  public boolean reload(ControllerUserToken token){
    if(!isValidToken(token))
        throw new RuntimeException("invalid user token");
    try{
      synchronized(controllerMutex){
      DatabaseCacheController dcc=databaseCache.get().controller;
      if(dcc!=null){
      if(!dcc.reload(token))
        return false;
      }
        
      if(!messageLauncherMap.isEmpty()){
      Collection<MessageLauncherSet> mls=messageLauncherMap.values();
      for(MessageLauncherSet ml:mls){
        if(!ml.controller.reload(token)){
        return false;
        }
      }
      }
      return true;
    }
    }catch(RemoteException ex){
      return false;
    }
  }

  public boolean restart(ControllerUserToken token){
    if(!isValidToken(token))
        throw new RuntimeException("invalid user token");

    try{
      synchronized(controllerMutex){
        DatabaseCacheController dcc=databaseCache.get().controller;
        if(dcc!=null){
          if(!dcc.restart(token))
            return false;
        }
        
        if(!messageLauncherMap.isEmpty()){
          Collection<MessageLauncherSet> mls=messageLauncherMap.values();
          for(MessageLauncherSet ml:mls){
            if(!ml.controller.restart(token)){
              return false;
            }
          }
        }
        return true;
      }
    }catch(RemoteException ex){
      return false;
    }
  }

  public boolean resume(ControllerUserToken token){
    if(!isValidToken(token))
        throw new RuntimeException("invalid user token");
     
    try{
      synchronized(controllerMutex){
        DatabaseCacheController dcc=databaseCache.get().controller;
        if(dcc!=null){
          if(!dcc.resume(token))
            return false;
        }
        
        if(!messageLauncherMap.isEmpty()){
          Collection<MessageLauncherSet> mls=messageLauncherMap.values();
          for(MessageLauncherSet ml:mls){
            if(!ml.controller.resume(token)){
              return false;
            }
          }
        }
        return true;
      }
    }catch(RemoteException ex){
      return false;
    }
  }

  public boolean stop(ControllerUserToken token){
    if(!isValidToken(token))
        throw new RuntimeException("invalid user token");

      try{
    int exitCode=0;
    synchronized(controllerMutex){
      // stop message launcher first
      if(!messageLauncherMap.isEmpty()){
        Collection<MessageLauncherSet> mls=messageLauncherMap.values();
        for(MessageLauncherSet ml:mls){
          String tag=ml.controller.getMessageLauncherTag(token);
          if(!ml.controller.stop(token)){
            return false;
          }
          if(ml.process!=null){
            ml.process.destroy();
            try{
              exitCode=ml.process.waitFor();
            }
            catch(InterruptedException ex){
            }
            logger.info("MessageLauncherDaemon terminated with exit code "+exitCode);
            ml.process=null;
          }
          else{
            logger.info("MessageLauncherDaemon was not started by SuperChannelController. Can not get exit code this case");
          }

          messageLauncherMap.remove(tag);
        }
      }

      // stop database cache second
      DatabaseCacheController dcc=databaseCache.get().controller;
      if(dcc!=null){
        try{
          if(!dcc.stop(token))
            return false;
        }
        catch(RemoteException ex){
          return false;
        }
      }
      databaseCache.set(null);

      if(databaseCache.get().process!=null){
        databaseCache.get().process.destroy();
        try{
          exitCode=databaseCache.get().process.waitFor();
        }
        catch(InterruptedException ex){
        }
        logger.info("DatabaseCacheDaemon terminated with exit code "+exitCode);
        databaseCache.get().process=null;
      }else{
        logger.info("DatabaseCacheDaemon was not started by SuperChannelController. Can not get exit code this case");
      }
    }
      }
      catch(RemoteException ex){
      }
    // stop will always sucessful
    return true;
  }

  public boolean isValidToken(ControllerUserToken token){
    synchronized(currentUsers){
          if(currentUsers.containsKey(token.sid))
            return true;
          return internalUserToken.sid.equals(token.sid);
    }
  }

  public String getDatabaseCacheState(ControllerUserToken token){
    if(!isValidToken(token))
        throw new RuntimeException("invalid user token");

    try{
      synchronized(controllerMutex){
        return databaseCache.get().monitor.getState(internalUserToken);
      }
    }catch(RemoteException ex){
      return "Stopped";
    }
  }

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

    try{
      synchronized(controllerMutex){
        return databaseCache.get().monitor.getState(internalUserToken);
      }
    }catch(RemoteException ex){
      return "Stopped";
    }
  }

  public void setDatabaseCache(ControllerUserToken internalToken, DatabaseCache daemon, DatabaseCacheController controller){
    if(!isValidToken(internalToken))
        throw new RuntimeException("invalid user token");

    Collection<ControllerUserToken> tokens=null;
    
    synchronized(currentUsers){
      tokens=currentUsers.values();
    }

    synchronized(controllerMutex){
      try{
        databaseCache.get().daemon=daemon;
        databaseCache.get().controller=controller;
        databaseCache.get().monitor=controller.getStatusMonitor(internalUserToken);
        
        for(ControllerUserToken token:tokens){
          databaseCache.get().monitor.attach(token);
        }
      }
      catch(RemoteException ex){
      }
    }

    logger.info("Database Cache Daemon registered in system.");
  }

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

    Collection<ControllerUserToken> tokens=null;
    
    synchronized(currentUsers){
      tokens=currentUsers.values();
    }

    synchronized(controllerMutex){
      try{
        MessageLauncherSet ml=messageLauncherMap.get(tag);
        if(ml!=null){
          ml.controller=controller;
          ml.monitor=controller.getStatusMonitor(internalUserToken);
          ml.channelMonitor=controller.getChannelMonitor(internalUserToken);
        }else{
          // it does not exist. should not happen. 
        }

        for(ControllerUserToken token:tokens){
          ml.monitor.attach(token);
          ml.channelMonitor.attach(token);
        }
        messageLauncherMap.put(tag,ml);
      }catch(RemoteException ex){ 
      }
    }

    StringBuilder sb=new StringBuilder();
    sb.append("Message Launcher Daemon with tag'");
    sb.append(tag);
    sb.append("' is registered in system");

    logger.info(sb.toString());
  }

  public boolean heartbeat(ControllerUserToken token) {
    synchronized(currentUsers){
      ControllerUserToken aToken=currentUsers.get(token.sid);
      if(aToken==null)
        return false;

      aToken.heartbeatTime=new Date();
      currentUsers.put(aToken.sid,aToken);
    }
    return false;
  }

  public String getStartMessageLauncherCommand(ControllerUserToken token, String tag){
    synchronized(controllerMutex){
      MessageLauncherSet mls=messageLauncherMap.get(tag);
      if(mls==null)
        throw new RuntimeException("invalid tag");

      StringBuilder sb=new StringBuilder();
      sb.append(mls.jvmHome);
      sb.append("/bin/java -cp ");
      sb.append(mls.classPath);
      sb.append(" ");
      sb.append(mls.jvmArguments);
      sb.append(" -Dsuperchannel.home=");
      sb.append(System.getProperty("superchannel.home"));
      sb.append(" -Djava.rmi.server.codebase=");
      sb.append(System.getProperty("java.rmi.server.codebase"));
      sb.append(" -Dsun.rmi.dgc.client.gcInterval=");
      sb.append(System.getProperty("sun.rmi.dgc.client.gcInterval"));
      sb.append(" -Dsun.rmi.dgc.server.gcInterval=");
      sb.append(System.getProperty("sun.rmi.dgc.server.gcInterval"));
      sb.append(" ");
      sb.append(mls.debug);
      sb.append(mls.mainClass);
      if(!mls.debug.enabled){
        sb.append(" -noconsole ");
      }
      sb.append(" -tag ");
      sb.append(tag);
      sb.append(" -token ");
      sb.append(internalUserTokenString);
      if(!mls.applicationArguments.isEmpty()){
        sb.append(" ");
        sb.append(mls.applicationArguments);
      }
      return preprocessString(sb.toString());
    }
  }

  public String getStartDatabaseCacheCommand(ControllerUserToken token){
    StringBuilder sb=new StringBuilder();
    sb.append(databaseCache.get().jvmHome);
    sb.append("/bin/java -cp ");
    sb.append(databaseCache.get().classPath);
    sb.append(" ");
    sb.append(databaseCache.get().jvmArguments);
    sb.append(" -Dsuperchannel.home=");
    sb.append(System.getProperty("superchannel.home"));
    sb.append(" -Djava.rmi.server.codebase=");
    sb.append(System.getProperty("java.rmi.server.codebase"));
    sb.append(" -Dsun.rmi.dgc.client.gcInterval=");
    sb.append(System.getProperty("sun.rmi.dgc.client.gcInterval"));
    sb.append(" -Dsun.rmi.dgc.server.gcInterval=");
    sb.append(System.getProperty("sun.rmi.dgc.server.gcInterval"));
    sb.append(" ");
    sb.append(databaseCache.get().debug);
    sb.append(databaseCache.get().mainClass);
    if(!databaseCache.get().debug.enabled){
      // not debugging
      sb.append(" -noconsole ");
    }
    sb.append(" -token ");
    sb.append(internalUserTokenString);
    if(!databaseCache.get().applicationArguments.isEmpty()){
      sb.append(" ");
      sb.append(databaseCache.get().applicationArguments);
    }
    return preprocessString(sb.toString());
  }

  public boolean startDatabaseCache(ControllerUserToken token) {
    if(!isValidToken(token))
      throw new RuntimeException("invalid user token");

    synchronized(controllerMutex){
      databaseCache.get().daemon=null;
      databaseCache.get().controller=null;
      databaseCache.get().monitor=null;
 
      Runtime rt=Runtime.getRuntime();
      String cmd=getStartDatabaseCacheCommand(token);
      try{
        databaseCache.get().process=rt.exec(cmd);
        databaseCache.get().process.getOutputStream().close();
      }
      catch(IOException ex){
        logger.error("Could not start Database Cache Daemon with the following command.\n"+cmd);
        return false;
      }
      
      logger.info("Database Cache Daemon started with the following command.\n"+cmd);
    }
    
    while(true){
      synchronized(controllerMutex){
        if(databaseCache.get().controller!=null)
          break;
      }
      
      try{
        Thread.sleep(1000);
      }
      catch(InterruptedException ex){
      }
    }
    return true;
  }

  public boolean startAllMessageLauncher(ControllerUserToken token) {
    boolean result=false;
    Set<String> tags=messageLauncherMap.keySet();
    for(String tag:tags){
      result=startMessageLauncher(token,tag);
    }
    return result;
  }

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

    synchronized(controllerMutex){
      MessageLauncherSet mls=messageLauncherMap.get(tag);
      if(mls==null)
        throw new RuntimeException("invalid tag");

      mls.controller=null;
      mls.monitor=null;
      mls.channelMonitor=null;

      Runtime rt=Runtime.getRuntime();
      String cmd=getStartMessageLauncherCommand(token,tag); 
      try{
        mls.process=rt.exec(cmd);
        mls.process.getOutputStream().close();
        messageLauncherMap.put(tag,mls);
      }
      catch(IOException ex){
        logger.error("Could not start Message Launcher Daemon with the following command.\n"+cmd);
        return false;
      }
      
      logger.info("Message Launcher Daemon started with the following command.\n"+cmd);
    }
    
    while(true){
    synchronized(controllerMutex){
      if(messageLauncherMap.get(tag).controller!=null)
        break;
      }
      
      try{
        Thread.sleep(1000);
      }
      catch(InterruptedException ex){
      }
    }
    return true;
  }

  public boolean stopAllMessageLauncher(ControllerUserToken token) {
    if(!isValidToken(token))
      throw new RuntimeException("invalid user token");
    return false;
  }

  public boolean stopDatabaseCache(ControllerUserToken token) {
    if(!isValidToken(token))
      throw new RuntimeException("invalid user token");
    return false;
  }

  public boolean stopMessageLauncher(ControllerUserToken token, String tag) {
    if(!isValidToken(token))
      throw new RuntimeException("invalid user token");
    return false;
  }

    public DatabaseCache getDatabaseCache(ControllerUserToken token){
    if(!isValidToken(token))
      throw new RuntimeException("invalid user token");
      synchronized(controllerMutex){
        return databaseCache.get().daemon;
      }
    }
}