def test_swift_checksum_etag_mismatch(self):
"""This tests that when etag doesn't match swift checksum False is
returned and None for checksum and location"""
context = TroveContext()
# this backup_id will trigger fake swift client with calculate_etag
# enabled to spit out a bad etag when a segment object is uploaded
backup_id = 'bad_manifest_etag_123'
user = '******'
password = '******'
backup_container = 'database_backups'
swift_client = fake_create_swift_client(calculate_etag=True)
when(swift).create_swift_client(context).thenReturn(swift_client)
storage_strategy = SwiftStorage(context)
with MockBackupRunner(filename=backup_id, user=user,
password=password) as runner:
(success, note, checksum,
location) = storage_strategy.save(backup_container, runner)
self.assertEqual(success, False, "The backup should have failed!")
self.assertTrue(note.startswith("Error saving data to Swift!"))
self.assertIsNone(checksum,
"Swift checksum should be None for failed backup.")
self.assertIsNone(location,
"Swift location should be None for failed backup.")
def test_run_verify_checksum(self):
"""This tests that swift download cmd runs if original backup checksum
matches swift object etag"""
context = TroveContext()
location = "/backup/location/123"
is_zipped = False
backup_checksum = "fake-md5-sum"
swift_client = fake_create_swift_client()
when(swift).create_swift_client(context).thenReturn(swift_client)
download_process = MockProcess()
subprocess = mock(swift.subprocess)
when(subprocess).Popen(any(), any(), any(),
any()).thenReturn(download_process)
when(swift.utils).raise_if_process_errored().thenReturn(None)
storage_strategy = SwiftStorage(context)
download_stream = storage_strategy.load(context, location, is_zipped,
backup_checksum)
self.assertEqual(download_stream.container, "location")
self.assertEqual(download_stream.filename, "123")
with download_stream as stream:
print "Testing SwiftDownloadStream context manager: %s" % stream
self.assertIsNotNone(
download_stream.process,
"SwiftDownloadStream process/cmd is supposed "
"to run.")
self.assertIsNotNone(
download_stream.pid, "SwiftDownloadStream process/cmd is supposed "
"to run.")
def test_run_verify_checksum_mismatch(self):
"""This tests that SwiftDownloadIntegrityError is raised and swift
download cmd does not run when original backup checksum does not match
swift object etag"""
context = TroveContext()
location = "/backup/location/123"
is_zipped = False
backup_checksum = "checksum_different_then_fake_swift_etag"
swift_client = fake_create_swift_client()
when(swift).create_swift_client(context).thenReturn(swift_client)
storage_strategy = SwiftStorage(context)
download_stream = storage_strategy.load(context, location, is_zipped,
backup_checksum)
self.assertEqual(download_stream.container, "location")
self.assertEqual(download_stream.filename, "123")
self.assertRaises(SwiftDownloadIntegrityError,
download_stream.__enter__)
self.assertEqual(
download_stream.process, None,
"SwiftDownloadStream process/cmd was not supposed"
"to run.")
def test_backup_incremental_metadata(self):
when(backupagent).get_storage_strategy(any(),
any()).thenReturn(MockSwift)
MockStorage.save_metadata = Mock()
when(MockSwift).load_metadata(any(),
any()).thenReturn({'lsn': '54321'})
meta = {
'lsn': '12345',
'parent_location': 'fake',
'parent_checksum': 'md5',
}
when(mysql_impl.InnoBackupExIncremental).metadata().thenReturn(meta)
when(mysql_impl.InnoBackupExIncremental).check_process().thenReturn(
True)
agent = backupagent.BackupAgent()
bkup_info = {
'id': '123',
'location': 'fake-location',
'type': 'InnoBackupEx',
'checksum': 'fake-checksum',
'parent': {
'location': 'fake',
'checksum': 'md5'
}
}
agent.execute_backup(TroveContext(), bkup_info, '/var/lib/mysql')
self.assertTrue(MockStorage.save_metadata.called_once_with(
any(), meta))
def test_backup_incremental_metadata(self):
with patch.object(backupagent, 'get_storage_strategy',
return_value=MockSwift):
MockStorage.save_metadata = Mock()
with patch.object(MockSwift, 'load_metadata',
return_value={'lsn': '54321'}):
meta = {
'lsn': '12345',
'parent_location': 'fake',
'parent_checksum': 'md5',
}
mysql_impl.InnoBackupExIncremental.metadata = MagicMock(
return_value=meta)
mysql_impl.InnoBackupExIncremental.run = MagicMock(
return_value=True)
mysql_impl.InnoBackupExIncremental.__exit__ = MagicMock(
return_value=True)
agent = backupagent.BackupAgent()
bkup_info = {'id': '123',
'location': 'fake-location',
'type': 'InnoBackupEx',
'checksum': 'fake-checksum',
'parent': {'location': 'fake', 'checksum': 'md5'}
}
agent.execute_backup(TroveContext(),
bkup_info,
'/var/lib/mysql')
self.assertTrue(MockStorage.save_metadata.called_once_with(
ANY,
meta))
def test_swift_checksum_save(self):
"""This tests that SwiftStorage.save returns the swift checksum"""
context = TroveContext()
backup_id = '123'
user = '******'
password = '******'
swift_client = FakeSwiftConnection()
with patch.object(swift, 'create_swift_client',
return_value=swift_client):
storage_strategy = SwiftStorage(context)
with MockBackupRunner(filename=backup_id,
user=user,
password=password) as runner:
(success,
note,
checksum,
location) = storage_strategy.save(runner.manifest, runner)
self.assertTrue(success, "The backup should have been successful.")
self.assertIsNotNone(note, "A note should have been returned.")
self.assertEqual('http://mockswift/v1/database_backups/123.gz.enc',
location,
"Incorrect swift location was returned.")
def setUp(self):
super(GuestAgentManagerTest, self).setUp()
self.context = TroveContext()
self.replication_strategy = 'MysqlGTIDReplication'
self.patch_rs = patch(
'trove.guestagent.strategies.replication.get_strategy',
return_value=self.replication_strategy)
self.mock_rs = self.patch_rs.start()
self.addCleanup(self.patch_rs.stop)
self.manager = Manager()
self.origin_MySqlAppStatus = dbaas.MySqlAppStatus.get
self.origin_os_path_exists = os.path.exists
self.origin_format = volume.VolumeDevice.format
self.origin_migrate_data = volume.VolumeDevice.migrate_data
self.origin_mount = volume.VolumeDevice.mount
self.origin_unmount = volume.VolumeDevice.unmount
self.origin_mount_points = volume.VolumeDevice.mount_points
self.origin_stop_mysql = dbaas.MySqlApp.stop_db
self.origin_start_mysql = dbaas.MySqlApp.start_mysql
self.origin_update_overrides = dbaas.MySqlApp.update_overrides
self.origin_install_if_needed = dbaas.MySqlApp.install_if_needed
self.origin_secure = dbaas.MySqlApp.secure
self.origin_secure_root = dbaas.MySqlApp.secure_root
self.origin_pkg_is_installed = pkg.Package.pkg_is_installed
self.origin_os_path_exists = os.path.exists
self.origin_chown = operating_system.chown
# set up common mock objects, etc. for replication testing
self.patcher_gfvs = patch(
'trove.guestagent.dbaas.get_filesystem_volume_stats')
self.patcher_rs = patch(
'trove.guestagent.strategies.replication.get_instance')
self.mock_gfvs_class = self.patcher_gfvs.start()
self.mock_rs_class = self.patcher_rs.start()
def setUp(self):
super(GuestAgentManagerTest, self).setUp()
self.manager = Manager()
self.context = TroveContext()
self.patcher_rs = patch(self.manager.replication_namespace + "." +
self.manager.replication_strategy)
self.mock_rs_class = self.patcher_rs.start()
def test_create_with_catalog_all_opts(self):
cfg.CONF.set_override('swift_service_type', 'object-storev3')
cfg.CONF.set_override('os_region_name', 'RegionTwo')
client = remote.create_swift_client(
TroveContext(service_catalog=self.service_catalog))
self.assertEqual(self.swiftv3_public_url_region_two,
client.url)
def test_swift_checksum_etag_mismatch(self):
"""This tests that when etag doesn't match swift checksum False is
returned and None for checksum and location
"""
context = TroveContext()
# this backup_id will trigger fake swift client with calculate_etag
# enabled to spit out a bad etag when a segment object is uploaded
backup_id = 'bad_manifest_etag_123'
user = '******'
password = '******'
swift_client = FakeSwiftConnection()
with patch.object(swift,
'create_swift_client',
return_value=swift_client):
storage_strategy = SwiftStorage(context)
with MockBackupRunner(filename=backup_id,
user=user,
password=password) as runner:
(success, note, checksum,
location) = storage_strategy.save(runner.manifest, runner)
self.assertFalse(success, "The backup should have failed!")
self.assertTrue(note.startswith("Error saving data to Swift!"))
self.assertIsNone(checksum,
"Swift checksum should be None for failed backup.")
self.assertEqual(
'http://mockswift/v1/database_backups/'
'bad_manifest_etag_123.gz.enc', location,
"Incorrect swift location was returned.")
def test_swift_checksum_save(self):
"""This tests that SwiftStorage.save returns the swift checksum"""
context = TroveContext()
backup_id = '123'
user = '******'
password = '******'
backup_container = 'database_backups'
swift_client = FakeSwiftConnectionWithRealEtag()
when(swift).create_swift_client(context).thenReturn(swift_client)
storage_strategy = SwiftStorage(context)
with MockBackupRunner(filename=backup_id,
user=user,
password=password) as runner:
(success,
note,
checksum,
location) = storage_strategy.save(backup_container, runner)
self.assertEqual(success, True,
"The backup should have been successful.")
self.assertIsNotNone(note, "A note should have been returned.")
self.assertEqual(location, 'http://mockswift/v1/database_backups/123',
"Incorrect swift location was returned.")
def setUp(self):
super(GuestAgentManagerTest, self).setUp()
self.manager = Manager()
self.context = TroveContext()
self.patcher_rs = patch(
'trove.guestagent.strategies.replication.get_instance')
self.mock_rs_class = self.patcher_rs.start()
def test_backup_incremental_metadata(self, mock_logging,
get_storage_strategy_mock,
save_metadata_mock,
load_metadata_mock, get_datadir_mock):
meta = {
'lsn': '12345',
'parent_location': 'fake',
'parent_checksum': 'md5',
}
with patch.multiple(mysql_impl.InnoBackupExIncremental,
metadata=MagicMock(return_value=meta),
_run=MagicMock(return_value=True),
__exit__=MagicMock(return_value=True)):
agent = backupagent.BackupAgent()
bkup_info = {
'id': '123',
'location': 'fake-location',
'type': 'InnoBackupEx',
'checksum': 'fake-checksum',
'parent': {
'location': 'fake',
'checksum': 'md5'
},
'datastore': 'mysql',
'datastore_version': 'bo.gus'
}
agent.execute_backup(TroveContext(), bkup_info,
'/var/lib/mysql/data')
self.assertTrue(
MockStorage.save_metadata.called_once_with(ANY, meta))
def test_execute_restore(self):
"""This test should ensure backup agent
resolves backup instance
determines backup/restore type
transfers/downloads data and invokes the restore module
reports status
"""
with patch.object(backupagent,
'get_storage_strategy',
return_value=MockStorage):
with patch.object(backupagent,
'get_restore_strategy',
return_value=MockRestoreRunner):
agent = backupagent.BackupAgent()
bkup_info = {
'id': '123',
'location': 'fake-location',
'type': 'InnoBackupEx',
'checksum': 'fake-checksum',
}
agent.execute_restore(TroveContext(), bkup_info,
'/var/lib/mysql/data')
def test_execute_restore(self):
"""This test should ensure backup agent
resolves backup instance
determines backup/restore type
transfers/downloads data and invokes the restore module
reports status
"""
backup = mock(DBBackup)
backup.location = "/backup/location/123"
backup.backup_type = 'InnoBackupEx'
when(utils).execute(contains('sudo rm -rf')).thenReturn(None)
when(utils).clean_out(any()).thenReturn(None)
when(backupagent).get_storage_strategy(any(), any()).thenReturn(
MockStorage)
when(backupagent).get_restore_strategy(
'InnoBackupEx', any()).thenReturn(MockRestoreRunner)
when(DatabaseModelBase).find_by(id='123').thenReturn(backup)
when(backup).save().thenReturn(backup)
agent = backupagent.BackupAgent()
bkup_info = {'id': '123',
'location': 'fake-location',
'type': 'InnoBackupEx',
'checksum': 'fake-checksum',
}
agent.execute_restore(TroveContext(), bkup_info, '/var/lib/mysql')
def setUp(self):
super(GuestAgentCassandraDBManagerTest, self).setUp()
self.real_status = cass_service.CassandraAppStatus.set_status
class FakeInstanceServiceStatus(object):
status = ServiceStatuses.NEW
def save(self):
pass
cass_service.CassandraAppStatus.set_status = MagicMock(
return_value=FakeInstanceServiceStatus())
self.context = TroveContext()
self.manager = cass_manager.Manager()
self.pkg = cass_service.packager
self.real_db_app_status = cass_service.CassandraAppStatus
self.origin_os_path_exists = os.path.exists
self.origin_format = volume.VolumeDevice.format
self.origin_migrate_data = volume.VolumeDevice.migrate_data
self.origin_mount = volume.VolumeDevice.mount
self.origin_mount_points = volume.VolumeDevice.mount_points
self.origin_stop_db = cass_service.CassandraApp.stop_db
self.origin_start_db = cass_service.CassandraApp.start_db
self.origin_install_db = cass_service.CassandraApp._install_db
self.original_get_ip = netutils.get_my_ipv4
self.orig_make_host_reachable = (
cass_service.CassandraApp.make_host_reachable)
def setUp(self):
super(GuestAgentDB2ManagerTest, self).setUp()
self.real_status = db2_service.DB2AppStatus.set_status
class FakeInstanceServiceStatus(object):
status = ServiceStatuses.NEW
def save(self):
pass
db2_service.DB2AppStatus.set_status = MagicMock(
return_value=FakeInstanceServiceStatus())
self.context = TroveContext()
self.manager = db2_manager.Manager()
self.real_db_app_status = db2_service.DB2AppStatus
self.origin_format = volume.VolumeDevice.format
self.origin_mount = volume.VolumeDevice.mount
self.origin_mount_points = volume.VolumeDevice.mount_points
self.origin_stop_db = db2_service.DB2App.stop_db
self.origin_start_db = db2_service.DB2App.start_db
self.orig_change_ownership = (db2_service.DB2App.change_ownership)
self.orig_create_databases = db2_service.DB2Admin.create_database
self.orig_list_databases = db2_service.DB2Admin.list_databases
self.orig_delete_database = db2_service.DB2Admin.delete_database
self.orig_create_users = db2_service.DB2Admin.create_user
self.orig_list_users = db2_service.DB2Admin.list_users
self.orig_delete_user = db2_service.DB2Admin.delete_user
def setUp(self, *args, **kwargs):
super(RedisGuestAgentManagerTest, self).setUp()
self.patch_ope = patch('os.path.expanduser')
self.mock_ope = self.patch_ope.start()
self.addCleanup(self.patch_ope.stop)
self.context = TroveContext()
self.manager = RedisManager()
self.packages = 'redis-server'
self.origin_RedisAppStatus = redis_service.RedisAppStatus
self.origin_start_redis = redis_service.RedisApp.start_redis
self.origin_stop_redis = redis_service.RedisApp.stop_db
self.origin_install_redis = redis_service.RedisApp._install_redis
self.origin_install_if_needed = \
redis_service.RedisApp.install_if_needed
self.origin_format = VolumeDevice.format
self.origin_mount = VolumeDevice.mount
self.origin_mount_points = VolumeDevice.mount_points
self.origin_restore = backup.restore
self.patch_rs = patch(
'trove.guestagent.datastore.experimental.redis.manager.'
'REPLICATION_STRATEGY_CLASS')
self.mock_rs_class = self.patch_rs.start()
self.addCleanup(self.patch_rs.stop)
self.patch_gfvs = patch(
'trove.guestagent.dbaas.get_filesystem_volume_stats')
self.mock_gfvs_class = self.patch_gfvs.start()
self.addCleanup(self.patch_gfvs.stop)
self.repl_datastore_manager = 'redis'
self.repl_replication_strategy = 'RedisSyncReplication'
def setUp(self):
super(SwiftMetadataTests, self).setUp()
self.swift_client = FakeSwiftConnection()
self.context = TroveContext()
when(swift).create_swift_client(self.context).thenReturn(
self.swift_client)
self.swift = SwiftStorage(self.context)
def setUp(self):
super(GuestAgentManagerTest, self).setUp()
self.context = TroveContext()
self.manager = Manager()
self.origin_MySqlAppStatus = dbaas.MySqlAppStatus
self.origin_os_path_exists = os.path.exists
self.origin_format = volume.VolumeDevice.format
self.origin_migrate_data = volume.VolumeDevice.migrate_data
self.origin_mount = volume.VolumeDevice.mount
self.origin_unmount = volume.VolumeDevice.unmount
self.origin_mount_points = volume.VolumeDevice.mount_points
self.origin_stop_mysql = dbaas.MySqlApp.stop_db
self.origin_start_mysql = dbaas.MySqlApp.start_mysql
self.origin_update_overrides = dbaas.MySqlApp.update_overrides
self.origin_pkg_is_installed = pkg.Package.pkg_is_installed
self.origin_os_path_exists = os.path.exists
self.origin_chown = operating_system.chown
# set up common mock objects, etc. for replication testing
self.patcher_gfvs = patch(
'trove.guestagent.dbaas.get_filesystem_volume_stats')
self.patcher_rs = patch('trove.guestagent.datastore.mysql.manager.'
'REPLICATION_STRATEGY_CLASS')
self.mock_gfvs_class = self.patcher_gfvs.start()
self.mock_rs_class = self.patcher_rs.start()
self.repl_datastore_manager = 'mysql'
self.repl_replication_strategy = 'MysqlGTIDReplication'
def test_create_with_catalog_all_opts(self):
cfg.CONF.set_override('nova_compute_service_type', 'computev3')
cfg.CONF.set_override('os_region_name', 'RegionTwo')
client = remote.create_nova_client(
TroveContext(service_catalog=self.service_catalog))
self.assertEqual(self.computev3_public_url_region_two,
client.client.endpoint_override)
def _init(self):
self.mock = mox.Mox()
self.instance_id = 500
context = TroveContext()
self.db_info = DBInstance.create(
name="instance",
flavor_id=OLD_FLAVOR_ID,
tenant_id=999,
volume_size=None,
datastore_version_id=test_config.dbaas_datastore_version_id,
task_status=InstanceTasks.RESIZING)
self.server = self.mock.CreateMock(Server)
self.instance = models.BuiltInstanceTasks(
context,
self.db_info,
self.server,
datastore_status=InstanceServiceStatus.create(
instance_id=self.db_info.id,
status=rd_instance.ServiceStatuses.RUNNING))
self.instance.server.flavor = {'id': OLD_FLAVOR_ID}
self.guest = self.mock.CreateMock(guest.API)
self.instance._guest = self.guest
self.instance.refresh_compute_server_info = lambda: None
self.instance._refresh_datastore_status = lambda: None
self.mock.StubOutWithMock(self.instance, 'update_db')
self.mock.StubOutWithMock(self.instance,
'set_datastore_status_to_paused')
self.poll_until_mocked = False
self.action = None
def test_create_with_catalog_all_opts(self):
cfg.CONF.set_override('cinder_service_type', 'volume')
cfg.CONF.set_override('os_region_name', 'RegionTwo')
client = remote.create_cinder_client(
TroveContext(service_catalog=self.service_catalog))
self.assertEqual(self.volume_public_url_region_two,
client.client.management_url)
def _init(self):
self.mock = mox.Mox()
self.instance_id = 500
context = TroveContext()
self.db_info = DBInstance.create(name="instance",
flavor_id=OLD_FLAVOR_ID,
tenant_id=999,
volume_size=None,
service_type='mysql',
task_status=InstanceTasks.RESIZING)
self.server = self.mock.CreateMock(Server)
self.instance = models.BuiltInstanceTasks(context,
self.db_info,
self.server,
service_status="ACTIVE")
self.instance.server.flavor = {'id': OLD_FLAVOR_ID}
self.guest = self.mock.CreateMock(guest.API)
self.instance._guest = self.guest
self.instance._refresh_compute_server_info = lambda: None
self.instance._refresh_compute_service_status = lambda: None
self.mock.StubOutWithMock(self.instance, 'update_db')
self.mock.StubOutWithMock(self.instance,
'_set_service_status_to_paused')
self.poll_until_mocked = False
self.action = None
def test_create_with_catalog_all_opts(self):
cfg.CONF.set_override('heat_service_type', 'orchestrationv3')
cfg.CONF.set_override('os_region_name', 'RegionTwo')
client = remote.create_heat_client(
TroveContext(service_catalog=self.service_catalog))
self.assertEqual(self.heatv3_public_url_region_two,
client.http_client.endpoint)
def test_create_swift_client(self):
mock_resp = mock(dict)
when(swiftclient.client.Connection).get_container('bob').thenReturn(
["text", mock_resp])
client = remote.create_swift_client(TroveContext(tenant='123'))
headers, container = client.get_container('bob')
self.assertIs(headers, "text")
self.assertIs(container, mock_resp)
def test_create_with_conf_override_trailing_slash(self):
nova_url_from_conf = 'http://example.com/'
tenant_from_ctx = uuid.uuid4().hex
cfg.CONF.set_override('nova_compute_url', nova_url_from_conf)
client = remote.create_nova_client(
TroveContext(tenant=tenant_from_ctx))
self.assertEqual('%s%s' % (nova_url_from_conf, tenant_from_ctx),
client.client.endpoint_override)
def test_create_with_conf_override_trailing_slash(self):
heat_url_from_conf = 'http://example.com/'
tenant_from_ctx = 'abc'
cfg.CONF.set_override('heat_url', heat_url_from_conf)
client = remote.create_heat_client(
TroveContext(tenant=tenant_from_ctx))
self.assertEqual('%s%s' % (heat_url_from_conf, tenant_from_ctx),
client.http_client.endpoint)
def test_create_with_conf_override_trailing_slash(self):
cinder_url_from_conf = 'http://example.com/'
tenant_from_ctx = uuid.uuid4().hex
cfg.CONF.set_override('cinder_url', cinder_url_from_conf)
client = remote.create_cinder_client(
TroveContext(tenant=tenant_from_ctx))
self.assertEqual('%s%s' % (cinder_url_from_conf, tenant_from_ctx),
client.client.management_url)
def setUp(self):
super(GuestAgentManagerTest, self).setUp()
self.manager = mariadb_manager.Manager()
self.context = TroveContext()
patcher_rs = patch(
'trove.guestagent.strategies.replication.get_instance')
patcher_rs.start()
self.addCleanup(patcher_rs.stop)
