def main(): # 準備 database_manager = DatabaseManager(DEV_DB_CONFIG) Model.set_connection_resolver(database_manager) reservation_repository = OratorReservationRepository() find_available_reservation_usecase = FindAvalibleReservationUsecase(reservation_repository) task_キャンセル対象 = Taskキャンセル対象(find_available_reservation_usecase) cancel_meeting_room_usecase = CancelMeetingRoomUsecase(reservation_repository) find_reservation_usecase = FindReservatnionUsecase() meeting_room_repository = OratorMeetingRoomRepository() meeting_room_domain_service = MeetingRoomDomainService(meeting_room_repository) find_meeting_room_usecase = FindMeetingRoomUseCase(meeting_room_repository, meeting_room_domain_service) message_builder = CliSuccessToCancelMessageBuilder(find_reservation_usecase=find_reservation_usecase, find_meeting_room_usecase=find_meeting_room_usecase) coordinator = CancelMeetingCoordinator(task_キャンセル対象, cancel_meeting_room_usecase, message_builder) # 実行 try: coordinator.cancel_meeting_room() except Exception as e: print('Internal Server Error') # TODO: logging print(e)
def connect_db_orator(env): config = { 'default': 'read', 'read': { 'host': env("POSTGRE_HOST_READ"), 'driver': 'pgsql', 'database': env("POSTGRE_DATABASE"), 'user': env("POSTGRE_USERNAME"), 'password': env("POSTGRE_PASSWORD"), 'prefix': '', 'port': env("POSTGRE_PORT") }, 'write': { 'host': env("POSTGRE_HOST_READ"), 'driver': 'pgsql', 'database': env("POSTGRE_DATABASE"), 'user': env("POSTGRE_USERNAME"), 'password': env("POSTGRE_PASSWORD"), 'prefix': '', 'port': env("POSTGRE_PORT") } } db = DatabaseManager(config) Model.set_connection_resolver(db) return db
def dump(db_path): """Dump the DB contents to STDOUT, requiring only that the DB is a version that has an otus table in sqlite3 form (i.e. version 2 and 3 at least). """ sqlite_db = os.path.join(db_path, SequenceDatabase.SQLITE_DB_NAME) logging.debug("Connecting to DB {}".format(sqlite_db)) if not os.path.exists(sqlite_db): raise Exception( "SQLite3 database does not appear to exist in the SingleM database - perhaps it is the wrong version?" ) db = DatabaseManager( {'sqlite3': { 'driver': 'sqlite', 'database': sqlite_db }}) Model.set_connection_resolver(db) print "\t".join(OtuTable.DEFAULT_OUTPUT_FIELDS) for chunk in db.table('otus').chunk(1000): for entry in chunk: otu = OtuTableEntry() otu.marker = entry.marker otu.sample_name = entry.sample_name otu.sequence = entry.sequence otu.count = entry.num_hits otu.coverage = entry.coverage otu.taxonomy = entry.taxonomy print str(otu)
def setup_database(): """ enable database """ from orator import DatabaseManager, Model db = DatabaseManager(config.DATABASES) Model.set_connection_resolver(db)
def __init__(self): """ Initializes a database instance and binds the models to it. Arguement(s) - self """ # Bind Models to local variables self.City = city self.Country = country self.CountryInfo = countryinfo self.CountryLanguage = countrylanguage # Set config self.config = { 'mysql': { 'driver': 'mysql', 'host': os.getenv('DB_HOST'), 'database': os.getenv('DB_NAME'), 'user': os.getenv('DB_USER'), 'password': os.getenv('DB_PASSWORD'), 'prefix': '' } } # Create database from config self.db = DatabaseManager(self.config) # Auto-resolve connection Model.set_connection_resolver(self.db)
class Helper: # pragma: sql NO cover host = config.esm_sql_host port = config.esm_sql_port user = config.esm_sql_user password = config.esm_sql_password database = config.esm_sql_database config = { 'mysql': { 'driver': 'mysql', 'prefix': '', 'host': host, 'database': database, 'user': user, 'password': password, 'port': port } } db = DatabaseManager(config) schema = Schema(db) @staticmethod def to_blob(model) -> str: return json.dumps(model) @staticmethod def from_blob(blob) -> dict: temp = json.loads(blob) if temp: return dict(json.loads(blob)) else: return temp
def test_rollback_migration_can_be_pretended(self): resolver_mock = flexmock(DatabaseManager) resolver_mock.should_receive('connection').and_return({}) resolver = flexmock(DatabaseManager({})) connection = flexmock(Connection(None)) connection.should_receive('pretend').replace_with( lambda callback: callback(None)) resolver.should_receive('connection').with_args(None).and_return( connection) migrator = flexmock( Migrator( flexmock(DatabaseMigrationRepository(resolver, 'migrations')), resolver)) foo_migration = MigrationStub('foo') bar_migration = MigrationStub('bar') migrator.get_repository().should_receive('get_last').once().and_return( [foo_migration, bar_migration]) bar_mock = flexmock(MigrationStub()) bar_mock.should_receive('down').once() foo_mock = flexmock(MigrationStub()) foo_mock.should_receive('down').once() migrator.should_receive('_resolve').with_args( os.getcwd(), 'bar').once().and_return(bar_mock) migrator.should_receive('_resolve').with_args( os.getcwd(), 'foo').once().and_return(foo_mock) migrator.rollback(os.getcwd(), True)
def __init__(self): """ Initializes a database instance and binds the models to it. Arguement(s) - self """ # Set config self.config = { 'mysql': { 'driver': 'mysql', 'host': os.getenv('DB_HOST'), 'database': os.getenv('DB_NAME'), 'user': os.getenv('DB_USER'), 'password': os.getenv('DB_PASSWORD'), 'prefix': '' } } # Bind Models to local variables self.Posts = posts self.Drafts = drafts self.Users = users self.Notes = notes # Create database from config self.db = DatabaseManager(self.config) # Auto-resolve connection Model.set_connection_resolver(self.db)
def __init__(self, task, worker_control, queue): Thread.__init__(self) self.task = task self.worker_control = worker_control self.db = DatabaseManager(DATABASES) self.ipfs_s3_auth = (USERNAME, PASSWORD) self.result_queue = queue
class Helper: host = os.environ.get('ET_EDM_MYSQL_HOST', '127.0.0.1') user = os.environ.get('DATABASE_USER', 'root') password = os.environ.get('DATABASE_PASSWORD', '') database = os.environ.get('DATABASE_NAME', 'mysql') port = int(os.environ.get('MYSQL_3306_TCP', 3306)) config = { 'mysql': { 'driver': 'mysql', 'prefix': '', 'host': host, 'database': database, 'user': user, 'password': password, 'port': port } } db = DatabaseManager(config) schema = Schema(db) @staticmethod def to_blob(model) -> str: return json.dumps(model) @staticmethod def from_blob(blob) -> dict: return dict(json.loads(blob))
def test_last_batch_of_migrations_can_be_rolled_back(self): resolver_mock = flexmock(DatabaseManager) resolver_mock.should_receive('connection').and_return({}) resolver = flexmock(DatabaseManager({})) connection = flexmock() connection.should_receive('transaction').twice().and_return(connection) resolver.should_receive('connection').and_return(connection) migrator = flexmock( Migrator( flexmock(DatabaseMigrationRepository(resolver, 'migrations')), resolver)) foo_migration = MigrationStub('foo') bar_migration = MigrationStub('bar') migrator.get_repository().should_receive('get_last').once().and_return( [foo_migration, bar_migration]) bar_mock = flexmock(MigrationStub()) bar_mock.set_connection(connection) bar_mock.should_receive('down').once() foo_mock = flexmock(MigrationStub()) foo_mock.set_connection(connection) foo_mock.should_receive('down').once() migrator.should_receive('_resolve').with_args( os.getcwd(), 'bar').once().and_return(bar_mock) migrator.should_receive('_resolve').with_args( os.getcwd(), 'foo').once().and_return(foo_mock) migrator.get_repository().should_receive('delete').once().with_args( bar_migration) migrator.get_repository().should_receive('delete').once().with_args( foo_migration) migrator.rollback(os.getcwd())
def test_rollback_migration_can_be_pretended(self): resolver_mock = flexmock(DatabaseManager) resolver_mock.should_receive("connection").and_return({}) resolver = flexmock(DatabaseManager({})) connection = flexmock(Connection(None)) connection.should_receive("get_logged_queries").twice().and_return([]) resolver.should_receive("connection").with_args(None).and_return( connection) migrator = flexmock( Migrator( flexmock(DatabaseMigrationRepository(resolver, "migrations")), resolver)) foo_migration = flexmock(MigrationStub("foo")) foo_migration.should_receive("get_connection").and_return(connection) bar_migration = flexmock(MigrationStub("bar")) bar_migration.should_receive("get_connection").and_return(connection) migrator.get_repository().should_receive("get_last").once().and_return( [foo_migration, bar_migration]) migrator.should_receive("_resolve").with_args( os.getcwd(), "bar").once().and_return(bar_migration) migrator.should_receive("_resolve").with_args( os.getcwd(), "foo").once().and_return(foo_migration) migrator.rollback(os.getcwd(), True) self.assertTrue(foo_migration.downed) self.assertFalse(foo_migration.upped) self.assertTrue(foo_migration.downed) self.assertFalse(foo_migration.upped)
def load_data(): try: db = DatabaseManager(app.config.get('DB_CONFIG')).connection() if not db.table('greetings').get(['message']).first(): db.table('greetings').insert({'message': 'Hello world!'}) except Exception as e: app.logger.error('Unable to connect to db: %s' % e)
def test_last_batch_of_migrations_can_be_rolled_back(self): resolver_mock = flexmock(DatabaseManager) resolver_mock.should_receive("connection").and_return({}) resolver = flexmock(DatabaseManager({})) connection = flexmock() connection.should_receive("transaction").twice().and_return(connection) resolver.should_receive("connection").and_return(connection) migrator = flexmock( Migrator( flexmock(DatabaseMigrationRepository(resolver, "migrations")), resolver)) foo_migration = MigrationStub("foo") bar_migration = MigrationStub("bar") migrator.get_repository().should_receive("get_last").once().and_return( [foo_migration, bar_migration]) bar_mock = flexmock(MigrationStub()) bar_mock.set_connection(connection) bar_mock.should_receive("down").once() foo_mock = flexmock(MigrationStub()) foo_mock.set_connection(connection) foo_mock.should_receive("down").once() migrator.should_receive("_resolve").with_args( os.getcwd(), "bar").once().and_return(bar_mock) migrator.should_receive("_resolve").with_args( os.getcwd(), "foo").once().and_return(foo_mock) migrator.get_repository().should_receive("delete").once().with_args( bar_migration) migrator.get_repository().should_receive("delete").once().with_args( foo_migration) migrator.rollback(os.getcwd())
def __init__(self, host, port, user, password, database, trace=0): self._client = 'MariaDB' self._host = host self._port = port self._user = user self._password = password self._database = database self._api = None self._last_query = None # Debug messages self._trace = trace # This is to avoid problems that mysql has with localhost if host == 'localhost': self._host = '127.0.0.1' # Create connection with pony orm python API config = { 'mysql': { 'driver': 'mysql', 'host': host, 'database': database, 'user': user, 'password': password, 'port': port, 'prefix': '' } } self._api = DatabaseManager(config) result = self._api.select('SHOW TABLES') if not list(result): raise DBConnectionFailed( f'Connection to MariaDB failed. Check connection parameters')
def __init__(self): self.configuration = {'mysql':{'driver':'mysql','host': 'localhost','database': 'atm3',\ 'user': '******','password': '', 'prefix': '' } } self.db = DatabaseManager(self.configuration) self.customer = self.db.table('customers') self.account = self.db.table('accounts') self.transaction = self.db.table('transactions')
def _connect_to_sqlite(self, db): sqlite_db_path = db.sqlite_file if not os.path.exists(sqlite_db_path): raise Exception( "Sqlite database not found at '%s', indicating that either the SingleM database was built with an out-dated SingleM version, or that the database is corrupt. Please generate a new database with the current version of SingleM." ) logging.debug("Connecting to %s" % sqlite_db_path) dbm = DatabaseManager( {'sqlite3': { 'driver': 'sqlite', 'database': sqlite_db_path }}) Model.set_connection_resolver(dbm) try: len(dbm.table('otus').limit(1).get()) except Exception as e: logging.error( "Failure to extract any data from the otus table of the SQ Lite DB indicates this SingleM DB is either too old or is corrupt." ) raise (e) try: len(dbm.table('clusters').limit(1).get()) except QueryException: logging.error( "Failure to extract any data from the 'clusters' table indicates this SingleM DB is out-dated, and cannot be used with query implemented in this version of SingleM" ) sys.exit(1) return dbm
def db_health(): try: DatabaseManager( app.config.get('DB_CONFIG')).connection().get_connection() return 'Ok' except Exception as e: return 'Failure %s' % e
def setup(self): database_manager = DatabaseManager(TEST_DB_CONFIG) Model.set_connection_resolver(database_manager) migrate_in_memory(database_manager) self.repository = OratorEmployeeRepository()
def test_rollback_migration_can_be_pretended(self): import orator.migrations.migrator as migrator d = flexmock(migrator) resolver_mock = flexmock(DatabaseManager) resolver_mock.should_receive('connection').and_return({}) resolver = flexmock(DatabaseManager({})) connection = flexmock(Connection(None)) connection.should_receive('get_logged_queries').twice().and_return([]) resolver.should_receive('connection').with_args(None).and_return( connection) d.should_receive('dump').with_args(connection).and_return('') migrator = flexmock( Migrator( flexmock(DatabaseMigrationRepository(resolver, 'migrations')), resolver)) foo_migration = flexmock(MigrationStub('foo')) foo_migration.should_receive('get_connection').and_return(connection) bar_migration = flexmock(MigrationStub('bar')) bar_migration.should_receive('get_connection').and_return(connection) migrator.get_repository().should_receive('get_last').once().and_return( [foo_migration, bar_migration]) migrator.should_receive('_resolve').with_args( os.getcwd(), 'bar').once().and_return(bar_migration) migrator.should_receive('_resolve').with_args( os.getcwd(), 'foo').once().and_return(foo_migration) migrator.rollback(os.getcwd(), True) self.assertTrue(foo_migration.downed) self.assertFalse(foo_migration.upped) self.assertTrue(foo_migration.downed) self.assertFalse(foo_migration.upped)
def database(self): if not self.use_database(): raise AttributeError("No database configuration") if not self._database: self._database = DatabaseManager(self.config['databases']) return self._database
async def connect_to_mysql(): logging.info("Connecting to database") db.pool = DatabaseManager(CONFIG) Model.set_connection_resolver(db.pool) logging.info("Connected to database")
def test_connection_management(self): resolver = flexmock(DatabaseManager) resolver.should_receive('connection').once().with_args('foo').and_return('bar') OrmModelStub.set_connection_resolver(DatabaseManager({})) model = OrmModelStub() model.set_connection('foo') self.assertEqual('bar', model.get_connection())
def setup(self): database_manager = DatabaseManager(TEST_DB_CONFIG) Model.set_connection_resolver(database_manager) migrate_in_memory(database_manager) self.repository = OratorReservationRepository() domain_service = ReservationDomainService(self.repository) self.usecase = ChangeTimeRangeUsecase(self.repository, domain_service)
def test_connection_management(self): resolver = flexmock(DatabaseManager) resolver.should_receive("connection").once().with_args("foo").and_return("bar") models.OrmModelStub.set_connection_resolver(DatabaseManager({})) model = models.OrmModelStub() model.set_connection("foo") self.assertEqual("bar", model.get_connection())
def init_orator(settings): import yaml from orator import DatabaseManager from orator import Model dbconfig = get_dbconfig(settings) if Model.get_connection_resolver(): Model.get_connection_resolver().disconnect() Model.set_connection_resolver(DatabaseManager(dbconfig))
def index(): ts = time() st = datetime.datetime.fromtimestamp(ts).strftime('%Y-%m-%d %H:%M:%S') db = DatabaseManager(app.config.get('DB_CONFIG')).connection() res = db.table('greetings').get(['message']).first() return render_template('index.html', message=res.get('message'), time=st, image_to_show=app.config.get('IMAGE_DEST_PATH'))
def setup(self): database_manager = DatabaseManager(TEST_DB_CONFIG) Model.set_connection_resolver(database_manager) migrate_in_memory(database_manager) self.repository = OratorReservationRepository() self.usecase = CancelMeetingRoomUsecase(self.repository)
def get_connection_resolver(cls): # Adding another connection to test connection switching config = cls.get_manager_config() config['test'] = {'driver': 'sqlite', 'database': ':memory:'} db = DatabaseManager(config) db.connection().enable_query_log() return db
def get_connection_resolver(cls): # Adding another connection to test connection switching config = cls.get_manager_config() config['test'] = { 'driver': 'sqlite', 'database': ':memory:' } return DatabaseManager(config)