* JORAM: Java(TM) Open Reliable Asynchronous Messaging

* Copyright (C) 2001 - 2011 ScalAgent Distributed Technologies

* Copyright (C) 1996 - 2000 Dyade

*

* This library is free software; you can redistribute it and/or

* modify it under the terms of the GNU Lesser General Public

* License as published by the Free Software Foundation; either

* version 2.1 of the License, or any later version.

*

* This library is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

* Lesser General Public License for more details.

*

* You should have received a copy of the GNU Lesser General Public

* License along with this library; if not, write to the Free Software

* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307

* USA.

*

* Initial developer(s): Frederic Maistre (INRIA)

* Contributor(s): ScalAgent Distributed Technologies

*/

* The <code>AdminTopic</code> class implements the administration topic

* behavior, basically processing administration requests.

* <p>

* It receives administration requests from the client encapsulated in JMS

* messages:

* <ul>

* <li>If the request concerns an user or a destination it forwards the request

* to the target. This target directly replies (*) to the client sending a JMS

* message to the replyTo destination specified in the original JMS message.</li>

* <li>If the request can be processed by the administration topic, either the

* request concerns the local server and it is processed, or it is forwarded to

* the administration topic of the target server.</li>

* </ul>

* (*) Currently the getRights reply is handled differently as it needs the

* transformation of the user list. This behavior should disappear with the role

* based mechanism.

