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()
