/*
    * 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.test.performance.upgrade;
  
  import java.util.Date;
  
  import jgroup.core.ConfigManager;
  import jgroup.core.registry.DependableRegistry;
  import jgroup.core.registry.RegistryFactory;
  import jgroup.relacs.config.AppConfig;
  import jgroup.test.performance.SpeedTest;
  import jgroup.upgrade.UpgradeManagementClient;
  
  import org.apache.log4j.Logger;
  
  
  
  /**
   *  Test suite for measuring the performance of a server during the upgrade process.
   *  The class parses the experiment parameter from command line. The following
   *  parameters are interpreted:
   *
   *  <p>
   *  @param -method type of test calls sent to the server
   *  @param -calibrate number of calibration calls
   *  @param -rate the rate at which requests are sent to the test server
   *  @param -time the time of the cycle in seconds
   *  @param -cycles number of cycles of request bursts
   *  @param -upgradeStart the cycle number at which the upgrade starts
   *  @param -clients number of local clients generating the requests
   *          This parameter is left for compatibility but is not considereed.
   *  @param -server name at which the test server is registered at the repository
   *  @param -verbose verbose way of performing the experiment 
   *
   *  @author       Marcin Solarski
   *  @since        Jgroup 2.1
   */
  public class SimpleUpgradeTestSuite
  {
  
  
    /** Obtain logger for this class */
    private static Logger log = Logger.getLogger(SimpleUpgradeTestSuite.class);
    private static SimpleUpgradeTestSuite instance = null;
    private boolean verbose;
    private int method;
    private int calibReqCallNo;
    private int rps;
    private int expTime;
    private int cycles;
    private int upgrade_cycle;
    private int client_no;
    private String serverName;
    private SpeedTest server; 
    private float avRT[];
    private long startCycleTime[];
   
    private static final long  TIME_UNIT = 1000;
  
    public static void main(String[] argv) throws Exception
    {
      ConfigManager.init();
      if (instance == null)
        instance = new SimpleUpgradeTestSuite(argv);
    }
    
    public SimpleUpgradeTestSuite(String argv[]) throws Exception {
      if( argv.length <1 ) help();
      verbose = PUtil.getSwitch(argv, "-v");
      method = PUtil.getIntParameter(argv, "-method", "1");
      calibReqCallNo = PUtil.getIntParameter(argv, "-calibrate", "10");
      rps = PUtil.getIntParameter(argv, "-rate", "1");
      expTime = PUtil.getIntParameter(argv, "-time", "10");
      cycles = PUtil.getIntParameter(argv, "-cycles", "1");
      upgrade_cycle = PUtil.getIntParameter(argv, "-upgradeStart", "-1");
      client_no = PUtil.getIntParameter(argv, "-clients", "1");
      serverName = PUtil.getStringParameter(argv, "-server", "UpgradeServer");
      //package name is hard coded
      String cl_name = "jgroup.test.performance." + serverName;
      int rep_lvl = 0;
      ConfigManager.init();
      rep_lvl = AppConfig.getApplication(cl_name).getInitialRedundancy();
  
     ClientThreadPool client[] = new ClientThreadPool[client_no];
 
     int times = expTime*rps;
     DependableRegistry reg = RegistryFactory.getRegistry();
     server = (SpeedTest) reg.lookup(serverName);
     int call_no = 0;
     
     avRT = new float[cycles+1];
     startCycleTime = new long[cycles+1];
     SimpleTestThread testRun = new SimpleTestThread(Thread.currentThread());
     float allowedDelay = 1.20f;
     testRun.start();
     long expStartTime = System.currentTimeMillis();
     long expEndTime = expStartTime + expTime*cycles*TIME_UNIT;
     boolean terminated_ok = false;
     System.out.println("Test started. Should be fininshed in " + expTime*cycles + "sec.");
     try { Thread.sleep((long)(expTime*cycles*allowedDelay*TIME_UNIT)); }
     catch (InterruptedException e) {
        terminated_ok = true;
     }
     
    
     /*for(int i=0; i< client_no; i++) 
       client[i].CycleDone(cycles);
     ClientThreadPool.allStop();
 */
     //header printout
      if( verbose ) {
        expEndTime = System.currentTimeMillis();
        String date = new Date(expStartTime).toString();
        log.info("R" + rep_lvl + " m" + method + " r" + rps) ;
        log.info("#Experiment started at: " + new Date(expStartTime));
        String term_mesg = terminated_ok ? " ok" : " not ok";
        log.info("#Experiment terminated at: " + new Date(expEndTime) + term_mesg);
        log.info("#Testing suite with the following parameters: ");
        log.info("#Server name:                \t"+ serverName);
        log.info("#Server replication level:   \t"+ rep_lvl);
        log.info("#Number of calibration calls:\t" + calibReqCallNo);
        log.info("#Test method:                \t" + method);
        log.info("#Request rate per sec:       \t" + rps);
        log.info("#Cycle time:                 \t" + expTime);
        log.info("#Cycles number:              \t"+ cycles);
        log.info("#Staring upgrade at cycle:   \t" + upgrade_cycle);
     }
 
    StringBuilder header = new StringBuilder("#Cycle\tT0\tdT");
     for(int i=0; i< client_no; i++) 
       header.append("\t" + "RT[" + i +"]");
     log.info(header);
    
     for(int j=1; j< testRun.getLastCycleTerminated(); j++) {
       long T0 = startCycleTime[j];
       long dT = j>1 ? T0-startCycleTime[j-1] : 0;
       StringBuilder line = new StringBuilder(""+j + "\t" + T0 + "\t" + dT);
       for(int i=0; i< client_no; i++) 
           line.append("\t" + avRT[j]);
       log.info(line);
     }
       
     //log.info("Stopping all threads");
     //ClientThreadPool.allStop();
     System.exit(0);
 
  }
 
 
 
   static void help() {
      System.out.println("SimpleUpgradeTestSuite [-v][-method M][-calibrate C][-rate R][-time T][cycles Y][-clientsi N][-upgradeStart U][-server ServerName]");
   } 
 
   class SimpleTestThread extends Thread {
      private Thread mainThread;
      private int j=1;
      private UpgradeStart upgradeT;
  
      private UpgradeClientTest test;
      public int getLastCycleTerminated() { return j-1; }
 
      //SimpleTestThread(Thread t, int method, int calibReqCallNo, int cycles, int rps, int times) { 
      SimpleTestThread(Thread t) {
 
       upgradeT = new UpgradeStart();
       mainThread= t; 
 
       test = new UpgradeClientTest(server);
       avRT[0] = test.calibrate(method, calibReqCallNo);
      }
 
      public void run() { 
       //runTest(cyc, rate, calls); 
       runTest(cycles, rps, expTime*rps); 
       mainThread.interrupt(); 
      } 
  
      private void runTest(int cycles, int rps, int times) {
        for(j=1; j<= cycles; j++) { 
         startCycleTime[j] = System.currentTimeMillis();
         avRT[j] = test.generate_traffic(rps, times);
         if(j == upgrade_cycle ) { upgradeT.start(); System.out.println("upgrade started at cycle" + j);}
         if(j%5==0) System.out.println("Cycles done: " + j +" out of " + cycles);
        }
      }
   }
 
 
   class UpgradeStart extends Thread { 
 	  String argv[] = new String[] {"u"}; 
      public void run(){
 	 try { UpgradeManagementClient.main(argv);
 	 } catch(Exception e) {log.error("Exception in main", e);}
 
      }
 
 
   }
 
   
 }