/*
Copyright 1999-2011 (c) My-Channels
Copyright (c) 2012Ð2014 Software AG, Darmstadt, Germany and/or Software AG USA Inc., Reston, VA, USA, and/or its subsidiaries and/or its affiliates and/or their licensors.

Use, reproduction, transfer, publication or disclosure is prohibited except as specifically provided for in your License Agreement with Software AG.
*/
package com.pcbsys.nirvana.nAdminAPI.apps;
import com.pcbsys.nirvana.client.nSessionAttributes;
import com.pcbsys.nirvana.nAdminAPI.*;
import java.io.*;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.text.SimpleDateFormat;
import java.util.*;

/**
 * This application will start multiple threads to monitor each specified Nirvana realm. Triggers can be set in the
 * configuration file.  If these triggers are hit, information regarding this issue will be output to a CSV file.
 */
public class RealmMonitor {

  String sampleConfig = ""
    +  "#  SAMPLE CONFIG FILE \n"
    +  "\n"
    +  "\n"
    +  "#If no workingdir set then will default to current dir\n"
    +  "\n"
    +  "#workingdir=/Users/XXX/Desktop/\n"
    +  "runRealmMonitor=true \n"
    +  "runConnectionMonitor=true \n"
    +  "runThreadMonitor= true \n"
    +  "runLogMonitor= true \n"
    +  "runChannelMonitor= true\n"
    +   "\n"
    +  "#--------------------\n"
    +  "monitor=connectionmonitor \n"
    +  "headings=Date,Time,Name,Last received,Queue Size,Events Received,Events Transmitted\n"
    +  "methods=getDate,getTime,getRealmName,getTimeOfLastReceive,getQueueSize,getEventsReceived,getEventsTransmitted\n"
    +  "#outputfile=/Users/XXX/Desktop/ConnectionMonitor.txt \n"
    +  "refreshrate=5000\n"
    +  "#maxTimeOfLastTransmitt=5000 #default = keepAliveTime * 1.5\n"
    +  "maxQueuedEvents=0\n"
    +  "\n"
    +  "#-------------------- \n"
    +  "monitor = threadmonitor  \n"
    +  "headings = Time,Realm Name,Name,Queued,Idle,Allocated,Tasks Executed \n"
    +  "methods = getTime, getRealmName,getName,getQueue,getIdle,getSize,getTotal\n"
    +  "maxQueueSize=0;\n"
    +  "minIdle=0\n"
    +  "\n"
    +  "#---------------------\n"
    +  "monitor = logmonitor\n"
    +  "keywords = exception,stalled,attack,Exceeded\n"
    +  "\n"
    +  "#---------------------\n"
    +  "monitor = realmmonitor \n"
    +  "refreshrate=5000\n"
    +  "headings=Time,Name,Channels,Queues,Current Connections,Total Connections,Free Memory,Total Memory,Used Memory,Threads \n"
    +  "methods=getTime, getRealmName,getNoOfChannels,getNoOfQueues,getCurrentConnections,getTotalConnections,getFreeMemory,getTotalMemory,getUsedMemory,getNoOfThreads \n"
    +  "methodsError=getTime, getRealmName,print0, print0, print0, print0, print0, print0, print0, print0\n"
    +  "#methodsError lists the methods to call if there is an error.  print0 will simply output 0 so there are clear errors in any graphs\n"
    +  "\n"
    +  "\n"
    +  "#---------------------\n"
    +  "monitor = channelmonitor \n"
    +  "#debug=true\n"
    +  "refreshrate=10000\n"
    +  "headings=Time,Name,Type, Published, Consumed, Connections, Used Space, pub rate\n"
    +  "methods = getTime,getName,getType, getTotalPublished,getTotalConsumed, getTotalNoOfConnections, getUsedSpace, getPublishRate\n"
    +  "\n"
    +  "#int\n"
    +  "minPercentFreeInStore = 0;\n"
    +  "minFanoutTime         = 0;\n"
    +  "minUsedSpace          = 0;\n"
    +  "#long\n"
    +  "minCurrentEvents      = 0;\n"
    +  "#float\n"
    +  "minConsumedRate       = 0.0;\n"
    +  "minPubRate            = .0; \n"
    +  "minCacheHitRatio      = 0;\n"
    +  "minConnectionRate     = 0;\n"
    +  "minCurrentCons        = 0;\n"
    +  "\n"
    +  "#maxFanoutTime         =           #Integer.MAX_VALUE; <default value if left commented\n"
    +  "#maxUsedSpace          =           #0;\n"
    +  "#maxConsumedRate       =           #0;\n"
    +  "#maxCurrentEvents      =           #Long.MAX_VALUE;\n"
    +  "#maxPubRate            =           #Float.MAX_VALUE;\n"
    +  "#maxCacheHitRatio      =           #Float.MAX_VALUE;\n"
    +  "#maxConnectionRate     =           #Float.MAX_VALUE;\n"
    +  "#maxCurrentCons        =           #Float.MAX_VALUE;\n"
    +  "#maxPercentFreeInStore =           #Integer.MAX_VALUE;\n";

  private String configloc = "";
  private String[] rnames = new String[]{"nsp://localhost:9000"};


  //------- What to run -------
  private boolean runRealmMonitor = true;
  private boolean runChannelMonitor = true;
  private boolean runConnectionMonitor = true;
  private boolean runThreadMonitor = true;
  private boolean runLogMonitor = true;
  //-------------------------

