def delete(self, req, tenant_id, id): LOG.info(_('Deleting backup for tenant %(tenant_id)s ' 'ID: %(backup_id)s') % {'tenant_id': tenant_id, 'backup_id': id}) context = req.environ[wsgi.CONTEXT_KEY] Backup.delete(context, id) return wsgi.Result(None, 202)
def _create_replication_slave(self, context, instance_id, name, flavor, image_id, databases, users, datastore_manager, packages, volume_size, availability_zone, root_password, nics, overrides, slave_of_id, backup_id, volume_type, modules): if type(instance_id) in [list]: ids = instance_id root_passwords = root_password else: ids = [instance_id] root_passwords = [root_password] replica_number = 0 replica_backup_id = backup_id replica_backup_created = False replicas = [] master_instance_tasks = BuiltInstanceTasks.load(context, slave_of_id) server_group = master_instance_tasks.server_group scheduler_hints = srv_grp.ServerGroup.convert_to_hint(server_group) LOG.debug("Using scheduler hints for locality: %s", scheduler_hints) try: for replica_index in range(0, len(ids)): try: replica_number += 1 LOG.debug("Creating replica %(num)d of %(count)d.", {'num': replica_number, 'count': len(ids)}) instance_tasks = FreshInstanceTasks.load( context, ids[replica_index]) snapshot = instance_tasks.get_replication_master_snapshot( context, slave_of_id, flavor, replica_backup_id, replica_number=replica_number) replica_backup_id = snapshot['dataset']['snapshot_id'] replica_backup_created = (replica_backup_id is not None) instance_tasks.create_instance( flavor, image_id, databases, users, datastore_manager, packages, volume_size, replica_backup_id, availability_zone, root_passwords[replica_index], nics, overrides, None, snapshot, volume_type, modules, scheduler_hints) replicas.append(instance_tasks) except Exception: # if it's the first replica, then we shouldn't continue LOG.exception( "Could not create replica %(num)d of %(count)d.", {'num': replica_number, 'count': len(ids)}) if replica_number == 1: raise for replica in replicas: replica.wait_for_instance(CONF.restore_usage_timeout, flavor) finally: if replica_backup_created: Backup.delete(context, replica_backup_id)
def _create_replication_slave(self, context, instance_id, name, flavor, image_id, databases, users, datastore_manager, packages, volume_size, availability_zone, root_password, nics, overrides, slave_of_id, backup_id, volume_type, modules): if type(instance_id) in [list]: ids = instance_id root_passwords = root_password else: ids = [instance_id] root_passwords = [root_password] replica_number = 0 replica_backup_id = backup_id replica_backup_created = False replicas = [] master_instance_tasks = BuiltInstanceTasks.load(context, slave_of_id) server_group = master_instance_tasks.server_group scheduler_hints = srv_grp.ServerGroup.convert_to_hint(server_group) LOG.debug("Using scheduler hints for locality: %s" % scheduler_hints) try: for replica_index in range(0, len(ids)): try: replica_number += 1 LOG.debug("Creating replica %d of %d." % (replica_number, len(ids))) instance_tasks = FreshInstanceTasks.load( context, ids[replica_index]) snapshot = instance_tasks.get_replication_master_snapshot( context, slave_of_id, flavor, replica_backup_id, replica_number=replica_number) replica_backup_id = snapshot['dataset']['snapshot_id'] replica_backup_created = (replica_backup_id is not None) instance_tasks.create_instance( flavor, image_id, databases, users, datastore_manager, packages, volume_size, replica_backup_id, availability_zone, root_passwords[replica_index], nics, overrides, None, snapshot, volume_type, modules, scheduler_hints) replicas.append(instance_tasks) except Exception: # if it's the first replica, then we shouldn't continue LOG.exception(_( "Could not create replica %(num)d of %(count)d.") % {'num': replica_number, 'count': len(ids)}) if replica_number == 1: raise for replica in replicas: replica.wait_for_instance(CONF.restore_usage_timeout, flavor) finally: if replica_backup_created: Backup.delete(context, replica_backup_id)
def delete(self, req, tenant_id, id): LOG.info(_('Deleting backup for tenant %(tenant_id)s ' 'ID: %(backup_id)s') % {'tenant_id': tenant_id, 'backup_id': id}) context = req.environ[wsgi.CONTEXT_KEY] context.notification = notification.DBaaSBackupDelete(context, request=req) with StartNotification(context, backup_id=id): Backup.delete(context, id) return wsgi.Result(None, 202)
def _create_replication_slave(self, context, instance_id, name, flavor, image_id, databases, users, datastore_manager, packages, volume_size, availability_zone, root_password, nics, overrides, slave_of_id, backup_id): if type(instance_id) in [list]: ids = instance_id root_passwords = root_password else: ids = [instance_id] root_passwords = [root_password] replica_number = 0 replica_backup_id = backup_id replica_backup_created = False replicas = [] try: for replica_index in range(0, len(ids)): try: replica_number += 1 LOG.debug("Creating replica %d of %d." % (replica_number, len(ids))) instance_tasks = FreshInstanceTasks.load( context, ids[replica_index]) snapshot = instance_tasks.get_replication_master_snapshot( context, slave_of_id, flavor, replica_backup_id, replica_number=replica_number) replica_backup_id = snapshot['dataset']['snapshot_id'] replica_backup_created = True instance_tasks.create_instance( flavor, image_id, databases, users, datastore_manager, packages, volume_size, replica_backup_id, availability_zone, root_passwords[replica_index], nics, overrides, None, snapshot) replicas.append(instance_tasks) except Exception: # if it's the first replica, then we shouldn't continue LOG.exception( _("Could not create replica %(num)d of %(count)d.") % { 'num': replica_number, 'count': len(instance_id) }) if replica_number == 1: raise for replica in replicas: replica.wait_for_instance(CONF.restore_usage_timeout, flavor) finally: if replica_backup_created: Backup.delete(context, replica_backup_id)
def _create_replication_slave(self, context, instance_id, name, flavor, image_id, databases, users, datastore_manager, packages, volume_size, availability_zone, root_password, nics, overrides, slave_of_id, backup_id): if type(instance_id) in [list]: ids = instance_id root_passwords = root_password else: ids = [instance_id] root_passwords = [root_password] replica_number = 0 replica_backup_id = backup_id replica_backup_created = False replicas = [] try: for replica_index in range(0, len(ids)): try: replica_number += 1 LOG.debug("Creating replica %d of %d." % (replica_number, len(ids))) instance_tasks = FreshInstanceTasks.load( context, ids[replica_index]) snapshot = instance_tasks.get_replication_master_snapshot( context, slave_of_id, flavor, replica_backup_id, replica_number=replica_number) replica_backup_id = snapshot['dataset']['snapshot_id'] replica_backup_created = True instance_tasks.create_instance( flavor, image_id, databases, users, datastore_manager, packages, volume_size, replica_backup_id, availability_zone, root_passwords[replica_index], nics, overrides, None, snapshot) replicas.append(instance_tasks) except Exception: # if it's the first replica, then we shouldn't continue LOG.exception(_( "Could not create replica %(num)d of %(count)d.") % {'num': replica_number, 'count': len(instance_id)}) if replica_number == 1: raise for replica in replicas: replica.wait_for_instance(CONF.restore_usage_timeout, flavor) #rds-start replica.create_monitor() #rds-end finally: if replica_backup_created: Backup.delete(context, replica_backup_id)
def delete(self, req, tenant_id, id): LOG.info(_('Deleting backup for tenant %(tenant_id)s ' 'ID: %(backup_id)s') % {'tenant_id': tenant_id, 'backup_id': id}) context = req.environ[wsgi.CONTEXT_KEY] backup = Backup.get_by_id(context, id) policy.authorize_on_target(context, 'backup:delete', {'tenant': backup.tenant_id}) context.notification = notification.DBaaSBackupDelete(context, request=req) with StartNotification(context, backup_id=id): Backup.delete(context, id) return wsgi.Result(None, 202)
def _create_replication_slave(self, context, instance_id, name, flavor, image_id, databases, users, datastore_manager, packages, volume_size, availability_zone, root_password, nics, overrides, slave_of_id): instance_tasks = FreshInstanceTasks.load(context, instance_id) snapshot = instance_tasks.get_replication_master_snapshot(context, slave_of_id) try: instance_tasks.create_instance(flavor, image_id, databases, users, datastore_manager, packages, volume_size, snapshot['dataset']['snapshot_id'], availability_zone, root_password, nics, overrides, None) finally: Backup.delete(context, snapshot['dataset']['snapshot_id']) instance_tasks.attach_replication_slave(snapshot, flavor)
def delete(self, req, tenant_id, id): LOG.debug("Delete Backup for tenant: %s, ID: %s" % (tenant_id, id)) context = req.environ[wsgi.CONTEXT_KEY] Backup.delete(context, id) return wsgi.Result(None, 202)
def _create_replication_slave(self, context, instance_id, name, flavor, image_id, databases, users, datastore_manager, packages, volume_size, availability_zone, root_password, nics, overrides, slave_of_id, backup_id, volume_type, modules): if type(instance_id) in [list]: ids = instance_id root_passwords = root_password else: ids = [instance_id] root_passwords = [root_password] replica_number = 0 replica_backup_id = backup_id replica_backup_created = False replicas = [] master_instance_tasks = BuiltInstanceTasks.load(context, slave_of_id) server_group = master_instance_tasks.server_group scheduler_hints = srv_grp.ServerGroup.convert_to_hint(server_group) LOG.debug("Using scheduler hints for locality: %s" % scheduler_hints) try: for replica_index in range(0, len(ids)): try: replica_number += 1 LOG.debug("Creating replica %d of %d." % (replica_number, len(ids))) instance_tasks = FreshInstanceTasks.load( context, ids[replica_index]) snapshot = instance_tasks.get_replication_master_snapshot( context, slave_of_id, flavor, replica_backup_id, replica_number=replica_number) replica_backup_id = snapshot['dataset']['snapshot_id'] replica_backup_created = (replica_backup_id is not None) instance_tasks.create_instance( flavor, image_id, databases, users, datastore_manager, packages, volume_size, replica_backup_id, availability_zone, root_passwords[replica_index], nics, overrides, None, snapshot, volume_type, modules, scheduler_hints) replicas.append(instance_tasks) except Exception: # if it's the first replica, then we shouldn't continue LOG.exception(_( "Could not create replica %(num)d of %(count)d.") % {'num': replica_number, 'count': len(ids)}) if replica_number == 1: raise for replica in replicas: replica.wait_for_instance(CONF.restore_usage_timeout, flavor) # Some datastores requires completing configuration of replication # nodes with information that is only available after all the # instances has been started. if (master_instance_tasks .post_processing_required_for_replication()): slave_instances = [BuiltInstanceTasks.load(context, slave.id) for slave in master_instance_tasks.slaves] # Collect info from each slave post instance launch slave_detail = [slave_instance.get_replication_detail() for slave_instance in slave_instances] # Pass info of all replication nodes to the master for # replication setup completion master_detail = master_instance_tasks.get_replication_detail() master_instance_tasks.complete_master_setup(slave_detail) # Pass info of all replication nodes to each slave for # replication setup completion for slave_instance in slave_instances: slave_instance.complete_slave_setup(master_detail, slave_detail) # Push pending data/transactions from master to slaves master_instance_tasks.sync_data_to_slaves() # Set the status of all slave nodes to ACTIVE for slave_instance in slave_instances: slave_guest = remote.create_guest_client( slave_instance.context, slave_instance.db_info.id, slave_instance.datastore_version.manager) slave_guest.cluster_complete() finally: if replica_backup_created: Backup.delete(context, replica_backup_id)
def _create_replication_slave(self, context, instance_id, name, flavor, image_id, databases, users, datastore_manager, packages, volume_size, availability_zone, root_password, nics, overrides, slave_of_id, backup_id, volume_type, modules, access=None, ds_version=None): if type(instance_id) in [list]: ids = instance_id root_passwords = root_password else: ids = [instance_id] root_passwords = [root_password] replica_number = 0 replica_backup_id = backup_id replicas = [] master_instance_tasks = BuiltInstanceTasks.load(context, slave_of_id) server_group = master_instance_tasks.server_group scheduler_hints = srv_grp.ServerGroup.convert_to_hint(server_group) LOG.debug("Using scheduler hints %s for creating instance %s", scheduler_hints, instance_id) # Create backup for master snapshot = None try: instance_tasks = FreshInstanceTasks.load(context, ids[0]) snapshot = instance_tasks.get_replication_master_snapshot( context, slave_of_id, flavor, parent_backup_id=replica_backup_id) LOG.info('Snapshot info for creating replica of %s: %s', slave_of_id, snapshot) except Exception as err: LOG.error( 'Failed to get master snapshot info for creating ' 'replica, error: %s', str(err)) if snapshot and snapshot.get('dataset', {}).get('snapshot_id'): backup_id = snapshot['dataset']['snapshot_id'] Backup.delete(context, backup_id) raise # Create replicas using the master backup replica_backup_id = snapshot['dataset']['snapshot_id'] try: for replica_index in range(0, len(ids)): replica_number += 1 LOG.info(f"Creating replica {replica_number} " f"({ids[replica_index]}) of {len(ids)}.") instance_tasks = FreshInstanceTasks.load( context, ids[replica_index]) instance_tasks.create_instance(flavor, image_id, databases, users, datastore_manager, packages, volume_size, replica_backup_id, availability_zone, root_passwords[replica_index], nics, overrides, None, snapshot, volume_type, modules, scheduler_hints, access=access, ds_version=ds_version) replicas.append(instance_tasks) for replica in replicas: replica.wait_for_instance(CONF.restore_usage_timeout, flavor) LOG.info('Replica %s created successfully', replica.id) except Exception as err: LOG.error('Failed to create replica from %s, error: %s', slave_of_id, str(err)) raise finally: Backup.delete(context, replica_backup_id)
def _create_replication_slave(self, context, instance_id, name, flavor, image_id, databases, users, datastore_manager, packages, volume_size, availability_zone, root_password, nics, overrides, slave_of_id, backup_id, volume_type, modules): if type(instance_id) in [list]: ids = instance_id root_passwords = root_password else: ids = [instance_id] root_passwords = [root_password] replica_number = 0 replica_backup_id = backup_id replica_backup_created = False replicas = [] master_instance_tasks = BuiltInstanceTasks.load(context, slave_of_id) server_group = master_instance_tasks.server_group scheduler_hints = srv_grp.ServerGroup.convert_to_hint(server_group) LOG.debug("Using scheduler hints for locality: %s" % scheduler_hints) try: for replica_index in range(0, len(ids)): try: replica_number += 1 LOG.debug("Creating replica %d of %d." % (replica_number, len(ids))) instance_tasks = FreshInstanceTasks.load( context, ids[replica_index]) snapshot = instance_tasks.get_replication_master_snapshot( context, slave_of_id, flavor, replica_backup_id, replica_number=replica_number) replica_backup_id = snapshot['dataset']['snapshot_id'] replica_backup_created = (replica_backup_id is not None) instance_tasks.create_instance( flavor, image_id, databases, users, datastore_manager, packages, volume_size, replica_backup_id, availability_zone, root_passwords[replica_index], nics, overrides, None, snapshot, volume_type, modules, scheduler_hints) replicas.append(instance_tasks) except Exception: # if it's the first replica, then we shouldn't continue LOG.exception( _("Could not create replica %(num)d of %(count)d.") % { 'num': replica_number, 'count': len(ids) }) if replica_number == 1: raise for replica in replicas: replica.wait_for_instance(CONF.restore_usage_timeout, flavor) # Some datastores requires completing configuration of replication # nodes with information that is only available after all the # instances has been started. if (master_instance_tasks.post_processing_required_for_replication( )): slave_instances = [ BuiltInstanceTasks.load(context, slave.id) for slave in master_instance_tasks.slaves ] # Collect info from each slave post instance launch slave_detail = [ slave_instance.get_replication_detail() for slave_instance in slave_instances ] # Pass info of all replication nodes to the master for # replication setup completion master_detail = master_instance_tasks.get_replication_detail() master_instance_tasks.complete_master_setup(slave_detail) # Pass info of all replication nodes to each slave for # replication setup completion for slave_instance in slave_instances: slave_instance.complete_slave_setup( master_detail, slave_detail) # Push pending data/transactions from master to slaves master_instance_tasks.sync_data_to_slaves() # Set the status of all slave nodes to ACTIVE for slave_instance in slave_instances: slave_guest = remote.create_guest_client( slave_instance.context, slave_instance.db_info.id, slave_instance.datastore_version.manager) slave_guest.cluster_complete() finally: if replica_backup_created: Backup.delete(context, replica_backup_id)