agentadmin.java

一个类似于openJMS分布在ObjectWeb之下的JMS消息中间件。

        doReact((NewServiceCmd) cmd);
      } else if (cmd instanceof NewNetworkCmd) {
        doReact((NewNetworkCmd) cmd);
      } else if (cmd instanceof SetJvmArgsCmd) {
        doReact((SetJvmArgsCmd) cmd);
      } else if (cmd instanceof SetServerPropertyCmd) {
        doReact((SetServerPropertyCmd) cmd);
      } else if (cmd instanceof SetPropertyCmd) {
        doReact((SetPropertyCmd) cmd);
      } else if (cmd instanceof SetServerNatCmd) {
        doReact((SetServerNatCmd) cmd);
      }  else if (cmd instanceof RemoveDomainCmd) {
        doReact((RemoveDomainCmd) cmd);
      }  else if (cmd instanceof RemoveNetworkCmd) {
        doReact((RemoveNetworkCmd) cmd);
      }  else if (cmd instanceof RemoveServerCmd) {
        doReact((RemoveServerCmd) cmd);
      }  else if (cmd instanceof RemoveServiceCmd) {
        doReact((RemoveServiceCmd) cmd);
      }  else if (cmd instanceof UnsetServerPropertyCmd) {
        doReact((UnsetServerPropertyCmd) cmd);
      }  else if (cmd instanceof UnsetPropertyCmd) {
        doReact((UnsetPropertyCmd) cmd);
      }  else if (cmd instanceof UnsetJvmArgsCmd) {
        doReact((UnsetJvmArgsCmd) cmd);
      } else if (cmd instanceof UnsetServerNatCmd) {
        doReact((UnsetServerNatCmd) cmd);
      } else if (cmd instanceof SetNetworkPortCmd) {
        doReact((SetNetworkPortCmd) cmd);
      } 
    }

    A3CMLServer root = a3cmlConfig.getServer(AgentServer.getServerId());
    a3cmlConfig.configure(root);

    if (script.newConfig)
      AgentServer.setConfig(a3cmlConfig);

    // save configuration (transaction)
    a3cmlConfig.save();
  }

  /** 
   * create new domain 
   *
   * @param cmd NewDomainCmd
   *
   * @exception DomainCmdException
   */
  private void doReact(NewDomainCmd cmd) throws DomainCmdException {
    if (logmon.isLoggable(BasicLevel.DEBUG))
      logmon.log(BasicLevel.DEBUG,
                 "AgentAdmin.doReact(" + cmd + ")");
    
    try {
      if (!a3cmlConfig.containsDomain(cmd.name)) {
        a3cmlConfig.addDomain(
          new A3CMLDomain(cmd.name,
                          cmd.networkClass));
        rollback.add(new RemoveDomainCmd(cmd.name,cmd.networkClass));
      } else {
        if (silence) return;
        throw new DomainCmdException("Domain " + cmd.name + " already exist.");
      }
    } catch (Exception exc) {
      if (logmon.isLoggable(BasicLevel.ERROR))
        logmon.log(BasicLevel.ERROR, "", exc);
      throw new DomainCmdException(exc);
    }
  }

  /** 
   * create new server 
   *
   * @param cmd NewServerCmd
   *
   * @exception ServerCmdException
   */
  private void doReact(NewServerCmd cmd) throws ServerCmdException {
    if (logmon.isLoggable(BasicLevel.DEBUG))
      logmon.log(BasicLevel.DEBUG,
                 "AgentAdmin.doReact(" + cmd + ")");
    
    try {
      if (!a3cmlConfig.containsServer(cmd.name)) {
        // set id for new server
        Short id = null;
        if (cmd.sid == null) {
          id = getSid();
          if (id == null) 
            throw new ServerCmdException(
              "AgentAdmin : NewServerCmd(" + cmd + 
              ")not authorized on " + 
              AgentServer.getServerId());
        } else
          id = cmd.sid;
        
        a3cmlConfig.addServer(
          new A3CMLServer(id.shortValue(),
                           cmd.name,
                           cmd.hostname));
        rollback.add(new RemoveServerCmd(cmd.name,cmd.hostname));

        // prepare serverDesc and add to startScript
        ServerDesc sd = new ServerDesc(id.shortValue(),
                                       cmd.name,
                                       cmd.hostname,
                                       -1);
//         sd.isTransient = false;
        sd.gateway = id.shortValue();
        startScript.serverDesc.put(id, sd);
        startScript.add(new StartServerCmd(id.shortValue(),cmd.name));
        if (logmon.isLoggable(BasicLevel.DEBUG))
          logmon.log(BasicLevel.DEBUG, 
                     "AgentAdmin startScript.serverDesc.put(" + id + "," + sd + ")");
      } else {
        if (silence) {
          short sid;
          if (cmd.sid == null) {
            sid = a3cmlConfig.getServerIdByName(cmd.name);
          } else {
            sid = cmd.sid.shortValue();
          }
          if (sid != AgentServer.getServerId()) {
            startScript.add(new StartServerCmd(
              sid,
              cmd.name));
          }
        } else {
          throw new ServerCmdException(
            "Server " + cmd.name + " already exists");
        }
      }
    } catch (Exception exc) {
      if (logmon.isLoggable(BasicLevel.DEBUG))
        logmon.log(BasicLevel.DEBUG,
                   "AgentAdmin.doReact(NewServerCmd)",exc);
      throw new ServerCmdException(exc);
    }
  }
  
  /** 
   * create new service
   *
   * @param cmd NewServiceCmd
   *
   * @exception ServiceCmdException
   */
  private void doReact(NewServiceCmd cmd) throws ServiceCmdException {
    if (logmon.isLoggable(BasicLevel.DEBUG))
      logmon.log(BasicLevel.DEBUG,
                 "AgentAdmin.doReact(" + cmd + ")");
    
    try {
      A3CMLServer server = a3cmlConfig.getServer(cmd.serverName);
      A3CMLService newService = new A3CMLService(cmd.className,cmd.args);
      if (!server.services.contains(newService)) {
        server.services.addElement(newService);
        rollback.add(new RemoveServiceCmd(cmd.serverName,
                                          cmd.className,
                                          cmd.args));
        
        A3CMLServer adm = a3cmlConfig.getServer(AgentServer.getServerId());
        if (cmd.serverName.equals(adm.name)) {
          if (logmon.isLoggable(BasicLevel.DEBUG))
            logmon.log(BasicLevel.DEBUG,
                       "NewServiceCmd startScript.add(" + cmd.className + ")");
          startScript.add(new StartServiceCmd(cmd.className,cmd.args));
        }
      } else {
        if (silence) {
          startScript.add(new StartServiceCmd(cmd.className,cmd.args));
          return;
        }
        throw new ServiceCmdException("Service " + newService + " already exist in server " + server);
      }
    } catch (Exception exc) {
      if (logmon.isLoggable(BasicLevel.ERROR))
        logmon.log(BasicLevel.ERROR, "", exc);
      throw new ServiceCmdException(exc);
    }
  }
  
  /** 
   * create new network
   *
   * @param cmd NewNetworkCmd
   *
   * @exception NetworkCmdException
   */
  private void doReact(NewNetworkCmd cmd) throws NetworkCmdException {
    if (logmon.isLoggable(BasicLevel.DEBUG))
      logmon.log(BasicLevel.DEBUG,
                 "AgentAdmin.doReact(" + cmd + ")");

    try {
      A3CMLServer server = a3cmlConfig.getServer(cmd.serverName);
      A3CMLNetwork toadd = new A3CMLNetwork(cmd.domain,cmd.port);
      if (server.networks.contains(toadd)) {
        if (silence) {
          if (server.sid == AgentServer.getServerId()) {
            startScript.add(new StartNetworkCmd(server.sid,
                                                cmd.domain));
          }
          return;
        }
        throw new NetworkCmdException(cmd.serverName + " already contains network " + toadd);
      }
      server.networks.addElement(toadd);
      rollback.add(new RemoveNetworkCmd(cmd.serverName,
                                        cmd.domain));
      
      if (!cmd.domain.equals("transient")) {
        // add server in domains
        A3CMLDomain domain = (A3CMLDomain) a3cmlConfig.getDomain(cmd.domain);
        domain.addServer(server);
        
        if (server.sid == AgentServer.getServerId()) {
          if (logmon.isLoggable(BasicLevel.DEBUG))
            logmon.log(BasicLevel.DEBUG,
                       "startScript.add(" + server.sid + ")");
          startScript.add(new StartNetworkCmd(server.sid,
                                              cmd.domain));
        }

        // prepare serverDesc and add to startScript
        ServerDesc serverDesc = 
          (ServerDesc) startScript.serverDesc.get(new Short(server.sid));
        if (serverDesc == null)
          serverDesc = AgentServer.getServerDesc(server.sid);
//         if (serverDesc != null) {
//           serverDesc.port = cmd.port;
//         }
      }
    } catch (Exception exc) {
      if (logmon.isLoggable(BasicLevel.ERROR))
        logmon.log(BasicLevel.ERROR, "", exc);
      throw new NetworkCmdException(exc);
    }
  }

  /** 
   * Set the port of a network
   *
   * @param cmd SetNetworkPortCmd
   *
   * @exception NetworkCmdException
   */
  private void doReact(SetNetworkPortCmd cmd) throws NetworkCmdException {
    if (logmon.isLoggable(BasicLevel.DEBUG))
      logmon.log(BasicLevel.DEBUG,
                 "AgentAdmin.doReact(" + cmd + ")");
    try {
      A3CMLServer server = a3cmlConfig.getServer(cmd.serverName);
      A3CMLNetwork network = null;
      for (int i = 0; i < server.networks.size(); i++) {
        A3CMLNetwork nw = 
          (A3CMLNetwork)server.networks.elementAt(i);
        if (nw.domain.equals(cmd.domain)) {
          network = nw;
        }
      }
      if (network != null) {
        // DF: the rollback script doesn't
        //     work properly:
        // 1- a 'remove' command is not rollbacked
        //    because it is considered as a rollback action.
        // 2- a 'set' command is its own reverse command.
        //    So a rollback loops indefinitely.
        // rollback.add(
//           new SetNetworkPortCmd(
//             cmd.serverName, cmd.domain, network.port));
        network.port = cmd.port;
        startScript.add(
          new StartNetworkCmd(
            server.sid,
            cmd.domain));
      } else {
        throw new Exception("Unknown network");
      }
    } catch (Exception exc) {
      if (logmon.isLoggable(BasicLevel.ERROR))
        logmon.log(BasicLevel.ERROR, "", exc);
      throw new NetworkCmdException(exc);
    }    
  }

  /** 
   * set jvm arguments
   *
   * @param cmd SetJvmArgsCmd
   *
   * @exception JvmArgsCmdException
   */
  private void doReact(SetJvmArgsCmd cmd) throws JvmArgsCmdException {
    if (logmon.isLoggable(BasicLevel.DEBUG))
      logmon.log(BasicLevel.DEBUG,
                 "AgentAdmin.doReact(" + cmd + ")");

    try {
      A3CMLServer server = a3cmlConfig.getServer(cmd.serverName);
      server.jvmArgs = cmd.args;
      rollback.add(new UnsetJvmArgsCmd(cmd.serverName,cmd.args));
    } catch (Exception exc) {
      if (logmon.isLoggable(BasicLevel.ERROR))
        logmon.log(BasicLevel.ERROR, "", exc);
      throw new JvmArgsCmdException(exc);
    }
  }
  
  /** 
   * set property
   *
   * @param cmd SetPropertyCmd
   *
   * @exception PropertyCmdException
   */
  private void doReact(SetPropertyCmd cmd) throws PropertyCmdException {
    if (logmon.isLoggable(BasicLevel.DEBUG))
      logmon.log(BasicLevel.DEBUG,
                 "AgentAdmin.doReact(" + cmd + ")");

    try {
      if (!a3cmlConfig.containsProperty(cmd.name)) {
        a3cmlConfig.addProperty(
          new A3CMLProperty(cmd.name,
                            cmd.value));
        rollback.add(new UnsetPropertyCmd(cmd.name,cmd.value));
      } else {
        if (silence) return;
        throw new PropertyCmdException("Property " + cmd.name + " already exist.");
      }
    } catch (Exception exc) {
      if (logmon.isLoggable(BasicLevel.ERROR))
        logmon.log(BasicLevel.ERROR, "", exc);
      throw new PropertyCmdException(exc);
    }
  }
  
  /** 
   * set server property
   *
   * @param cmd SetServerPropertyCmd
   *
   * @exception PropertyCmdException
   */
  private void doReact(SetServerPropertyCmd cmd) throws PropertyCmdException {
    if (logmon.isLoggable(BasicLevel.DEBUG))
      logmon.log(BasicLevel.DEBUG,
                 "AgentAdmin.doReact(" + cmd + ")");

    try {
      A3CMLServer server = a3cmlConfig.getServer(cmd.serverName);
      if (!server.containsProperty(cmd.name)) {
        server.addProperty(
          new A3CMLProperty(cmd.name,
                            cmd.value));
        rollback.add(new UnsetServerPropertyCmd(cmd.serverName,cmd.name,cmd.value));
      } else {
        if (silence) return;
        throw new PropertyCmdException("Property " + cmd.name + 
                                       " already exist in server " + cmd.serverName);
      }
    } catch (Exception exc) {
      if (logmon.isLoggable(BasicLevel.ERROR))
        logmon.log(BasicLevel.ERROR, "", exc);
      throw new PropertyCmdException(exc);
    }
  }
  
  /** 
   * set network address translation
   *