agentadmin.java

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

   * @param cmd SetServerNatCmd
   *
   * @exception NatCmdException
   */
  private void doReact(SetServerNatCmd cmd) throws NatCmdException {
    if (logmon.isLoggable(BasicLevel.DEBUG))
      logmon.log(BasicLevel.DEBUG,
                 "AgentAdmin.doReact(" + cmd + ")");

    try {
      A3CMLServer server = a3cmlConfig.getServer(cmd.serverName);
      short sid = a3cmlConfig.getServerIdByName(cmd.translationServerName);
      if (!server.containsNat(sid)) {
        server.addNat(
          new A3CMLNat(sid,
                       cmd.translationHostName,
                       cmd.translationHostPort));
        rollback.add(new UnsetServerNatCmd(cmd.serverName,
                                           cmd.translationServerName,
                                           cmd.translationHostName,
                                           cmd.translationHostPort));
      } else {
        if (silence) return;
        throw new NatCmdException("Nat " + cmd.translationServerName + 
                                  " already exist in server " + cmd.serverName);
      }
    } catch (Exception exc) {
      if (logmon.isLoggable(BasicLevel.ERROR))
        logmon.log(BasicLevel.ERROR, "", exc);
      throw new NatCmdException(exc);
    }
  }

  /** 
   * start service
   *
   * @param cmd StartServiceCmd
   *
   * @exception ServiceCmdException
   */
  private void doReact(StartServiceCmd cmd) throws ServiceCmdException {
    if (logmon.isLoggable(BasicLevel.DEBUG))
      logmon.log(BasicLevel.DEBUG,
                 "AgentAdmin.doReact(" + cmd + ")");
    
    try {
      A3CMLServer a3cmlServer = 
        a3cmlConfig.getServer(AgentServer.getServerId());
      A3CMLService a3cmlService = 
        a3cmlServer.getService(cmd.className);
      ServiceManager.register(
        a3cmlService.classname, a3cmlService.args);
      ServiceDesc desc = 
        (ServiceDesc) ServiceManager.manager.registry.get(
          a3cmlService.classname);
      if (desc.running) return;
      ServiceManager.start(desc);
      if (stopScript == null) stopScript = new StopScript();
      stopScript.add(new StopServiceCmd(a3cmlService.classname,
                                        a3cmlService.args));
    } catch (Exception exc) {
      if (logmon.isLoggable(BasicLevel.ERROR))
        logmon.log(BasicLevel.ERROR, "", exc);
      throw new ServiceCmdException(exc);
    }
  }

  /** 
   * Starts a network (idempotent).
   *
   * @param cmd StartNetworkCmd
   *
   * @exception NetworkCmdException
   */
  private void doReact(StartNetworkCmd cmd) throws NetworkCmdException {
    if (logmon.isLoggable(BasicLevel.DEBUG))
      logmon.log(BasicLevel.DEBUG,
                 "AgentAdmin.doReact(" + cmd + ")");
    try {
      if (a3cmlConfig == null)
        a3cmlConfig = AgentServer.getConfig();
      A3CMLServer a3cmlServer = a3cmlConfig.getServer(cmd.sid);
      A3CMLNetwork a3cmlNetwork = null;
      for (int i = 0; i < a3cmlServer.networks.size(); i++) {
        A3CMLNetwork nw = 
          (A3CMLNetwork)a3cmlServer.networks.elementAt(i);
        if (nw.domain.equals(cmd.domainName)) {
          a3cmlNetwork = nw;
        }
      }
      
      if (a3cmlNetwork == null)
        throw new NetworkCmdException(
          "Unknown network: " + 
          cmd.sid + '.' + cmd.domainName);

      if (cmd.sid == AgentServer.getServerId()) {
        Network network;
        try {
          // The network may have already been 
          // added (idempotency).
          network =
            (Network) AgentServer.getConsumer(cmd.domainName);
        } catch (Exception exc) {
          network = null;
        }

        if (network != null) {         
          if (network.getPort() != a3cmlNetwork.port) {
            if (logmon.isLoggable(BasicLevel.DEBUG))
              logmon.log(BasicLevel.DEBUG,
                         " -> port change (before = " + 
                         network.getPort() + 
                         ", after = " + 
                         a3cmlNetwork.port + ')');
            // The network is local so we have to 
            // stop it in order to update the listen port.
            network.stop();
            network.setPort(a3cmlNetwork.port);
          }
          network.start();
        } else {
          A3CMLDomain a3cmlDomain = 
            (A3CMLDomain) a3cmlConfig.getDomain(cmd.domainName);
          network = 
            (Network) Class.forName(a3cmlDomain.network).newInstance();        
          short[] domainSids = new short[a3cmlDomain.servers.size()];
          for (int i = 0; i < domainSids.length; i++) {
            domainSids[i] = 
              ((A3CMLServer) a3cmlDomain.servers.elementAt(i)).sid;
          }
          AgentServer.addConsumer(cmd.domainName, network);
          network.init(a3cmlDomain.name, 
                       a3cmlNetwork.port, 
                       domainSids);
          network.start();
        }
      } else {
        // The network is remote so we just 
        // may have to update the port value
        // of the server desc.
        try {
          ServerDesc serverDesc = 
            AgentServer.getServerDesc(cmd.sid);
          if (cmd.domainName.equals(serverDesc.getDomainName())) {
            //serverDesc.setPort(a3cmlNetwork.port);
            serverDesc.updateSockAddr(
              serverDesc.getHostname(),
              a3cmlNetwork.port);
          }
        } catch (UnknownServerException exc) {
          // Nothing to do
        }
      }
      if (stopScript == null) stopScript = new StopScript();
      stopScript.add(new StopNetworkCmd(cmd.sid,
                                        cmd.domainName));
    } catch (Exception exc) {
      if (logmon.isLoggable(BasicLevel.ERROR))
        logmon.log(BasicLevel.ERROR, "", exc);
      throw new NetworkCmdException(exc);
    }
  }

  // DF: removed this command. It is replaced by StartNetworkCmd
  // 
  // private void doReact(UpdateNetworkPortCmd cmd) throws NetworkCmdException {    
