def run_migrations_online():
set_mysql_engine()
try:
extra_args = {}
if hasattr(neutron_config.database, 'mysql_enable_ndb'):
extra_args = {
mysql_enable_ndb: neutron_config.database.mysql_enable_ndb
}
engine = session.create_engine(
sql_connection=neutron_config.database.connection, **extra_args)
except NameError:
# This permits this plugin to work with older Neutron versions
# that don't support the extended 'create_engine' call syntax
engine = session.create_engine(neutron_config.database.connection)
with engine.connect() as connection:
context.configure(connection=connection,
target_metadata=target_metadata,
include_object=include_object,
version_table=VPP_VERSION_TABLE)
try:
with context.begin_transaction():
context.run_migrations()
finally:
connection.close()
engine.dispose()
def run_migrations_online():
set_mysql_engine()
try:
extra_args = {}
if hasattr(neutron_config.database, 'mysql_enable_ndb'):
extra_args = {
mysql_enable_ndb: neutron_config.database.mysql_enable_ndb}
engine = session.create_engine(
sql_connection=neutron_config.database.connection,
**extra_args)
except NameError:
# This permits this plugin to work with older Neutron versions
# that don't support the extended 'create_engine' call syntax
engine = session.create_engine(neutron_config.database.connection)
with engine.connect() as connection:
context.configure(
connection=connection,
target_metadata=target_metadata,
include_object=include_object,
version_table=VPP_VERSION_TABLE
)
try:
with context.begin_transaction():
context.run_migrations()
finally:
connection.close()
engine.dispose()
def main(argv):
"""Main function.
:param argv: Argument list
:type argv: List[str]
:returns: POSIX exit code
:rtype: int
"""
program = os.path.basename(argv[0])
if len(argv) < 2:
usage(program)
return os.EX_USAGE
elif len(argv) < 3 or argv[2] != 'morph':
print('DRY-RUN, WILL NOT COMMIT TRANSACTION')
db_engine = session.create_engine(argv[1])
db_maker = session.get_maker(db_engine, autocommit=False)
db_session = db_maker(bind=db_engine)
to_network_type = 'geneve'
for network_type in ('gre', 'vxlan'):
n_morphed = morph_networks(db_session, network_type, to_network_type)
print('Morphed {} networks of type {} to {}.'.format(
n_morphed, network_type, to_network_type))
if len(argv) < 3 or argv[2] != 'morph':
print('DRY-RUN, WILL NOT COMMIT TRANSACTION')
return os.EX_USAGE
db_session.commit()
db_session.close()
db_engine.dispose()
return os.EX_OK
def run_migrations_online():
"""Run migrations in 'online' mode.
In this scenario we need to create an Engine
and associate a connection with the context.
"""
set_mysql_engine()
connection = config.attributes.get('connection')
new_engine = connection is None
if new_engine:
engine = session.create_engine(neutron_config.database.connection)
connection = engine.connect()
context.configure(
connection=connection,
target_metadata=target_metadata,
include_object=include_object,
process_revision_directives=autogen.process_revision_directives
)
try:
with context.begin_transaction():
context.run_migrations()
finally:
if new_engine:
connection.close()
engine.dispose()
def provisioned_engine(self, base_url, ident):
"""Return a provisioned engine.
Given the URL of a particular database backend and the string
name of a particular 'database' within that backend, return
an Engine instance whose connections will refer directly to the
named database.
For hostname-based URLs, this typically involves switching just the
'database' portion of the URL with the given name and creating
an engine.
For URLs that instead deal with DSNs, the rules may be more custom;
for example, the engine may need to connect to the root URL and
then emit a command to switch to the named database.
"""
url = sa_url.make_url(str(base_url))
url.database = ident
return session.create_engine(
url,
logging_name="%s@%s" % (self.drivername, ident),
**self.default_engine_kwargs
)
def provisioned_engine(self, base_url, ident):
"""Return a provisioned engine.
Given the URL of a particular database backend and the string
name of a particular 'database' within that backend, return
an Engine instance whose connections will refer directly to the
named database.
For hostname-based URLs, this typically involves switching just the
'database' portion of the URL with the given name and creating
an engine.
For URLs that instead deal with DSNs, the rules may be more custom;
for example, the engine may need to connect to the root URL and
then emit a command to switch to the named database.
"""
url = sa_url.make_url(str(base_url))
url.database = ident
return session.create_engine(
url,
logging_name="%s@%s" % (self.drivername, ident),
**self.default_engine_kwargs
)
def run_migrations_online():
"""Run migrations in 'online' mode.
In this scenario we need to create an Engine
and associate a connection with the context.
"""
set_mysql_engine()
connection = config.attributes.get('connection')
new_engine = connection is None
if new_engine:
engine = session.create_engine(neutron_config.database.connection)
connection = engine.connect()
context.configure(
connection=connection,
target_metadata=target_metadata,
include_object=include_object,
process_revision_directives=autogen.process_revision_directives)
try:
with context.begin_transaction():
context.run_migrations()
finally:
if new_engine:
connection.close()
engine.dispose()
def __call__(self,
connection_url,
save_tables=False,
tunnel_type=None,
vxlan_udp_port=None):
engine = session.create_engine(connection_url)
metadata = sa.MetaData()
check_db_schema_version(engine, metadata)
if hasattr(self, 'define_ml2_tables'):
self.define_ml2_tables(metadata)
# Autoload the ports table to ensure that foreign keys to it and
# the network table can be created for the new tables.
sa.Table('ports', metadata, autoload=True, autoload_with=engine)
metadata.create_all(engine)
self.migrate_network_segments(engine, metadata)
if tunnel_type:
self.migrate_tunnels(engine, tunnel_type, vxlan_udp_port)
self.migrate_vlan_allocations(engine)
self.migrate_port_bindings(engine, metadata)
if hasattr(self, 'drop_old_tables'):
self.drop_old_tables(engine, save_tables)
def __enter__(self):
self.new_engine = self.connection is None
if self.new_engine:
self.engine = session.create_engine(
sql_connection=self.sql_connection,
mysql_enable_ndb=self.mysql_enable_ndb)
self.connection = self.engine.connect()
return self.connection
def __init__(self, db_connection, library_path, login, slot_id):
self.dry_run = False
self.db_engine = session.create_engine(db_connection)
self._session_creator = scoping.scoped_session(
orm.sessionmaker(bind=self.db_engine, autocommit=True))
self.crypto_plugin = p11_crypto.P11CryptoPlugin(CONF)
self.plugin_name = utils.generate_fullname_for(self.crypto_plugin)
self.pkcs11 = self.crypto_plugin.pkcs11
self.session = self.pkcs11.get_session()
def setUp(self):
super(DBManageTestCase, self).setUp()
self.sbehaviors = secret_behaviors.SecretBehaviors(self.client)
self.cbehaviors = container_behaviors.ContainerBehaviors(self.client)
db_url = BCONF.sql_connection
time.sleep(5)
# Setup session for tests to query DB
engine = session.create_engine(db_url)
self.conn = engine.connect()
def setUp(self):
super(DBManageTestCase, self).setUp()
self.sbehaviors = secret_behaviors.SecretBehaviors(self.client)
self.cbehaviors = container_behaviors.ContainerBehaviors(self.client)
db_url = BCONF.sql_connection
time.sleep(5)
# Setup session for tests to query DB
engine = session.create_engine(db_url)
self.conn = engine.connect()
def test_mysql_opportunistically(self):
connect_string = oslo_utils.get_connect_string(self.BACKEND,
"openstack_citest", user="******",
passwd="openstack_citest")
engine = session.create_engine(connect_string)
config = self._get_alembic_config(connect_string)
self.engines["mysqlcitest"] = engine
self.test_databases["mysqlcitest"] = connect_string
# build a fully populated mysql database with all the tables
self._reset_databases()
self._walk_versions(config, engine, False, False)
def test_mysql_opportunistically(self):
connect_string = oslo_utils.get_connect_string(self.BACKEND,
"openstack_citest", user="******",
passwd="openstack_citest")
engine = session.create_engine(connect_string)
config = self._get_alembic_config(connect_string)
self.engines["mysqlcitest"] = engine
self.test_databases["mysqlcitest"] = connect_string
# build a fully populated mysql database with all the tables
self._reset_databases()
self._walk_versions(config, engine, False, False)
def run_migrations_online():
set_mysql_engine()
engine = session.create_engine(neutron_config.database.connection)
connection = engine.connect()
context.configure(connection=connection, target_metadata=target_metadata, version_table=FWAAS_VERSION_TABLE)
try:
with context.begin_transaction():
context.run_migrations()
finally:
connection.close()
engine.dispose()
def __init__(self, db_connection, library_path, login, slot_id):
self.dry_run = False
self.db_engine = session.create_engine(db_connection)
self._session_creator = scoping.scoped_session(
orm.sessionmaker(
bind=self.db_engine,
autocommit=True
)
)
self.crypto_plugin = p11_crypto.P11CryptoPlugin(CONF)
self.plugin_name = utils.generate_fullname_for(self.crypto_plugin)
self.pkcs11 = self.crypto_plugin.pkcs11
self.session = self.pkcs11.get_session()
def __init__(self, conf):
self.dry_run = False
self.db_engine = session.create_engine(conf.sql_connection)
self._session_creator = scoping.scoped_session(
orm.sessionmaker(bind=self.db_engine, autocommit=True))
self.crypto_plugin = p11_crypto.P11CryptoPlugin(conf)
self.pkcs11 = self.crypto_plugin.pkcs11
self.plugin_name = utils.generate_fullname_for(self.crypto_plugin)
self.hsm_session = self.pkcs11.get_session()
self.new_mkek_label = self.crypto_plugin.mkek_label
self.new_hmac_label = self.crypto_plugin.hmac_label
self.new_mkek = self.crypto_plugin._get_master_key(self.new_mkek_label)
self.new_mkhk = self.crypto_plugin._get_master_key(self.new_hmac_label)
def run_migrations_online():
set_mysql_engine()
engine = session.create_engine(neutron_config.database.connection)
connection = engine.connect()
context.configure(connection=connection,
target_metadata=target_metadata,
version_table=FWAAS_VERSION_TABLE)
try:
with context.begin_transaction():
context.run_migrations()
finally:
connection.close()
engine.dispose()
def test_postgresql_opportunistically(self):
# add this to the global lists to make reset work with it, it's removed
# automatically in tearDown so no need to clean it up here.
connect_string = oslo_utils.get_connect_string(self.BACKEND,
"openstack_citest",
"openstack_citest",
"openstack_citest")
engine = session.create_engine(connect_string)
config = self._get_alembic_config(connect_string)
self.engines["postgresqlcitest"] = engine
self.test_databases["postgresqlcitest"] = connect_string
# build a fully populated postgresql database with all the tables
self._reset_databases()
self._walk_versions(config, engine, False, False)
def run_migrations_online():
"""Run migrations in 'online' mode.
In this scenario we need to create an Engine
and associate a connection with the context.
"""
engine = session.create_engine(get_sqlalchemy_url())
connection = engine.connect()
context.configure(connection=connection, target_metadata=target_metadata)
try:
with context.begin_transaction():
context.run_migrations()
finally:
connection.close()
def test_postgresql_opportunistically(self):
# add this to the global lists to make reset work with it, it's removed
# automatically in tearDown so no need to clean it up here.
connect_string = oslo_utils.get_connect_string(self.BACKEND,
"openstack_citest",
"openstack_citest",
"openstack_citest")
engine = session.create_engine(connect_string)
config = self._get_alembic_config(connect_string)
self.engines["postgresqlcitest"] = engine
self.test_databases["postgresqlcitest"] = connect_string
# build a fully populated postgresql database with all the tables
self._reset_databases()
self._walk_versions(config, engine, False, False)
def setUp(self):
super(MySQLModeTestCase, self).setUp()
self.engine = session.create_engine(self.engine.url,
mysql_sql_mode=self.mysql_mode)
self.connection = self.engine.connect()
meta = MetaData()
meta.bind = self.engine
self.test_table = Table(_TABLE_NAME + "mode", meta,
Column('id', Integer, primary_key=True),
Column('bar', String(255)))
self.test_table.create()
self.addCleanup(self.test_table.drop)
self.addCleanup(self.connection.close)
def setUp(self):
super(MySQLModeTestCase, self).setUp()
mode_engine = session.create_engine(
self.engine.url,
mysql_sql_mode=self.mysql_mode)
self.connection = mode_engine.connect()
meta = MetaData()
self.test_table = Table(_TABLE_NAME + "mode", meta,
Column('id', Integer, primary_key=True),
Column('bar', String(255)))
self.test_table.create(self.connection)
def cleanup():
self.test_table.drop(self.connection)
self.connection.close()
mode_engine.dispose()
self.addCleanup(cleanup)
def run_migrations_online():
"""Run migrations in 'online' mode.
In this scenario we need to create an Engine
and associate a connection with the context.
"""
url = CONF.pdns_database.connection
engine = session.create_engine(url)
connection = engine.connect()
context.configure(
connection=connection,
target_metadata=target_metadata
)
with context.begin_transaction():
context.run_migrations()
def run_migrations_online():
"""Run migrations in 'online' mode.
In this scenario we need to create an Engine
and associate a connection with the context.
"""
engine = session.create_engine(neutron_config.database.connection)
connection = engine.connect()
context.configure(connection=connection,
target_metadata=None,
version_table=VERSION_TABLE)
try:
with context.begin_transaction():
context.run_migrations()
finally:
connection.close()
engine.dispose()
def _is_backend_avail(backend,
user="******",
passwd="openstack_citest",
database="openstack_citest"):
# is_backend_avail will be soon deprecated from oslo_db
# thats why its added here
try:
connect_uri = oslo_utils.get_connect_string(backend, user=user,
passwd=passwd,
database=database)
engine = session.create_engine(connect_uri)
connection = engine.connect()
except Exception:
# intentionally catch all to handle exceptions even if we don't
# have any backend code loaded.
return False
else:
connection.close()
engine.dispose()
return True
def _is_backend_avail(backend,
user="******",
passwd="openstack_citest",
database="openstack_citest"):
# is_backend_avail will be soon deprecated from oslo_db
# thats why its added here
try:
connect_uri = oslo_utils.get_connect_string(backend, user=user,
passwd=passwd,
database=database)
engine = session.create_engine(connect_uri)
connection = engine.connect()
except Exception:
# intentionally catch all to handle exceptions even if we don't
# have any backend code loaded.
return False
else:
connection.close()
engine.dispose()
return True
def run_migrations_online():
"""Run migrations in 'online' mode.
In this scenario we need to create an Engine
and associate a connection with the context.
"""
set_mysql_engine()
engine = session.create_engine(neutron_config.database.connection)
connection = engine.connect()
context.configure(connection=connection,
target_metadata=target_metadata,
include_object=include_object)
try:
with context.begin_transaction():
context.run_migrations()
finally:
connection.close()
engine.dispose()
def run_migrations_online():
"""Run migrations in 'online' mode.
In this scenario we need to create an Engine
and associate a connection with the context.
"""
engine = session.create_engine(neutron_config.database.connection)
connection = engine.connect()
context.configure(
connection=connection,
target_metadata=None,
version_table=VERSION_TABLE
)
try:
with context.begin_transaction():
context.run_migrations()
finally:
connection.close()
engine.dispose()
def run_migrations_online():
"""Run migrations in 'online' mode.
In this scenario we need to create an Engine
and associate a connection with the context.
"""
set_mysql_engine()
engine = session.create_engine(congress_config.database.connection)
connection = engine.connect()
context.configure(
connection=connection,
target_metadata=target_metadata
)
try:
with context.begin_transaction():
context.run_migrations()
finally:
connection.close()
def run_migrations_online():
"""Run migrations in 'online' mode.
In this scenario we need to create an Engine
and associate a connection with the context.
"""
set_mysql_engine()
engine = session.create_engine(vnfsvc_config.database.connection)
connection = engine.connect()
context.configure(
connection=connection,
target_metadata=target_metadata
)
try:
with context.begin_transaction():
context.run_migrations(active_plugins=active_plugins,
options=build_options())
finally:
connection.close()
def __call__(self, connection_url, save_tables=False, tunnel_type=None,
vxlan_udp_port=None):
engine = session.create_engine(connection_url)
metadata = sa.MetaData()
check_db_schema_version(engine, metadata)
if hasattr(self, 'define_ml2_tables'):
self.define_ml2_tables(metadata)
# Autoload the ports table to ensure that foreign keys to it and
# the network table can be created for the new tables.
sa.Table('ports', metadata, autoload=True, autoload_with=engine)
metadata.create_all(engine)
self.migrate_network_segments(engine, metadata)
if tunnel_type:
self.migrate_tunnels(engine, tunnel_type, vxlan_udp_port)
self.migrate_vlan_allocations(engine)
self.migrate_port_bindings(engine, metadata)
if hasattr(self, 'drop_old_tables'):
self.drop_old_tables(engine, save_tables)
def __init__(self, conf):
self.dry_run = False
self.db_engine = session.create_engine(conf.sql_connection)
self._session_creator = scoping.scoped_session(
orm.sessionmaker(
bind=self.db_engine,
autocommit=True
)
)
self.crypto_plugin = p11_crypto.P11CryptoPlugin(conf)
self.pkcs11 = self.crypto_plugin.pkcs11
self.plugin_name = utils.generate_fullname_for(self.crypto_plugin)
self.hsm_session = self.pkcs11.get_session()
self.new_mkek_label = self.crypto_plugin.mkek_label
self.new_hmac_label = self.crypto_plugin.hmac_label
self.new_mkek_type = self.crypto_plugin.mkek_key_type
self.new_hmac_type = self.crypto_plugin.hmac_key_type
self.new_mkek = self.crypto_plugin._get_master_key(
self.new_mkek_type,
self.new_mkek_label)
self.new_mkhk = self.crypto_plugin._get_master_key(
self.new_hmac_type,
self.new_hmac_label)
def run_migrations_online():
"""Run migrations in 'online' mode.
In this scenario we need to create an Engine
and associate a connection with the context.
"""
set_mysql_engine()
connection = config.attributes.get('connection')
new_engine = connection is None
if new_engine:
engine = session.create_engine(neutron_config.database.connection)
connection = engine.connect()
context.configure(connection=connection,
target_metadata=target_metadata,
version_table='netforce_version')
try:
with context.begin_transaction():
context.run_migrations()
finally:
if new_engine:
connection.close()
engine.dispose()
def _fixture(self, sql_mode):
return session.create_engine(self.engine.url, mysql_sql_mode=sql_mode)
def _setUp(self):
self._engine = session.create_engine('sqlite:///:memory:')
self.Session = sa.orm.sessionmaker(bind=self._engine)
self.external_id = 'EXTERNAL_ID'
models.BASE.metadata.create_all(self._engine)
self._load_sample_data()
def _setUp(self):
self._engine = session.create_engine('sqlite:///:memory:')
self.Session = sa.orm.sessionmaker(bind=self._engine)
self.external_id = 'EXTERNAL_ID'
models.BASE.metadata.create_all(self._engine)
self._load_sample_data()
def __enter__(self):
self.new_engine = self.connection is None
if self.new_engine:
self.engine = session.create_engine(self.connection_url)
self.connection = self.engine.connect()
return self.connection
def __enter__(self):
self.new_engine = self.connection is None
if self.new_engine:
self.engine = session.create_engine(self.connection_url)
self.connection = self.engine.connect()
return self.connection
def _fixture(self, **kw):
return session.create_engine("sqlite://", **kw)
def _fixture(self, **kw):
return session.create_engine("sqlite://", **kw)
def provisioned_engine(self, base_url, ident):
return session.create_engine(
self._provisioned_database_url(base_url, ident))
def provisioned_engine(self, base_url, ident):
return session.create_engine(
self._provisioned_database_url(base_url, ident))
def _fixture(self, sql_mode):
return session.create_engine(self.engine.url, mysql_sql_mode=sql_mode)
def version(self):
engine = db_session.create_engine(self.db_url)
with engine.connect() as conn:
context = alembic_migration.MigrationContext.configure(conn)
return context.get_current_revision()
