def discover_handlers(database_name, logger_enabled): pool_manager = PoolManager(database_name) transaction = Transaction() logger.debug("Starting db transaction for domain:%s" % database_name) transaction.start(database_name, 0) logger.debug("Connecting to table") transaction_handler_table = pool_manager.get_table("hl7.transaction_handler") logger.debug("Preparing query for table -> %s" % transaction_handler_table) query = transaction_handler_table.select(*[transaction_handler_table.message_handler_module_name, transaction_handler_table.message_handler_class_name, transaction_handler_table.message_type]) cursor = transaction.cursor logger.debug("Executing query:%s" % query) cursor.execute(*query) results = cursor.fetchall() # return all results logger.debug("Query results: %s" % results) transaction.stop() handlers = { "ERR": (HL7ErrorHandler, pool_manager) } if results: for r in results: handler_module_name = r[0] handler_class_name = r[1] message_type = r[2] handlers[message_type] = (str_to_class(handler_module_name, handler_class_name), pool_manager, logger_enabled) logger.debug("handlers found: " + str(handlers)) return handlers
def wrap(self, *args, **kwargs): message_res = met(self, *args, **kwargs) if self.logger_enabled: message_req = self.incoming_message logger.debug("Saving transition:\nIN: %s\nOUT: %s\nHandler: %s\n" % (message_req, message_res, self.__class__.__name__)) transaction = Transaction() logger.debug("Starting db transaction for domain:%s" % self.pool_manager.get_domain()) transaction.start(self.pool_manager.get_domain(), 0) logger.debug("Connecting to table") hl7_message_logger = self.pool_manager.get_table("hl7.message_logger") logger.debug("Preparing query for table:::%s" % hl7_message_logger) cursor = transaction.cursor insert_columns = [hl7_message_logger.create_uid, hl7_message_logger.create_date, hl7_message_logger.creation_date, hl7_message_logger.request, hl7_message_logger.response, hl7_message_logger.handler_module] insert_values = [transaction.user, Now(), Now(), message_req, message_res[1:-2], self.__class__.__name__] cursor.execute(*hl7_message_logger.insert(insert_columns, [insert_values])) cursor.execute("commit") logger.debug("Query executed") transaction.stop() return message_res
def _get_sending_application(self): transaction = Transaction() transaction.start(self.pool.get_domain(), 0) query = self.hl7_conf_table.select(*[self.hl7_conf_table.application_code]) cursor = transaction.cursor cursor.execute(*query) results = cursor.fetchall() # return all results transaction.stop() if results is not None and len(results) > 0: return results[0][0] else: return "gnuhealth"
def _get_pdq_allowed_applications(self): transaction = Transaction() transaction.start(self.pool.get_domain(), 0) query = self.pdq_allowed_apps_table.select(*[self.pdq_allowed_apps_table.allowed_application]) cursor = transaction.cursor cursor.execute(*query) results = cursor.fetchall() # return all results transaction.stop() # cursor.close() if results is not None and len(results) > 0: allowed_apps = [res[0] for res in results] logger.debug("Allowed APPS:%s" % allowed_apps) return allowed_apps else: logger.debug("NO allowed applications found") return []
def run(cls, db_name): transaction = Transaction() logger.info('cron started for "%s"', db_name) now = datetime.datetime.now() retry = config.getint('database', 'retry') with transaction.start(db_name, 0, context={'_skip_warnings': True}): transaction.database.lock(transaction.connection, cls._table) crons = cls.search(['OR', ('next_call', '<=', now), ('next_call', '=', None), ]) for cron in crons: name = '<Cron %s@%s %s>' % (cron.id, db_name, cron.method) logger.info("%s started", name) for count in range(retry, -1, -1): if count != retry: time.sleep(0.02 * (retry - count)) try: with processing(name): cron.run_once() cron.next_call = cron.compute_next_call(now) cron.save() transaction.commit() except Exception as e: transaction.rollback() if (isinstance(e, backend.DatabaseOperationalError) and count): continue logger.error('%s failed', name, exc_info=True) break while transaction.tasks: task_id = transaction.tasks.pop() run_task(db_name, task_id) logger.info('cron finished for "%s"', db_name)
def wrapper(*args, **kwargs): transaction = Transaction() with transaction.start(DB_NAME, user, context=context): result = func(*args, **kwargs) transaction.rollback() # Drop the cache as the transaction is rollbacked Cache.drop(DB_NAME) return result
def wrapper(*args, **kwargs): transaction = Transaction() with transaction.start(DB_NAME, user, context=context): result = func(*args, **kwargs) transaction.cursor.rollback() # Drop the cache as the transaction is rollbacked Cache.drop(DB_NAME) return result
def _load_pdq_configuration_dict(self): """ Load the pdq configuration dict from the database, based on the current content of the hl7 and pdq tables """ conf = { "ENABLED": False, "ALLOWED_APPLICATIONS": [], "FILTER_BY_ALLOWED_APP": False, "SENDING_FACILITY": "gnuhealth", "SENDING_APPLICATION": "gnuhealth", "CHARACTER_SET": CHARACTER_SET, "LANGUAGE": LANGUAGE, "COUNTRY": COUNTRY_CODE } transaction = Transaction() transaction.start(self.pool.get_domain(), 0) query = self.pdq_conf_table.select(*[self.pdq_conf_table.enabled, self.pdq_conf_table.facility_name, self.pdq_conf_table.filter_by_allowed_app, self.pdq_conf_table.encoding_char, self.pdq_conf_table.country, self.pdq_conf_table.language]) cursor = transaction.cursor cursor.execute(*query) results = cursor.fetchall() # return all results logger.debug("PDQ CONFIGURATION Query results: %s" % results) transaction.stop() if results: conf["ENABLED"] = results[0][0] conf["SENDING_FACILITY"] = results[0][1] conf["FILTER_BY_ALLOWED_APP"] = results[0][2] conf["CHARACTER_SET"] = results[0][3] conf["COUNTRY"] = results[0][4] conf["LANGUAGE"] = results[0][5] conf["ALLOWED_APPLICATIONS"] = self._get_pdq_allowed_applications() conf["SENDING_APPLICATION"] = self._get_sending_application() return conf
def transaction(request): """Yields transaction with installed module. """ # Importing transaction directly causes cyclic dependency in 3.6 from trytond.tests.test_tryton import USER, CONTEXT, DB_NAME, POOL from trytond.tools.singleton import Singleton # noqa from trytond.transaction import Transaction from trytond.cache import Cache # Inject helper functions in instance on which test function was collected. request.instance.POOL = POOL request.instance.USER = USER request.instance.CONTEXT = CONTEXT request.instance.DB_NAME = DB_NAME transaction = Transaction() with transaction.start(DB_NAME, USER, context=CONTEXT) as txn: yield txn transaction.rollback() Cache.drop(DB_NAME)
def test_subscribe_message(self): "Test subscribe with message" Bus.subscribe(DB_NAME, ['user:1']) transaction = Transaction() with transaction.start(DB_NAME, 1): notify("Test", "Message", user=1) transaction.commit() # Let the listen thread registers the message time.sleep(1) response = Bus.subscribe(DB_NAME, ['user:1']) self.assertTrue(response['message'].pop('message_id')) self.assertEqual(response, { 'message': { 'type': 'notification', 'title': "Test", 'body': "Message", 'priority': 1, }, 'channel': 'user:1', })
def transaction(request): """Yields transaction with installed module. """ # Importing transaction directly causes cyclic dependency in 3.6 from trytond.tests.test_tryton import USER, CONTEXT, DB_NAME, POOL from trytond.tools.singleton import Singleton # noqa from trytond.transaction import Transaction from trytond.cache import Cache # Inject helper functions in instance on which test function was collected. request.instance.POOL = POOL request.instance.USER = USER request.instance.CONTEXT = CONTEXT request.instance.DB_NAME = DB_NAME transaction = Transaction() with transaction.start(DB_NAME, USER, context=CONTEXT) as txn: yield txn transaction.rollback() Cache.drop(DB_NAME)