/*
 * JBoss, Home of Professional Open Source.
 * Copyright 2006, Red Hat Middleware LLC, and individual contributors
 * as indicated by the @author tags. See the copyright.txt file in the
 * distribution for a full listing of individual contributors.
 *
 * This 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 (at your option) any later version.
 *
 * This software 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 software; if not, write to the Free
 * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
 * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
 */
package org.jboss.ha.singleton;

import java.util.List;

import javax.management.Notification;

import org.jboss.ha.framework.interfaces.ClusterMergeStatus;
import org.jboss.ha.jmx.HAServiceMBeanSupport;

/** 
 * Base class for HA-Singleton services.
 *
 * @author <a href="mailto:ivelin@apache.org">Ivelin Ivanov</a>
 * @author <a href="mailto:scott.stark@jboss.org">Scott Stark</a>
 * @author <a href="mailto:dimitris@jboss.org">Dimitris Andreadis</a>
 * @version $Revision: 61770 $
 */
public class HASingletonSupport extends HAServiceMBeanSupport
   implements HASingletonSupportMBean, HASingleton
{
   // Private Data --------------------------------------------------
   
   private boolean isMasterNode = false;
   private HASingletonElectionPolicy mElectionPolicyMB = null;
   private boolean restartOnMerge = true;

   // Constructors --------------------------------------------------
   
   /**
    * Default CTOR
    */
   public HASingletonSupport()
   {
      // empty
   }

   // Attributes ----------------------------------------------------
   
   /**
    * @jmx:managed-attribute
    * 
    * @return true if this cluster node has the active mbean singleton, false otherwise
    */
   public boolean isMasterNode()
   {
      return isMasterNode;
   }

   /**
    * @see HASingletonSupportMBean#setElectionPolicy(HASingletonElectionPolicy)
    */
   public void setElectionPolicy(HASingletonElectionPolicy mb)
   {
      this.mElectionPolicyMB = mb;
   }
   
   /**
    * @see HASingletonSupportMBean#getElectionPolicy()
    */
   public HASingletonElectionPolicy getElectionPolicy()
   {
      return this.mElectionPolicyMB;
   }

   /**
    * Gets whether this singleton will stop and restart itself if it is the
    * master and a cluster merge occurs.
    * <p/>
    * A restart allows the service to reset any state that may
    * have gotten out-of-sync with the rest of the cluster while
    * the just-merged split was in effect.
    * 
    * @return <code>true</code> if a restart will occur, <code>false</code>
    *         otherwise
    */
   public boolean getRestartOnMerge()
   {
      return restartOnMerge;
   }

   /**
    * Sets whether this singleton will stop and restart itself if it is the
    * master and a cluster merge occurs?
    * <p/>
    * A restart allows the service to reset any state that may
    * have gotten out-of-sync with the rest of the cluster while
    * the just-merged split was in effect.
    * 
    * @param restartOnMerge <code>true</code> if a restart should occur, 
    *                       <code>false</code> otherwise
    */
   public void setRestartOnMerge(boolean restartOnMerge)
   {
      this.restartOnMerge = restartOnMerge;
   }

   // Public --------------------------------------------------------

   /**
    * Extending classes should override this method and implement the custom
    * singleton logic. Only one node in the cluster is the active master.
    * If the current node is elected for master, this method is invoked.
    * When another node is elected for master for some reason, the
    * stopSingleton() method is invokded.
    * <p>
    * When the extending class is a stateful singleton, it will
    * usually use putDistributedState() and getDistributedState() to save in
    * the cluster environment information that will be needed by the next node
    * elected for master should the current master node fail.  
    *
    * @see HASingleton
    */
   public void startSingleton()
   {
      if (log.isDebugEnabled())
         log.debug("startSingleton() : elected for master singleton node");

      // Extending classes will implement the singleton logic here
   }

   /**
    * Extending classes should override this method and implement the custom
    * singleton logic. Only one node in the cluster is the active master.
    * If the current node is master and another node is elected for master, this
    * method is invoked.
    * 
    * @see HASingleton
    */
   public void stopSingleton()
   {
      if (log.isDebugEnabled())
         log.debug("stopSingleton() : another node in the partition (if any) is elected for master");
      
      // Extending classes will implement the singleton logic here
   }

   /**
    * When topology changes, a new master is elected based on the result
    * of the isDRMMasterReplica() call.
    * 
    * @see HAServiceMBeanSupport#partitionTopologyChanged(List, int)
    * @see  DistributedReplicantManager#isMasterReplica(String);
    */
   public void partitionTopologyChanged(List newReplicants, int newViewID)
   {   
      boolean isElectedNewMaster;
      if (this.mElectionPolicyMB != null)
         isElectedNewMaster = this.mElectionPolicyMB.isElectedMaster(this.getPartition());
      else
         isElectedNewMaster = isDRMMasterReplica();
      
      if (log.isDebugEnabled())
      {
         log.debug("partitionTopologyChanged, isElectedNewMaster=" + isElectedNewMaster
            + ", isMasterNode=" + isMasterNode + ", viewID=" + newViewID);
      }

      // if this node is already the master, don't bother electing it again
      if (isElectedNewMaster && isMasterNode)
      {
         // JBAS-4229         
         if (restartOnMerge && ClusterMergeStatus.isMergeInProcess())
         {
            restartMaster();
         }
      }
      // just becoming master
      else if (isElectedNewMaster && !isMasterNode)
      {
         makeThisNodeMaster();
      }
      // transition from master to slave
      else if (isMasterNode == true)
      {
         _stopOldMaster();
      }
   }

   /**
    * This method will be invoked twice by the local node 
    * when it stops as well as by the remote
    */
   public void _stopOldMaster()
   {
      log.debug("_stopOldMaster, isMasterNode=" + isMasterNode);
      
      try 
      {
         // since this is a cluster call, all nodes will hear it
         // so if the node is not the master, then ignore 
         if (isMasterNode == true)
         {
            isMasterNode = false;
            
            // notify stopping
            sendLocalNotification(HASINGLETON_STOPPING_NOTIFICATION);
            
            // stop the singleton
            stopSingleton();
            
            // notify stopped
            sendLocalNotification(HASINGLETON_STOPPED_NOTIFICATION);
         }
      }
      catch (Exception ex)
      {
         log.error(
            "_stopOldMaster failed. Will still try to start new master. " +
            "You need to examine the reason why the old master wouldn't stop and resolve it. " +
            "It is bad that the old singleton may still be running while we are starting a new one, " +
            "so you need to resolve this ASAP.", ex);
      }
   }

   // Protected -----------------------------------------------------
   
   protected void makeThisNodeMaster()
   {
      try
      {
         // stop the old master (if there is one) before starting the new one

         // ovidiu 09/02/04 - temporary solution for Case 1843, use an asynchronous
         // distributed call.
         //callMethodOnPartition("_stopOldMaster", new Object[0], new Class[0]);
         callAsyncMethodOnPartition("_stopOldMaster", new Object[0], new Class[0]);

         startNewMaster();  
      }
      catch (Exception ex)
      {
         log.error("_stopOldMaster failed. New master singleton will not start.", ex);
      }
   }
   
   protected void startNewMaster()
   {
      log.debug("startNewMaster, isMasterNode=" + isMasterNode);
      
      isMasterNode = true;
      
      // notify starting
      sendLocalNotification(HASINGLETON_STARTING_NOTIFICATION);

      // start new master
      startSingleton();
      
      // notify started
      sendLocalNotification(HASINGLETON_STARTED_NOTIFICATION);
   }
   
   protected void restartMaster()
   {
      _stopOldMaster();
      startNewMaster();
   }
   
   // Private -------------------------------------------------------
   
   private void sendLocalNotification(String type)
   {
      Notification n = new Notification(type, this, getNextNotificationSequenceNumber());
      super.sendNotificationToLocalListeners(n);
   }
}