*/

  /** define serialVersionUID for interoperability */

  private static final long serialVersionUID = 1L;

  /** Reference of the server's local AdminTopic instance. */

  private static AdminTopic ref;

  /** Identifier of the server this topic is deployed on. */

  private int serverId;

  /**

   * Table holding the local server's destinations names.

   * This table is used by more than one thread so it needs to be synchronized.

   * <p>

   * <b>Key:</b> destination name<br>

   * <b>Object:</b> destination agent identifier

   */

  private Map destinationsTable = new Hashtable();

  /**

   * Table holding the TCP users identifications.

   * <p>

   * <b>Key:</b> user name<br>

   * <b>Object:</b> user password

   */

  private Map usersTable = new Hashtable();

  /**

   * Table holding the TCP users proxies identifiers.

   * <p>

   * <b>Key:</b> user name<br>

   * <b>Object:</b> proxy's identifier

   */

  private Map proxiesTable = new Hashtable();

  /**

   * Table keeping the administrator's requests.

   * <p>

   * <b>Key:</b> request's message identifier<br>

   * <b>Value:</b> request's message ReplyTo field

   */

  private Map requestsTable = new Hashtable();

  /** Counter of messages produced by this AdminTopic. */

  private long msgCounter = 0;

  /**

   * Constructs an <code>AdminTopic</code> agent.

   */

  public AdminTopic() throws RequestException {

    super("JoramAdminTopic", true, AgentId.JoramAdminStamp);

    setAdminId(getId());

    serverId = AgentServer.getServerId();

  }

  public String toString() {

    return "AdminTopic";

  }

  /**

   * Gets the identifier of the default administration topic on a given server.

   */

  public static AgentId getDefault(short serverId) {

    return new AgentId(serverId, serverId, AgentId.JoramAdminStamp);

  }

  static AgentId adminId = null;

  /**

   * Gets the identifier of the default administration topic on the

   * current server.

   */

  public final static AgentId getDefault() {

    if (adminId == null)

      adminId = new AgentId(AgentServer.getServerId(), AgentServer.getServerId(), AgentId.JoramAdminStamp);

    return adminId;

  }

  /**

   * Returns true if the given AgentId is the unique identifier of an AdminTopic

   * agent.

   *

   * @param id the AgentId to verify.

   * @return true if the given AgentId is the unique identifier of an AdminTopic

   *         agent.

   */

  public final static boolean isAdminTopicId(AgentId id) {

    if (id == null)

      return false;

    return id.getStamp() == AgentId.JoramAdminStamp;

  }

  /**

   * Distributes the received notifications to the appropriate reactions.

   *

   * @throws Exception

   */

  public void react(AgentId from, Notification not) throws Exception {

    if (logger.isLoggable(BasicLevel.DEBUG))

      logger.log(BasicLevel.DEBUG, "--- " + this + ": got " + not + " from: " + from.toString());

    // state change, so save.

    setSave();

    if (not instanceof AdminNotification) {

      // This notification is used at boot by an administrator proxy to declare

      // its identification.

      handleAdminNotification((AdminNotification) not);

    } else if (not instanceof FwdAdminRequestNot) {

      // This notification contains forwarded administration request from remote

      // AdminTopic. This code overloads the normal behavior in Destination.

      // AF (TODO): May be we should verify that from is an AdminTopic but in the

      // AgentServer sandbox only an AdminTopic can generate such a notification.

      processAdminRequests(((FwdAdminRequestNot) not).getReplyTo(),

          ((FwdAdminRequestNot) not).getRequestMsgId(), ((FwdAdminRequestNot) not).getRequest(), from);

    } else if (not instanceof AdminReplyNot) {

      // Now most of the replies are sent directly to the waiting destination. Only

      // the GetRightsReplyNot requires a processing, in future it will be removed.

      handleAdminReply((AdminReplyNot) not);

    } else if (not instanceof GetProxyIdNot) {

      // This notification (SyncNotification) is used during connection to get the

      // AgentId of the user's proxy.

      handleGetProxyIdNot((GetProxyIdNot) not);

    } else if (not instanceof GetProxyIdListNot) {

      // This notification is needed by the HA mode.

      // AF (TODO): remove it.

      handleGetProxyIdListNot((GetProxyIdListNot) not);

    } else {

      super.react(from, not);

    }

  }

  /**

   * Method used by <code>ConnectionManager</code> proxies to check their

   * clients identification.

   *

   * @param identity

   * @param inaddr

   * @return The agent unique identifier of the authentified user.

   *

   * @exception Exception  If the user does not exist, is wrongly identified,

   *              or does not have any proxy deployed.

   * @see org.objectweb.joram.mom.proxies.ConnectionManager

   */

  private AgentId getProxyId(Identity identity,

                            String inaddr) throws Exception {

    AgentId userProxId = null;

    Identity userIdentity = (Identity) usersTable.get(identity.getUserName());

    if (userIdentity == null) {

      if (logger.isLoggable(BasicLevel.ERROR))

        logger.log(BasicLevel.ERROR, "User [" + identity.getUserName() + "] does not exist");

      throw new Exception("User [" + identity.getUserName() + "] does not exist");

    }

    if (!userIdentity.check(identity)) {

      if (logger.isLoggable(BasicLevel.ERROR))

        logger.log(BasicLevel.ERROR, "identity check failed.");

      throw new Exception("identity check failed.");

    }

    userProxId = (AgentId) proxiesTable.get(identity.getUserName());

    if (userProxId == null) {

      if (logger.isLoggable(BasicLevel.ERROR))

        logger.log(BasicLevel.ERROR, "No proxy deployed for user [" + identity.getUserName() + "]");

      throw new Exception("No proxy deployed for user [" + identity.getUserName() + "]");

    }

    return userProxId;

  }

  /**

   * Method used to send a response when a message is denied because of a lack

   * of rights.

   */

  protected void handleDeniedMessage(String msgId, AgentId replyTo) {

    distributeReply(replyTo, msgId, new AdminReply(AdminReply.PERMISSION_DENIED, "Permission denied."));

  }

  /**

   * Method implementing the reaction to a <code>AdminNotification</code>

   * notification notifying of the creation of an administrator proxy.

   *

   * @param adminNot  the <code>AdminNotification</code> notification.

   */

  private void handleAdminNotification(AdminNotification adminNot) {

    Identity identity = adminNot.getIdentity();

    try {

      //identity.validate();

      if (logger.isLoggable(BasicLevel.DEBUG))

        logger.log(BasicLevel.DEBUG,

                   "AdminTopic store identity = " + identity);

     

      usersTable.put(identity.getUserName(), identity);

      proxiesTable.put(identity.getUserName(), adminNot.getProxyId());

      clients.put(adminNot.getProxyId(), new Integer(READWRITE));

      if (logger.isLoggable(BasicLevel.DEBUG))

        logger.log(BasicLevel.DEBUG,

                   identity.getUserName() + " successfully set as admin client.");

    } catch (Exception e) {

      if (logger.isLoggable(BasicLevel.ERROR))

        logger.log(BasicLevel.ERROR, "Exception:: ", e);

    }

  }

  /**

   * Method implementing the reaction to a

   * <code>org.objectweb.joram.mom.notifications.AdminReply</code>

   * notification replying to an administration request.

   * <p>

   * A reply is sent back to the connected administrator if needed.

   */ 

  private void handleAdminReply(AdminReplyNot not) {

    String requestId = not.getRequestId();

    if (requestId == null) return;

    AgentId replyTo = (AgentId) requestsTable.remove(requestId);

    if (replyTo == null) return;

    AdminReply reply;

    if (not instanceof GetRightsReplyNot)

      reply = doProcess((GetRightsReplyNot) not);

    else

      reply = new AdminReply(not.getSuccess(), not.getInfo());

    distributeReply(replyTo, requestId, reply);

  }

  private void handleGetProxyIdNot(GetProxyIdNot not) {

    try {

      AgentId proxyId = getProxyId(not.getIdentity(), not.getInAddr());

      not.Return(proxyId);

    } catch (Exception exc) {

      not.Throw(exc);

    }

  }

  private void handleGetProxyIdListNot(GetProxyIdListNot not) {

    List idList = new ArrayList();

    Iterator ids = proxiesTable.values().iterator();

    while (ids.hasNext()) {

      AgentId aid = (AgentId) ids.next();

      idList.add(aid);

    }

    AgentId[] res = (AgentId[]) idList.toArray(new AgentId[idList.size()]);

    not.Return(res);

  }

  /**

   * Processes a <code>Monit_GetUsersRep</code> notification holding a

   * destination's readers' or writers' identifiers.

   */

  private AdminReply doProcess(GetRightsReplyNot not) {

    Vector readers = not.getReaders();

    Vector writers = not.getWriters();

    String name;

    AgentId proxyId;

    GetRightsReply reply = new GetRightsReply(not.getSuccess(), not.getInfo(), not.isFreeReading(), not.isFreeWriting());

    for (Iterator names = proxiesTable.keySet().iterator(); names.hasNext();) {

      name = (String) names.next();

      proxyId = (AgentId) proxiesTable.get(name);

      if (readers.contains(proxyId))

        reply.addReader(name, proxyId.toString());

      if (writers.contains(proxyId))

        reply.addWriter(name, proxyId.toString());

    }

    return reply;

  }

  protected void requestGroupNot(AgentId from, RequestGroupNot not) {

    if (logger.isLoggable(BasicLevel.DEBUG))

      logger.log(BasicLevel.DEBUG, "AdminTopic.requestGroupNot(" + not + ')');

    Enumeration en = not.getClientMessages();

    while (en.hasMoreElements()) {

      ClientMessages cm = (ClientMessages) en.nextElement();

      try {

        clientMessages(from, cm);

      } catch (Exception exc) {

      }

    }

  }

  /**

   * Overrides this {@link Destination} method;

   *

   * @param msgs <code>ClientMessages</code> notifications hold requests sent by

   *          an administrator.

   */

  protected ClientMessages preProcess(AgentId from, ClientMessages msgs) {

    if (logger.isLoggable(BasicLevel.DEBUG))

      logger.log(BasicLevel.DEBUG, "AdminTopic.clientMessages(" + msgs + ')');

    if (!msgs.isPersistent() && !msgs.getAsyncSend()) {

      // Means that this notification has been sent by a local

      // proxy (optimization). Must acknowledge it.

      forward(from, new SendReplyNot(msgs.getClientContext(), msgs.getRequestId()));

    }

    // ... and processing the wrapped requests locally:

    processAdminRequests(msgs);

    return null;

  }

  /* ***** ***** ***** ***** *****

   * Overrides 'cluster' and 'tree' default behaviors from Topic:

   * - AdminTopics are part of an implicit cluster.

   * - AdminTopics do not accept to join a hierarchy.

   * ***** ***** ***** ***** ***** */

  /**

   * Overrides this <code>Topic</code> method; a <code>ClusterAck</code> is not

   * expected by an AdminTopic.

   */

  protected void clusterJoinAck(ClusterJoinAck ack) {

    if (logger.isLoggable(BasicLevel.WARN))

      logger.log(BasicLevel.WARN, "Unexpected notification: " + ack);

  }

  /**

   * Overrides this <code>Topic</code> method; if this AdminTopic is on

   * server0, new cluster fellow is notified to other fellows and other

   * fellows are notified to it.

   */

  protected void clusterJoin(ClusterJoinNot not) {

    if (logger.isLoggable(BasicLevel.WARN))

      logger.log(BasicLevel.WARN, "Unexpected notification: " + not);

  }

  /**

   * Overrides this <code>Topic</code> method; the forwarded messages

   * contain admin requests and will be processed.

   */

  protected void topicForwardNot(AgentId from, TopicForwardNot not) {

    if (logger.isLoggable(BasicLevel.WARN))

      logger.log(BasicLevel.WARN, "Unexpected notification: " + not);

  }

  /* ***** ***** ***** ***** *****

   * ***** ***** ***** ***** ***** */

  /**

   * Overrides this {@link Destination} method.

   * Deletion requests are not accepted by AdminTopics.

   */

  public void deleteNot(AgentId from, DeleteNot not) {

    if (logger.isLoggable(BasicLevel.WARN))

      logger.log(BasicLevel.WARN, "Unexpected request: " + not);

  }

  /**

   * Specializes this <code>Topic</code> reaction.

   */

  protected void doUnknownAgent(UnknownAgent uA) {

    AgentId agId = uA.agent;

    Notification not = uA.not;

    // For admin requests, notifying the administrator.

    if (not instanceof AdminRequestNot) {

      String reqId = ((AdminRequestNot) not).getId();

      if (reqId != null) {

        AgentId replyTo = (AgentId) requestsTable.remove(reqId);

        strbuf.append("Request [").append(not.getClass().getName());

        strbuf.append("], sent to AdminTopic on server [").append(serverId);

        strbuf.append("], successful [false]: unknown agent [").append(agId).append(']');

        distributeReply(replyTo, reqId, new AdminReply(false, strbuf.toString()));

        strbuf.setLength(0);

      }

    } else {

      super.doUnknownAgent(uA);

    }

  }

  /**

   * Method getting the administration requests from messages, and

   * distributing them to the appropriate reactions.

   */

  private void processAdminRequests(ClientMessages not) {

    if (not == null) return;

    Iterator messages = not.getMessages().iterator();

    while (messages.hasNext()) {

      Message msg = (Message) messages.next();

      nbMsgsReceiveSinceCreation += 1;

      String msgId = msg.id;

      AgentId replyTo = AgentId.fromString(msg.replyToId);

      AdminRequest request = (AdminRequest) msg.getAdminMessage();

      if (logger.isLoggable(BasicLevel.DEBUG))

        logger.log(BasicLevel.DEBUG, "--- " + this + ": got " + request);

      if (request == null) {

        logger.log(BasicLevel.ERROR, "--- " + this + ": got bad AdminRequest.");

        distributeReply(replyTo, msgId, new AdminReply(false, "Unexpected request to AdminTopic"));

      }

      processAdminRequests(replyTo, msgId, request, null);

    }

  }

  /**

   * Method getting the administration requests from messages, and

   * distributing them to the appropriate reactions.

   */

  private void processAdminRequests(AgentId replyTo,

                            String msgId,

                            AdminRequest request,

                            AgentId from) {

    if (logger.isLoggable(BasicLevel.DEBUG))

      logger.log(BasicLevel.DEBUG, this + ".processAdminRequests(" + msgId + ',' + request + ')');

   

    String info = null;

    // state change, so save.

    setSave();

    try {

      if (request instanceof StopServerRequest)

        doProcess((StopServerRequest) request, replyTo, msgId);

      else if (request instanceof CreateDestinationRequest)

        doProcess((CreateDestinationRequest) request, replyTo, msgId);

      else if (request instanceof DeleteDestination)

        doProcess((DeleteDestination) request, replyTo, msgId);

      else if (request instanceof CreateUserRequest)

        doProcess((CreateUserRequest) request, replyTo, msgId);

      else if (request instanceof UpdateUser)

        doProcess((UpdateUser) request, replyTo, msgId);

      else if (request instanceof DeleteUser)

        doProcess((DeleteUser) request, replyTo, msgId);

      else if (request instanceof SetDMQRequest)

        doProcess((SetDMQRequest) request, replyTo, msgId);

      else if (request instanceof SetThresholdRequest)

        doProcess((SetThresholdRequest) request, replyTo, msgId);

      else if (request instanceof GetServersIdsRequest)

        doProcess((GetServersIdsRequest) request, replyTo, msgId);

      else if (request instanceof GetDomainNames)

        doProcess((GetDomainNames) request, replyTo, msgId);

      else if (request instanceof GetLocalServer)

        doProcess(replyTo, msgId);

      else if (request instanceof GetDestinationsRequest)

        doProcess((GetDestinationsRequest) request, replyTo, msgId);

      else if (request instanceof GetUsersRequest)

        doProcess((GetUsersRequest) request, replyTo, msgId);

      else if (request instanceof GetRightsRequest)

        doProcess((GetRightsRequest) request, replyTo, msgId);

      else if (request instanceof GetDMQSettingsRequest)

        doProcess((GetDMQSettingsRequest) request, replyTo, msgId);

      else if (request instanceof GetStatsRequest)

        doProcess((GetStatsRequest) request, replyTo, msgId);

      else if (request instanceof DestinationAdminRequest)

        doProcess((DestinationAdminRequest) request, replyTo, msgId);

      else if (request instanceof AddServerRequest)

        doProcess((AddServerRequest) request, replyTo, msgId, from);

      else if (request instanceof AddDomainRequest)

        doProcess((AddDomainRequest) request, replyTo, msgId, from);

      else if (request instanceof RemoveServerRequest)

        doProcess((RemoveServerRequest) request, replyTo, msgId, from);

      else if (request instanceof RemoveDomainRequest)

        doProcess((RemoveDomainRequest) request, replyTo, msgId, from);

      else if (request instanceof GetConfigRequest)

        doProcess((GetConfigRequest) request, replyTo, msgId);

      else if (request instanceof UserAdminRequest)

        doProcess((UserAdminRequest) request, replyTo, msgId);

      else if (request instanceof AdminCommandRequest)

        doProcess((AdminCommandRequest) request, replyTo, msgId);

    } catch (UnknownServerException exc) {

      // Caught when a target server is invalid.

      info = strbuf.append("Request [").append(request.getClass().getName())

      .append("], successful [false]: ")

      .append(exc.getMessage()).toString();

      strbuf.setLength(0);

      distributeReply(replyTo, msgId, new AdminReply(AdminReply.UNKNOWN_SERVER, info));

    } catch (MomException exc) {

      if (logger.isLoggable(BasicLevel.WARN))

        logger.log(BasicLevel.WARN, exc);

      if (request == null) {

        info = strbuf.append("Unexpected request to AdminTopic on server [")

        .append(serverId).append("]: ").append(exc.getMessage()).toString();

        strbuf.setLength(0);

      } else {

        info = strbuf.append("Request [").append(request.getClass().getName())

        .append("], sent to AdminTopic on server [").append(serverId)

        .append("], successful [false]: ")

        .append(exc.getMessage()).toString();

        strbuf.setLength(0);

      }

      distributeReply(replyTo, msgId, new AdminReply(false, info));

    }

  }

  /**

   * Processes a <code>StopServerRequest</code> instance requesting to stop

   * a given server.

   */

  private void doProcess(StopServerRequest request,

                         AgentId replyTo,

                         String msgId) throws UnknownServerException {

    if (checkServerId(request.getServerId())) {

      // It's the local server, process the request.

      distributeReply(replyTo, msgId,

                      new AdminReply(true, "Server stopped"));

      AgentServer.stop(false, 500L, true);

    } else {

      // Forward the request to the right AdminTopic agent.

      forward(getDefault((short) request.getServerId()),

              new FwdAdminRequestNot(request, replyTo, msgId));

    }

  }

  /**

   * Processes a <code>CreateDestinationRequest</code> instance

   * requesting the creation of a destination.

   *

   * @exception UnknownServerException  If the target server does not exist.

   * @exception RequestException  If the destination deployment fails.

   */

  private void doProcess(CreateDestinationRequest request,

                         AgentId replyTo,

                         String msgId) throws UnknownServerException, RequestException {

    if (checkServerId(request.getServerId())) {

      // The destination is local, process the request.

      DestinationDesc destDesc = createDestination(request.getDestinationName(),

                                                   // Not really needed, the administration topic already has administration rights.

                                                   getId(),

                                                   request.getProperties(),

                                                   request.getExpectedType(),

                                                   request.getClassName(),

                                                   request.getClass().getName(),

                                                   strbuf);

      distributeReply(replyTo,

                      msgId,

                      new CreateDestinationReply(destDesc.getId().toString(),

                                                 destDesc.getName(),

                                                 strbuf.toString()));

      if (logger.isLoggable(BasicLevel.DEBUG))

        logger.log(BasicLevel.DEBUG, strbuf.toString());

      strbuf.setLength(0);

    } else {

      // Forward the request to the right AdminTopic agent.

      forward(getDefault((short) request.getServerId()),

              new FwdAdminRequestNot(request, replyTo, msgId));

    }

  }

 

  /**

   * Instantiating the destination class or retrieving the destination.

   *

   * @param destName           destination Name

   * @param adminId            other admin (null for TopicAdmin)

   * @param properties         destination properties

   * @param type               destination type ("queue" or "topic")

   * @param className          creates an instance of the class

   * @param requestClassName 

   * @param strbuf             information

   * @return DestinationDesc   contain destination description

   * @throws UnknownServerException

   * @throws RequestException

   */

  private DestinationDesc createDestination(String destName,

                                           AgentId adminId,

                                           Properties properties,

                                           byte type,

                                           String className,

                                           String requestClassName,

                                           StringBuffer strbuf) throws UnknownServerException, RequestException {

    DestinationDesc destDesc;

    // Retrieving an existing destination:

    if (destName != null && ! destName.equals("") && destinationsTable.containsKey(destName)) {

      destDesc = (DestinationDesc) destinationsTable.get(destName);

      if (! DestinationConstants.compatible(destDesc.getType(), type)) {

        throw new RequestException("Destination type not compliant");

      }

      strbuf.append("Request [").append(requestClassName)

      .append("], processed by AdminTopic on server [").append(serverId)

      .append("], successful [true]: destination [")

      .append(destName).append("] has been retrieved");

    } else {

      // Instantiating the destination class.

      Destination dest = null;

      try {

        dest = (Destination) Class.forName(className).newInstance();

        dest.setName(destName);

        dest.setAdminId(adminId);

        dest.setProperties(properties, true);

      } catch (Exception exc) {

        logger.log(BasicLevel.ERROR,

                   "Could not instantiate Destination class [" + className + "]: ", exc);

        if (exc instanceof ClassCastException)

          throw new RequestException("Class [" + className + "] is not a Destination class.");

        throw new RequestException("Could not instantiate Destination class [" + className + "]: " + exc);

      }

     

      byte destType = dest.getType();

      if (! DestinationConstants.compatible(destType, type)) {

        throw new RequestException("Requested destination type is not compliant with destination classname");

      }

      if (destName == null || destName.equals(""))

        destName = dest.getAgentId();

      destDesc = new DestinationDesc(dest.getId(), destName, destType);

      try {

        dest.deploy();

        destinationsTable.put(destName, destDesc);

        strbuf.append("Request [").append(requestClassName)

        .append("], processed by AdminTopic on server [").append(serverId)

        .append("], successful [true]: ").append(className).append(" [")

        .append(dest.getAgentId()).append("] has been created and deployed");

      } catch (Exception exc) {

        if (logger.isLoggable(BasicLevel.ERROR))

          logger.log(BasicLevel.ERROR, "xxx", exc);

        throw new RequestException("Error while deploying Destination [" + className + "]: " + exc);

      }

    }

    return destDesc;

  }

  /**

   * Processes a <code>DeleteDestination</code> instance requesting the

   * deletion of a destination.

   */

  private void doProcess(DeleteDestination request,

                         AgentId replyTo,

                         String msgId) throws UnknownServerException {

    AgentId destId = AgentId.fromString(request.getId());

    // If the destination is not local, doing nothing:

    if (checkServerId(destId.getTo())) {

      // The destination is  local, process the request.

      String info;

      Iterator destinations = destinationsTable.values().iterator();

      while (destinations.hasNext()) {

        DestinationDesc destDesc = (DestinationDesc) destinations.next();

        if (destDesc.getId().equals(destId)) {

          destinationsTable.remove(destDesc.getName());

          break;

        }

      }

      forward(destId, new DeleteNot());

      info = strbuf.append("Request [").append(request.getClass().getName())

      .append("], sent to AdminTopic on server [").append(serverId)

      .append("], successful [true]: destination [").append(destId)

      .append("], successfuly notified for deletion").toString();

      strbuf.setLength(0);

      distributeReply(replyTo, msgId, new AdminReply(true, info));

      if (logger.isLoggable(BasicLevel.DEBUG))

        logger.log(BasicLevel.DEBUG, info);

    } else {

      // Forward the request to the right AdminTopic agent.

      forward(getDefault(destId.getTo()),

              new FwdAdminRequestNot(request, replyTo, msgId));

    }

  }

  /**

   * Processes a <code>CreateUserRequest</code> instance requesting the

   * creation of a <code>UserAgent</code> for a given user.

   *

   * @exception UnknownServerException  If the target server does not exist.

   * @exception RequestException  If the user already exists but with a

   *              different password, or if the proxy deployment failed.

   */

  private void doProcess(CreateUserRequest request,

                        AgentId replyTo,

                        String msgId) throws UnknownServerException, RequestException {

    if (checkServerId(request.getServerId())) {

      // If this server is the target server, process the request.

      Identity identity = request.getIdentity();

      String name = identity.getUserName();

      AgentId proxId = (AgentId) proxiesTable.get(name);

      String info;

      // The user has already been set.

      if (proxId != null) {

        Identity userIdentity = (Identity) usersTable.get(name);

        if (logger.isLoggable(BasicLevel.INFO))

          logger.log(BasicLevel.INFO, "User [" + name + "] already exists : " + userIdentity);

        try {

          if (! userIdentity.check(identity)) {

            throw new RequestException("User [" + name + "] already exists"

                                       + " but with a different password.");

          }

        } catch (Exception e) {

          throw new RequestException("User [" + name + "] already exists :: Exception :" + e.getMessage());

        }

        info = strbuf.append("Request [").append(request.getClass().getName())

        .append("], processed by AdminTopic on server [").append(serverId)

        .append("], successful [true]: proxy [").append(proxId.toString())

        .append("] of user [").append(name)

        .append("] has been retrieved").toString();

        strbuf.setLength(0);

      } else {

//          if (! identity.validate()) {

//            throw new RequestException("User [" + name + "] security validate failed.");

//          }

//        } catch (Exception e) {

//          throw new RequestException(e.getMessage());

//        }

        UserAgent proxy = new UserAgent();

        proxy.setName(name);

        proxId = proxy.getId();

       

        // set interceptors.

        proxy.setInterceptors(request.getProperties());

       

        try {

          // deploy UserAgent

          proxy.deploy();

          if (logger.isLoggable(BasicLevel.DEBUG))

            logger.log(BasicLevel.DEBUG, "doProcess CreateUserRequest:: store (in usersTable) this identity = " + identity);

          usersTable.put(name, identity);

          proxiesTable.put(name, proxy.getId());

          info = strbuf.append("Request [").append(request.getClass().getName())

          .append("], processed by AdminTopic on server [").append(serverId)

          .append("], successful [true]: proxy [")

          .append(proxId.toString()).append("] for user [").append(name)

          .append("] has been created and deployed").toString();

          strbuf.setLength(0);

        }

        catch (Exception exc) {

          if (logger.isLoggable(BasicLevel.ERROR))

            logger.log(BasicLevel.ERROR, "EXCEPTION:: createUser [" + name + "]", exc);

          throw new RequestException("User proxy not deployed: " + exc);

        }

      }

      if (logger.isLoggable(BasicLevel.DEBUG))

        logger.log(BasicLevel.DEBUG, info);

      distributeReply(replyTo,

                      msgId,

                      new CreateUserReply(proxId.toString(), info));

    } else {

      // Forward the request to the right AdminTopic agent.

      forward(getDefault((short) request.getServerId()),

              new FwdAdminRequestNot(request, replyTo, msgId));

    }

  }

  /**

   * Processes an <code>UpdateUser</code> instance requesting to modify the

   * identification of a user.

   *

   * @exception RequestException  If the user does not exist, or if it's new

   *              name is already used.

   */

  private void doProcess(UpdateUser request,

                         AgentId replyTo,

                         String msgId)

  throws RequestException, UnknownServerException {

    String name = request.getUserName();

    AgentId proxId = AgentId.fromString(request.getProxId());

    if (checkServerId(proxId.getTo())) {

      // If the user belong to this server, process the request.

      String info;

      // If the user does not exist: throwing an exception:

      if (! usersTable.containsKey(name))

        throw new RequestException("User [" + name + "] does not exist");

      Identity newIdentity = request.getNewIdentity();

      // If the new name is already taken by an other user than the modified

      // one:

      if (! newIdentity.getUserName().equals(name)

          && (usersTable.containsKey(newIdentity.getUserName())))

        throw new RequestException("Name [" + newIdentity.getUserName() + "] already used");