def do(self):
from backup.tasks import make_instance_snapshot_backup
from backup.models import BackupGroup
if (self.database_migrate
and self.database_migrate.host_migrate_snapshot):
snapshot = self.database_migrate.host_migrate_snapshot
else:
group = BackupGroup()
group.save()
snapshot = make_instance_snapshot_backup(
self.instance, {}, group, provider_class=self.provider_class)
if not snapshot:
raise Exception('Backup was unsuccessful in {}'.format(
self.instance))
snapshot.is_automatic = False
snapshot.save()
if self.database_migrate:
host_migrate = self.host_migrate
host_migrate.snapshot = snapshot
host_migrate.save()
else:
self.step_manager.snapshot = snapshot
self.step_manager.save()
if snapshot.has_warning:
raise Exception('Backup was warning')
def do(self, workflow_dict):
try:
group = BackupGroup()
group.save()
for host_and_export in workflow_dict['hosts_and_exports']:
host = host_and_export['host']
export_id = host_and_export['old_export_id']
ret = make_host_backup(database=workflow_dict['database'],
instance=host.instances.all()[0],
export_id=export_id,
group=group)
if not ret:
msg = 'Could not make snapshot for export_id: {} on host {}'.format(
export_id, host)
LOG.error(msg)
raise Exception(msg)
return True
except Exception:
traceback = full_stack()
workflow_dict['exceptions']['error_codes'].append(DBAAS_0021)
workflow_dict['exceptions']['traceback'].append(traceback)
return False
def do(self):
from backup.tasks import make_instance_snapshot_backup
from backup.models import BackupGroup
if self.database_migrate and self.database_migrate.host_migrate_snapshot:
snapshot = self.database_migrate.host_migrate_snapshot
else:
group = BackupGroup()
group.save()
snapshot = make_instance_snapshot_backup(
self.instance,
{},
group,
provider_class=VolumeProviderBaseMigrate
)
if not snapshot:
raise Exception('Backup was unsuccessful in {}'.format(self.instance))
snapshot.is_automatic = False
snapshot.save()
if self.database_migrate:
host_migrate = self.host_migrate
host_migrate.snapshot = snapshot
host_migrate.save()
else:
self.step_manager.snapshot = snapshot
self.step_manager.save()
if snapshot.has_warning:
raise Exception('Backup was warning')
def do(self, workflow_dict):
try:
group = BackupGroup()
group.save()
for instance in workflow_dict['instances']:
error = {}
snapshot = make_instance_snapshot_backup(instance=instance,
error=error,
group=group)
if snapshot and snapshot.was_successful:
msg = "Backup for %s was successful" % (str(instance))
LOG.info(msg)
elif snapshot and snapshot.has_warning:
msg = "Backup for %s has warning" % (str(instance))
LOG.info(msg)
else:
msg = "Backup for %s was unsuccessful. Error: %s" % (
str(instance), error['errormsg'])
LOG.error(msg)
raise Exception(msg)
return True
except Exception:
traceback = full_stack()
workflow_dict['exceptions']['error_codes'].append(DBAAS_0023)
workflow_dict['exceptions']['traceback'].append(traceback)
return False
def test_current_hour_with_pending_backup(self, get_worker_name_mock,
task_register, save_backup_group,
make_instance_snapshot_backup):
infra_mock = InfraHelper.create(name='pending_backup_test',
backup_hour=self.backup_hour - 1,
plan__has_persistence=True,
environment=self.dev_env,
plan=self.plan)
DatabaseHelper.create(databaseinfra=infra_mock,
environment=self.dev_env)
instance_mock = mommy.make('Instance', databaseinfra=infra_mock)
get_worker_name_mock.return_value = 'test'
group = BackupGroup()
save_backup_group.return_value = group
make_instance_snapshot_backup.return_value.status.return_value = (
Snapshot.SUCCESS)
make_databases_backup()
calls = [
call(current_hour=self.backup_hour,
instance=self.instance,
error={},
group=group),
call(current_hour=self.backup_hour,
instance=instance_mock,
error={},
group=group)
]
make_instance_snapshot_backup.assert_has_calls(calls, any_order=True)
def test_current_hour_without_pending_backup(
self, get_worker_name_mock, task_register, save_backup_group,
make_instance_snapshot_backup):
infra_mock = InfraHelper.create(
name='backup_test',
backup_hour=self.backup_hour - 1,
plan__has_persistence=True,
environment=self.dev_env,
plan=self.plan,
)
DatabaseHelper.create(databaseinfra=infra_mock,
environment=self.dev_env)
instance_mock = mommy.make('Instance', databaseinfra=infra_mock)
get_worker_name_mock.return_value = 'test'
group = BackupGroup()
save_backup_group.return_value = group
snapshot = mommy.make('Snapshot',
instance=instance_mock,
group=group,
status=Snapshot.SUCCESS,
end_at=FAKE_NOW - timedelta(hours=1))
make_instance_snapshot_backup.return_value = snapshot
make_databases_backup()
make_instance_snapshot_backup.assert_called_once_with(
current_hour=self.backup_hour,
instance=self.instance,
error={},
group=group)
def restore_snapshot(database, group, task, retry_from=None):
restore = DatabaseRestore()
restore.task = task
restore.database = database
restore.group = group
new_group = retry_from.new_group if retry_from else BackupGroup()
new_group.save()
restore.new_group = new_group
restore.save()
restore.load_instances(retry_from)
topology_path = database.plan.replication_topology.class_path
steps = get_restore_snapshot_settings(topology_path)
since_step = retry_from.current_step if retry_from else None
if steps_for_instances(
steps, restore.instances, task, restore.update_step, since_step=since_step
):
restore.set_success()
task.set_status_success('Restore is done')
else:
restore.set_error()
task.set_status_error(
'Could not do restore\n'
'Please check error message and do retry'
)
def setUp(self):
self.backup_hour = 5
self.year = 2020
self.month = 1
self.day = 1
mommy.make(
'Configuration', name='backup_hour', value=str(self.backup_hour)
)
mommy.make(
'Configuration', name='make_database_backup_hour',
value=','.join(map(str, FAKE_MAKE_DATABASE_BACKUP_HOUR))
)
self.dev_env = mommy.make(
'Environment', name='dev', stage=Environment.DEV
)
mommy.make('Environment', name='prod', stage=Environment.PROD)
self.engine_type = mommy.make(
'EngineType', name='mysql'
)
self.engine = mommy.make(
'Engine', engine_type=self.engine_type
)
self.replication_topology = mommy.make(
'ReplicationTopology',
name='MySQL Single 5.7.25',
class_path='drivers.replication_topologies.mysql.MySQLSingle'
)
self.plan = mommy.make(
'Plan', engine=self.engine,
replication_topology=self.replication_topology
)
self.infra = mommy.make(
'DatabaseInfra', backup_hour=self.backup_hour,
plan__has_persistence=True,
environment=self.dev_env,
plan=self.plan,
endpoint='127.0.0.1:1111'
)
self.host = mommy.make_recipe(
'physical.host',
)
self.instance = mommy.make(
'Instance', databaseinfra=self.infra,
hostname=self.host
)
self.volume = mommy.make(
'Volume', host=self.host
)
self.database = DatabaseHelper.create(
environment=self.dev_env,
databaseinfra=self.infra
)
self.group = BackupGroup()
def test_backup_current_hour(self, get_worker_name_mock, task_register,
save_backup_group,
make_instance_snapshot_backup):
get_worker_name_mock.return_value = 'test'
group = BackupGroup()
save_backup_group.return_value = group
make_instance_snapshot_backup.return_value.status.return_value = (
Snapshot.SUCCESS)
make_databases_backup()
make_instance_snapshot_backup.assert_called_with(
current_hour=self.backup_hour,
instance=self.instance,
error={},
group=group)
def test_snapshot_with_error(self, get_worker_name_mock, task_register,
save_backup_group,
make_instance_snapshot_backup):
get_worker_name_mock.return_value = 'test'
group = BackupGroup()
save_backup_group.return_value = group
snapshot = mommy.make('Snapshot',
instance=self.instance,
group=group,
status=Snapshot.ERROR)
make_instance_snapshot_backup.return_value = snapshot
make_databases_backup()
make_instance_snapshot_backup.assertEqual(snapshot.status,
Snapshot.ERROR)
def group(self):
from backup.models import BackupGroup
group = BackupGroup()
group.save()
return group
def group(self):
from backup.models import BackupGroup
group = BackupGroup()
group.save()
return group