  //--------MonitorObjects------
  private List<RealmMonitor_t> realm_m = new ArrayList<RealmMonitor_t>();
  private List<ChannelMonitor_t> chan_m = new ArrayList<ChannelMonitor_t>();
  private List<ConnectionMonitor_t> con_m = new ArrayList<ConnectionMonitor_t>();
  private List<ThreadMonitor_t> thread_m = new ArrayList<ThreadMonitor_t>();
  private List<LogMonitor_t> log_m = new ArrayList<LogMonitor_t>();
  //----------------------------

  String TIME_FORMAT_NOW = "HH:mm:ss";
  String DATE_FORMAT_NOW = "dd.MM.yyyy";
  SimpleDateFormat timeformat = new SimpleDateFormat(TIME_FORMAT_NOW);
  SimpleDateFormat dateformat = new SimpleDateFormat(DATE_FORMAT_NOW);

  String workingdir = "";

  public static void main(String[] args){
    new RealmMonitor(args);
  }

  /**
   * First process the arguments (Rname and config file location)
   *
   * All other properties are then read in from the config file.  Config file can set properties for the individual
   * monitor threads but also specify which methods to invoke and output to the csv files.
   *
   * Each monitor thread is passed a list of methods to invoke.  The connection monitor for example will try to invoke
   * these methods on the nConnectionDetails object where as the Realm monitor will invoke the methods on the rNode.
   *
   * It is also possible to override these methods or define custom methods.  This is handled by the order in which the application
   * tries to invoke the methods.  First we try to invoke on the monitor thread, then the actual object (e.g. nConnectionDetails)
   * and finally this class.  By doing this we can override certain methods in order to return a value in a different format (e.g. a time)
   * Also we will want to timestamp everything that is written to the csv file so there is a getTime method written for this class
   * so we can add getTime to our methods list.
   *
   */
  public RealmMonitor(String[] args){
    workingdir = System.getProperty("user.dir")+"/RealmMonitorOut/";
    processArgs(args);
    setupMonitorThreads();
    checkConfig();
    try{
      getConfigDetails();
    }
    catch(Exception e){
      e.printStackTrace();
    }
    new ExitHandler();
    startMonitorThreads();
  }

  /**
   * We store everything based on rname so when we get a nRealmNode for a cluster node we need to find that nodes rname.
   * @param n a realm node
   * @return the rname for n
   */
  public String getRname(nRealmNode n){
    nInterfaceStatus is = (nInterfaceStatus)n.getInterfaceManager().getInterfaces().get(0);
    nInterface i = is.getInterface();
    return i.getURL();
  }

  /**
   * Creates one rnode for every rname passed in, also gets any other realm nodes which are part of a cluster.
   * A new thread is then created (but not started) for every rname and every different monitor.
   */
  private void setupMonitorThreads(){
    if(runRealmMonitor) {
      for (String rname : rnames) {
        nRealmNode rNode = getRealmNode(rname);
        rNode.waitForEntireNameSpace();
        if (rNode.isClustered()) {
          nClusterNode cNode = rNode.getCluster();
          Enumeration nodes = cNode.getNodes();
          while (nodes.hasMoreElements()) {
            nRealmNode n;
            try {
              n = (nRealmNode) nodes.nextElement();
              realm_m.add(new RealmMonitor_t(getRname(n)).withRnode(n));
            } catch (Exception e) {
              System.out.println("Error trying to get all nodes in cluster: attempting to continue");
            }
          }
        } else realm_m.add(new RealmMonitor_t(rname).withRnode(rNode));
      }
    }
    if(runChannelMonitor) {
      for (String rname : rnames) {
        nRealmNode rNode = getRealmNode(rname);
        rNode.waitForEntireNameSpace();
        if (rNode.isClustered()) {
          nClusterNode cNode = rNode.getCluster();
          Enumeration nodes = cNode.getNodes();
          while (nodes.hasMoreElements()) {
            nRealmNode n;
            try {
              n = (nRealmNode) nodes.nextElement();
              chan_m.add(new ChannelMonitor_t(getRname(n)).withRnode(n));
            } catch (Exception e) {
              System.out.println("Error trying to get all nodes in cluster: attempting to continue");
            }
          }
        } else chan_m.add(new ChannelMonitor_t(rname).withRnode(rNode));
      }
    }
    if(runLogMonitor) {
      for (String rname : rnames) {
        nRealmNode rNode = getRealmNode(rname);
        rNode.waitForEntireNameSpace();
        if (rNode.isClustered()) {
          nClusterNode cNode = rNode.getCluster();
          Enumeration nodes = cNode.getNodes();
          while (nodes.hasMoreElements()) {
            nRealmNode n;
            try {
              n = (nRealmNode) nodes.nextElement();
              log_m.add(new LogMonitor_t(getRname(n)).withRnode(n));
            } catch (Exception e) {
              System.out.println("Error trying to get all nodes in cluster: attempting to continue");
            }
          }
        } else log_m.add(new LogMonitor_t(rname).withRnode(rNode));
      }
    }
    if(runConnectionMonitor) {
      for (String rname : rnames) {
        nRealmNode rNode = getRealmNode(rname);
        rNode.waitForEntireNameSpace();
        if (rNode.isClustered()) {
          nClusterNode cNode = rNode.getCluster();
          Enumeration nodes = cNode.getNodes();
          while (nodes.hasMoreElements()) {
            nRealmNode n;
            try {
              n = (nRealmNode) nodes.nextElement();
              con_m.add(new ConnectionMonitor_t(getRname(n)).withRnode(n));
            } catch (Exception e) {
              System.out.println("Error trying to get all nodes in cluster: attempting to continue");
            }
          }
        } else con_m.add(new ConnectionMonitor_t(rname).withRnode(rNode));
      }
    }
    if(runThreadMonitor) {
      for (String rname : rnames) {
        nRealmNode rNode = getRealmNode(rname);
        rNode.waitForEntireNameSpace();
        if (rNode.isClustered()) {
          nClusterNode cNode = rNode.getCluster();
          Enumeration nodes = cNode.getNodes();
          while (nodes.hasMoreElements()) {
            nRealmNode n;
            try {
              n = (nRealmNode) nodes.nextElement();
              thread_m.add(new ThreadMonitor_t(getRname(n)).withRnode(n));
            } catch (Exception e) {
              System.out.println("Error trying to get all nodes in cluster: attempting to continue");
            }
          }
        } else thread_m.add(new ThreadMonitor_t(rname).withRnode(rNode));
      }
    }
  }

