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)
