def setup(): sqlite_db = "tests.sqlite" # Set COBALT_TESTS_TMPFS to a tmpfs mount for faster setup. The fsyncs that # sqlite does nops :-) state_path = tempfile.mkdtemp(dir=tmpfs_tmp_dir(), prefix='cobalt.tests.') testdb = os.path.join(state_path, sqlite_db) if os.path.exists(testdb): os.unlink(testdb) from oslo.config import cfg from nova.db import migration test_opts = [ cfg.StrOpt('sqlite_clean_db', default='tests.clean.sqlite', help='File name of clean sqlite db') ] CONF = cfg.CONF CONF.register_opts(test_opts) CONF.import_opt('connection', 'nova.openstack.common.db.sqlalchemy.session', group='database') CONF.sqlite_db = sqlite_db CONF.state_path = state_path CONF.sql_connection = 'sqlite:///%s' % testdb CONF.set_override('connection', CONF.sql_connection, group='database') CONF.database.connection = CONF.sql_connection print CONF.sqlite_clean_db migration.db_sync() cleandb = os.path.join(CONF.state_path, CONF.sqlite_clean_db) shutil.copyfile(testdb, cleandb)
def setup(): import os import shutil from nova import context from nova import flags from nova.db import migration from nova.network import manager as network_manager from nova.tests import fake_flags FLAGS = flags.FLAGS testdb = os.path.join(FLAGS.state_path, FLAGS.sqlite_db) if os.path.exists(testdb): os.unlink(testdb) migration.db_sync() ctxt = context.get_admin_context() network_manager.VlanManager().create_networks( ctxt, FLAGS.fixed_range, FLAGS.num_networks, FLAGS.network_size, FLAGS.fixed_range_v6, FLAGS.vlan_start, FLAGS.vpn_start, ) cleandb = os.path.join(FLAGS.state_path, FLAGS.sqlite_clean_db) shutil.copyfile(testdb, cleandb)
def setup(): import os import shutil from nova import context from nova import flags from nova.db import migration from nova.network import manager as network_manager from nova.tests import fake_flags FLAGS = flags.FLAGS testdb = os.path.join(FLAGS.state_path, FLAGS.sqlite_db) if os.path.exists(testdb): os.unlink(testdb) migration.db_sync() ctxt = context.get_admin_context() network_manager.VlanManager().create_networks(ctxt, FLAGS.fixed_range, FLAGS.num_networks, FLAGS.network_size, FLAGS.fixed_range_v6, FLAGS.vlan_start, FLAGS.vpn_start, ) cleandb = os.path.join(FLAGS.state_path, FLAGS.sqlite_clean_db) shutil.copyfile(testdb, cleandb)
def setup(): import os import shutil sqlite_db = "tests.sqlite" state_path = tempfile.mkdtemp() testdb = os.path.join(state_path, sqlite_db) if os.path.exists(testdb): os.unlink(testdb) from oslo.config import cfg from nova.db import migration test_opts = [ cfg.StrOpt('sqlite_clean_db', default='tests.clean.sqlite', help='File name of clean sqlite db') ] CONF = cfg.CONF CONF.register_opts(test_opts) CONF.sqlite_db = sqlite_db CONF.state_path = state_path CONF.sql_connection = 'sqlite:///%s' % testdb print CONF.sqlite_clean_db migration.db_sync() cleandb = os.path.join(CONF.state_path, CONF.sqlite_clean_db) shutil.copyfile(testdb, cleandb)
def setup(): import os import shutil sqlite_db = "tests.sqlite" state_path = tempfile.mkdtemp() testdb = os.path.join(state_path, sqlite_db) if os.path.exists(testdb): os.unlink(testdb) from nova import flags from nova.openstack.common import cfg from nova.db import migration test_opts = [ cfg.StrOpt('sqlite_clean_db', default='tests.clean.sqlite', help='File name of clean sqlite db') ] FLAGS = flags.FLAGS FLAGS.register_opts(test_opts) FLAGS.sqlite_db = sqlite_db FLAGS.state_path = state_path FLAGS.sql_connection = 'sqlite:///%s' % testdb print FLAGS.sql_connection migration.db_sync() cleandb = os.path.join(FLAGS.state_path, FLAGS.sqlite_clean_db) shutil.copyfile(testdb, cleandb)
def setup(): import os import shutil sqlite_db = "tests.sqlite" state_path = tempfile.mkdtemp() testdb = os.path.join(state_path, sqlite_db) if os.path.exists(testdb): os.unlink(testdb) from oslo.config import cfg from nova.db import migration test_opts = [cfg.StrOpt("sqlite_clean_db", default="tests.clean.sqlite", help="File name of clean sqlite db")] CONF = cfg.CONF CONF.register_opts(test_opts) CONF.sqlite_db = sqlite_db CONF.state_path = state_path CONF.sql_connection = "sqlite:///%s" % testdb print CONF.sqlite_clean_db migration.db_sync() cleandb = os.path.join(CONF.state_path, CONF.sqlite_clean_db) shutil.copyfile(testdb, cleandb)
def _cache_schema(self): global DB_SCHEMA if not DB_SCHEMA: engine = session.get_engine() conn = engine.connect() migration.db_sync() DB_SCHEMA = "".join(line for line in conn.connection.iterdump()) engine.dispose()
def _cache_schema(self): global DB_SCHEMA if not DB_SCHEMA: engine = session.get_engine() conn = engine.connect() migration.db_sync() DB_SCHEMA = "".join(line for line in conn.connection.iterdump()) engine.dispose()
def _cache_schema(self): global DB_SCHEMA if not DB_SCHEMA[self.database]: engine = self.get_engine() conn = engine.connect() migration.db_sync(database=self.database) DB_SCHEMA[self.database] = "".join(line for line in conn.connection.iterdump()) engine.dispose()
def test_db_version_alembic(self): engine = enginefacade.writer.get_engine() with mock.patch.object(migration, '_get_engine', return_value=engine): migration.db_sync(database='main') script = alembic_script.ScriptDirectory.from_config(self.config) head = script.get_current_head() self.assertEqual(head, migration.db_version(database='main'))
def _cache_schema(self): global DB_SCHEMA if not DB_SCHEMA[self.database]: engine = self.get_engine() conn = engine.connect() migration.db_sync(database=self.database) DB_SCHEMA[self.database] = "".join( line for line in conn.connection.iterdump()) engine.dispose()
def _test_db_sync( self, has_migrate, has_alembic, mock_get_engine, mock_find_repo, mock_find_conf, mock_is_migrate, mock_is_alembic, mock_init, mock_upgrade, ): # return an encoded URL to mimic sqlalchemy mock_get_engine.return_value.url = ( 'mysql+pymysql://nova:[email protected]/nova?' 'read_default_file=%2Fetc%2Fmy.cnf.d%2Fnova.cnf' '&read_default_group=nova') mock_is_migrate.return_value = has_migrate mock_is_alembic.return_value = has_alembic migration.db_sync() mock_get_engine.assert_called_once_with('main', context=None) mock_find_repo.assert_called_once_with('main') mock_find_conf.assert_called_once_with('main') mock_find_conf.return_value.set_main_option.assert_called_once_with( 'sqlalchemy.url', 'mysql+pymysql://nova:[email protected]/nova?' # ... 'read_default_file=%%2Fetc%%2Fmy.cnf.d%%2Fnova.cnf' # ... '&read_default_group=nova') mock_is_migrate.assert_called_once_with(mock_get_engine.return_value, mock_find_repo.return_value) if has_migrate: mock_is_alembic.assert_called_once_with( mock_get_engine.return_value) else: mock_is_alembic.assert_not_called() # we should only attempt the upgrade of the remaining # sqlalchemy-migrate-based migrations and fake apply of the initial # alembic migrations if sqlalchemy-migrate is in place but alembic # hasn't been used yet if has_migrate and not has_alembic: mock_init.assert_called_once_with(mock_get_engine.return_value, 'main', mock_find_repo.return_value, mock_find_conf.return_value) else: mock_init.assert_not_called() # however, we should always attempt to upgrade the requested migration # to alembic mock_upgrade.assert_called_once_with(mock_get_engine.return_value, mock_find_conf.return_value, None)
def setup(): import mox # Fail fast if you don't have mox. Workaround for bug 810424 from nova import rpc # Register rpc_backend before fake_flags sets it FLAGS.register_opts(rpc.rpc_opts) from nova import context from nova import db from nova.db import migration from nova.network import manager as network_manager from nova.tests import fake_flags fake_flags.set_defaults(FLAGS) rpc.register_opts(FLAGS) if FLAGS.sql_connection == "sqlite://": if migration.db_version() > migration.INIT_VERSION: return else: testdb = os.path.join(FLAGS.state_path, FLAGS.sqlite_db) if os.path.exists(testdb): return migration.db_sync() ctxt = context.get_admin_context() network = network_manager.VlanManager() bridge_interface = FLAGS.flat_interface or FLAGS.vlan_interface network.create_networks( ctxt, label="test", cidr=FLAGS.fixed_range, multi_host=FLAGS.multi_host, num_networks=FLAGS.num_networks, network_size=FLAGS.network_size, cidr_v6=FLAGS.fixed_range_v6, gateway=FLAGS.gateway, gateway_v6=FLAGS.gateway_v6, bridge=FLAGS.flat_network_bridge, bridge_interface=bridge_interface, vpn_start=FLAGS.vpn_start, vlan_start=FLAGS.vlan_start, dns1=FLAGS.flat_network_dns, ) for net in db.network_get_all(ctxt): network.set_network_host(ctxt, net) if FLAGS.sql_connection == "sqlite://": global _DB engine = get_engine() conn = engine.connect() _DB = "".join(line for line in conn.connection.iterdump()) else: cleandb = os.path.join(FLAGS.state_path, FLAGS.sqlite_clean_db) shutil.copyfile(testdb, cleandb)
def _cache_schema(self, connection_str): # NOTE(melwitt): See the regular Database fixture for why # we do this. global DB_SCHEMA if not DB_SCHEMA['main']: ctxt_mgr = self._ctxt_mgrs[connection_str] engine = ctxt_mgr.get_legacy_facade().get_engine() conn = engine.connect() migration.db_sync(database='main') DB_SCHEMA['main'] = "".join(line for line in conn.connection.iterdump()) engine.dispose()
def _cache_schema(self, connection_str): # NOTE(melwitt): See the regular Database fixture for why # we do this. global DB_SCHEMA if not DB_SCHEMA['main']: ctxt_mgr = self._ctxt_mgrs[connection_str] engine = ctxt_mgr.get_legacy_facade().get_engine() conn = engine.connect() migration.db_sync(database='main') DB_SCHEMA['main'] = "".join(line for line in conn.connection.iterdump()) engine.dispose()
def setup(): import mox # Fail fast if you don't have mox. Workaround for bug 810424 from nova import rpc # Register rpc_backend before fake_flags sets it FLAGS.register_opts(rpc.rpc_opts) from nova import context from nova import db from nova.db import migration from nova.network import manager as network_manager from nova.tests import fake_flags rpc.register_opts(FLAGS) if FLAGS.sql_connection == "sqlite://": if migration.db_version() > migration.INIT_VERSION: return else: testdb = os.path.join(FLAGS.state_path, FLAGS.sqlite_db) if os.path.exists(testdb): return migration.db_sync() ctxt = context.get_admin_context() network = network_manager.VlanManager() bridge_interface = FLAGS.flat_interface or FLAGS.vlan_interface network.create_networks(ctxt, label='test', cidr=FLAGS.fixed_range, multi_host=FLAGS.multi_host, num_networks=FLAGS.num_networks, network_size=FLAGS.network_size, cidr_v6=FLAGS.fixed_range_v6, gateway=FLAGS.gateway, gateway_v6=FLAGS.gateway_v6, bridge=FLAGS.flat_network_bridge, bridge_interface=bridge_interface, vpn_start=FLAGS.vpn_start, vlan_start=FLAGS.vlan_start, dns1=FLAGS.flat_network_dns) for net in db.network_get_all(ctxt): network.set_network_host(ctxt, net) if FLAGS.sql_connection == "sqlite://": global _DB engine = get_engine() conn = engine.connect() _DB = "".join(line for line in conn.connection.iterdump()) else: cleandb = os.path.join(FLAGS.state_path, FLAGS.sqlite_clean_db) shutil.copyfile(testdb, cleandb)
def init_db(): # create DB print "Starting creating DB tables" url=sqlalchemy.engine.url.make_url(CONF.database.connection) fd, path = tempfile.mkstemp() with os.fdopen(fd, "w") as f: f.write('mysql -u%s -p%s -h%s -e "DROP DATABASE IF EXISTS %s;"\n' % ( url.username, url.password, url.host, url.database)) f.write('mysql -u%s -p%s -h%s -e "CREATE DATABASE %s CHARACTER SET %s;"\n' % ( url.username, url.password, url.host, url.database, url.query.get('charset', 'utf8'))) utils.execute('sh', '%s' % path) os.remove(path) #create tables migration.db_sync() print "Finished creating DB tables"
def setup(): ''' for nova test.py create a dummy clean.sqlite ''' cleandb = os.path.join(CONF.state_path, CONF.sqlite_clean_db) if os.path.exists(cleandb): pass else: open(cleandb, 'w').close() ''' for healthnmon create db ''' healthnmon_path = os.path.abspath( os.path.join(healthnmon.get_healthnmon_location(), '../')) sql_connection_url = "sqlite:///" + str(healthnmon_path) + "/$sqlite_db" CONF.set_default("sql_connection", sql_connection_url) testdb = os.path.join(healthnmon_path, CONF.sqlite_db) if os.path.exists(testdb): return nova_migration.db_sync() healthnmon_migration.db_sync() cleandb = os.path.join(healthnmon_path, CONF.sqlite_clean_db) shutil.copyfile(testdb, cleandb)
def setup(): fake_flags.set_defaults(CONF) if CONF.sql_connection == "sqlite://": if migration.db_version() > migration.INIT_VERSION: return else: testdb = os.path.join(CONF.state_path, CONF.sqlite_db) if os.path.exists(testdb): return migration.db_sync() ctxt = context.get_admin_context() network = network_manager.VlanManager() bridge_interface = CONF.flat_interface or CONF.vlan_interface network.create_networks( ctxt, label="test", cidr=CONF.fixed_range, multi_host=CONF.multi_host, num_networks=CONF.num_networks, network_size=CONF.network_size, cidr_v6=CONF.fixed_range_v6, gateway=CONF.gateway, gateway_v6=CONF.gateway_v6, bridge=CONF.flat_network_bridge, bridge_interface=bridge_interface, vpn_start=CONF.vpn_start, vlan_start=CONF.vlan_start, dns1=CONF.flat_network_dns, ) for net in db.network_get_all(ctxt): network.set_network_host(ctxt, net) if CONF.sql_connection == "sqlite://": global _DB engine = get_engine() conn = engine.connect() _DB = "".join(line for line in conn.connection.iterdump()) else: cleandb = os.path.join(CONF.state_path, CONF.sqlite_clean_db) shutil.copyfile(testdb, cleandb)
def test_db_sync_with_special_symbols_in_connection_string(self): qargs = 'read_default_group=data with/a+percent_%-and%20symbols!' url = f"sqlite:///:memory:?{qargs}" self.flags(connection=url, group='database') self.useFixture(nova_fixtures.Database()) alembic_config = migration._find_alembic_conf() with mock.patch.object( migration, '_find_alembic_conf', return_value=alembic_config): migration.db_sync() actual = alembic_config.get_main_option('sqlalchemy.url') expected = ( "sqlite:///:memory:?read_default_group=data+with%2Fa" "+percent_%25-and+symbols%21" ) self.assertEqual(expected, actual) self.assertEqual( urllib.parse.unquote_plus(url), urllib.parse.unquote_plus(actual) )
def setup(): ''' for nova test.py create a dummy clean.sqlite ''' cleandb = os.path.join(CONF.state_path, CONF.sqlite_clean_db) if os.path.exists(cleandb): pass else: open(cleandb, 'w').close() ''' for healthnmon create db ''' healthnmon_path = os.path.abspath( os.path.join(healthnmon.get_healthnmon_location(), '../')) sql_connection_url = "sqlite:///" + str(healthnmon_path) + "/$sqlite_db" CONF.set_default("sql_connection", sql_connection_url) testdb = os.path.join(healthnmon_path, CONF.sqlite_db) if os.path.exists(testdb): return nova_migration.db_sync() healthnmon_migration.db_sync() cleandb = os.path.join(healthnmon_path, CONF.sqlite_clean_db) shutil.copyfile(testdb, cleandb)
def setup(): import os import shutil from nova import context from nova import flags from nova import db from nova.db import migration from nova.network import manager as network_manager from nova.tests import fake_flags FLAGS = flags.FLAGS testdb = os.path.join(FLAGS.state_path, FLAGS.sqlite_db) if os.path.exists(testdb): return migration.db_sync() ctxt = context.get_admin_context() network = network_manager.VlanManager() bridge_interface = FLAGS.flat_interface or FLAGS.vlan_interface network.create_networks( ctxt, label="test", cidr=FLAGS.fixed_range, multi_host=FLAGS.multi_host, num_networks=FLAGS.num_networks, network_size=FLAGS.network_size, cidr_v6=FLAGS.fixed_range_v6, gateway=FLAGS.gateway, gateway_v6=FLAGS.gateway_v6, bridge=FLAGS.flat_network_bridge, bridge_interface=bridge_interface, vpn_start=FLAGS.vpn_start, vlan_start=FLAGS.vlan_start, dns1=FLAGS.flat_network_dns, ) for net in db.network_get_all(ctxt): network.set_network_host(ctxt, net) cleandb = os.path.join(FLAGS.state_path, FLAGS.sqlite_clean_db) shutil.copyfile(testdb, cleandb)
def setup(): from nova.tests import fake_flags return import os import shutil from nova import context from nova import flags from nova.db import migration from nova.network import manager as network_manager FLAGS = flags.FLAGS testdb = os.path.join(FLAGS.state_path, FLAGS.sqlite_db) if os.path.exists(testdb): os.unlink(testdb) migration.db_sync() ctxt = context.get_admin_context() cleandb = os.path.join(FLAGS.state_path, FLAGS.sqlite_clean_db) shutil.copyfile(testdb, cleandb)
def setup(): from nova.tests import fake_flags return import os import shutil from nova import context from nova import flags from nova.db import migration from nova.network import manager as network_manager FLAGS = flags.FLAGS testdb = os.path.join(FLAGS.state_path, FLAGS.sqlite_db) if os.path.exists(testdb): os.unlink(testdb) migration.db_sync() ctxt = context.get_admin_context() cleandb = os.path.join(FLAGS.state_path, FLAGS.sqlite_clean_db) shutil.copyfile(testdb, cleandb)
def setup(): fake_flags.set_defaults(CONF) if CONF.sql_connection == "sqlite://": if migration.db_version() > migration.INIT_VERSION: return else: testdb = os.path.join(CONF.state_path, CONF.sqlite_db) if os.path.exists(testdb): return migration.db_sync() ctxt = context.get_admin_context() network = network_manager.VlanManager() bridge_interface = CONF.flat_interface or CONF.vlan_interface network.create_networks(ctxt, label='test', cidr=CONF.fixed_range, multi_host=CONF.multi_host, num_networks=CONF.num_networks, network_size=CONF.network_size, cidr_v6=CONF.fixed_range_v6, gateway=CONF.gateway, gateway_v6=CONF.gateway_v6, bridge=CONF.flat_network_bridge, bridge_interface=bridge_interface, vpn_start=CONF.vpn_start, vlan_start=CONF.vlan_start, dns1=CONF.flat_network_dns) for net in db.network_get_all(ctxt): network.set_network_host(ctxt, net) if CONF.sql_connection == "sqlite://": global _DB engine = get_engine() conn = engine.connect() _DB = "".join(line for line in conn.connection.iterdump()) else: cleandb = os.path.join(CONF.state_path, CONF.sqlite_clean_db) shutil.copyfile(testdb, cleandb)
def setup(): import mox # Fail fast if you don't have mox. Workaround for bug 810424 import os import shutil from nova import context from nova import flags from nova import db from nova.db import migration from nova.network import manager as network_manager from nova.tests import fake_flags FLAGS = flags.FLAGS testdb = os.path.join(FLAGS.state_path, FLAGS.sqlite_db) if os.path.exists(testdb): return migration.db_sync() ctxt = context.get_admin_context() network = network_manager.VlanManager() bridge_interface = FLAGS.flat_interface or FLAGS.vlan_interface network.create_networks(ctxt, label='test', cidr=FLAGS.fixed_range, multi_host=FLAGS.multi_host, num_networks=FLAGS.num_networks, network_size=FLAGS.network_size, cidr_v6=FLAGS.fixed_range_v6, gateway=FLAGS.gateway, gateway_v6=FLAGS.gateway_v6, bridge=FLAGS.flat_network_bridge, bridge_interface=bridge_interface, vpn_start=FLAGS.vpn_start, vlan_start=FLAGS.vlan_start, dns1=FLAGS.flat_network_dns) for net in db.network_get_all(ctxt): network.set_network_host(ctxt, net) cleandb = os.path.join(FLAGS.state_path, FLAGS.sqlite_clean_db) shutil.copyfile(testdb, cleandb)
def test_db_sync_with_special_symbols_in_connection_string(self): qargs = 'read_default_group=data with/a+percent_%-and%20symbols!' url = f"sqlite:///:memory:?{qargs}" self.flags(connection=url, group='database') # since the engine.url is immutable it will never get updated # once its created so reusing the engine instance would break # this test. engine = enginefacade.writer.get_engine() self.useFixture( fixtures.MonkeyPatch('nova.db.migration._get_engine', mock.Mock(return_value=engine))) alembic_config = migration._find_alembic_conf() with mock.patch.object(migration, '_find_alembic_conf', return_value=alembic_config): migration.db_sync() actual = alembic_config.get_main_option('sqlalchemy.url') expected = ("sqlite:///:memory:?read_default_group=data+with%2Fa" "+percent_%25-and+symbols%21") self.assertEqual(expected, actual) self.assertEqual(urllib.parse.unquote_plus(url), urllib.parse.unquote_plus(actual))
def sync(self, version=None): """Sync the database up to the most recent version.""" return migration.db_sync(version)
def db_sync(self, engine): with mock.patch.object(migration, '_get_engine', return_value=engine): migration.db_sync(database='main')
def test_db_version_alembic(self): migration.db_sync(database='main') script = alembic_script.ScriptDirectory.from_config(self.config) head = script.get_current_head() self.assertEqual(head, migration.db_version(database='main'))
def reset(self): engine = self.get_engine() engine.dispose() engine.connect() migration.db_sync(version=self.version, database=self.database)
def reset(self): engine = self.get_engine() engine.dispose() engine.connect() migration.db_sync(version=self.version, database=self.database)
def sync(self, version=None): """Sync the database up to the most recent version.""" return migration.db_sync(version)