  /**
   * Once we have dealt with the configuration file the threads are all initialised.
   */
  private void startMonitorThreads(){
    if(runRealmMonitor) {
      for (RealmMonitor_t aRealm_m : realm_m) {
        aRealm_m.init();
      }
    }
    if(runChannelMonitor) {
      for (ChannelMonitor_t aChan_m : chan_m) {
        aChan_m.init();
      }
    }
    if(runLogMonitor) {
      for (LogMonitor_t aLog_m : log_m) {
        aLog_m.init();
      }
    }
    if(runConnectionMonitor) {
      for (ConnectionMonitor_t aCon_m : con_m) {
        aCon_m.init();
      }
    }
    if(runThreadMonitor) {
      for (ThreadMonitor_t aThread_m : thread_m) {
        aThread_m.init();
      }
    }
  }

  /**
   * This class monitors the threads of a realm
   */
  public class ThreadMonitor_t extends MonitorThread{
    nRealmNode rNode;
    long maxQueueSize = 0;
    long minIdle = 0;

    private ThreadMonitor_t(String rname){
      this.rname=rname;
      headings = new String[]{"getTime","getQueue","getIdle","getName","getTotal"};
    }

    void init(){
      if(rNode==null)rNode = getRealmNode(rname);
      name=rNode.getName();
      if(outputFile.equals(""))outputFile = workingdir+"ThreadMonitor_"+name+".txt";
      if(refreshRate==0)refreshRate=5000;
      try{
        FileWriter fstream = new FileWriter(outputFile,true);
        out = new BufferedWriter(fstream);
        printHeadings();
      }
      catch(Exception e){
        e.printStackTrace();
      }
      this.start();
    }
    public ThreadMonitor_t withRnode(nRealmNode n){
      rNode = n;
      return this;
    }
    public void run(){
      while(true){
        for(Object tp : rNode.getThreadPoolDetails()){
          if(checkThreadPool((nThreadPool)tp)){
            write(printDetails(tp,this));
          }
        }
        try {
          Thread.sleep(refreshRate);
        } catch (InterruptedException ignore) {
        }
      }
    }
    private boolean checkThreadPool(nThreadPool tp){
      return debug || tp.getQueue() > maxQueueSize || tp.getIdle() <= minIdle;
    }
    public void setMaxQueueSize(Object o){
      maxQueueSize = Long.valueOf((String)o);
      if(debug)System.out.println("setting maxQueueSize = "+maxQueueSize);
    }
    public void setMinIdle(Object o){
      minIdle = Long.valueOf((String)o);
      if(debug)System.out.println("setting minIdle = "+minIdle);
    }
  }

  /**
   * Monitors the log and writes to a csv file if a keyword is found
   */
  public class LogMonitor_t extends MonitorThread implements nLogListener{
    nRealmNode rNode;
    String[]keywords;
    private LogMonitor_t(String rname){
      this.rname = rname;

      headings = new String[]{"Log Listener"};
    }

    void init(){
      if(rNode==null)rNode = getRealmNode(rname);
      name = rNode.getName();
      if(outputFile.equals(""))outputFile = workingdir+"LogMonitor_"+name+".txt";
      try{
        FileWriter fstream = new FileWriter(outputFile,true);
        out = new BufferedWriter(fstream);
        printHeadings();
        rNode.addLogListener(this);
      }
      catch(Exception e){
        e.printStackTrace();
      }
    }

    public LogMonitor_t withRnode(nRealmNode n){
      rNode = n;
      return this;
    }

    public void setKeywords(Object o){
      keywords = RealmMonitor.getStringArray((String)o);
      if(debug) System.out.println("Setting keywords = "+o);
    }

    private boolean checkForProblems(String line){
      if(keywords == null)return true;
      for(String keyword : keywords){
        if(line.contains(keyword))return true;
      }
      return false;
    }

    public void report(String message) {
      if(checkForProblems(message)){
        write(message+"\n");
      }
    }
  }

  /**
   * Monitors changes to realm connections
   */
  public class ConnectionMonitor_t extends MonitorThread implements nConnectionListener{
    nRealmNode rNode;
    final Hashtable<String, nConnectionDetails> cons = new Hashtable<String, nConnectionDetails>();
    int maxQueuedEvents = 0;
    long keepAliveTime = 60000;
    Double maxTimeOfLastTransmitt = -1.0;

    private ConnectionMonitor_t(String rname){
      this.name = rname;
      headings = new String[]{"getTime","getTimeOfLastReceive","getQueueSize","getEventsReceived","getEventsTransmitted"};
    }

