def __init__(self, cfg_manager):
super(AuthDatabaseGateway, self).__init__(cfg_manager)
user = cfg_manager.get_doc_value(configuration_doc.WEBLAB_DB_USERNAME)
password = cfg_manager.get_doc_value(
configuration_doc.WEBLAB_DB_PASSWORD)
host = self.host
dbname = self.database_name
engine = self.engine_name
if AuthDatabaseGateway.engine is None or cfg_manager.get_doc_value(
configuration_doc.WEBLAB_DB_FORCE_ENGINE_CREATION):
getconn = generate_getconn(engine, user, password, host, dbname)
if engine == 'sqlite':
connection_url = 'sqlite:///%s' % get_sqlite_dbname(dbname)
pool = sqlalchemy.pool.NullPool(getconn)
else:
connection_url = "%(ENGINE)s://%(USER)s:%(PASSWORD)s@%(HOST)s/%(DATABASE)s" % \
{ "ENGINE": engine,
"USER": user, "PASSWORD": password,
"HOST": host, "DATABASE": dbname }
pool = sqlalchemy.pool.QueuePool(getconn,
pool_size=15,
max_overflow=20,
recycle=3600)
AuthDatabaseGateway.engine = create_engine(connection_url,
echo=False,
convert_unicode=True,
pool=pool)
self.Session = sessionmaker(bind=self.engine)
def __init__(self, cfg_manager):
super(DatabaseGateway, self).__init__(cfg_manager)
user = cfg_manager.get_doc_value(configuration_doc.WEBLAB_DB_USERNAME)
password = cfg_manager.get_doc_value(configuration_doc.WEBLAB_DB_PASSWORD)
host = self.host
dbname = self.database_name
engine = self.engine_name
if DatabaseGateway.engine is None or cfg_manager.get_doc_value(configuration_doc.WEBLAB_DB_FORCE_ENGINE_CREATION):
getconn = generate_getconn(engine, user, password, host, dbname)
if engine == 'sqlite':
connection_url = 'sqlite:///%s' % get_sqlite_dbname(dbname)
pool = sqlalchemy.pool.NullPool(getconn)
else:
connection_url = "%(ENGINE)s://%(USER)s:%(PASSWORD)s@%(HOST)s/%(DATABASE)s" % \
{ "ENGINE": engine,
"USER": user, "PASSWORD": password,
"HOST": host, "DATABASE": dbname }
pool = sqlalchemy.pool.QueuePool(getconn, pool_size=15, max_overflow=20, recycle=3600)
DatabaseGateway.engine = create_engine(connection_url, echo=False, convert_unicode=True, pool = pool)
self.Session = sessionmaker(bind=self.engine)
def __init__(self, cfg_manager):
engine = cfg_manager.get_value(COORDINATOR_DB_ENGINE, DEFAULT_COORDINATOR_DB_ENGINE)
username = CoordinationDatabaseManager.username = cfg_manager.get_value(COORDINATOR_DB_USERNAME) # REQUIRED!
password = CoordinationDatabaseManager.password = cfg_manager.get_value(COORDINATOR_DB_PASSWORD) # REQUIRED!
host = CoordinationDatabaseManager.host = cfg_manager.get_value(COORDINATOR_DB_HOST, DEFAULT_COORDINATOR_DB_HOST)
dbname = CoordinationDatabaseManager.dbname = cfg_manager.get_value(COORDINATOR_DB_NAME, DEFAULT_COORDINATOR_DB_NAME)
if CoordinationDatabaseManager.engine is None or cfg_manager.get_doc_value(WEBLAB_DB_FORCE_ENGINE_CREATION):
getconn = generate_getconn(engine, username, password, host, dbname)
connect_args = {}
if engine == 'sqlite':
sqlalchemy_engine_str = 'sqlite:///%s' % get_sqlite_dbname(dbname)
if dbname == ':memory:':
connect_args['check_same_thread'] = False
pool = sqlalchemy.pool.StaticPool(getconn)
else:
pool = sqlalchemy.pool.NullPool(getconn)
else:
sqlalchemy_engine_str = "%s://%s:%s@%s/%s" % (engine, username, password, host, dbname)
pool = sqlalchemy.pool.QueuePool(getconn, pool_size=15, max_overflow=20, recycle=3600)
CoordinationDatabaseManager.engine = sqlalchemy.create_engine(sqlalchemy_engine_str, convert_unicode=True, echo=False, connect_args = connect_args, pool = pool)
if engine == 'sqlite' and dbname == ':memory:':
coord_model.load()
metadata = coord_model.Base.metadata
metadata.drop_all(self.engine)
metadata.create_all(self.engine)
self.session_maker = sessionmaker(bind=self.engine, autoflush = True, autocommit = False)
def __init__(self, cfg_manager, session_pool_id):
super(DbLock, self).__init__()
self.cfg_manager = cfg_manager
self.pool_id = session_pool_id
(engine_name, host, dbname, username, password) = self._parse_config()
DbLock.username = username
DbLock.password = password
DbLock.host = host
DbLock.dbname = dbname
if DbLock.engine is None:
getconn = generate_getconn(engine_name, username, password, host,
dbname)
if engine_name == 'sqlite':
sqlalchemy_engine_str = 'sqlite:///%s' % get_sqlite_dbname(
dbname)
pool = sqlalchemy.pool.NullPool(getconn)
else:
sqlalchemy_engine_str = "%s://%s:%s@%s/%s" % (
engine_name, username, password, host, dbname)
pool = sqlalchemy.pool.QueuePool(getconn,
pool_size=15,
max_overflow=20,
recycle=3600)
DbLock.engine = sqlalchemy.create_engine(sqlalchemy_engine_str,
convert_unicode=True,
echo=False,
pool=pool)
self._session_maker = sessionmaker(bind=self.engine,
autoflush=True,
autocommit=False)
def __init__(self, cfg_manager, session_pool_id):
super(DbLock, self).__init__()
self.cfg_manager = cfg_manager
self.pool_id = session_pool_id
(
engine_name,
host,
dbname,
username,
password
) = self._parse_config()
DbLock.username = username
DbLock.password = password
DbLock.host = host
DbLock.dbname = dbname
if DbLock.engine is None:
getconn = generate_getconn(engine_name, username, password, host, dbname)
if engine_name == 'sqlite':
sqlalchemy_engine_str = 'sqlite:///%s' % get_sqlite_dbname(dbname)
pool = sqlalchemy.pool.NullPool(getconn)
else:
sqlalchemy_engine_str = "%s://%s:%s@%s/%s" % (engine_name, username, password, host, dbname)
pool = sqlalchemy.pool.QueuePool(getconn, pool_size=15, max_overflow=20, recycle=3600)
DbLock.engine = sqlalchemy.create_engine(sqlalchemy_engine_str, convert_unicode=True, echo=False, pool = pool)
self._session_maker = sessionmaker(bind=self.engine, autoflush = True, autocommit = False)
def __init__(self, engine, host, dbname, user, password):
super(DbGateway, self).__init__()
getconn = generate_getconn(engine, user, password, host, dbname)
if engine == 'sqlite':
connection_url = 'sqlite:///%s' % get_sqlite_dbname(dbname)
pool = sqlalchemy.pool.NullPool(getconn)
else:
connection_url = "%(ENGINE)s://%(USER)s:%(PASSWORD)s@%(HOST)s/%(DATABASE)s" % \
{ "ENGINE": engine,
"USER": user, "PASSWORD": password,
"HOST": host, "DATABASE": dbname }
pool = sqlalchemy.pool.QueuePool(getconn,
pool_size=15,
max_overflow=20,
recycle=3600)
engine = create_engine(connection_url,
echo=False,
convert_unicode=True,
pool=pool)
self.Session = sessionmaker(bind=engine)
self.session = self.Session()
def __init__(self, cfg_manager):
engine = cfg_manager.get_doc_value(
configuration_doc.COORDINATOR_DB_ENGINE)
username = CoordinationDatabaseManager.username = cfg_manager.get_doc_value(
configuration_doc.COORDINATOR_DB_USERNAME)
password = CoordinationDatabaseManager.password = cfg_manager.get_doc_value(
configuration_doc.COORDINATOR_DB_PASSWORD)
host = CoordinationDatabaseManager.host = cfg_manager.get_doc_value(
configuration_doc.COORDINATOR_DB_HOST)
port = CoordinationDatabaseManager.port = cfg_manager.get_doc_value(
configuration_doc.COORDINATOR_DB_PORT)
dbname = CoordinationDatabaseManager.dbname = cfg_manager.get_doc_value(
configuration_doc.COORDINATOR_DB_NAME)
if CoordinationDatabaseManager.engine is None or cfg_manager.get_doc_value(
configuration_doc.DB_FORCE_ENGINE_CREATION):
getconn = generate_getconn(engine, username, password, host, port,
dbname)
connect_args = {}
if engine == 'sqlite':
sqlalchemy_engine_str = 'sqlite:///%s' % get_sqlite_dbname(
dbname)
if dbname == ':memory:':
connect_args['check_same_thread'] = False
pool = sqlalchemy.pool.StaticPool(getconn)
else:
pool = sqlalchemy.pool.NullPool(getconn)
else:
if port is None:
port_str = ''
else:
port_str = ':%s' % port
sqlalchemy_engine_str = "%s://%s:%s@%s%s/%s" % (
engine, username, password, host, port_str, dbname)
pool = sqlalchemy.pool.QueuePool(getconn,
pool_size=15,
max_overflow=20,
recycle=3600)
CoordinationDatabaseManager.engine = sqlalchemy.create_engine(
sqlalchemy_engine_str,
convert_unicode=True,
echo=False,
connect_args=connect_args,
pool=pool)
if engine == 'sqlite' and dbname == ':memory:':
coord_model.load()
metadata = coord_model.Base.metadata
metadata.drop_all(self.engine)
metadata.create_all(self.engine)
self.session_maker = sessionmaker(bind=self.engine,
autoflush=True,
autocommit=False)
def __init__(self, cfg_manager, session_pool_id, timeout):
super(SessionSqlalchemyGateway, self).__init__()
self.session_pool_id = session_pool_id
self.timeout = timeout
self.cfg_manager = cfg_manager
(engine_name, host, port, dbname, username,
password) = self._parse_config()
SessionSqlalchemyGateway.username = username
SessionSqlalchemyGateway.password = password
SessionSqlalchemyGateway.host = host
SessionSqlalchemyGateway.port = port
SessionSqlalchemyGateway.dbname = dbname
self._generator = SessionGenerator.SessionGenerator()
self._serializer = SessionSerializer.SessionSerializer()
self._lock = DbLock.DbLock(cfg_manager, session_pool_id)
if SessionSqlalchemyGateway.engine is None:
getconn = generate_getconn(engine_name, username, password, host,
port, dbname)
if engine_name == 'sqlite':
sqlalchemy_engine_str = 'sqlite:///%s' % get_sqlite_dbname(
dbname)
pool = sqlalchemy.pool.NullPool(getconn)
else:
if port is None:
port_str = ''
else:
port_str = ':%s' % port
sqlalchemy_engine_str = "%s://%s:%s@%s%s/%s" % (
engine_name, username, password, host, port_str, dbname)
pool = sqlalchemy.pool.QueuePool(getconn,
pool_size=15,
max_overflow=20,
recycle=3600)
SessionSqlalchemyGateway.engine = sqlalchemy.create_engine(
sqlalchemy_engine_str,
convert_unicode=True,
echo=False,
pool=pool)
self._session_maker = sessionmaker(bind=self.engine,
autoflush=True,
autocommit=False)
def initialize(self, cfg_manager):
try:
host = cfg_manager.get_doc_value(configuration_doc.DB_HOST)
port = cfg_manager.get_doc_value(configuration_doc.DB_PORT)
dbname = cfg_manager.get_doc_value(configuration_doc.DB_DATABASE)
engine = cfg_manager.get_doc_value(configuration_doc.DB_ENGINE)
pool_size = cfg_manager.get_doc_value(
configuration_doc.DB_POOL_SIZE)
max_overflow = cfg_manager.get_doc_value(
configuration_doc.DB_MAX_OVERFLOW)
user = cfg_manager.get_doc_value(configuration_doc.DB_USERNAME)
password = cfg_manager.get_doc_value(configuration_doc.DB_PASSWORD)
except CfgErrors.KeyNotFoundError as knfe:
raise DbMisconfiguredError(
"Configuration manager didn't provide values for at least one parameter: %s"
% knfe, knfe)
if self.engine is None or cfg_manager.get_doc_value(
configuration_doc.DB_FORCE_ENGINE_CREATION):
getconn = generate_getconn(engine, user, password, host, port,
dbname)
if engine == 'sqlite':
connection_url = 'sqlite:///%s' % get_sqlite_dbname(dbname)
pool = sqlalchemy.pool.NullPool(getconn)
else:
if port is None:
port_str = ''
else:
port_str = ':%s' % port
connection_url = "%(ENGINE)s://%(USER)s:%(PASSWORD)s@%(HOST)s%(PORT)s/%(DATABASE)s" % \
{ "ENGINE": engine, 'PORT' : port_str,
"USER": user, "PASSWORD": password,
"HOST": host, "DATABASE": dbname }
pool = sqlalchemy.pool.QueuePool(getconn,
pool_size=pool_size,
max_overflow=max_overflow,
recycle=3600)
self.engine = create_engine(connection_url,
echo=False,
convert_unicode=True,
pool=pool)
self.Session = sessionmaker(bind=self.engine)
return self.Session, self.engine
def __init__(self, cfg_manager, session_pool_id, timeout):
super(SessionSqlalchemyGateway, self).__init__()
self.session_pool_id = session_pool_id
self.timeout = timeout
self.cfg_manager = cfg_manager
(
engine_name,
host,
port,
dbname,
username,
password
) = self._parse_config()
SessionSqlalchemyGateway.username = username
SessionSqlalchemyGateway.password = password
SessionSqlalchemyGateway.host = host
SessionSqlalchemyGateway.port = port
SessionSqlalchemyGateway.dbname = dbname
self._generator = SessionGenerator.SessionGenerator()
self._serializer = SessionSerializer.SessionSerializer()
self._lock = DbLock.DbLock(cfg_manager, session_pool_id)
if SessionSqlalchemyGateway.engine is None:
getconn = generate_getconn(engine_name, username, password, host, port, dbname)
if engine_name == 'sqlite':
sqlalchemy_engine_str = 'sqlite:///%s' % get_sqlite_dbname(dbname)
pool = sqlalchemy.pool.NullPool(getconn)
else:
if port is None:
port_str = ''
else:
port_str = ':%s' % port
sqlalchemy_engine_str = "%s://%s:%s@%s%s/%s" % (engine_name, username, password, host, port_str, dbname)
pool = sqlalchemy.pool.QueuePool(getconn, pool_size=15, max_overflow=20, recycle=3600)
SessionSqlalchemyGateway.engine = sqlalchemy.create_engine(sqlalchemy_engine_str, convert_unicode=True, echo=False, pool = pool)
self._session_maker = sessionmaker(bind=self.engine, autoflush = True, autocommit = False)
def __init__(self, engine, host, dbname, user, password):
super(DbGateway, self).__init__()
getconn = generate_getconn(engine, user, password, host, dbname)
if engine == 'sqlite':
connection_url = 'sqlite:///%s' % get_sqlite_dbname(dbname)
pool = sqlalchemy.pool.NullPool(getconn)
else:
connection_url = "%(ENGINE)s://%(USER)s:%(PASSWORD)s@%(HOST)s/%(DATABASE)s" % \
{ "ENGINE": engine,
"USER": user, "PASSWORD": password,
"HOST": host, "DATABASE": dbname }
pool = sqlalchemy.pool.QueuePool(getconn, pool_size=15, max_overflow=20, recycle=3600)
engine = create_engine(connection_url, echo=False, convert_unicode=True, pool = pool)
self.Session = sessionmaker(bind=engine)
self.session = self.Session()
def initialize(self, cfg_manager):
try:
host = cfg_manager.get_doc_value(configuration_doc.DB_HOST)
port = cfg_manager.get_doc_value(configuration_doc.DB_PORT)
dbname = cfg_manager.get_doc_value(configuration_doc.DB_DATABASE)
engine = cfg_manager.get_doc_value(configuration_doc.DB_ENGINE)
pool_size = cfg_manager.get_doc_value(configuration_doc.DB_POOL_SIZE)
max_overflow = cfg_manager.get_doc_value(configuration_doc.DB_MAX_OVERFLOW)
user = cfg_manager.get_doc_value(configuration_doc.DB_USERNAME)
password = cfg_manager.get_doc_value(configuration_doc.DB_PASSWORD)
except CfgErrors.KeyNotFoundError as knfe:
raise DbMisconfiguredError(
"Configuration manager didn't provide values for at least one parameter: %s" % knfe, knfe
)
if self.engine is None or cfg_manager.get_doc_value(configuration_doc.DB_FORCE_ENGINE_CREATION):
getconn = generate_getconn(engine, user, password, host, port, dbname)
if engine == "sqlite":
connection_url = "sqlite:///%s" % get_sqlite_dbname(dbname)
pool = sqlalchemy.pool.NullPool(getconn)
else:
if port is None:
port_str = ""
else:
port_str = ":%s" % port
connection_url = "%(ENGINE)s://%(USER)s:%(PASSWORD)s@%(HOST)s%(PORT)s/%(DATABASE)s" % {
"ENGINE": engine,
"PORT": port_str,
"USER": user,
"PASSWORD": password,
"HOST": host,
"DATABASE": dbname,
}
pool = sqlalchemy.pool.QueuePool(getconn, pool_size=pool_size, max_overflow=max_overflow, recycle=3600)
self.engine = create_engine(connection_url, echo=False, convert_unicode=True, pool=pool)
self.Session = sessionmaker(bind=self.engine)
return self.Session, self.engine
def __init__(self, cfg_manager):
self.cfg_manager = cfg_manager
try:
host = cfg_manager.get_doc_value(configuration_doc.DB_HOST)
port = cfg_manager.get_doc_value(configuration_doc.DB_PORT)
dbname = cfg_manager.get_doc_value(configuration_doc.DB_DATABASE)
engine = cfg_manager.get_doc_value(configuration_doc.DB_ENGINE)
user = cfg_manager.get_doc_value(configuration_doc.WEBLAB_DB_USERNAME)
password = cfg_manager.get_doc_value(configuration_doc.WEBLAB_DB_PASSWORD)
except CfgErrors.KeyNotFoundError as knfe:
raise DbErrors.DbMisconfiguredError(
"Configuration manager didn't provide values for at least one parameter: %s" % knfe,
knfe
)
if AbstractDatabaseGateway.engine is None or cfg_manager.get_doc_value(configuration_doc.WEBLAB_DB_FORCE_ENGINE_CREATION):
getconn = generate_getconn(engine, user, password, host, port, dbname)
if engine == 'sqlite':
connection_url = 'sqlite:///%s' % get_sqlite_dbname(dbname)
pool = sqlalchemy.pool.NullPool(getconn)
else:
if port is None:
port_str = ''
else:
port_str = ':%s' % port
connection_url = "%(ENGINE)s://%(USER)s:%(PASSWORD)s@%(HOST)s%(PORT)s/%(DATABASE)s" % \
{ "ENGINE": engine, 'PORT' : port_str,
"USER": user, "PASSWORD": password,
"HOST": host, "DATABASE": dbname }
pool = sqlalchemy.pool.QueuePool(getconn, pool_size=15, max_overflow=20, recycle=3600)
AbstractDatabaseGateway.engine = create_engine(connection_url, echo=False, convert_unicode=True, pool = pool)
self.Session = sessionmaker(bind=self.engine)
