def subscribe(self): """ Start to subscribing the check point into main service :param connection: :param config_file: :return: """ loader = config_loader.ConfigLoader() configuration = loader.get_config() # subscription message dictionary subscription_message_dictionary = { "type": "registry", "queue": configuration["check_point.message_server"]["subscription"], "id": configuration["check_point.message_server"]["id"], "time": date_time.get_date(), "location": configuration["check_point.specification"]["location"], "host": configuration["check_point.specification"]["host"] } # send data with sender module sender = send_module.SendModule() sender.send(destination=configuration["monit_engine.message_queue"] ["registry"], message=subscription_message_dictionary) logging.logger( "INFO", "subscriber/check_point_subscriber : subscription is complete")
def __init__(self, connection, connection_listener, topic, config_file="monit_engine.yml"): loader = config_loader.ConfigLoader() configuration = loader.get_config() self.connection = connection self.connection.set_listener("message_broker_interface_listener", connection_listener.Listener()) self.connection.subscribe( destination=topic, id=configuration["monitor_engine.message_server"]["id"], ack='auto') logger( "INFO", "message_broker/connection_handler : connection stablished successfully for topic : " + topic) thread = threading.Thread(target=self.__run__, args=()) thread.daemon = True thread.start()
def __inti__(self): """ :return: """ logger( "INFO", "database_management_system/database_connection_pool : connection pool initialized" )
def handle(self, info): """ :param info: :return: """ self.validator.check(info) logger("INFO", "message_handler/handler/handle : receive an action") if info["action"] == "add": self.url_service.add_url(info=info) elif info["action"] == "delete": self.url_service.delete_url(info=info) else: raise Exception("action " + info["action"] + " not implemented")
def on_message(self, headers, message): try: logger( "INFO", "message_broker_interface_listener/registration_listener : register requests" ) if type(message) is bytes: message = message.data.decode('utf-8') message_dic = json.loads(message) self.checkpoint_handler.add_check_point(message_dic) except Exception as e: logger( "EXCEPTION", "message_broker_interface_listener/registration_listener : " + str(e))
def __init__(self): """ initial starter kit """ loader = config_loader.ConfigLoader() self.configuration = loader.get_config() logger("INFO", "service_starter : start starter kit to initialization") # start all of the services self.__start_all__() logger( "INFO", "service_starter : starter service has completed initialization")
def __init__(self, connection, config_file="monit_engine.yml"): """ pass """ loader = config_loader.ConfigLoader() self.configuration = loader.get_config() # select the correct database self.database = connection[ self.configuration["monitor_engine.data_base"]["database_name"]] self.collection = self.database[ self.configuration["monitor_engine.data_base"]["url_collection"]] logger( "INFO", "database_management_system/url_db : url database has initialized")
def add_check_point(self, info): """ :param info: type json :return: """ validate = validator.SchemaValidator( self.config['schema']['checkpoint_register_schema']) validate.check(info) self.database.insert_check_point(info) logger( "INFO", "check_point_service/check_point_service/add_check_point : check point has initialized successfully" ) return { 'status': True, 'result': 'check point registered successfully' }
def delete_url(self, info): """ info is a url_id and action dictionary :param info: :return: """ logger( "INFO", "url_service/url_service/delete_url : delete url request started") job_scheduler = scheduler.Scheduler.get_scheduler() self.database.delete_job(info['url_id']) job_scheduler.remove_job(info['url_id']) logger( "INFO", "url_service/url_service/delete_url : url " + info['url_id'] + " deleted successfully")
def http_test(server_info): """ this function will test the up status of the url :param server_info: :return: """ try: start_time = time.time() data = urlopen(server_info).read() end_time = time.time() speed = end_time - start_time if type(data) is bytes: data = data.decode('utf-8') return {"status": True, "speed": speed, "data": data} except Exception as e: logger("EXCEPTION", "services/up_and_speed/http_test : " + str(e)) return {'status': False, 'speed': -1, "data": -1}
def __init__(self, connection): """ oops """ loader = config_loader.ConfigLoader() self.configuration = loader.get_config() # select the correct database self.database = connection[ self.configuration["monitor_engine.data_base"]["database_name"]] self.collection = self.database[self.configuration[ "monitor_engine.data_base"]["result_collection"]] logger( "INFO", "database_management_system/result_db : result database has initialized" )
def put(self): """ the put request handler :return: """ try: result = {} new_user = request.data if type(new_user) is bytes: new_user = new_user.decode("utf-8") new_user_dictionary = json.loads(new_user) result['user_id'] = self.user_service.register_user(new_user_dictionary) status = True except Exception as e: status = False result = str(e) logger("EXCEPTION", "restful_interface/user/user_register : " + str(e)) return {"result": result, "status": status}
def put_result(self, info): """ :param info: :return: """ # forward data into monitoring engine try: self.sender.send( destination=self.config["monit_engine.message_queue"] ["result"], message=info) logger( "INFO", "result_service/result_service/put_result : send test result for url_id " + info["url_id"] + " into monitoring engine") except Exception as e: logger( "EXCEPTION", "result_service/result_service/put_result : exception on sending result for url_id " + info["url_id"] + " into monitoring engine : " + str(e))
def send(self, title, message, to): """ :param title: :param message: :param to: :return: """ logger("INFO", "mail_agent/mailing : start sending email to : " + to) targets = [to] msg = MIMEText(message, ) msg['Subject'] = title msg['From'] = self.sender msg['To'] = ', '.join(targets) server = smtplib.SMTP_SSL(self.smtp_ssl_host, self.smtp_ssl_port) server.login(self.username, self.password) server.sendmail(self.sender, targets, msg.as_string()) server.quit() logger("INFO", "mail_agent/mailing : email sent successfully")
def get_connection(self): """ Create and return a stomp connection into wanted host message broker. :return: """ loader = config_loader.ConfigLoader() configuration = loader.get_config() logger( "INFO", "message_broker_interface/connection : start to connecting to JMS") logger( "INFO", "message_broker_interface/connection : jms server host : " + configuration["check_point.message_server"]["host"]) logger( "INFO", "message_broker_interface/connection : jms server port : " + str(configuration["check_point.message_server"]["port"])) connection = stomp.Connection([ (configuration["check_point.message_server"]["host"], configuration["check_point.message_server"]["port"]) ]) connection.start() connection.connect( configuration["check_point.message_server"]["user_name"], configuration["check_point.message_server"]["password"], wait=True) return connection
def load_urls_to_scheduler(self): """ this function will call at starting level of check point :return: """ logger( "INFO", "url_service/url_service/load_urls_to_scheduler : start loading jobs into scheduler" ) jobs = self.database.get_jobs() job_scheduler = scheduler.Scheduler.get_scheduler() for item in jobs: new_job = job.Job(item) job_scheduler.add_job( function=new_job.do, kwargs=None, minutes=item["credit"]["url_activities"]["check_time_slot"], id=item["url_id"]) logger( "INFO", "url_service/url_service/load_urls_to_scheduler : jobs loaded into scheduler" )
def get_connection(self, config_file="monit_engine.yml"): """ Create and return a stomp connection into wanted host message broker. :return: """ loader = config_loader.ConfigLoader() configuration = loader.get_config() logger( "INFO", "message_broker_interface/connection : start to connecting to JMS") logger( "INFO", "message_broker_interface/connection : jms server host : " + configuration["monitor_engine.message_server"]["host"]) logger( "INFO", "message_broker_interface/connection : jms server port : " + str(configuration["monitor_engine.message_server"]["port"])) connection = stomp.Connection([ (configuration["monitor_engine.message_server"]["host"], configuration["monitor_engine.message_server"]["port"]) ]) connection.start() connection.connect( configuration["monitor_engine.message_server"]["user_name"], configuration["monitor_engine.message_server"]["password"], wait=True) # Don't subscribe into any queue just return connection itself. return connection
def __init__(self): logger( "INFO", "message_broker_interface_listener/result_listener : listener established" ) self.result_service = result_service.ResultService()
def __init__(self): logger( "INFO", "message_broker_interface_listener/registration_listener : listener established" ) self.checkpoint_handler = check_point_service.CheckPointService()
def on_error(self, headers, message): # Do some operation on the error message ! logger( "ERROR", "message_broker_interface_listener/registration_listener : " + message)
def __init__(self): logger( "INFO", "message_broker_interface_listener/registration_listener : listener established" ) self.handler = handler.Handler()