    void init(){
      if(rNode==null)rNode = getRealmNode(rname);
      name = rNode.getName();
      if(maxTimeOfLastTransmitt==-1.0){
        try {
          keepAliveTime = Long.valueOf(rNode.getConfigGroup("Connection Config").find("KeepAlive").getValue()); //6.0
        } catch (Exception e) {
          try{
            keepAliveTime = Long.valueOf(rNode.getConfigGroup("FanoutValues").find("KeepAlive").getValue()); //5.5
          }
          catch(Exception e2){
            System.out.println("could not get keep alive value");
          }
          keepAliveTime=60000;
        }
        maxTimeOfLastTransmitt = keepAliveTime*1.5;
      }
      if(refreshRate==0)refreshRate=5000;
      if(outputFile.equals(""))outputFile = workingdir+"ConnectionMonitor_"+name+".txt";
      try{
        rNode.addConnectionListener(this);
        FileWriter fstream = new FileWriter(outputFile,true);
        out = new BufferedWriter(fstream);
        printHeadings();
      }
      catch(Exception e){
        e.printStackTrace();
      }
      this.start();
    }

    public ConnectionMonitor_t withRnode(nRealmNode n){
      rNode = n;
      return this;
    }

    public void run(){
      while(true){
        synchronized(cons){
          for(nConnectionDetails details : cons.values()){
            if(checkForProblems(details)){
              write(printDetails(details,this));
            }
          }
        }
        try {
          Thread.sleep(refreshRate);
        } catch (InterruptedException ignore) {
        }
      }
    }

    public void add(nConnectionDetails details) {
      synchronized(cons){
        cons.put(details.getId(),details);
      }
    }

    public void del(nConnectionDetails details) {
      synchronized(cons){
        cons.remove(details.getId());
      }
    }

    private boolean checkForProblems(nConnectionDetails details){
      return  details.getQueueSize() > maxQueuedEvents || details.getTimeOfLastTransmitt() > maxTimeOfLastTransmitt || debug;

    }

    public void setMaxQueuedEvents(Object o){
      maxQueuedEvents = Integer.valueOf((String)o);
      if(debug)System.out.println("setting maxQueuedEvents = "+maxQueuedEvents);
    }

    public void setMaxTimeOfLastTransmitt(Object o){
      maxTimeOfLastTransmitt = Double.valueOf((String)o);
      if(debug)System.out.println("setting maxTimeOfLastTransmitt = "+maxTimeOfLastTransmitt);
    }
  }

  /**
   * Monitors channels for issues.  Will write to the csv if any triggers are hit e.g. the used space reaches a
   * certain level.
   */
  public class ChannelMonitor_t extends MonitorThread{
    nRealmNode rNode;

    int   maxFanoutTime = Integer.MAX_VALUE;
    int   maxUsedSpace = 0;
    float maxConsumedRate = 0;
    long maxCurrentEvents = Long.MAX_VALUE;
    float maxPubRate = Float.MAX_VALUE;
    float maxCacheHitRatio = Float.MAX_VALUE;
    float maxConnectionRate = Float.MAX_VALUE;
    float maxCurrentCons = Float.MAX_VALUE;
    int   maxPercentFreeInStore = Integer.MAX_VALUE;

    int   minPercentFreeInStore=0;
    int   minFanoutTime =0;
    int   minUsedSpace = 0;
    float minConsumedRate = 0;
    long minCurrentEvents = 0;
    float minPubRate = 0;
    float minCacheHitRatio = 0;
    float minConnectionRate = 0;
    float minCurrentCons = 0;



    private ChannelMonitor_t(String rname){
      this.rname = rname;
    }
    public void init(){
      if(rNode==null)rNode = getRealmNode(rname);
      name = rNode.getName();
      if(outputFile.equals(""))outputFile = workingdir+"ChannelMonitor_"+name+".txt";
      try{
        FileWriter fstream = new FileWriter(outputFile,true);
        out = new BufferedWriter(fstream);
        printHeadings();
        this.start();
      }
      catch(Exception e){
        e.printStackTrace();
      }
    }
    public ChannelMonitor_t withRnode(nRealmNode n){
      rNode = n;
      return this;
    }

    public void run(){
      while(true){
        try {
          checkForProblems(rNode);
          Thread.sleep(refreshRate);
        } catch (InterruptedException ignore) {
        }
      }
    }

    public void checkForProblems(nRealmNode rNode){
      checkForProblems(rNode.getNodes());
    }
    public void checkForProblems(Enumeration nodes){
      while ( nodes.hasMoreElements() ) {
        Object obj = nodes.nextElement();
        if ( obj instanceof nLeafNode ) {
          checkForProblems( (nLeafNode)obj );
        }
        else if ( obj instanceof nRealmNode ) {
          checkForProblems( (nRealmNode)obj );
        }
        else if ( obj instanceof nContainer ) {
          checkForProblems((nContainer)obj);
        }
      }
    }
    public void checkForProblems(nLeafNode node){
      if(node.getUsedSpace()<minUsedSpace||node.getUsedSpace()>=maxUsedSpace){
        write(printDetails(node, this));
        return;
      }
      if(node.getConsumedRate()<=minConsumedRate||node.getConsumedRate()>=maxConsumedRate){
        write(printDetails(node, this));
        return;
      }
      if(node.getPublishRate()<=minPubRate||node.getPublishRate()>=maxPubRate){
        write(printDetails(node, this));
        return;
      }
      if(node.getCacheHitRatio()<=minCacheHitRatio||node.getCacheHitRatio()>=maxCacheHitRatio){
        write(printDetails(node, this));
        return;
      }
      if(node.getConnectionRate()<=minConnectionRate||node.getConnectionRate()>=maxConnectionRate){
        write(printDetails(node, this));
        return;
      }
      if(node.getCurrentNoOfConnections()<=minCurrentCons||node.getCurrentNoOfConnections()>=maxCurrentCons){
        write(printDetails(node, this));
        return;
      }
      if(node.getCurrentNumberOfEvents()<=minCurrentEvents||node.getCurrentNumberOfEvents()>=maxCurrentEvents){
        write(printDetails(node, this));
        return;
      }
      if(node.getFanoutTime()<=minFanoutTime||node.getFanoutTime()>=maxFanoutTime){
        write(printDetails(node, this));
        return;
      }
      if(node.getPercentageFreeInStore()<=minPercentFreeInStore||node.getPercentageFreeInStore()>=maxPercentFreeInStore){
        write(printDetails(node, this));
        return;
      }
      if(debug)write(printDetails(node, this));

    }
    public void checkForProblems(nContainer container){
      checkForProblems(container.getNodes());
    }