//     try {
//       ServerDesc serverDesc = AgentServer.getServerDesc(cmd.sid);
//       if (cmd.domainName.equals(serverDesc.getDomainName())) {
//         // DF: Don't add the reverse action into the
//         // stopScript because the meaning of the
//         // update command does not fit into the start/stop
//         // script principle.
//         serverDesc.port = cmd.port;
//       }
//     } catch (Exception exc) {
//       if (logmon.isLoggable(BasicLevel.ERROR))
//         logmon.log(BasicLevel.ERROR, "", exc);
//       throw new NetworkCmdException(exc);
//     }
//   }

  /** 
   * start server
   *
   * @param cmd StartServerCmd
   *
   * @exception ServerCmdException
   */
  private void doReact(StartServerCmd cmd) throws ServerCmdException {
    if (logmon.isLoggable(BasicLevel.DEBUG))
      logmon.log(BasicLevel.DEBUG, "AgentAdmin.doReact(" + cmd + ")");

    try {
      // Attention, on prend des infos de la config courante (!=  de celle
      // de l'AgentServer et on reporte les modifs dans les ServerDesc de
      // l'AgentServer.
      if (a3cmlConfig == null)
        a3cmlConfig = AgentServer.getConfig();
      A3CMLServer current = a3cmlConfig.getServer(AgentServer.getServerId());
      A3CMLServer server = a3cmlConfig.getServer(cmd.sid);
      ServerDesc desc = AgentServer.getServerDesc(server.sid);

      if (logmon.isLoggable(BasicLevel.DEBUG))
        logmon.log(BasicLevel.DEBUG,
                   "AgentAdmin.StartServerCmd : desc = " + desc);

//       if (current.containsNat(server.sid)) {
//         A3CMLNat nat = current.getNat(server.sid);
//         desc.setPort(nat.portT);
//         desc.setHostname(nat.hostT);
//         if (logmon.isLoggable(BasicLevel.DEBUG))
//           logmon.log(BasicLevel.DEBUG,
//                      "AgentAdmin.StartServerCmd : NAT desc = " + desc);
//       }

      AgentServer.initServerDesc(desc, server);
        if (desc.gateway == desc.sid)
          ((Network) desc.domain).addServer(server.sid);

      if (logmon.isLoggable(BasicLevel.DEBUG))
        logmon.log(BasicLevel.DEBUG,
                   "AgentAdmin.StartServerCmd : " +
                   "desc = " + AgentServer.getServerDesc(server.sid));
    } catch (Exception exc) {
      if (logmon.isLoggable(BasicLevel.ERROR))
        logmon.log(BasicLevel.ERROR, "", exc);
      throw new ServerCmdException(exc);
    }
  }

  /** 
   * stop network
   *
   * @param cmd StopNetworkCmd
   *
   * @exception NetworkCmdException
   */
  private void doReact(StopNetworkCmd cmd) throws NetworkCmdException {
    if (logmon.isLoggable(BasicLevel.DEBUG))
      logmon.log(BasicLevel.DEBUG,
                 "AgentAdmin.doReact(" + cmd + ")");

    try {
      for (Enumeration c=AgentServer.getConsumers(); c.hasMoreElements(); ) {
	MessageConsumer consumer = (MessageConsumer) c.nextElement();
        if (logmon.isLoggable(BasicLevel.DEBUG))
          logmon.log(BasicLevel.DEBUG,
                     "AgentAdmin consumer = " + consumer);
        
        if (consumer.getDomainName().equals(cmd.domainName)
            && consumer.isRunning()) {
          if (logmon.isLoggable(BasicLevel.DEBUG))
            logmon.log(BasicLevel.DEBUG,
                       "AgentAdmin Stop domain = " + cmd.domainName);
          consumer.stop();

          A3CMLNetwork nw = getNetwork(
            AgentServer.getServerId(), cmd.domainName);
          if (nw == null) {
            // Means that the network has been removed.
            AgentServer.removeConsumer(cmd.domainName);
          }
        }
      }        
    } catch (Exception exc) {
      if (logmon.isLoggable(BasicLevel.ERROR))
        logmon.log(BasicLevel.ERROR, "", exc);
      throw new NetworkCmdException(exc);
    }
  }
  
  private A3CMLNetwork getNetwork(short sid, String domainName) 
    throws Exception {
    if (a3cmlConfig == null)
      a3cmlConfig = AgentServer.getConfig();
    A3CMLServer server = a3cmlConfig.getServer(sid);
    if (server == null) return null;
    for (int i = 0; i < server.networks.size(); i++) {
      A3CMLNetwork network = (A3CMLNetwork) server.networks.elementAt(i);
      if (network.domain.equals(domainName)) {
        return network;
      }
    }
    return null;
  }

  /** 
   * stop service
   *
   * @param cmd StopServiceCmd
   *
   * @exception ServiceCmdException
   */
  private void doReact(StopServiceCmd cmd) throws ServiceCmdException {
    if (logmon.isLoggable(BasicLevel.DEBUG))
      logmon.log(BasicLevel.DEBUG,
                 "AgentAdmin.doReact(" + cmd + ")");

   try {
      ServiceManager.stop(cmd.className);
    } catch (Exception exc) {
      if (logmon.isLoggable(BasicLevel.ERROR))
        logmon.log(BasicLevel.ERROR, "", exc);
      throw new ServiceCmdException(exc);
    }
  }

  /** 
   * remove domain
   *
   * @param cmd RemoveDomainCmd
   *
   * @exception DomainCmdException
   */
  private void doReact(RemoveDomainCmd cmd) throws DomainCmdException {
    if (logmon.isLoggable(BasicLevel.DEBUG))
      logmon.log(BasicLevel.DEBUG,
                 "AgentAdmin.doReact(" + cmd + ")");
    
    try {
      if (a3cmlConfig.containsDomain(cmd.name)) {
        A3CMLDomain domain = a3cmlConfig.getDomain(cmd.name);

        if (domain.servers == null) {
          removeDomain(cmd.name);
          return;
        }

        Vector toRemove = new Vector();
        for (Enumeration s = domain.servers.elements(); s.hasMoreElements(); ) {
          A3CMLServer server = (A3CMLServer) s.nextElement();

          if (server.networks.size() > 2) {
            doReact(new RemoveNetworkCmd(server.name,
                                         cmd.name));
          } else if (server.networks.size() == 2) {
            if ((((A3CMLNetwork) server.networks.elementAt(0)).domain.equals("transient") && 
                 ((A3CMLNetwork) server.networks.elementAt(1)).domain.equals(cmd.name)) ||
                (((A3CMLNetwork) server.networks.elementAt(1)).domain.equals("transient") && 
                 ((A3CMLNetwork) server.networks.elementAt(0)).domain.equals(cmd.name)))
              toRemove.addElement(new RemoveServerCmd(server.name,
                                                      server.hostname));
            else
              doReact(new RemoveNetworkCmd(server.name,
                                           cmd.name));
          } else
            toRemove.addElement(new RemoveServerCmd(server.name,
                                             server.hostname));
        }
        
        for (int i = 0; i < toRemove.size(); i++)
          doReact((RemoveServerCmd)toRemove.elementAt(i));
        
        removeDomain(cmd.name);
      }
    } catch (Exception exc) {
      if (logmon.isLoggable(BasicLevel.ERROR))
        logmon.log(BasicLevel.ERROR, "", exc);
      throw new DomainCmdException(exc);
    }
  }

  /** 
   * remove network
   *
   * @param cmd RemoveNetworkCmd
   *
   * @exception NetworkCmdException
   */
  private void doReact(RemoveNetworkCmd cmd) throws NetworkCmdException {
    if (logmon.isLoggable(BasicLevel.DEBUG))