def execute(self, p_request: ExportRequest = None):
""" Executes the export operation """
self._prepare_before_execute(p_request)
try:
self._status = ExportStatus.BUSY
log = Log()
log.append_text("Starting data export")
self.request.dispatcher.export_data_begin()
source_db = self.request.dispatcher.get_client_database(
self.request.client)
package = Exporter._pull(source_db)
Exporter._push(package, self.request.target_db)
except Exception as error: # pylint: disable=W0703
error_entry = LogEntry(str(error), p_type=MessageType.error)
log.append_entry(error_entry)
finally:
self.request.dispatcher.export_data_end()
log.append_text("Data export finished")
try:
self.request.target_db.insert_log(log)
except Exception: # pylint: disable=W0703
pass
self._status = ExportStatus.IDLE
print("Export complete")
def delete_log_file_before(self, p_client_id: str, p_before: datetime,
p_log: Log):
""" Deletes log files before the given date """
log_root_path = self.get_root_path(p_client_id)
all_log_files = self.get_log_file_list(p_client_id)
for log_file in all_log_files:
split1 = log_file.split("T")
split2 = split1[0].split("-")
log_file_date = datetime(year=int(split2[0]),
month=int(split2[1]),
day=int(split2[2]))
if log_file_date < p_before:
full_log_file_path = path.join(log_root_path, log_file)
p_log.append_text(f"Deleting {full_log_file_path}")
remove(full_log_file_path)
def test116(action: int):
""" Runs the test for issue 116 """
log = Log()
exchange = Exchange116(p_log=log)
passengers = exchange.pull()
if passengers is None or len(passengers) <= 0:
return
for passenger in passengers:
if action == 1:
exchange.delete_seated_passengers_from_inbox([passenger])
continue
if action == 2:
exchange.forward_seated_passengers([passenger],
["*****@*****.**"])
continue
if action == 3:
exchange.trash_seated_passengers([passenger])
continue
if action == 4:
folder = ExchangeFolder(ExchangeFolderParent.INBOX, "kktest1")
exchange.move_seated_passengers([passenger], folder)
continue
if action == 5:
folder = ExchangeFolder(ExchangeFolderParent.ROOT, "kktest2")
exchange.move_seated_passengers([passenger], folder)
continue
def all_clients(self) -> List[Client]:
""" Returns a list of clients from the database within the ticket """
dummy_db = self.ticket.database_factory.create_database(
p_log=Log(),
p_module=self.ticket.database_module,
p_client_id=None,
p_passenger_factory=self.ticket.passenger_factory,
p_arguments=self.ticket.database_arguments)
return dummy_db.get_clients()
def pull_passengers_from_module(
self,
p_puller_module: str,
p_log: Log = None) -> List[AbstractPassenger]:
""" Pulls new passengers from the given puller module """
if p_log is None:
log = Log()
else:
log = p_log
puller_obj = self.puller_factory.create_puller(p_puller_module, log)
return puller_obj.pull()
def get_client_database(self,
p_client_id: str,
p_log: Log = None) -> AbstractDatabase:
""" Returns a database instance for the given client """
if p_log is None:
log = Log()
else:
log = p_log
return self.ticket.database_factory.create_database( # pylint: disable=C0103
p_passenger_factory=self.ticket.passenger_factory,
p_client_id=p_client_id,
p_module=self.ticket.database_module,
p_log=log,
p_arguments=self.ticket.database_arguments)
def __init__(self,
p_client_passenger: ClientPassenger = None,
p_log: Log = None,
p_database: AbstractDatabase = None):
if p_client_passenger is None:
self.client_passenger = ClientPassenger()
else:
self.client_passenger = p_client_passenger
if p_log is None:
self.log = Log()
else:
self.log = p_log
self.database = p_database
def get_log_content(self, p_log_id: str) -> str:
""" Returns the contents of the given log
p_log_id is whatever you have returned in get_log_list.
"""
output = ""
log_id = p_log_id.split(SqlDatabase._LOG_ID_SEPARATOR)[1]
cond = "log_id = '" + log_id + "'"
log_entries = self._query_helper.select_all("log_item", cond)
for log_entry in log_entries:
if output != "":
output += "\r\n"
line = Log.build_entry_field_string(
p_date=str(log_entry["message_on"]),
p_source=log_entry["module"],
p_type=SqlToDatabus.message_type(
log_entry["message_type"]).name,
p_message=log_entry["message"])
output += line
return output
def execute(self):
""" Executes an export request """
try:
self._authenticate(must_be_admin=True)
except AuthenticationError as authentication_error:
return authentication_error.output
exporter = ExporterFactory.get_singleton()
if exporter.status == ExportStatus.BUSY:
return render_template("export_busy.html",
alias=self.dispatcher.ticket.system_alias)
client = request.form["client"]
db_module = request.form["db_module"]
db_args = json.loads(request.form["args"])
mode = request.form["mode"]
if self.authenticated_client_id != Client.ROOT:
if client != self.authenticated_client_id:
return redirect(url_for("_login"), code=302)
target_db = self.dispatcher.ticket.database_factory.create_database(
db_module, client, Log(), self.dispatcher.ticket.passenger_factory,
db_args)
export_request = ExportRequest(self.dispatcher, target_db, db_args,
client, self.authenticated_client_id)
if mode == "async":
exporter.execute_async(export_request)
else:
exporter.execute(export_request)
return render_template("export_started.html",
mode=mode,
alias=self.dispatcher.ticket.system_alias)
def _drive_passenger(self, p_client: Client,
p_client_passenger: ClientPassenger):
if self.paused or self._status.shutting_down:
return
log = Log()
db = None # pylint: disable=C0103
driver = None
try:
log.append_text("Dispatching client " + p_client.id +
" passenger " + p_client_passenger.name)
log.append_text(f"Creating database {self.ticket.database_module}")
db = self.get_client_database(p_client.id, log) # pylint: disable=C0103
log.append_text("Checking schema")
db.ensure_schema_existence()
log.append_text(f"Creating driver {self.ticket.driver_module}")
driver = self.get_driver()
log.append_text("Creating ticket")
ticket = BusTicket(p_client_passenger=p_client_passenger,
p_log=log,
p_database=db)
log.append_text("Driving")
driver.drive(ticket)
except Exception as drive_error: # pylint: disable=W0703
if log is not None:
log.append_entry(
LogEntry(p_message=str(drive_error),
p_type=MessageType.error))
finally:
self._tick_count.reset_tick(p_client.id, p_client_passenger.name)
if self.ticket.dispatcher_observer is not None and log is not None:
self.ticket.dispatcher_observer.drive_passenger_complete(
p_client, p_client_passenger, log)
if db is not None:
db.insert_log(log)
db.delete_old_logs(p_client.log_expiry_date)
if driver is not None:
driver.queue.delete_completed_passengers(
p_client_passenger.name,
p_client_passenger.queue_expiry_date)