    public String getType(Object o){
      nLeafNode leaf = (nLeafNode)o;
      if(leaf.isChannel()){
        return "Channel";
      }
      if(leaf.isQueue()){
        return "Queue";
      }
      return "unknown";
    }
    public String getUsedSpace(Object o){
      long used = ((nLeafNode)o).getUsedSpace();
      used = used/1024;
      return used+"";
    }

    /**
     * All these set methods are invoked if the property is set in the config file i.e if maxUsedSpace is set in the properties
     * file then setMaxUsedSpace is invoked with the value
     * @param o the value set in the config file.  We know this is a string so we can immediately cast it.
     */
    public void setMaxUsedSpace(Object o){
      maxUsedSpace = Integer.valueOf((String)o);
      if(debug)System.out.println("setting maxUsedSpace = "+maxUsedSpace);
    }
    public void setMaxConsumedRate(Object o){
      maxConsumedRate = Float.valueOf((String)o);
      if(debug)System.out.println("setting maxConsumedRate = "+maxConsumedRate);
    }
    public void setMaxPubRate(Object o){
      maxPubRate = Float.valueOf((String)o);
      if(debug)System.out.println("setting maxPubRate = "+maxPubRate);
    }
    public void setMaxConnectionRate(Object o){
      maxConnectionRate = Float.valueOf((String)o);
      if(debug)System.out.println("setting maxConnectionRate = "+maxConnectionRate);
    }
    public void setMaxCacheHitRatio(Object o){
      maxCacheHitRatio = Float.valueOf((String)o);
      if(debug)System.out.println("setting maxCacheHitRatio = "+maxCacheHitRatio);
    }
    public void setMaxCurrentCons(Object o){
      maxCurrentCons = Float.valueOf((String)o);
      if(debug)System.out.println("setting maxCurrentCons = "+maxCurrentCons);
    }
    public void setMaxFanoutTime(Object o){
      maxFanoutTime = Integer.valueOf((String)o);
      if(debug)System.out.println("setting maxFanoutTime = "+maxFanoutTime);
    }
    public void setMaxPercentFreeInStore(Object o){
      maxPercentFreeInStore = Integer.valueOf((String)o);
      if(debug)System.out.println("setting maxPercentFreeInStore = "+maxPercentFreeInStore);
    }
    public void setMaxCurrentEvents(Object o){
      maxCurrentEvents = Long.valueOf((String)o);
      if(debug)System.out.println("setting maxCurrentEvents = "+maxCurrentEvents);
    }


    public void setMinPercentFreeInStore(Object o){
      minPercentFreeInStore = Integer.valueOf((String)o);
      if(debug)System.out.println("setting minPercentFreeInStore = "+minPercentFreeInStore);
    }
    public void setMinUsedSpace(Object o){
      minUsedSpace = Integer.valueOf((String)o);
      if(debug)System.out.println("setting minUsedSpace = "+minUsedSpace);
    }
    public void setMinConsumedRate(Object o){
      minConsumedRate = Float.valueOf((String)o);
      if(debug)System.out.println("setting minConsumedRate = "+minConsumedRate);
    }
    public void setMinPubRate(Object o){
      minPubRate = Float.valueOf((String)o);
      if(debug)System.out.println("setting minPubRate = "+minPubRate);
    }
    public void setMinConnectionRate(Object o){
      minConnectionRate = Float.valueOf((String)o);
      if(debug)System.out.println("setting minConnectionRate = "+minConnectionRate);
    }
    public void setMinCacheHitRatio(Object o){
      minCacheHitRatio = Float.valueOf((String)o);
      if(debug)System.out.println("setting minCacheHitRatio = "+minCacheHitRatio);
    }
    public void setMinCurrentCons(Object o){
      minCurrentCons = Float.valueOf((String)o);
      if(debug)System.out.println("setting minCurrentCons = "+minCurrentCons);
    }
    public void setMinFanoutTime(Object o){
      minFanoutTime = Integer.valueOf((String)o);
      if(debug)System.out.println("setting minFanoutTime = "+minFanoutTime);
    }
    public void setMinCurrentEvents(Object o){
      minCurrentEvents = Long.valueOf((String)o);
      if(debug)System.out.println("setting minCurrentEvents = "+minCurrentEvents);
    }
  }

