def insert_log(self, p_log: Log):
""" Creates a new log file on the disk """
self.log.append_text("Writing log to the database")
insert = InsertBuilder(self._query_helper.args, self.client_id)
insert.table = "log_head"
insert.add_string("log_id", p_log.guid)
insert.add_datetime("created_on", p_log.creation_datetime)
self._query_helper.execute_insert(insert)
item_no = 0
try:
for log_entry in p_log.entries:
item_no += 1
insert.table = "log_item"
insert.add_string("log_id", p_log.guid)
insert.add_int("item_no", item_no)
insert.add_string("module", log_entry.source)
insert.add_string("message_type",
DatabusToSql.message_type(log_entry.type))
insert.add_string("message", log_entry.message)
self._query_helper.execute_insert(insert)
self._query_helper.commit()
except Exception as error:
self._query_helper.rollback()
raise error
def update_queue_status(self, p_status: PassengerQueueStatus):
""" Updates queue files on the database """
self.log.append_text("Updating passenger " +
p_status.passenger.id_text)
try:
where = WhereBuilder(p_client_id=self.client_id)
where.add_and("queue_id = '" + p_status.passenger.internal_id +
"'")
update = UpdateBuilder(self._query_helper.args)
update.table = "queue"
update.add_int("puller_notified",
DatabusToSql.boolean(p_status.puller_notified))
update.where = where
self._query_helper.execute_update(update)
for processor_status in p_status.processor_statuses:
update.table = "queue_processor"
update.add_string(
"status",
DatabusToSql.queue_status(processor_status.status))
update.where = where
self._query_helper.execute_update(update)
for pusher_status in p_status.pusher_statuses:
update.table = "queue_pusher"
update.add_string(
"status", DatabusToSql.queue_status(pusher_status.status))
update.where = where
self._query_helper.execute_update(update)
self._insert_logs(p_status)
self._query_helper.commit()
except Exception as error:
self._query_helper.rollback()
raise error
def date_lt(p_field: str, p_date: datetime):
""" p_field < p_date """
return p_field + " < '" + DatabusToSql.date_time(p_date) + "'"
def add_datetime(self, p_key: str, p_val: datetime):
""" Adds a new datetime """
keyval = KeyValue(p_key, DatabusToSql.date_time(p_val), True)
self._key_values.append(keyval)
def _select_from_queue(
self, # pylint: disable=R0912, R0913, R0914, R0915
p_passenger_module: str = None,
p_processor_status: QueueStatus = None,
p_pusher_status: QueueStatus = None,
p_puller_notified: bool = None,
p_pulled_before: datetime = None,
p_queue_id: str = None) -> List[PassengerQueueStatus]:
output = []
where = WhereBuilder(self.client_id)
if p_queue_id is not None:
where.add_and("queue_id = '" + p_queue_id + "'")
if p_passenger_module is not None:
where.add_and("passenger_module = '" + p_passenger_module + "'")
if p_puller_notified is not None:
where.add_and("puller_notified = " +
str(DatabusToSql.boolean(p_puller_notified)))
if p_pulled_before is not None:
where.add_and_date_lt("pulled_on", p_pulled_before)
where.set_order_by(["pulled_on"])
queue_list = self._query_helper.select_all_where_builder(
"queue", where)
for queue_row in queue_list:
queue_row_is_eligible = True
queue_where = "queue_id = '" + queue_row["queue_id"] + "'"
processor_list = self._query_helper.select_all(
"queue_processor", queue_where, p_order_fields=["exe_order"]) # pylint: disable= C0301
if p_processor_status is not None and len(processor_list) > 0:
for processor_row in processor_list:
if SqlToDatabus.queue_status(
processor_row["status"]) != p_processor_status:
queue_row_is_eligible = False
break
if not queue_row_is_eligible:
continue
pusher_list = self._query_helper.select_all(
"queue_pusher", queue_where, p_order_fields=["exe_order"]) # pylint: disable= C0301
if p_pusher_status is not None and len(pusher_list) > 0:
for pusher_row in pusher_list:
if SqlToDatabus.queue_status(
pusher_row["status"]) != p_pusher_status:
queue_row_is_eligible = False
break
if not queue_row_is_eligible:
continue
passenger = self.passenger_factory.create_passenger(
queue_row["passenger_module"]) # pylint: disable=C0301
passenger.external_id = queue_row["external_id"]
passenger.internal_id = queue_row["queue_id"]
passenger.source_system = queue_row["source_system"]
passenger.puller_module = queue_row["puller_module"]
passenger.pull_datetime = SqlToDatabus.date_time(
queue_row["pulled_on"])
attachment_list = self._query_helper.select_all(
"queue_attachment", queue_where)
for attachment_row in attachment_list:
if attachment_row["bin_content"] is None:
bin_content = None
else:
bin_content = attachment_row["bin_content"]
if attachment_row["txt_content"] is None:
txt_content = None
else:
txt_content = attachment_row["txt_content"]
attachment = Attachment(
p_name=attachment_row["attachment_id"],
p_format=SqlToDatabus.attachment_format(
attachment_row["file_format"]),
p_text_content=txt_content,
p_binary_content=bin_content)
passenger.attachments.append(attachment)
log_list = self._query_helper.select_all("queue_log", queue_where)
for log in log_list:
passenger.collect_log_guid(UUID(log["log_id"]))
output_row = PassengerQueueStatus(
p_passenger=passenger,
p_puller_notified=SqlToDatabus.boolean(
queue_row["puller_notified"]))
for processor_row in processor_list:
pqs = ProcessorQueueStatus(
processor_row["processor_module"],
SqlToDatabus.queue_status(processor_row["status"]))
output_row.processor_statuses.append(pqs)
for pusher_row in pusher_list:
pqs = PusherQueueStatus(
pusher_row["pusher_module"],
SqlToDatabus.queue_status(pusher_row["status"]))
output_row.pusher_statuses.append(pqs)
output.append(output_row)
return output
def insert_passenger_queue(self, p_passenger_status: PassengerQueueStatus):
""" Writes new files to the database """
self.log.append_text("Appending passenger " +
p_passenger_status.passenger.id_text)
try:
insert = InsertBuilder(self._query_helper.args, self.client_id)
insert.table = "queue"
insert.add_string("queue_id",
p_passenger_status.passenger.internal_id)
insert.add_string("external_id",
p_passenger_status.passenger.external_id)
insert.add_string("source_system",
p_passenger_status.passenger.source_system)
insert.add_string("passenger_module",
p_passenger_status.passenger.passenger_module)
insert.add_string("puller_module",
p_passenger_status.passenger.puller_module)
insert.add_string("puller_notified", DatabusToSql.boolean(False))
insert.add_string("pulled_on",
DatabusToSql.date_time(
p_passenger_status.passenger.pull_datetime)) # pylint: disable= C0301
self._query_helper.execute_insert(insert)
processor_exe_order = 0
for processor in p_passenger_status.processor_statuses:
processor_exe_order += 1
insert.table = "queue_processor"
insert.add_string("queue_id",
p_passenger_status.passenger.internal_id)
insert.add_string("processor_module",
processor.processor_module)
insert.add_string("status",
DatabusToSql.queue_status(processor.status))
insert.add_int("exe_order", processor_exe_order)
self._query_helper.execute_insert(insert)
pusher_exe_order = 0
for pusher in p_passenger_status.pusher_statuses:
pusher_exe_order += 1
insert.table = "queue_pusher"
insert.add_string("queue_id",
p_passenger_status.passenger.internal_id)
insert.add_string("pusher_module", pusher.pusher_module)
insert.add_string("status",
DatabusToSql.queue_status(pusher.status))
insert.add_int("exe_order", pusher_exe_order)
self._query_helper.execute_insert(insert)
for attachment in p_passenger_status.passenger.attachments:
table_path = self._query_helper.path_builder.get_table_path(
"insert_queue_attachment") # pylint: disable=C0301
sql = "{call " + table_path + "(?, ?, ?, ?, ?, ?)}"
values = (self.client_id,
p_passenger_status.passenger.internal_id,
attachment.name, attachment.text_content,
attachment.binary_content,
DatabusToSql.attachment_format(attachment.format))
self._query_helper.execute_stored_procedure(sql, values)
self._insert_logs(p_passenger_status)
self._query_helper.commit()
except Exception as error:
self._query_helper.rollback()
raise error