/*
    * Copyright (c) 1998-2004 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.experiment.runnables;
  
  import java.io.File;
  import java.util.Random;
  import java.util.Set;
  
  import jgroup.core.ConfigurationException;
  import jgroup.experiment.Experiment;
  import jgroup.experiment.PropertyDefinition;
  import jgroup.experiment.Runnable;
  import jgroup.relacs.config.AppConfig;
  import jgroup.relacs.config.ClassData;
  import jgroup.relacs.config.ExperimentConfig;
  import jgroup.relacs.config.Host;
  import jgroup.relacs.config.HostSet;
  import jgroup.util.IntList;
  import jgroup.util.log.Eventlogger;
  
  /**
   * @author Hein Meling
   */
  public class CrashFailure
    implements Runnable
  {
  
    ////////////////////////////////////////////////////////////////////////////////////////////
    // Static fields
    ////////////////////////////////////////////////////////////////////////////////////////////
  
    /**
     * Access key to store/retreive the set of replicas in the
     * <code>Host</code> content map.
     */
    private static final String REPLICAS      = "Replicas";
  
    /** Property strings */
    private static final String CRASHES       = "processors.to.crashes";
    private static final String TMAX          = "tmax";
    private static final String RECOVERY_TIME = "recovery.time";
    private static final String MONITORED_APP = "service.being.monitored";
  
    private static final PropertyDefinition[] properties = {
        new PropertyDefinition(CRASHES, PropertyDefinition.INT_TYPE),
        new PropertyDefinition(TMAX, PropertyDefinition.INT_TYPE),
        new PropertyDefinition(RECOVERY_TIME, PropertyDefinition.INT_TYPE),
        new PropertyDefinition(MONITORED_APP, PropertyDefinition.STRING_TYPE)
    };
  
  
    ////////////////////////////////////////////////////////////////////////////////////////////
    // Fields
    ////////////////////////////////////////////////////////////////////////////////////////////
  
    private Random rnd = new Random();
  
  
    ////////////////////////////////////////////////////////////////////////////////////////////
    // Methods from Runnable
    ////////////////////////////////////////////////////////////////////////////////////////////
  
    /* (non-Javadoc)
     * @see jgroup.experiment.Runnable#run(jgroup.relacs.config.ExperimentConfig)
     */
    public void run(ExperimentConfig ec)
      throws ConfigurationException
    {
      // The service to be monitored must be specified
      String monitoredService = ec.getProperty(this, MONITORED_APP);
      int crashes = ec.getIntProperty(this, CRASHES, 1);
      int tmax = ec.getIntProperty(this, TMAX, 5000);
      int recoveryTime = ec.getIntProperty(this, RECOVERY_TIME, 10000);
  
      // All available hosts may be selected to be crashed
      HostSet availableHosts = ec.getServerConfig().getAllHosts().getAvailHosts();
      Host[] aHosts = availableHosts.toArray();
      if (aHosts.length < crashes)
        throw new ConfigurationException("Not enough available hosts to support "
            + crashes + " crashes: " + availableHosts);
  
      if (Eventlogger.ENABLED) {
        String logDir = ec.getProperty("local.save.dir");
       logDir = logDir + File.separator + ec.getExperimentName();
       File ldir = new File(logDir);
       // If the directory does not exist, create it.
       if (!ldir.exists()) {
         if (!ldir.mkdirs()) {
           throw new ConfigurationException("Could not create experiment directory: " + ldir);
         }
       }
     }
 
     /*
      * Compute the uniform distribution of failure injection times
      */
     int[] failureTime = new int[crashes];
     failureTime[0] = 0; // first failure always at t=0.
     for (int i = 1; i < failureTime.length; i++) {
       failureTime[i] = rnd.nextInt(tmax);
     }
 
     /*
      * Compute the uniform distribution of processors that is to be crashed
      */
     IntList hostsToCrash = new IntList();
     for (int i = 0; i < crashes; i++) {
       int tmpRnd = rnd.nextInt(aHosts.length);
       if (!hostsToCrash.contains(tmpRnd))
         hostsToCrash.insert(tmpRnd);
       // if the same host is selected again, then we crash one less host.
     }
     // The hcrash array contains indecies into the aHosts/failureTime arrays
     int[] hcrash = hostsToCrash.toIntArray();
 
     if (Eventlogger.ENABLED)
       //Debug.logEvent("BeginCrashRound", "Exp.no: " + ec.getIntProperty("repeat"));
       Eventlogger.logEventFlush("BeginCrashRound Exp.no: " + ec.getIntProperty("repeat"));
 
     /*
      * In this part we perform the actual failure injections.
      */
     int lastFailureTime = 0;
     ClassData monCD = AppConfig.getApplication(monitoredService).getClassData();
     boolean monitoredServiceAffected = false;
     for (int i = 0; i < hcrash.length; i++) {
       Host host = aHosts[hcrash[i]];
       String hostname = host.getCanonicalHostName();
       System.out.println("Shutdown: " + hostname + " @ " + failureTime[i]);
       if (Eventlogger.ENABLED) {
         /*
          * Check which replicas exists on the selected host.
          */
         Set replicas = host.queryReplicas();
         if (replicas.contains(monCD)) {
           monitoredServiceAffected = true;
         }
         //Debug.logEvent("Crashing @ " + failureTime[i], hostname + ", apps: " + replicas);
         Eventlogger.logEventFlush("Crashing @ " + failureTime[i] + " " + hostname + ", apps: " + replicas);
         
         
       }
       if (failureTime[i] > lastFailureTime)
         lastFailureTime = failureTime[i];
       host.shutdown(failureTime[i]);
     }
     recoveryTime += lastFailureTime;
     Experiment.log.info("Waiting for recovery for: " + (recoveryTime/1000) + " seconds.");
     try {
       Thread.sleep(recoveryTime);
     } catch (InterruptedException e) { }
     Experiment.log.info("Waiting completed");
     if (Eventlogger.ENABLED) {
       Eventlogger.logEventFlush("EndCrashRound " +
           ((monitoredServiceAffected) ?
               "MonitoredServiceAffected" : "MonitoredServiceNotActuallyAffected"));
     }
   }
 
 
   /* (non-Javadoc)
    * @see jgroup.experiment.Runnable#getProperties()
    */
   public PropertyDefinition[] getProperties()
   {
     return properties;
   }
 
 } // END CrashFailure