  /**
   * Monitors the realm.  Will continuously write to the csv file.  If we do not receive an update from the realm
   * in more than 2*updateInterval then we write 0s to the csv.  This way any problems will be clear if the csv is
   * used to create a graph.
   */
  public class RealmMonitor_t extends MonitorThread implements Observer {
    nRealmNode rNode;
    long lastUpdate;
    String[] methodsError;
    private RealmMonitor_t(String rname){
      this.rname = rname;
      headings = new String[]{"getTime","getNoOfChannels","getNoOfQueues","getCurrentConnections","getTotalConnections","getFreeMemory","getTotalMemory","getNoOfThreads"};//need get used!
    }

    public void init(){
      if(rNode==null)rNode = getRealmNode(rname);
      name = rNode.getName();
      if(outputFile.equals(""))outputFile = workingdir+"RealmMonitor_"+name+".txt";
      try{
        FileWriter fstream = new FileWriter(outputFile,true);
        out = new BufferedWriter(fstream);
        printHeadings();
        if(refreshRate==0)refreshRate = Long.parseLong(rNode.getConfigGroup("Connection Config").find("KeepAlive").getValue());
      }
      catch(Exception e){
        refreshRate=60000;
      }
      rNode.addObserver(this);
      lastUpdate = System.currentTimeMillis();
      this.start();
    }

    public RealmMonitor_t withRnode(nRealmNode rNode){
      this.rNode=rNode;
      return this;
    }

    public void run(){
      while(true){
        try {
          if(!checkForProblems(rNode)){
            write(printDetails(rNode, this));
          }
          else{
            print0s();
          }
          Thread.sleep(refreshRate);
        } catch (InterruptedException ignore) {
        }
      }
    }

    public void print0s(){
      StringBuilder sb = new StringBuilder();
      if(methodsError==null){
        for(String s : headings){
          sb.append("0,");
        }
        write(sb.substring(0,sb.length()-1)+"\n");
      }
      else{
        String[]temp = methods;
        methods = methodsError;
        write(printDetails(rNode, this));
        methods = temp;
      }
    }

    public String getTotalMemory(Object o){
      nRealmNode rn = (nRealmNode)o;
      long tot = rn.getTotalMemory();
      tot=tot/(1024*1024);
      return tot+"";
    }
    public String getFreeMemory(Object o){
      nRealmNode rn = (nRealmNode)o;
      long free = rn.getFreeMemory();
      free=free/(1024*1024);
      return free+"";
    }
    public String getUsedMemory(Object o){
      nRealmNode rn = (nRealmNode)o;
      long totalmem = rn.getTotalMemory();
      long freemem = rn.getFreeMemory();
      long diff = totalmem-freemem;
      diff = diff/(1024*1024);
      return  diff+"";
    }
    public void setMethodsError(Object o){
      methodsError=getStringArray((String) o);
      if(debug)System.out.println("setting methodsError = "+o);
    }

    public boolean checkForProblems(nRealmNode rNode){
      long now = System.currentTimeMillis();
      long diff = now - lastUpdate;
      return diff > rNode.getUpdateInterval() * 2;
    }

    public void update(Observable o, Object arg) {
      lastUpdate = System.currentTimeMillis();
    }
  }

  Hashtable<String,nRealmNode> rNodes = new Hashtable<String,nRealmNode>();

  /**
   * This method is used to ensure we do not start multiple rnodes for one rname
   * @param rname rname for the rnode to construct
   * @return either a cached rnode or a newly constructed rnode for rname
   */
  private nRealmNode getRealmNode(String rname){
    try {
      if(rNodes.containsKey(rname)){
        return rNodes.get(rname);
      }
      System.out.print("Establishing realm node...");
      nSessionAttributes nsa = new nSessionAttributes(rname);
      nRealmNode rNode = new nRealmNode(nsa);

      if (!rNode.isAuthorised()) {
        System.out.println("User not authorised on this node " + nsa);
        System.exit(1);
      }
      System.out.println("done\n");
      rNodes.put(rname,rNode);
      return rNode;
    }
    catch (Exception e) {
      e.printStackTrace();
      System.exit(1);
    }
    return null;
  }

  /**
   * Reads the configuration details from the config file.
   * @throws Exception
   */
  private void getConfigDetails() throws Exception {
    BufferedReader reader=null;
    try{
      File f = new File(configloc);
      reader = new BufferedReader(new FileReader(f));
      String line;
      String monitor = "";
      int linenum=-1;
      while ((line = reader.readLine()) != null)
      {
        linenum++;
        line = line.trim();
        if(line.length()==0 || line.charAt(0)=='#'){
          continue;
        }
        if(line.contains("#")){
          line = line.substring(0,line.indexOf('#'));
        }
        if(line.endsWith(";")){
          line = line.substring(0,line.length()-1);
        }

        String[] args = line.split("=");
        if(args.length!=2)throw new Exception("Syntax error in config file at line: "+linenum+" (too many '=')");

        String field = args[0].trim();
        String value = args[1].trim();

        if(field.equalsIgnoreCase("monitor")){
          monitor = value;
          continue;
        }
        setValue(monitor,field,value);
      }
    }finally {
      if (reader != null) {
        reader.close();
      }
    }
  }

