def handle(self, *args, **options):
if not options["task_code"]:
log.error("Expected a task_code argument, use --help.")
return
numeric_level = getattr(logging, options["log_level"].upper(), None)
if not isinstance(numeric_level, int):
log.error("Invalid log level: %s" % options["log_level"])
numeric_level = 10
broker = BrokerConnection()
connection = broker.connect_to_broker()
removeFileHandlers()
setFileHandler(options["worker_nr"])
setLevelToAllHandlers(numeric_level)
if connection is None:
log.error("Could not connect to broker.")
return
action = ActionTask(options["task_code"], options["worker_nr"])
logging.handlers.AMQPMessageHandler = AMQPMessageHandler
broker_logging_handler = logging.handlers.AMQPMessageHandler(
action, numeric_level)
action.set_broker_logging_handler(broker_logging_handler)
task_worker = Worker(connection, options["task_code"], action,
options["worker_nr"])
task_worker.run_worker()
removeFileHandlers()
def start_heartbeat(log_level='INFO'):
"""
Publish a message to execute a separate task.
"""
numeric_level = getattr(logging, log_level.upper(), None)
broker = BrokerConnection()
connection = broker.connect_to_broker()
if connection is None:
log.error("Could not connect to broker.")
return
action = ActionHeartbeat(connection, settings.HEARTBEAT_QUEUES)
logging.handlers.AMQPMessageHandler = AMQPMessageHandler
broker_handler = logging.handlers.AMQPMessageHandler(
action, numeric_level)
action.set_broker_logging_handler(broker_handler)
success = action.perform()
action.log.removeHandler(broker_handler)
if connection.is_open:
connection.close()
return success
def handle(self, *args, **options):
if not options["queue_code"]:
log.error("Expected a queue_code argument, use --help.")
return
numeric_level = getattr(logging, options["log_level"].upper(), None)
if not isinstance(numeric_level, int):
log.error("Invalid log level: %s" % options["log_level"])
numeric_level = 10
broker = BrokerConnection()
connection = broker.connect_to_broker()
removeFileHandlers()
setFileHandler(options["worker_nr"])
setLevelToAllHandlers(numeric_level)
if connection is None:
log.error("Could not connect to broker.")
return
action = ActionSupervisor(connection, options["queue_code"],
options["worker_nr"], numeric_level)
logging.handlers.AMQPMessageHandler = AMQPMessageHandler
broker_logging_handler = logging.handlers.AMQPMessageHandler(
action, numeric_level)
action.set_broker_logging_handler(broker_logging_handler)
task_worker = Worker(connection, options["queue_code"], action,
options["worker_nr"])
log.info("Start worker.")
task_worker.run_worker()
removeFileHandlers()
def start_task(task_id, log_level='INFO'):
"""
Publish a message to execute a separate task.
"""
task = WorkflowTask.objects.get(pk=task_id)
numeric_level = getattr(logging, log_level.upper(), None)
if not isinstance(numeric_level, int):
log.error("Invalid log level: %s" % log_level)
numeric_level = 10
broker = BrokerConnection()
connection = broker.connect_to_broker()
if connection is None:
log.error("Could not connect to broker.")
return
action = ActionTaskPublisher(connection, task)
logging.handlers.AMQPMessageHandler = AMQPMessageHandler
broker_handler = logging.handlers.AMQPMessageHandler(action, numeric_level)
action.set_broker_logging_handler(broker_handler)
success = action.perform()
action.log.removeHandler(broker_handler)
if connection.is_open:
connection.close()
return success
def start_task(task_id, log_level='INFO'):
"""
Publish a message to execute a separate task.
"""
task = WorkflowTask.objects.get(pk=task_id)
numeric_level = getattr(logging, log_level.upper(), None)
if not isinstance(numeric_level, int):
log.error("Invalid log level: %s" % log_level)
numeric_level = 10
broker = BrokerConnection()
connection = broker.connect_to_broker()
if connection is None:
log.error("Could not connect to broker.")
return
action = ActionTaskPublisher(connection, task)
logging.handlers.AMQPMessageHandler = AMQPMessageHandler
broker_handler = logging.handlers.AMQPMessageHandler(
action, numeric_level)
action.set_broker_logging_handler(broker_handler)
success = action.perform()
action.log.removeHandler(broker_handler)
if connection.is_open:
connection.close()
return success
class WorkerProcess(Process):
def __init__(self, action, worker_nr, task_code, *args, **kwargs):
self.worker_nr = worker_nr
self.task_code = task_code
self.connection = None
self.channel = None
self.action = action
self.set_connection()
self.set_channel()
Process.__init__(self, *args, **kwargs)
def set_connection(self):
self.connection = BrokerConnection().connect_to_broker()
def set_channel(self):
try:
self.channel = self.connection.channel()
except AMQPChannelError as ex:
log.error("Worker_nr: {0} error: {1}".format(
self.worker_nr, ",".join(map(str, ex.args))))
def set_action(self, action):
self.action = action
def run(self):
try:
self.channel.basic_qos(prefetch_count=1)
self.channel.basic_consume(self.action.callback,
queue=self.task_code,
no_ack=False)
self.channel.start_consuming()
except AMQPChannelError as ex:
log.error("Worker_nr: {0} error: {1}".format(
self.worker_nr, ",".join(map(str, ex.args))))
class WorkerProcess(Process):
def __init__(self, action, worker_nr, task_code, *args, **kwargs):
self.worker_nr = worker_nr
self.task_code = task_code
self.connection = None
self.channel = None
self.action = action
self.set_connection()
self.set_channel()
Process.__init__(self, *args, **kwargs)
def set_connection(self):
self.connection = BrokerConnection().connect_to_broker()
def set_channel(self):
try:
self.channel = self.connection.channel()
except AMQPChannelError as ex:
log.error("Worker_nr: {0} error: {1}".format(
self.worker_nr, ",".join(map(str, ex.args))))
def set_action(self, action):
self.action = action
def run(self):
try:
self.channel.basic_qos(prefetch_count=1)
self.channel.basic_consume(self.action.callback,
queue=self.task_code,
no_ack=False)
self.channel.start_consuming()
except AMQPChannelError as ex:
log.error("Worker_nr: {0} error: {1}".format(
self.worker_nr, ",".join(map(str, ex.args))))
def test_action(self, child, task_code, worker_nr):
#action = ActionTask('120', '10')
from lizard_worker.worker.worker import Worker
from lizard_worker.worker.broker_connection import BrokerConnection
connection = BrokerConnection().connect_to_broker()
action = ActionTask(task_code, worker_nr)
worker = Worker(connection, task_code, action, worker_nr)
worker.run_worker()
def handle(self, *args, **options):
queue_code = 'logging'
broker = BrokerConnection()
connection = broker.connect_to_broker()
removeFileHandlers()
setFileHandler('logging')
if connection is None:
log.error("Could not connect to broker.")
return
action = ActionLogging()
logging_worker = Worker(connection, queue_code, action)
log.info("Start logging worker.")
logging_worker.run_worker()
def __init__(self, log_level='INFO'):
self.numeric_level = getattr(logging, log_level.upper(), None)
self.document = None
self.connection = BrokerConnection().connect_to_broker()
self.channel = self.connection.channel()
result = self.channel.queue_declare(exclusive=True)
self.response_queue = result.method.queue
self.channel.basic_consume(self.on_response, no_ack=True,
queue=self.response_queue)
def handle(self, *args, **options):
queue_code = 'logging'
broker = BrokerConnection()
connection = broker.connect_to_broker()
removeFileHandlers()
setFileHandler('logging')
if connection is None:
log.error("Could not connect to broker.")
return
action = ActionLogging()
logging_worker = Worker(connection,
queue_code,
action)
log.info("Start logging worker.")
logging_worker.run_worker()
def start_workflow(scenario_id,
workflowtemplate_id,
log_level='INFO',
scenario_type="flooding_scenario"):
"""
Opens connection to broker.
Creates ActionWorkflow object.
Creates logging handler to send loggings to broker.
Sets logging handler to ActionWorkflow object.
Performs workflow.
Removes handler.
Closes connection.
See also: worker.action_workflow.ActionWorkflow object
"""
numeric_level = getattr(logging, log_level.upper(), None)
if not isinstance(numeric_level, int):
log.error("Invalid log level: %s" % log_level)
numeric_level = 10
broker = BrokerConnection()
connection = broker.connect_to_broker()
if connection is None:
log.error("Could not connect to broker.")
return
action = ActionWorkflow(connection,
scenario_id,
workflowtemplate_id,
scenario_type=scenario_type)
logging.handlers.AMQPMessageHandler = AMQPMessageHandler
broker_handler = logging.handlers.AMQPMessageHandler(action, numeric_level)
action.set_broker_logging_handler(broker_handler)
status = action.perform_workflow()
action.log.removeHandler(broker_handler)
if connection.is_open:
connection.close()
return status
def handle(self, *args, **options):
numeric_level = getattr(logging, options["log_level"].upper(), None)
if not isinstance(numeric_level, int):
log.error("Invalid log level: %s" % options["log_level"])
numeric_level = 10
broker = BrokerConnection()
connection = broker.connect_to_broker()
removeFileHandlers()
setFileHandler('queue')
if connection is None:
log.error("Could not connect to broker.")
return
# TODO CREATE ActionPreority
action = ActionPriority(connection, options["task_code"])
queue_worker = Worker(connection, options["task_code"], action)
queue_worker.run_worker()
def start_workflow(
scenario_id, workflowtemplate_id, log_level='INFO',
scenario_type="flooding_scenario"):
"""
Opens connection to broker.
Creates ActionWorkflow object.
Creates logging handler to send loggings to broker.
Sets logging handler to ActionWorkflow object.
Performs workflow.
Removes handler.
Closes connection.
See also: worker.action_workflow.ActionWorkflow object
"""
numeric_level = getattr(logging, log_level.upper(), None)
if not isinstance(numeric_level, int):
log.error("Invalid log level: %s" % log_level)
numeric_level = 10
broker = BrokerConnection()
connection = broker.connect_to_broker()
if connection is None:
log.error("Could not connect to broker.")
return
action = ActionWorkflow(
connection, scenario_id, workflowtemplate_id,
scenario_type=scenario_type)
logging.handlers.AMQPMessageHandler = AMQPMessageHandler
broker_handler = logging.handlers.AMQPMessageHandler(
action, numeric_level)
action.set_broker_logging_handler(broker_handler)
status = action.perform_workflow()
action.log.removeHandler(broker_handler)
if connection.is_open:
connection.close()
return status
class ConverterRpcClient(object):
"""
Publish a message to execute the converter.
"""
def __init__(self, log_level='INFO'):
self.numeric_level = getattr(logging, log_level.upper(), None)
self.document = None
self.connection = BrokerConnection().connect_to_broker()
self.channel = self.connection.channel()
result = self.channel.queue_declare(exclusive=True)
self.response_queue = result.method.queue
self.channel.basic_consume(self.on_response, no_ack=True,
queue=self.response_queue)
def on_response(self, ch, method, props, body):
self.response = body
self.body = simplejson.loads(body)
self.document = binascii.unhexlify(self.body["file"])
#self.document = base64.b64encode(self.body["file"])
if self.connection.is_open:
self.connection.close()
def call(self, html, format_ext, queue_code):
self.response = None
action = ActionConverterPublisher(
self.connection, queue_code, html, self.response_queue, format_ext)
logging.handlers.AMQPMessageHandler = AMQPMessageHandler
broker_handler = logging.handlers.AMQPMessageHandler(
action, self.numeric_level)
action.set_broker_logging_handler(broker_handler)
success = action.perform()
while self.response is None:
self.connection.process_data_events()
return self.document
def handle(self, *args, **options):
"""
Open connection to broker.
Creates message.
Creates logging handler to send loggings to broker.
Sets logging handler to ActionWorkflow object.
Close connection.
"""
numeric_level = getattr(logging, options["log_level"].upper(), None)
if not isinstance(numeric_level, int):
log.error("Invalid log level: %s" % options["log_level"])
numeric_level = 10
broker = BrokerConnection()
connection = broker.connect_to_broker()
removeFileHandlers()
setFileHandler('start')
if connection is None:
log.error("Could not connect to broker.")
return
action = ActionWorker(connection,
options["worker_nr"],
options["command"],
options["task_code"],
options["queue_code"])
logging.handlers.AMQPMessageHandler = AMQPMessageHandler
broker_handler = logging.handlers.AMQPMessageHandler(action,
numeric_level)
action.set_broker_logging_handler(broker_handler)
action.execute()
if connection.is_open:
connection.close()
def handle(self, *args, **options):
"""
Open connection to broker.
Creates message.
Creates logging handler to send loggings to broker.
Sets logging handler to ActionWorkflow object.
Close connection.
"""
numeric_level = getattr(logging, options["log_level"].upper(), None)
if not isinstance(numeric_level, int):
log.error("Invalid log level: %s" % options["log_level"])
numeric_level = 10
broker = BrokerConnection()
connection = broker.connect_to_broker()
removeFileHandlers()
setFileHandler('start')
if connection is None:
log.error("Could not connect to broker.")
return
action = ActionWorker(connection, options["worker_nr"],
options["command"], options["task_code"],
options["queue_code"])
logging.handlers.AMQPMessageHandler = AMQPMessageHandler
broker_handler = logging.handlers.AMQPMessageHandler(
action, numeric_level)
action.set_broker_logging_handler(broker_handler)
action.execute()
if connection.is_open:
connection.close()
def handle(self, *args, **options):
"""
Opens connection to broker.
Creates ActionWorkflow object.
Creates logging handler to send loggings to broker.
Sets logging handler to ActionWorkflow object.
Performs workflow.
Closes connection.
"""
numeric_level = getattr(logging, options["log_level"].upper(), None)
if not isinstance(numeric_level, int):
log.error("Invalid log level: %s" % options["log_level"])
numeric_level = 10
broker = BrokerConnection()
connection = broker.connect_to_broker()
removeFileHandlers()
setFileHandler('start')
if connection is None:
log.error("Could not connect to broker.")
return
action = ActionWorkflow(
connection, options["scenario_id"], options["workflowtemplate_id"])
logging.handlers.AMQPMessageHandler = AMQPMessageHandler
broker_handler = logging.handlers.AMQPMessageHandler(action,
numeric_level)
action.set_broker_logging_handler(broker_handler)
action.perform_workflow()
if connection.is_open:
connection.close()
def handle(self, *args, **options):
numeric_level = getattr(logging, options["log_level"].upper(), None)
if not isinstance(numeric_level, int):
log.error("Invalid log level: %s" % options["log_level"])
numeric_level = 10
broker = BrokerConnection()
connection = broker.connect_to_broker()
removeFileHandlers()
setFileHandler('queue')
if connection is None:
log.error("Could not connect to broker.")
return
# TODO CREATE ActionPreority
action = ActionPriority(connection,
options["task_code"])
queue_worker = Worker(connection,
options["task_code"],
action)
queue_worker.run_worker()
def start_heartbeat(log_level='INFO'):
"""
Publish a message to execute a separate task.
"""
numeric_level = getattr(logging, log_level.upper(), None)
broker = BrokerConnection()
connection = broker.connect_to_broker()
if connection is None:
log.error("Could not connect to broker.")
return
action = ActionHeartbeat(connection, settings.HEARTBEAT_QUEUES)
logging.handlers.AMQPMessageHandler = AMQPMessageHandler
broker_handler = logging.handlers.AMQPMessageHandler(action, numeric_level)
action.set_broker_logging_handler(broker_handler)
success = action.perform()
action.log.removeHandler(broker_handler)
if connection.is_open:
connection.close()
return success
def handle(self, *args, **options):
"""
Opens connection to broker.
Creates ActionWorkflow object.
Creates logging handler to send loggings to broker.
Sets logging handler to ActionWorkflow object.
Performs workflow.
Closes connection.
"""
numeric_level = getattr(logging, options["log_level"].upper(), None)
if not isinstance(numeric_level, int):
log.error("Invalid log level: %s" % options["log_level"])
numeric_level = 10
broker = BrokerConnection()
connection = broker.connect_to_broker()
removeFileHandlers()
setFileHandler('start')
if connection is None:
log.error("Could not connect to broker.")
return
action = ActionWorkflow(connection, options["scenario_id"],
options["workflowtemplate_id"])
logging.handlers.AMQPMessageHandler = AMQPMessageHandler
broker_handler = logging.handlers.AMQPMessageHandler(
action, numeric_level)
action.set_broker_logging_handler(broker_handler)
action.perform_workflow()
if connection.is_open:
connection.close()
def set_connection(self):
self.connection = BrokerConnection().connect_to_broker()
def set_connection(self):
self.connection = BrokerConnection().connect_to_broker()
