source: trunk/Monitoring/Analyze/analyze @ 877

#!/usr/bin/env python
# -*- coding: ISO-8859-1 -*-

##################################
#  @program        smon
#  @description    simulation monitor
#  @copyright      Copyright “(c)2009 Centre National de la Recherche Scientifique CNRS. 
#                             All Rights Reserved”
#  @svn_file       $Id: analyzer 2545 2013-02-01 09:58:10Z jripsl $
#  @version        $Rev: 2545 $
#  @lastrevision   $Date: 2013-02-01 10:58:10 +0100 (Fri, 01 Feb 2013) $
#  @license        CeCILL (http://dods.ipsl.jussieu.fr/jripsl/smon/LICENSE)
##################################

import sys
import signal
import traceback
import smtplib
from email.mime.text import MIMEText
import time;
from datetime import datetime


# line below is to include "smon" package in the search path
sys.path.append("/home/jripsl/snapshot/Monitoring")

import smon.repo_io as repo_io
import smon.types as types



class CheckList():
        max_time_between_msg=10 # unit => seconds

        @classmethod
        def datetime_to_epoch(cls,datetime):
                epoch = time.mktime(time.strptime(datetime, "%d.%m.%Y %H:%M:%S")).time(); # assuming datetime format is "29.08.2011 11:05:02"
                return epoch

        @classmethod
        def msg_timeout(cls,message):

                msg_time=cls.datetime_to_epoch(message.timestamp)
                current_time=time.time()

                diff=current_time-msg_time

                # debug
                print "diff=%s"%diff

                if diff>cls.max_time_between_msg:

                        return True
                else:
                        return False

        @classmethod
        def C0001(cls):
                """
                description
                  check heartbeat (currently, heartbeat is implemented using simulation progress messages).
                  if progress messages suddently stops, it is likely that the simulation was Killed or
                  a Segfault occurs. In such case, we inform the other components (failover, prodiguer GUI..) by
                  changing the simulation status 
                """


                for simulation in repo_io.get_running_simulations():

                        print "checking heartbeat for '%s'"%simulation.name

                        try:

                                message=repo_io.retrieve_last_message(simulation)

                        except types.MessageNotFoundException, e:

                                continue


                        if msg_timeout(message):

                                simulation.status="error"

                                repo_io.update_simulation_status(simulation)

                                print "heartbeat NOK (simulation status set to 'error')"%simulation.name


                        else:
                                print "heartbeat OK"%simulation.name

class Analyzer():

        @classmethod
        def start(cls):
                repo_io.init() # open DB connection

                Analyzer.main()

        @classmethod
        def stop(cls):
                repo_io.free() # close DB connection

        @classmethod
        def main(self):

                """
                # parse args
                parser = argparse.ArgumentParser(prog='analyzer')
                parser.add_argument('-v', dest='verbose',required=False,action='store_true')
                args = parser.parse_args()

                # check
                if not os.path.exists(SMON.smon_home):
                        sys.exit(1)

                SMON.init_singleton()
                """

                print ' [*] Analyzer running. To exit press CTRL+C'

                while True:

                        print "checking simulations heartbeats"

                        CheckList.C0001()


                        time.sleep(1)

                """
                SMON.free_singleton()
                """

def signal_handler(signal, frame):
                print 'You pressed Ctrl+C!'

                Analyzer.stop()

                sys.exit(0)

if __name__ == '__main__':

        signal.signal(signal.SIGINT, signal_handler)

        try:
                Analyzer.start()

                sys.exit(0)

        except Exception, e:

                traceback.print_exc()

                sys.exit(1)