  /**
   * For the given monitor object, sets the field for that monitor to the value read from the config file.
   * @param monitor the name of the monitor class e.g. connectionmonitor
   * @param field the field (variable) of the monitor to be set
   * @param value the value to set the field to
   */
  private void setValue(String monitor, String field, String value){
    try{
      String firstLetter = field.substring(0,1);
      field = "set"+firstLetter.toUpperCase()+field.substring(1);

      if(monitor.equalsIgnoreCase("")){
        this.getClass().getMethod(field,Object.class).invoke(this,value);
        return;
      }
      if(monitor.equalsIgnoreCase("realmmonitor")){
        if(runRealmMonitor) {
          for(RealmMonitor_t m : realm_m){
            m.getClass().getMethod(field,Object.class).invoke(m,value);
          }
        }
        return;
      }
      if(monitor.equalsIgnoreCase("channelmonitor")){
        if(runChannelMonitor) {
          for(ChannelMonitor_t m : chan_m){
            m.getClass().getMethod(field,Object.class).invoke(m,value);
          }
        }
        return;
      }
      if(monitor.equalsIgnoreCase("logmonitor")){
        if(runLogMonitor) {
          for(LogMonitor_t m : log_m){
            m.getClass().getMethod(field,Object.class).invoke(m,value);
          }
        }
        return;
      }
      if(monitor.equalsIgnoreCase("connectionmonitor")){
        if(runConnectionMonitor) {
          for(ConnectionMonitor_t m : con_m){
            m.getClass().getMethod(field,Object.class).invoke(m,value);
          }
        }
        return;
      }
      if(monitor.equalsIgnoreCase("threadmonitor")){
        if(runThreadMonitor) {
          for(ThreadMonitor_t m : thread_m){
            m.getClass().getMethod(field,Object.class).invoke(m,value);
          }
        }
        return;
      }
      throw new Exception("unknown monitor");
    }
    catch(Exception ignore){
    }
  }

  /**
   * If the user has not input a config file location then we can create a config file in the working directory
   */
  private void checkConfig(){
    if(configloc.equals("")){
      configloc = System.getProperty("user.dir")+"/RealmMonitorOut/";
      File f = new File(configloc);
      f.mkdirs();
      configloc+="config.txt";
      f = new File(configloc);
      if(!f.exists()){
        System.out.println("No config file found so generating one > "+configloc);
        try{
          FileWriter fstream = new FileWriter(configloc);
          BufferedWriter out = new BufferedWriter(fstream);
          out.write(sampleConfig);
          out.close();
        }
        catch(Exception e){
          System.out.println("Error generating sample config file.  Please specify one.");
          Usage();
          System.exit(0);
        }
      }
    }
    System.out.println("Using config file : "+configloc);
  }

  /**
   * Each monitor class has a list of methods which should be invoked and the return value printed to the csv.
   * This method takes a monitor thread and an object.  It then tries to invoke each method in the monitor's methods
   * array.  First it tries to invoke the method on the monitor object (e.g. ConnectionMonitor_t),
   * then the object passed in (e.g. nConnectionDetails) and then the enclosing class (RealmMonitor).
   * Once a the method is found it is invoked and the returned object is added to a comma separated list.
   * By trying to invoke the methods in this order we can override certain return types.  Some methods return an array of
   * String so would cause us to write something like String[] to the csv which is no good.  So instead we can add a
   * method in the monitor thread class which takes the String[] and returns a String representation.
   *
   * @param o an object such as nConnectionDetails or nRealmNode
   * @param mon the calling monitor thread
   * @return comma separated list of values to be written to the csv
   */
  private synchronized String printDetails(Object o, Object mon){
    StringBuilder sb = new StringBuilder();
    for(String methodname : ((MonitorThread)mon).getMethods()){
      //getName is a method in the Thread class so need to rename to make sure we invoke this on the correct object
      if(methodname.equals("getName"))methodname="_getName";
      try {
        sb.append(tryInvoke(methodname, mon, o));
      } catch (NoSuchMethodException e) {
        try {
          sb.append(tryInvoke(methodname, o, o));
        }
        catch (NoSuchMethodException e1) {
          try {
            sb.append(tryInvoke(methodname, this, o));
          } catch (Exception e11) {
            e11.printStackTrace();
          }
        }
        catch(Exception e2){
          e2.printStackTrace();
        }
      }
      catch (Exception e) {
        e.printStackTrace();
      }
    }
    return sb.substring(0,sb.length()-1)+"\n";
  }

