def __init__(self, name, config, config_no_sensitive):
self.logger = getLogger(self.__class__.__name__)
self.name = name
self.config = config
self.engine_name = config['engine'] # self.engine.name is 'mysql' while 'self.engine_name' is mysql+pymysql
# Safe for printing out to logs, any sensitive data has been shadowed
self.config_no_sensitive = config_no_sensitive
_extra = {}
# Postgres-only
if self.engine_name.startswith('mysql'):
_extra['pool_recycle'] = 600
elif self.engine_name.startswith('postgres'):
_extra['connect_args'] = {'application_name': get_component_name()}
extra = self.config.get('extra') # Optional, hence .get
_extra.update(parse_extra_into_dict(extra))
engine_url = engine_def.format(**config)
self.engine = create_engine(engine_url, pool_size=int(config['pool_size']), **_extra)
event.listen(self.engine, 'checkin', self.on_checkin)
event.listen(self.engine, 'checkout', self.on_checkout)
event.listen(self.engine, 'connect', self.on_connect)
event.listen(self.engine, 'first_connect', self.on_first_connect)
def __init__(self, name, config, config_no_sensitive):
self.name = name
self.config = config
self.logger = getLogger(self.__class__.__name__)
# Safe for printing out to logs, any sensitive data has been shadowed
self.config_no_sensitive = config_no_sensitive
_extra = {}
extra = self.config.get('extra') # Will be None at times
if extra:
extra = ';'.join(extra.splitlines())
for line in extra.split(';'):
original_line = line
if line:
line = line.split('=')
if not len(line) == 2:
raise ValueError(
'Each line must be a single key=value entry, not [{}]'
.format(original_line))
key, value = line
value = value.strip()
try:
value = is_boolean(value)
except VdtTypeError:
# It's cool, not a boolean
pass
try:
value = is_integer(value)
except VdtTypeError:
# OK, not an integer
pass
_extra[key.strip()] = value
engine_url = engine_def.format(**config)
self.engine = create_engine(engine_url,
pool_size=int(config['pool_size']),
**_extra)
event.listen(self.engine, 'checkin', self.on_checkin)
event.listen(self.engine, 'checkout', self.on_checkout)
event.listen(self.engine, 'connect', self.on_connect)
event.listen(self.engine, 'first_connect', self.on_first_connect)
def __init__(self, name, config, config_no_sensitive):
self.name = name
self.config = config
self.logger = getLogger(self.__class__.__name__)
# Safe for printing out to logs, any sensitive data has been shadowed
self.config_no_sensitive = config_no_sensitive
_extra = {}
extra = self.config.get('extra') # Will be None at times
if extra:
extra = ';'.join(extra.splitlines())
for line in extra.split(';'):
original_line = line
if line:
line = line.split('=')
if not len(line) == 2:
raise ValueError('Each line must be a single key=value entry, not [{}]'.format(original_line))
key, value = line
value = value.strip()
try:
value = is_boolean(value)
except VdtTypeError:
# It's cool, not a boolean
pass
try:
value = is_integer(value)
except VdtTypeError:
# OK, not an integer
pass
_extra[key.strip()] = value
engine_url = engine_def.format(**config)
self.engine = create_engine(engine_url, pool_size=int(config['pool_size']), **_extra)
event.listen(self.engine, 'checkin', self.on_checkin)
event.listen(self.engine, 'checkout', self.on_checkout)
event.listen(self.engine, 'connect', self.on_connect)
event.listen(self.engine, 'first_connect', self.on_first_connect)
def _get_engines(pool_list, crypto_manager, create_sa_engines):
""" A utility function which builds a dinctionary of engines of a particular
type, either plain _EngineInfo objects or the actual SQLAlchemy engines.
"""
engines = {}
for pool_name in pool_list:
try:
password = pool_list[pool_name]["password"]
# It's possible the pool had been defined but no password
# has been set yet.
if password:
password = str(crypto_manager.decrypt(password))
engine_params = copy.deepcopy(pool_list[pool_name])
engine_params["password"] = password
engine_params_no_password = dict(engine_params.items())
engine_params_no_password["password"] = "******"
engine_url = engine_def.format(**engine_params)
if create_sa_engines:
engine = create_engine(engine_url,
pool_size=engine_params["pool_size"], echo=False,
**engine_params["extra"])
else:
create_engine(engine_url, pool_size=engine_params["pool_size"],
**engine_params["extra"])
engine = _EngineInfo(engine_url, engine_params)
engines[pool_name] = engine
logger.debug("SQL connection pool [%s] definition successfully "
"read, params=[%s], create_sa_engines=[%s]" % (
pool_name, engine_params_no_password,
create_sa_engines))
except Exception, e:
logger.error(format_exc())
raise
def __init__(self, name, config, config_no_sensitive):
self.name = name
self.config = config
self.logger = getLogger(self.__class__.__name__)
# Safe for printing out to logs, any sensitive data has been shadowed
self.config_no_sensitive = config_no_sensitive
_extra = {}
_extra['connect_args'] = {'application_name': get_component_name()}
extra = self.config.get('extra') # Optional, hence .get
_extra.update(parse_extra_into_dict(extra))
engine_url = engine_def.format(**config)
self.engine = create_engine(engine_url, pool_size=int(config['pool_size']), **_extra)
event.listen(self.engine, 'checkin', self.on_checkin)
event.listen(self.engine, 'checkout', self.on_checkout)
event.listen(self.engine, 'connect', self.on_connect)
event.listen(self.engine, 'first_connect', self.on_first_connect)
if 'DATABASES' in globals():
db_data = DATABASES['default']
db_data['ENGINE'] = 'django.db.backends.' + django_sqlalchemy_engine[db_type]
for name in('ENGINE', 'NAME', 'USER', 'PASSWORD', 'HOST', 'PORT'):
globals()['DATABASE_{}'.format(name)] = DATABASES['default'][name]
# Crypto
ssl_key_file = os.path.abspath(os.path.join(config_dir, SSL_KEY_FILE))
ssl_cert_file = os.path.abspath(os.path.join(config_dir, SSL_CERT_FILE))
ssl_ca_certs = os.path.abspath(os.path.join(config_dir, SSL_CA_CERTS))
# SQLAlchemy setup
SASession = scoped_session(sessionmaker())
engine = create_engine(engine_def.format(engine=db_type, username=db_data['USER'],
password=db_data['PASSWORD'], host=db_data['HOST'], port=db_data['PORT'],
db_name=db_data['NAME']))
SASession.configure(bind=engine)
TEMPLATE_DEBUG = True
else:
ADMIN_INVOKE_NAME = 'dummy'
ADMIN_INVOKE_PASSWORD = '******'
DATABASES = {}
DATABASES['default'] = {}
DATABASES['default']['ENGINE'] = 'django.db.backends.sqlite3'
ssl_key_file = 'dummy'
ssl_cert_file = 'dummy'
ssl_ca_certs = 'dummy'
for name in ("ENGINE", "NAME", "USER", "PASSWORD", "HOST", "PORT"):
globals()["DATABASE_{}".format(name)] = DATABASES["default"][name]
# Crypto
ssl_key_file = os.path.abspath(os.path.join(config_dir, SSL_KEY_FILE))
ssl_cert_file = os.path.abspath(os.path.join(config_dir, SSL_CERT_FILE))
ssl_ca_certs = os.path.abspath(os.path.join(config_dir, SSL_CA_CERTS))
# SQLAlchemy setup
SASession = scoped_session(sessionmaker())
engine = create_engine(
engine_def.format(
engine=db_type,
username=db_data["USER"],
password=db_data["PASSWORD"],
host=db_data["HOST"],
db_name=db_data["NAME"],
)
)
SASession.configure(bind=engine)
TEMPLATE_DEBUG = True
else:
TECH_ACCOUNT_NAME = "dummy"
TECH_ACCOUNT_PASSWORD = "******"
DATABASES = {}
DATABASES["default"] = {}
DATABASES["default"]["ENGINE"] = "django.db.backends.sqlite3"
ssl_key_file = "dummy"
"django.contrib.messages",
"debug_toolbar",
"zato.admin.web",
)
# A list of prefixes pointing to resources (such as CSS or JS) which may be
# accessed by anonymous users
DONT_REQUIRE_LOGIN = ["/static/", "/favicon.ico"]
# Some values below, e.g. db_type, DATABASE_USER and others are magically injected
# here by the 'zato start /path/to/zato/admin' command. The command in turn
# fetches values from the 'zato-admin.conf' file.
DATABASES["default"]["ENGINE"] = "django.db.backends." + django_sqlalchemy_engine[db_type]
# SQLAlchemy setup
SASession = scoped_session(sessionmaker())
engine = create_engine(
engine_def.format(
engine=db_type, user=DATABASE_USER, password=DATABASE_PASSWORD, host=DATABASE_HOST, db_name=DATABASE_NAME
)
)
SASession.configure(bind=engine)
# Crypto
ssl_key_file = os.path.join(config_dir, SSL_KEY_FILE)
ssl_cert_file = os.path.join(config_dir, SSL_CERT_FILE)
ssl_ca_certs = os.path.join(config_dir, SSL_CA_CERTS)
TEMPLATE_DEBUG = True
def _get_engine(self, args):
engine_url = engine_def.format(engine=args.odb_type, user=args.odb_user,
password=args.odb_password, host=args.odb_host, db_name=args.odb_dbname)
return create_engine(engine_url)
if 'DATABASES' in globals():
db_data = DATABASES['default']
db_data['ENGINE'] = 'django.db.backends.' + django_sqlalchemy_engine[db_type]
for name in('ENGINE', 'NAME', 'USER', 'PASSWORD', 'HOST', 'PORT'):
globals()['DATABASE_{}'.format(name)] = DATABASES['default'][name]
# Crypto
ssl_key_file = os.path.abspath(os.path.join(config_dir, SSL_KEY_FILE))
ssl_cert_file = os.path.abspath(os.path.join(config_dir, SSL_CERT_FILE))
ssl_ca_certs = os.path.abspath(os.path.join(config_dir, SSL_CA_CERTS))
# SQLAlchemy setup
SASession = scoped_session(sessionmaker())
engine = create_engine(engine_def.format(engine=db_type, username=db_data['USER'],
password=db_data['PASSWORD'], host=db_data['HOST'], db_name=db_data['NAME']))
SASession.configure(bind=engine)
TEMPLATE_DEBUG = True
else:
ADMIN_INVOKE_NAME = 'dummy'
ADMIN_INVOKE_PASSWORD = '******'
DATABASES = {}
DATABASES['default'] = {}
DATABASES['default']['ENGINE'] = 'django.db.backends.sqlite3'
ssl_key_file = 'dummy'
ssl_cert_file = 'dummy'
ssl_ca_certs = 'dummy'
os.environ['DJANGO_SETTINGS_MODULE'] = 'zato.admin.settings'
