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)
