/*
    * Copyright (c) 1998-2002 The Jgroup Team.
    *
    * This program is free software; you can redistribute it and/or modify
    * it under the terms of the GNU Lesser General Public License version 2 as
    * published by the Free Software Foundation.
    *
    * This program 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 program; if not, write to the Free Software
   * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
   *
   */
  
  package jgroup.relacs.config;
  
  import static jgroup.util.log.ReplicaEvent.Type.Created;
  
  import java.io.Serializable;
  import java.lang.reflect.UndeclaredThrowableException;
  import java.net.InetAddress;
  import java.net.UnknownHostException;
  import java.rmi.AccessException;
  import java.rmi.NotBoundException;
  import java.rmi.Remote;
  import java.rmi.RemoteException;
  import java.util.Collections;
  import java.util.HashMap;
  import java.util.HashSet;
  import java.util.Iterator;
  import java.util.Map;
  import java.util.Set;
  
  import jgroup.core.arm.ExecException;
  import jgroup.core.arm.ExecService;
  import jgroup.core.registry.BootstrapRegistry;
  import jgroup.relacs.types.EndPointImpl;
  import jgroup.util.log.Eventlogger;
  import jgroup.util.log.ReplicaEvent;
  
  import org.apache.log4j.Logger;
  
  /**
   *  The <code>Host</code> class contains information about a single host
   *  in a domain.
   *
   *  @author Alberto Montresor
   *  @author Hein Meling
   *  @since Jgroup 1.2
   */
  public class Host
    extends EndPointImpl
    implements Iterable<AppConfig>
  {
  
    ////////////////////////////////////////////////////////////////////////////////////////////
    // Logger
    ////////////////////////////////////////////////////////////////////////////////////////////
  
    /** Obtain logger for this class */
    private static final Logger log = Logger.getLogger(Host.class);
  
  
    ////////////////////////////////////////////////////////////////////////////////////////////
    // Constants
    ////////////////////////////////////////////////////////////////////////////////////////////
  
    private static final long serialVersionUID = 5712317513876955415L;
  
    /**
     *  Key for the <code>Host</code> content map; to obtain a remote
     *  reference for the execution daemon running on the associated host.
     */
    private static final String EXEC_DAEMON = "ExecDaemon";
  
    /**
     * Replica state constants
     */
    public enum ReplicaState { FAILED_CREATION, JOIN_PENDING, NORMAL, REMOVE_PENDING }
  
  
    ////////////////////////////////////////////////////////////////////////////////////////////
    // Fields
    ////////////////////////////////////////////////////////////////////////////////////////////
  
    /** Host name */
    private String hostName;
  
    /** Domain of this <code>Host</code> object */
    private Domain domain;
  
    /** Fully Qualified Domain Name (FQDN) */
    private String fqdn;
  
    /** Map for storing content associated with this <code>Host</code> object */
   private final Map<String,Object> content = new HashMap<String,Object>();
 
   /** Set of replicas assigned to this host */
   private final Set<AppConfig> replicas = Collections.synchronizedSet(new HashSet<AppConfig>());
 
   /** Map for keeping track of the replica state of the applications on this host */
   private final Map<AppConfig,ReplicaState> appReplicaState = new HashMap<AppConfig,ReplicaState>();
 
 
   ////////////////////////////////////////////////////////////////////////////////////////////
   // Constructors
   ////////////////////////////////////////////////////////////////////////////////////////////
 
   /**
    *  Default constructor for externalization
    */
   public Host()
   {
     // Ensure that the fqdn is set after deserialization
     fqdn = getAddress().getCanonicalHostName();
   }
 
 
   /**
    *  Construct a new <code>Host</code> object containing information
    *  about the domain, the host and the port number for an entry in the
    *  <code>HostSet</code>.
    */
   public Host(String hostName, Domain domain, int port)
     throws UnknownHostException
   {
     this(getFQDN(hostName, domain), port);
     this.hostName = hostName;
     this.domain = domain;
     /*
      * If the <code>EndPointImpl</code> (see private constructor below)
      * sets this <code>Host</code> as the local host, we must also set
      * the provided <code>Domain</code> to be the local domain.
      */
     if (local)
       domain.setLocal(true);
   }
 
 
   /**
    *  Private constructor for creating a new <code>Host</code> instance,
    *  and initializing the <code>EndPointImpl</code> superclass.
    */
   private Host(String fqdn, int port)
     throws UnknownHostException
   {
     super(InetAddress.getByName(fqdn), port);
     this.fqdn = fqdn;
   }
 
 
   /**
    *  Obtain a stringified fully qualified domain name for the given
    *  host and domain.  That is simply a concatenation of the hostname
    *  and the domain name with a dot between.
    */
   private static String getFQDN(String hostName, Domain domain)
   {
     String fqdn = hostName;
     String domainName = domain.getName();
     if (!(fqdn.indexOf(".") > -1) && !domainName.equals(""))
       fqdn += "." + domainName;
     return fqdn;
   }
 
 
   ////////////////////////////////////////////////////////////////////////////////////////////
   // Host interface methods
   ////////////////////////////////////////////////////////////////////////////////////////////
 
   /**
    *  Returns the fully qualified domain name (host name and domain
    *  name) for this <code>Host</code> object.
    */
   public String getCanonicalHostName()
   {
     return fqdn;
   }
 
 
   /**
    *  Returns the host name for this <code>Host</code> object,
    *  excluding the domain name component.
    */
   public String getHostName()
   {
     return hostName;
   }
 
 
   /**
    *  Returns the domain name for this <code>Host</code> object,
    *  excluding the host name component.
    */
   public String getDomainName()
   {
     return domain.getName();
   }
 
 
   /**
    *  Returns the <code>Domain</code> object associated with
    *  this <code>Host</code> object.
    */
   public Domain getDomain()
   {
     return domain;
   }
 
   ////////////////////////////////////////////////////////////////////////////////////////////
   // Replica assignment handling
   ////////////////////////////////////////////////////////////////////////////////////////////
 
   public Iterator<AppConfig> iterator()
   {
     return replicas.iterator();
   }
 
   public boolean contains(AppConfig app)
   {
     return replicas.contains(app);
   }
 
   public int replicaCount()
   {
     return replicas.size();
   }
 
   /**
    * Assign the <code>app</code> replica to this host.
    * 
    * @param app
    */
   public void assign(AppConfig app)
   {
     replicas.add(app);
   }
 
   public void remove(AppConfig app)
   {
     replicas.remove(app);
   }
 
 
   ////////////////////////////////////////////////////////////////////////////////////////////
   // Content map
   ////////////////////////////////////////////////////////////////////////////////////////////
 
   /**
    *  Retrieve the value associated with this host for the given key.
    */
   public Object get(String key)
   {
     return content.get(key);
   }
 
 
   /**
    *  Associate the given value with this host under the given key.
    */
   public Object put(String key, Object value)
   {
     return content.put(key, value);
   }
 
   public Map<String,Object> getContentMap()
   {
     Map<String,Object> xferContent = new HashMap<String,Object>(content);
     for (Iterator iter = xferContent.values().iterator(); iter.hasNext();) {
       Object obj = (Object) iter.next();
       if (!(obj instanceof Serializable))
         iter.remove();
     }
     return xferContent;
   }
 
   public void setContentMap(Map<String,Object> c)
   {
     this.content.putAll(c);
   }
 
   ////////////////////////////////////////////////////////////////////////////////////////////
   // Host availability
   ////////////////////////////////////////////////////////////////////////////////////////////
 
   /**
    * Returns true if the host is available; otherwise false.
    * The method will also update the reachability status of the host.
    */
   public boolean isAvailable()
   {
     ExecService execRef = getExecDaemon();
     content.put(EXEC_DAEMON, execRef);
     return (execRef != null);
   }
 
   /**
    * Convenience method to update this hosts reachability status.
    */
   public void suspect()
   {
     isAvailable();
   }
 
   /**
    *  Returns true if this host responded to a ping invocation of its
    *  <code>ExecService</code>.  False is returned otherwise.
    */
   public boolean ping()
   {
     if (isAvailable()) {
       ExecService execRef = getExecRef();
       try {
         execRef.ping();
         return true;
       } catch (RemoteException e) {
         log.warn("ping failed: " + execRef, e);
       }
     }
     return false;
   }
 
   public Remote lookup(String name)
     throws AccessException, UnknownHostException, RemoteException, NotBoundException
   {
     return BootstrapRegistry.lookup(fqdn, name);
   }
 
   /**
    *  Get the execution daemon remote reference for the specified host.
    *  If the reference is not stored in the host object or was
    *  previously unavailable, we try to update it by looking up the
    *  bootstrap registry running on the specified host.
    *
    *  @return 
    *    The <code>ExecService</code> interface reference to the remote
    *    object of the execution daemon running on the specified host.
    *    If the return value is <code>null</code>, the specified host
    *    should be considered unavailable.
    */
   private ExecService getExecRef()
   {
     ExecService execRef = (ExecService) content.get(EXEC_DAEMON);
     if (execRef == null) {
       execRef = getExecDaemon();
       content.put(EXEC_DAEMON, execRef);
     }
     return execRef;
   }
 
 
   /**
    *  Get the ExecDaemon reference for this host, by looking up
    *  in the bootstrap registry running on this host.
    *
    *  @return 
    *    The <code>ExecService</code> interface reference to the remote
    *    object of the execution daemon running on this host.
    *    If the return value is <code>null</code>, this host
    *    should be considered unavailable.
    */
   private ExecService getExecDaemon()
   {
 //    if (log.isDebugEnabled())
 //      log.debug("Host " + fqdn + (isLocal() ? " is local" : " is remote"));
     try {
       return (ExecService) lookup(ExecService.EXEC_DAEMON_NAME);
 
     } catch (RemoteException exception) {
       if (log.isDebugEnabled())
         log.debug("Host " + fqdn + " is unavailable");
       return null;
     } catch (NotBoundException exception) {
       if (log.isDebugEnabled())
         log.debug("The ExecDaemon is not running on host " + fqdn);
       return null;
     } catch (UnknownHostException e) {
       if (log.isDebugEnabled())
         log.debug("Host " + fqdn + " is unknown", e);
       return null;
     }
   }
 
 
   ////////////////////////////////////////////////////////////////////////////////////////////
   // Replica management
   ////////////////////////////////////////////////////////////////////////////////////////////
 
   /**
    *  Create a replica for the given <code>app</code> on this host.
    *
    *  @param app
    *    The <code>app</code> for which to create a replica.
    *  @return 
    *    True if the creation was executed without any problems; false otherwise.
    */
   public boolean createReplica(AppConfig app)
   {
     ExecService exec = getExecRef();
     if (exec == null) {
       log.warn("Execution service unavailable on " + this);
       appReplicaState.put(app, ReplicaState.FAILED_CREATION);
       return false;
     }
 
     ClassData cdata = app.getClassData();
     boolean created = false;
     try {
       if (app.startInExecJVM()) {
         created = exec.createExecReplica(cdata);
       } else {
         created = exec.createReplica(cdata);
       }
       if (created) {
         appReplicaState.put(app, ReplicaState.JOIN_PENDING);
         log.info(cdata.getShortName() +" replica successfully created on " + this);
         if (Eventlogger.ENABLED)
           Eventlogger.logEventFlush(new ReplicaEvent(Created, app.getGroupId(), this.address));
       } else {
         ReplicaState state = getState(app);
         log.info(cdata.getShortName() +" replica already created on " + this + ", state: " + state);
         // Since it was already created we should return true from this method
         created = true;
       }
     } catch (UndeclaredThrowableException e) {
       log.warn("Failed to create replica "+ cdata.getShortName() +" on: "+ this, e);
     } catch (RemoteException re) {
       log.warn("Failed to create replica "+ cdata.getShortName() +" on: "+ this, re);
     } catch (ExecException ex) {
       if (log.isDebugEnabled()) {
         log.debug(ex.getMessage());
         Throwable e = ex.getCause();
         if (e != null)
           log.warn(e.getMessage());
       }
     }
     if (!created) {
       appReplicaState.put(app, ReplicaState.FAILED_CREATION);
     }
     return created;
   }
 
 
   /**
    *  Remove the replica for <code>app</code> running on <code>host</code>.
    *
    *  @param app
    *    The <code>app</code> whose replica to remove.
    *  @param host
    *    The <code>host</code> from which to remove the given replica.
    *  @return 
    *    True if the removal was executed without any problems; false otherwise.
    */
   public boolean removeReplica(AppConfig app)
   {
 //    if (log.isDebugEnabled())
 //      log.debug("isLocal: " + isLocal());
     ExecService exec = getExecRef();
     if (exec == null) {
       if (log.isDebugEnabled())
         log.debug("Execution service unavailable on " + this);
       return false;
     }
 
     ClassData cdata = app.getClassData();
     try {
       boolean removed = exec.removeReplica(cdata);
       if (log.isDebugEnabled()) {
         if (removed) {
           log.info(cdata.getShortName() +" replica successfully removed on " + this);
         } else {
           log.info(cdata.getShortName() +" replica already removed on " + this);
         }
       }
     } catch (UndeclaredThrowableException e) {
       log.warn("Failed to remove replica "+ cdata.getShortName() +" on: "+ this, e);
       return false;
     } catch (RemoteException re) {
       log.warn("Failed to remove replica "+ cdata.getShortName() +" on: "+ this, re);
       return false;
     }
     // Update the ReplicaState with the newly removed application
     //FIXME this should be updated also when we return false
     appReplicaState.put(app, ReplicaState.REMOVE_PENDING);
     return true;
   }
 
 
   /**
    * Return the set of replicas running on this host as reported by the ExecDaemon.
    */
   public Set<ClassData> queryReplicas()
   {
     ExecService exec = getExecRef();
     if (exec == null) {
       if (log.isDebugEnabled())
         log.debug("Execution service unavailable on " + this);
       return new HashSet<ClassData>(0);
     }
     try {
       return exec.queryReplicas();
     } catch (RemoteException e) {
       log.warn("Could not access the execution service on " + this, e);
       return new HashSet<ClassData>(0);
     }
   }
 
   /**
    * Returns true if the given application is currently joining at this host.
    */
   public boolean isJoining(AppConfig app)
   {
     ReplicaState state = appReplicaState.get(app);
     if (state == null)
       return false;
     else
       return state.equals(ReplicaState.JOIN_PENDING);
   }
 
   /**
    * Returns the current replica state of the given application on this host.
    */
   public ReplicaState getState(AppConfig app)
   {
     return appReplicaState.get(app);
   }
 
   /**
    * Mark the given application as in the normal state.
    */
   public void viewChange(AppConfig app)
   {
     appReplicaState.put(app, ReplicaState.NORMAL);
   }
 
   /**
    * Request the execution service on this host to shutdown.
    */
   public void shutdown(int delay)
   {
     ExecService exec = getExecDaemon();
     if (exec == null) {
       if (log.isDebugEnabled())
         log.debug("Execution service unavailable on " + this);
       return;
     }
     try {
       exec.shutdown(delay);
     } catch (RemoteException e) {
       log.warn("Could not access the execution service on " + this, e);
     }
   }
 
 } // END Host