/*
    * 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.upgrade;
  
  import java.rmi.NotBoundException;
  import java.rmi.RemoteException;
  
  import jgroup.core.ExternalGMIListener;
  import jgroup.core.ExternalGMIService;
  import jgroup.core.JgroupException;
  import jgroup.core.Layer;
  import jgroup.core.MemberId;
  import jgroup.core.MembershipListener;
  import jgroup.core.MembershipService;
  import jgroup.core.View;
  import jgroup.core.arm.ExecException;
  import jgroup.core.arm.UnknownGroupException;
  import jgroup.core.protocols.Multicast;
  import jgroup.core.registry.RegistryService;
  import jgroup.relacs.config.AppConfig;
  import jgroup.relacs.config.DistributedSystemConfig;
  import jgroup.relacs.config.Host;
  import jgroup.relacs.types.EndPointImpl;
  import jgroup.relacs.types.ViewImpl;
  
  import org.apache.log4j.Logger;
  
  /**
   *  The <code>UpgradeLayer</code> allows server replicas to be upgraded
   *  with new software versions.
   *
   *  This layer implements the <code>RecoveryListener</code>, causing the
   *  group manager construction to invoke the <code>initReplica</code>
   *  method on the recovery layer so as to initialize the replica and
   *  join the object group and also bind it with the dependable
   *  registry.
   *
   *  For this layer, the {@link UpgradeService} interface <code>extends</code>
   *  the {@link ExternalGMIListener} so as to be able to communicate with the
   *  external upgrade manager.  This however, prevents us from having the 
   *  {@link Layer} interface in the {@link UpgradeService} definition, since
   *  this is a <code>Remote</code> interface, and thus needs to have its methods
   *  declare a <code>RemoteException</code>.
   *
   *  @author Marcin Solarski
   *  @author Hein Meling
   *  @since Jgroup 2.1
   */
  public class UpgradeLayer
    implements MembershipListener, UpgradeService
  { 
  
    ////////////////////////////////////////////////////////////////////////////////////////////
    // Logger
    ////////////////////////////////////////////////////////////////////////////////////////////
  
    /** Obtain logger for this class */
    private static final Logger log = Logger.getLogger(UpgradeLayer.class);
  
  
    private static final int S_IDLE = 0;
    private static final int S_IDLE_UPGRADING = 1;
    private static final int S_UPGRADING = 2;
    private static final int S_LEAVING = 3;
    private static final int S_EXIT = 4;
  
    private static final String S_names[] = new String[] {
      "S_IDLE",
      "S_IDLE_UPGRADING",
      "S_UPGRADING",
      "S_LEAVING",
      "S_EXIT"
    };
  
    /** a flag enabling time measurements */
    private static final boolean MEASUREMENT = true;
  
    /** array with times of state transitions */
    private long times[] = new long [S_EXIT+1];
  
  
    ////////////////////////////////////////////////////////////////////////////////////////////
    // Fields
   ////////////////////////////////////////////////////////////////////////////////////////////
 
   /** state of the UpgradeLayer */
   private int state = S_IDLE;
 
   /** The upgrade listener associated with this GM layer. */
   private UpgradeListener upgradeListener;
 
   private MemberId thisMember;
 
   /** the last view known to the upgrade layer */
   private View currentView = new ViewImpl();
   
   /** the members of the view installed at the time the upgrade request is received */
   private MemberId[] initialMembers = null;
 
   private Host localHost = DistributedSystemConfig.getLocalHost();
 
   private AppConfig thisApp;
 
   private MembershipService membershipService;
 
   private RegistryService registryService;
 
   /** a support variable that states whether this member is to be upgraded as next */
   private boolean upgradable = false;
 
   /** a support variable that states whether this member can leave the group */
   private boolean leavingTime = false;
 
 
   ////////////////////////////////////////////////////////////////////////////////////////////
   // Constructors
   ////////////////////////////////////////////////////////////////////////////////////////////
 
   /**
    *
    */
   private UpgradeLayer(MembershipService pgms, RegistryService regs, ExternalGMIService egmi)
     throws JgroupException, RemoteException
   {
     membershipService = pgms;
     thisMember = pgms.getMyIdentifier();
     registryService = regs;
     if (log.isDebugEnabled())
       log.debug("UpgradeLayer constructed");
   }
 
 
   ////////////////////////////////////////////////////////////////////////////////////////////
   // Static factory
   ////////////////////////////////////////////////////////////////////////////////////////////
 
   public static UpgradeLayer getLayer(MembershipService pgms, RegistryService regs,
       ExternalGMIService egmi) throws JgroupException, RemoteException
   {
     return new UpgradeLayer(pgms, regs, egmi);
   }
 
 
   ////////////////////////////////////////////////////////////////////////////////////////////
   // Layer interface methods
   ////////////////////////////////////////////////////////////////////////////////////////////
 
   /**
    *  Add a listener object for upgraded events.
    */
   public void addListener(Object listener)
   {
     if (log.isDebugEnabled())
       log.debug("Adding a listener of the UpgradeLayer");
     if (listener == null)
       throw new NullPointerException("No replica specified for addListener");
     if (!(listener instanceof UpgradeListener))
       throw new IllegalArgumentException("Specified listener do not implement the UpgradeListener interface");
     if (upgradeListener != null)
       throw new IllegalStateException("Only one upgrade listener is allowed for each replica.");
     /* Get application object for this replica */
     thisApp = AppConfig.getApplication(listener);
     final String upgradeServiceName = UPGRADE_SERVICE + "-" + thisApp.getGroupId();
 
     try {
       registryService.bind(upgradeServiceName, this);
       if (log.isDebugEnabled())
         log.debug("Bound the UpgradeLayer in the registry: " + upgradeServiceName);
     } catch (Exception e) {
       throw new IllegalStateException("Unable to bind " + upgradeServiceName + 
           " in the dependable registry", e);
     }
 
     /* Keep the server reference for invoking the upgraded method. */
     upgradeListener = (UpgradeListener) listener;
   }
 
 
   ////////////////////////////////////////////////////////////////////////////////////////////
   // UpgradeService interface methods
   ////////////////////////////////////////////////////////////////////////////////////////////
 
   /**
    *  The <code>upgradeRequest</code> method will initiate the upgrade
    *  of the given application group to the new specified application
    *  class.
    *
    *  This method is invoked through the EGMI layer, so the upgrade
    *  manager must obtain a reference to this layer in order to request
    *  an upgrade.
    *
    *  @exception UnknownGroupException
    *    Raised if the specified application does not this replicas group.
    */
   @Multicast public synchronized void upgradeRequest(AppConfig newApp)
     throws RemoteException, UnknownGroupException, ExecException
   {
     if (MEASUREMENT) {
       times[S_IDLE_UPGRADING] = System.currentTimeMillis(); 
       if (log.isDebugEnabled())
         log.debug("S_IDLE_UPGRADING@" + thisMember + "time = " + times[S_IDLE_UPGRADING]);
     }
     if (log.isDebugEnabled())
       log.debug("UpgradeRequest@UpgradeLayer: " + newApp);
     if (state == S_UPGRADING) {
       if (log.isDebugEnabled())
         log.warn("Upgrade request ignored; already upgrading " + newApp);
       return;
     }
 
     // Change the layer state
     state = S_IDLE_UPGRADING;
     if (newApp.getGroupId() != currentView.getGid())
       throw new UnknownGroupException("This replica has GroupId: ", currentView.getGid());
     
     // joan commment: The new and the old version of the server has to have the same
     //                groupid. See applications.xml
     
     // Prepare the input data for the later selection algorithm
     prepareSelection();
 
     // Start the upgrade thread that will perform the upgrade "in the background"
     new Thread(new ReplicaUpgradingThread(this, newApp), "UPGRDADING_THREAD").start();
   }
 
 
   ////////////////////////////////////////////////////////////////////////////////////////////
   // Private methods
   ////////////////////////////////////////////////////////////////////////////////////////////
 
   private synchronized void wait_for_new_notifications()
   {
     try {
       wait();
     } catch (InterruptedException e) { /* Ignored; should never happen */ }
     if (log.isDebugEnabled())
       log.debug("After the UPGRADING_THREAD notification");
   }
 
   /**
    * prepares a later selection of the upgrade candidates.
    * stores the highest localIDs for each EndPoint
    * members with higher localIDs than the ones are considered
    * new members in the future views during the upgrade process
    */
   private void prepareSelection()
   {
     initialMembers = currentView.getMembers();
     if (log.isDebugEnabled())
       log.debug("Initial view = " + currentView);
     upgradable = amItheNext(currentView);
   }
 
   /**
    *  Checks whether this memeber is the one to be upgraded as 
    *  the next one.
    *  The current implementation is based on checking that
    *  (1) this member has the smallest MemberId (which should 
    *  be unique in the whole) and (2) it was in the view when 
    *  the upgrade request was received. 
    */
   
   /*  The implementation with 0-index 
    *  in the view did not work because the new replicas may
    *  get an index of 0. 
    */
   private boolean amItheNext(View view)
   {
     MemberId[] members = view.commonMembers(initialMembers);
   
     if (members.length == 0)
       return false;
     MemberId smallest = members[0];
   
     for (int i = 1; i < members.length; i++) {
       if (smallest.compareTo(members[i]) > 0)
         smallest = members[i];
     }
   
     if (log.isDebugEnabled())
       log.debug("amItheNext: Smallest member = " + smallest + " am I the next one = " + smallest.equals(thisMember));
     if (smallest.equals(thisMember))
       return true;
     else
       return false;
   }
 
   /**
    * check whether it is time for this replica to leave the group
    * after a new replica is started. this implementation checks just 
    * that the view size is greater than the view size before the upgrade
    * and that there are at least 2 replicas running on the host local
    * to the member being upgraded.
    */
   private boolean isItTimeToLeave(View view)
   {
     if (initialMembers == null)
       return false;
     int vl = view.size();
     if (vl > initialMembers.length) {
       int localReplicas = 0;
       for (int i = 0; i < vl; i++) {
         EndPointImpl ep = (EndPointImpl) view.getMembers()[i].getEndPoint();
         if (ep.compareTo(thisMember.getEndPoint()) == 0)
           localReplicas++;
       }
       if (log.isDebugEnabled())
         log.debug("Number of replicas on the local host: " + localReplicas);
       if (localReplicas > 1)
         return true;
     }
     return false;
   
   }
 
   /**
    * prints the time of state transitions of the upgrade algorithm
    */
   private void showTimes() {
     log.info("State transition times for replica at " + thisMember.getEndPoint().getIntAddress());
     StringBuilder b = new StringBuilder();
     for(int i=S_IDLE_UPGRADING; i<times.length-1; i++)
       b.append(S_names[i] + "\t");
     log.info(b);
     
     b = new StringBuilder();
     for(int i=S_IDLE_UPGRADING; i<times.length-1; i++)
       b.append(times[i] + "\t");
     log.info(b);
     log.info(" Time Diffs:");
     b = new StringBuilder();
     for(int i=S_IDLE_UPGRADING; i<times.length-1; i++)
       b.append((times[i]- times[i-1]) + "\t");
     log.info(b);
   }
 
   private boolean upgradeEnabled(AppConfig newApp)
   {
     int vs = currentView.size();
     if (log.isDebugEnabled())
       log.debug("Checking the upgrade enabling condition: View.size= "  + vs +  ", upgradable: " + upgradable);
     return (vs > newApp.getMinimalRedundancy() && upgradable);
     //joan comment: Make Hein explain the line above.
   }
 
 
   ////////////////////////////////////////////////////////////////////////////////////////////
   // Methods from MembershipListener
   ////////////////////////////////////////////////////////////////////////////////////////////
   
   /**
    *  Upcall that is invoked by Jgroup when a view change occur in this
    *  replica's object group.
    *
    *  @param view
    *    The new view object group.
    */
   public synchronized void viewChange(View view)
   {
     if (log.isDebugEnabled())
       log.debug("UpgradeLayer:viewChange: " + view);
     /* Keep the current view for later access */
     currentView = view;
   
     upgradable = amItheNext(view);
     if (log.isDebugEnabled())
       log.debug("Checking if I'm the replica to be upgraded next: " + upgradable);
   
     /* check whether it is time for this replica to leave the group */
     leavingTime = isItTimeToLeave(view);
   
     notifyAll();
   }
 
   /**
    *  Upcall that is invoked by Jgroup to acknowledge the fact that an
    *  object is not member of a group any more more:
    *
    */
   public void hasLeft()
   {
     if (log.isDebugEnabled()) log.debug("Replica upgraded");
     upgradeListener.upgraded();
     boolean removed = localHost.removeReplica(thisApp);
   }
 
   /**
    *  Currently not implemented.
    *
    */
   public void prepareChange()
   {
   }
 
 
   ////////////////////////////////////////////////////////////////////////////////////////////
   // Private inner class
   ////////////////////////////////////////////////////////////////////////////////////////////
 
   /**
    * an internal class implementing most of the upgrade algorithm.
    * It is started in another thread than the invocation thread of the 
    * upgrade request to carry out the algorithm asynchronously to
    * the upgrade request (the decision taken to overcome the bug
    * of the local membership service of Jgroup2)
    */
   private class ReplicaUpgradingThread
     implements Runnable
   {
     private AppConfig newApp;
     private UpgradeLayer monitor;
 
     ReplicaUpgradingThread(UpgradeLayer monitor, AppConfig newApp)
     {
       this.monitor=monitor;
       this.newApp=newApp; 
     }
 
     public void run()
     {
       if (log.isDebugEnabled())
         log.debug("UpgradeLayer: Entering the loop checking the enabling condition upgrading of this replica");
       while (!upgradeEnabled(newApp)) {
         if (log.isDebugEnabled())
           log.debug("UpgradeLayer: in the loop after having checked the condition");
         wait_for_new_notifications();
       }
       
       //joan comment: Is this where this UpgradeServer has become part of the set R
       //              described in the algorithm, and has not yet been picked for 
       //              upgrade ? 
       
       if (log.isDebugEnabled())
         log.debug("UpgradeLayer: Leaving the loop checking the enabling condition upgrading of this replica");
 
       /* FIXME Here we need to block requests to this replica, or ? */
 
       state = S_UPGRADING;
       if (MEASUREMENT) {
         times[S_UPGRADING] = System.currentTimeMillis(); 
         if (log.isDebugEnabled())
           log.debug("S_UPGRADING@" + thisMember + "time = " + times[S_UPGRADING]);
       }
 
       try {
         localHost.createReplica(newApp);
         //joan comment: Ask Hein if this is the ExecDeamon.
         
       } catch (Exception ex) {
         log.error("Cannot start a new replica", ex);
       }
       if (log.isDebugEnabled())
         log.debug("After a replica is triggered to be created");
 
       // Waiting for the new replica to join the group
       while (!leavingTime) {
         if (log.isDebugEnabled())
           log.debug("UpgradeLayer: S_UPGRADING loop");
         wait_for_new_notifications();
       }
 
       state = S_LEAVING;
       if (MEASUREMENT) {
         times[S_LEAVING] = System.currentTimeMillis(); 
         if (log.isDebugEnabled())
           log.debug("S_LEAVING@" + thisMember + "time = " + times[S_LEAVING]);
       }
       showTimes();
       if (log.isDebugEnabled())
         log.debug("Releasing the replica ...");
       try {
         membershipService.leave();
         registryService.unbind();
         if (log.isDebugEnabled())
           log.debug("Replica successfully released.");
         state = S_EXIT;
         if (MEASUREMENT) {
           times[S_EXIT] = System.currentTimeMillis(); 
           if (log.isDebugEnabled())
             log.debug("S_EXIT@" + thisMember + "time = " + times[S_EXIT]);
         }
         // we should not exit the jvm since it would kill the ExecDaemon
         //System.exit(0);
       } catch (JgroupException e) {
         log.error("An exception while releasing a replica", e);
       } catch (RemoteException e) {
         log.error("An exception while unbinding replica", e);
       } catch (NotBoundException e) {
         log.error("An exception while unbinding replica", e);
       }
     }
   }
 
 
 } // END UpgradeLayer