  /**
   *
   * @param method the name of the method to invoke
   * @param o the object to try to invoke on.  For example if this if the connection monitor, we will first try to invoke
   * on the connection monitor thread (to allow us to override methods), then the nConnectionDetails object, then
   * the this RealmMonitor class (e.g. getTime)
   * @param baseobject In the case of the connection monitor this will be the nConnectionDetails object.  This is passed
   * so that we can handle a method like getSubject differently.  getSubject returns an array of Strings so we would
   * need to override this in the monitor thread so we can output a comma separated list.  This still requires us to
   * pass the nConnectionDetails object to the monitor thread method.
   * @throws NoSuchMethodException
   * @throws InvocationTargetException
   * @throws IllegalAccessException
   */
  public String tryInvoke(String method,Object o, Object baseobject) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
    Object ret = null;
    Method m;
    try{
      m = o.getClass().getMethod(method);
      ret = m.invoke(o);
    }
    catch(Exception e){
      try{
        m =o.getClass().getMethod(method,Object.class);
        ret = m.invoke(o, baseobject);
      }
      catch(IllegalArgumentException e2){
        e2.printStackTrace();
      }
    }
    //Need to make sure we can handle all return types.
    //if the method name contains the word time we will format it as a time
    if(ret!=null){
      if(ret instanceof Long){
        if(method.toLowerCase().contains("time")){
          Calendar cal = Calendar.getInstance();
          cal.setTimeInMillis((Long)ret);
          ret = timeformat.format(cal.getTime());
        }
        else{
          ret = Long.toString((Long)ret);
        }
      }
      return ret.toString()+",";
    }
    return ",";
  }

  /**
   * Super class for each of the monitor threads.  Contains methods applicable to all monitor threads.
   */
  public class MonitorThread extends Thread{
    String rname;
    String name;
    String[] headings;
    String[] methods;
    BufferedWriter out;
    boolean debug = false;
    long refreshRate=0;
    String outputFile="";

    void write(String message){
      try {
        out.write(message);
        out.flush();
        if(debug)System.out.print(message);
      } catch (IOException ignored) {
      }
    }
    String[] getHeadings(){
      return headings;
    }
    String[] getMethods(){
      return methods;
    }

    public void setHeadings(Object o){
      headings = RealmMonitor.getStringArray((String)o);
      if(debug) System.out.println("setting headings = "+o);
    }
    public void setMethods(Object o){
      methods = RealmMonitor.getStringArray((String)o);
      if(debug) System.out.println("setting methods = "+o);
    }
    public void setDebug(Object o){
      debug = Boolean.valueOf((String)o);
      System.out.println("Setting debug mode = "+debug);
    }

    //log monitor is async so no refresh rate
    public void setRefreshrate(Object o){
      refreshRate = Long.parseLong((String)o);
      if(debug) System.out.println("setting refreshRate = "+o);
    }
    public void setOutputfile(Object o){
      outputFile = (String)o;
      if(debug) System.out.println("outputFile = "+o);
    }

    public String getRname(){
      return rname;
    }
    public String getRealmName(){
      return name;
    }

    public String _getName(Object o){
      Method m = null;
      try {
        m = o.getClass().getMethod("getName");
        Object ret =  m.invoke(o);
        return ret.toString();
      } catch (Exception ignored) {}
      return "error";
    }

    public String getID(){
      return name;
    }

    void printHeadings(){
      for(int i = 0; i < headings.length; i++){
        write(headings[i]);
        if(i<headings.length-1){
          write(",");
        }
        else{
          write("\n");
        }
      }
    }
  }

  public void setRnames(Object o){
    rnames=getStringArray((String)o);
    System.out.println("Setting rnames = "+o);
  }
  public void setRunRealmMonitor(Object o){
    runRealmMonitor=Boolean.valueOf((String)o);
    System.out.println("runRealmMonitor = "+runRealmMonitor);
  }
  public void setRunThreadMonitor(Object o){
    runThreadMonitor=Boolean.valueOf((String)o);
    System.out.println("runThreadMonitor = "+runThreadMonitor);
  }
  public void setRunLogMonitor(Object o){
    runLogMonitor=Boolean.valueOf((String)o);
    System.out.println("runLogMonitor = "+runLogMonitor);
  }
  public void setRunChannelMonitor(Object o){
    runChannelMonitor=Boolean.valueOf((String)o);
    System.out.println("runChannelMonitor = "+runChannelMonitor);
  }
  public void setRunConnectionMonitor(Object o){
    runConnectionMonitor=Boolean.valueOf((String)o);
    System.out.println("runConnectionMonitor = "+runConnectionMonitor);
  }
  public void setWorkingdir(Object o){
    workingdir = (String)o;
    System.out.println("workingdir = "+workingdir);
  }

  public String getTime(){
    Calendar cal = Calendar.getInstance();
    return timeformat.format(cal.getTime());
  }

  public String getDate(){
    Calendar cal = Calendar.getInstance();
    return dateformat.format(cal.getTime());
  }

  public static String[] getStringArray(String o){
    if(o.contains(",")){
      String[]args = o.split(",");
      for(int i=0;i<args.length;i++){
        args[i] = args[i].trim();
      }
      return args;
    }
    return new String[]{o};
  }


  private void processArgs(String[] args){
    switch(args.length){
      case 2 : {
        configloc = args[1];
      }
      case 1: {
        rnames = getRnames(args[0]);
      }
    }
    if(args.length<1){
      Usage();
      System.exit(1);
    }
  }

  public String[] getRnames(String rnames){
    return rnames.split(",");
  }

  public void Usage(){
    System.out.println("java RealmMonitor <rnames> [config file]\n");
    System.out.println("<Required Parameters>\n");
    System.out.println("<rname> : comma separated list of rnames to monitor.\n");
    System.out.println("[Optional Parameters]\n");
    System.out.println("[config file] : configuration file location e.g. c:\\config.txt\n");
    System.out.println("All other parameters can be specified in the config file.");
    System.out.println("If realm is clustered then other realms in cluster will");
    System.out.println("be found automatically.");
  }

  /**
   * Enables the user to stop the monitoring by removing a lock file.
   * The lock file is created in the working directory.
   */
  private class ExitHandler extends Thread {

    File lckFile = null;

    public ExitHandler() {
      try {
        setName("LoadRunner : exit thread");
        setDaemon(true);
        lckFile    = new File(workingdir + File.separator +"RealmMonitor.lck");
        start();
      } catch (Exception e) {
        e.printStackTrace();
      }
    }


    public void run() {
      try {
        if (lckFile.exists()) {
          lckFile.delete();
          try {
            Thread.sleep(2000);
          } catch (InterruptedException ignored) {
          }
        }
        else{
          try {
            lckFile.getParentFile().mkdirs();
          } catch (Exception ignored) {
          }
        }
        lckFile.createNewFile();
        while (lckFile.exists()) {
          try {
            Thread.sleep(1000);
          }
          catch (Exception ignored) {
          }
        }
        System.out.println("JVM exiting after lck file removal...");
        System.exit(1);
      } catch (Exception e) {
        e.printStackTrace();
      }
    }
  }
}