source: trunk/Monitoring/Watch/watch @ 857

#!/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: watcher 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)
##################################

#from smon import dao
import pika
import base64
import json
import sys
import signal
import traceback
import smtplib
from email.mime.text import MIMEText
from datetime import datetime




sys.path.append("/home/jripsl/snapshot/src") 
import elixir
import prodiguer_repository

#import prodiguer_repository.operations.mq_hooks_stub as mq_hooks
import prodiguer_repository.operations.mq_hooks as mq_hooks



"""
mq_hooks.retrieve_simulation(name)
mq_hooks.delete_simulation(name)
mq_hooks.create_simulation(activity,
mq_hooks.update_simulation_status(name,
mq_hooks.retrieve_messages(name)
mq_hooks.delete_messages(name)
"""

"""
from prodiguer_repository.models import (
        ExecutionState,
        EXECUTION_STATE_RUNNING,
        EXECUTION_STATE_SET,
        Message,
        Simulation,
        SIMULATION_SPACE_TEST
)
"""



"""
scenarios from ticket 136

libIGCM simulent des erreurs (killed, segfault, 1% d'erreur)
le watcher temps réel change le status des erreurs détéctés
le watcher temps différé détécte et change le statut des killed 
"""

class Watcher():
        # prod
        #message_code_action_mapping = {"0000":["log","mail"],"1000":["log"],"2000":["log"],"3000":["log"],"9000":["log"],"9999":["log","mail"]}

        # dev
        message_code_action_mapping = {"0000":["log","print_stdout"],"1000":[],"2000":[],"3000":[],"9000":["log"],"9999":["log"]}
        #message_code_action_mapping = {"0000":[],"1000":[],"2000":[],"3000":[],"9000":["log"],"9999":["log"]}

        # debug
        #message_code_action_mapping = {"0000":["print_stdout"],"1000":["log"],"2000":[],"3000":[],"9000":["log"],"9999":["log"]}

        @classmethod
        def get_fake_progress_messages(cls):
                pass

        @classmethod
        def start(cls):
                #dao.insert_progress_messages(cls.get_fake_progress_messages())
                pass

        @classmethod
        def stop(cls):
                pass

        @classmethod
        def add(cls,message):
                pass

        @classmethod
        def mail_example(cls):
                me="jripsl@ipsl.jussieu.fr"
                you="jripsl@ipsl.jussieu.fr"
                body="Alarm"
                object="Supervisor"

                cls.mail(me,you,object,body)

        @classmethod
        def mail(cls):
                cls.mail_example()

        @classmethod
        def send_mail(cls,me,you,object,body):
                msg = MIMEText(body)
                msg['Subject'] = object
                msg['From'] = me
                msg['To'] = you

                # Send the message via our own SMTP server, but don't include the # envelope header.
                s = smtplib.SMTP('localhost')
                s.sendmail(me,[you], msg.as_string())
                s.quit()

        @classmethod
        def print_stdout(cls,message):
                # used for debug

                if "file" in message:
                        print "%s %s %s\n"%(message["code"],message["jobid"],message["file"])
                else:
                        print "%s %s\n"%(message["code"],message["jobid"])

        @classmethod
        def log(cls,message):

                with open("/home/jripsl/supervisor/log/supervisor.log", "a") as log_file:
                        log_file.write("%s %s %s\n"%(datetime.now().strftime('%Y%m%d_%H%M%S'), message["code"],message["jobid"]))

        @classmethod
        def execActions(cls,message):

                message_code=message["code"]

                for action in cls.message_code_action_mapping[message_code]:
                        proc_name=action

                        try:
                                getattr(cls, proc_name)(message)
                        except Exception,e:
                                traceback.print_exc()

                                raise Exception("WATCH-ERR002","procedure error (%s,%s)"%(proc_name,str(e)))

        @classmethod
        def main(self):

                """
                _CONNECTION = "postgresql://postgres:Silence107!@localhost:5432/prodiguer" # Repo connection string.
                prodiguer_repository.connect(_CONNECTION) # Connect to repo.
                mq_hooks.create_message("test", 2, "bla")
                elixir.session.commit()
                #elixir.session.rollback()
                """
                mq_hooks.create_message()

                """
                # parse args
                parser = argparse.ArgumentParser(prog='watcher')
                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()
                """

                connection = pika.BlockingConnection(pika.ConnectionParameters( host='localhost'))
                self.channel = connection.channel()

                #self.channel.queue_declare(queue='myqueue')

                print ' [*] Waiting for messages. To exit press CTRL+C'

                def callback(ch, method, properties, raw_msg):
                        #
                        #return

                        base64_decoded_msg=base64.b64decode(raw_msg)

                        # debug
                        #print " [x] Received %s" % raw_msg
                        #print " [x] Received %s (uudecoded)" % base64_decoded_msg 

                        message=None
                        try:
                                message=json.loads(base64_decoded_msg)

                                # message code based action
                                Watcher.execActions(message)
                        except Exception,e:
                                print "Exception occurs (exception=%s,msg=%s)"%(str(e),base64_decoded_msg)

                self.channel.basic_consume(callback, queue='myqueue', no_ack=True)

                self.channel.start_consuming()


                """
                SMON.free_singleton()
                """

def signal_handler(signal, frame):
                print 'You pressed Ctrl+C!'
                Watcher.channel.stop_consuming()
                sys.exit(0)

if __name__ == '__main__':

        signal.signal(signal.SIGINT, signal_handler)
        #print 'Press Ctrl+C'

        try:
                Watcher.main()

                sys.exit(0)

        except Exception, e:

                traceback.print_exc()

                sys.exit(1)