def create_instance(self, context, instance_id, name, flavor, image_id,
databases, users, service_type, volume_size,
security_groups, backup_id):
instance_tasks = FreshInstanceTasks.load(context, instance_id)
instance_tasks.create_instance(flavor, image_id, databases, users,
service_type, volume_size,
security_groups, backup_id)
def create_instance(self, context, instance_id, name, flavor, image_id,
databases, users, service_type, volume_size, backup_id,
availability_zone, root_password):
instance_tasks = FreshInstanceTasks.load(context, instance_id)
instance_tasks.create_instance(flavor, image_id, databases, users,
service_type, volume_size, backup_id,
availability_zone, root_password)
def create_instance(self, context, instance_id, name, flavor,
image_id, databases, users, datastore_manager,
packages, volume_size, backup_id, availability_zone,
root_password, nics, overrides, slave_of_id,
cluster_config):
if slave_of_id:
self._create_replication_slave(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)
else:
if type(instance_id) in [list]:
raise AttributeError(_(
"Cannot create multiple non-replica instances."))
instance_tasks = FreshInstanceTasks.load(context, instance_id)
instance_tasks.create_instance(flavor, image_id, databases, users,
datastore_manager, packages,
volume_size, backup_id,
availability_zone, root_password,
nics, overrides, cluster_config)
timeout = (CONF.restore_usage_timeout if backup_id
else CONF.usage_timeout)
instance_tasks.wait_for_instance(timeout, flavor)
def _create_instance(self, context, instance_id, name, flavor, image_id,
databases, users, datastore_manager, packages,
volume_size, backup_id, availability_zone,
root_password, nics, overrides, slave_of_id,
cluster_config, volume_type, modules, locality):
if slave_of_id:
self._create_replication_slave(
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)
else:
if type(instance_id) in [list]:
raise AttributeError(
_("Cannot create multiple non-replica instances."))
instance_tasks = FreshInstanceTasks.load(context, instance_id)
scheduler_hints = srv_grp.ServerGroup.build_scheduler_hint(
context, locality, instance_id)
instance_tasks.create_instance(
flavor, image_id, databases, users, datastore_manager,
packages, volume_size, backup_id, availability_zone,
root_password, nics, overrides, cluster_config, None,
volume_type, modules, scheduler_hints)
timeout = (CONF.restore_usage_timeout
if backup_id else CONF.usage_timeout)
instance_tasks.wait_for_instance(timeout, flavor)
def create_instance(self, context, instance_id, name, flavor,
image_id, databases, users, service_type,
volume_size, backup_id, availability_zone,
root_password):
instance_tasks = FreshInstanceTasks.load(context, instance_id)
instance_tasks.create_instance(flavor, image_id, databases, users,
service_type, volume_size, backup_id,
availability_zone, root_password)
def create_instance(self, context, instance_id, name, flavor_id,
flavor_ram, image_id, databases, users, service_type,
volume_size, security_groups, backup_id):
instance_tasks = FreshInstanceTasks.load(context, instance_id)
instance_tasks.create_instance(flavor_id, flavor_ram, image_id,
databases, users, service_type,
volume_size, security_groups,
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 _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_instance(self, context, instance_id, name, flavor,
image_id, databases, users, datastore_manager,
packages, volume_size, backup_id, availability_zone,
root_password, nics, overrides):
instance_tasks = FreshInstanceTasks.load(context, instance_id)
instance_tasks.create_instance(flavor, image_id, databases, users,
datastore_manager, packages,
volume_size, backup_id,
availability_zone, root_password, nics,
overrides)
def create_instance(self, context, instance_id, name, flavor,
image_id, databases, users, datastore_manager,
packages, volume_size, backup_id, availability_zone,
root_password, nics, overrides):
instance_tasks = FreshInstanceTasks.load(context, instance_id)
instance_tasks.create_instance(flavor, image_id, databases, users,
datastore_manager, packages,
volume_size, backup_id,
availability_zone, root_password, nics,
overrides)
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 _relocate_master(self, master_id, slave_id,backup_id=None):
'''
Fore. 2014/9/29 desperated method. don't use it.
:param master_id:
:param slave_id:
:param backup_id:
'''
master_group_item = InstanceGroupItem.get_by_instance_id(self.context, master_id)
def __show_master_status(inst_id):
_instance = self.load(self.context, inst_id)
_guest = _instance.get_guest()
mStatus = _guest.ksc_show_master_status()
log_path, log_pos = mStatus['file'], mStatus['position']
return log_path, log_pos
if backup_id is None:
log_path, log_pos = __show_master_status(master_id)
else:
bk_info = Backup.get_by_id(self.context, backup_id)
if master_group_item.group_id == bk_info.group_id:
log_path, log_pos = Backup.get_binlog_info(self.context, backup_id)
else:
log_path, log_pos = __show_master_status(master_id)
LOG.debug("relocate master instance %s get binlog_path:%s binlog_pos:%s" \
%(master_id, log_path, log_pos))
group_item = master_group_item
master_host = self._get_instance_ip(master_id)
master_guest = FreshInstanceTasks.load(self.context, master_id).guest
master_port = int(master_guest.ksc_list_variables(["port"])["port"])
repl_user = CONF.rds_rpl_user
repl_password = self._gen_rpl_user_password(group_item.group_id)
master_log_file = log_path
master_log_pos = log_pos
slave_instance = self.load(self.context, slave_id)
slave_guest = slave_instance.get_guest()
slave_guest.ksc_relocate_master(master_host=master_host, master_port = master_port, repl_user=repl_user,
repl_password=repl_password, master_log_file=master_log_file,
master_log_pos=master_log_pos)
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)
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)
instance_tasks.attach_replication_slave(snapshot)
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)
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)
instance_tasks.attach_replication_slave(snapshot)
def create_instance(self, context, instance_id, name, flavor,
image_id, databases, users, datastore_manager,
packages, volume_size, backup_id, availability_zone,
root_password, nics, overrides, slave_of_id,
cluster_config):
if slave_of_id:
self._create_replication_slave(context, instance_id, name,
flavor, image_id, databases, users,
datastore_manager, packages,
volume_size,
availability_zone, root_password,
nics, overrides, slave_of_id)
else:
instance_tasks = FreshInstanceTasks.load(context, instance_id)
instance_tasks.create_instance(flavor, image_id, databases, users,
datastore_manager, packages,
volume_size, backup_id,
availability_zone, root_password,
nics, overrides, cluster_config)
def _create_instance(self, context, instance_id, name, flavor, image_id,
databases, users, datastore_manager, packages,
volume_size, backup_id, availability_zone,
root_password, nics, overrides, slave_of_id,
cluster_config, volume_type, locality):
if slave_of_id:
self._create_replication_slave(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)
else:
if type(instance_id) in [list]:
raise AttributeError(
_("Cannot create multiple non-replica instances."))
instance_tasks = FreshInstanceTasks.load(context, instance_id)
scheduler_hints = None
if locality:
try:
server_group = instance_tasks.create_server_group(locality)
scheduler_hints = self._convert_server_group_to_hint(
server_group)
except Exception as e:
msg = (_("Error creating '%(locality)s' server group for "
"instance %(id)s: $(error)s") % {
'locality': locality,
'id': instance_id,
'error': e.message
})
LOG.exception(msg)
raise
instance_tasks.create_instance(flavor, image_id, databases, users,
datastore_manager, packages,
volume_size, backup_id,
availability_zone, root_password,
nics, overrides, cluster_config,
None, volume_type, scheduler_hints)
timeout = (CONF.restore_usage_timeout
if backup_id else CONF.usage_timeout)
instance_tasks.wait_for_instance(timeout, flavor)
def create_instance(self, context, instance_id, name, flavor,
image_id, databases, users, datastore_manager,
packages, volume_size, backup_id, availability_zone,
root_password, nics, overrides, slave_of_id,
cluster_config):
if slave_of_id:
self._create_replication_slave(context, instance_id, name,
flavor, image_id, databases, users,
datastore_manager, packages,
volume_size,
availability_zone, root_password,
nics, overrides, slave_of_id)
else:
instance_tasks = FreshInstanceTasks.load(context, instance_id)
instance_tasks.create_instance(flavor, image_id, databases, users,
datastore_manager, packages,
volume_size, backup_id,
availability_zone, root_password,
nics, overrides, cluster_config)
def _create_instance(self, context, instance_id, name, flavor,
image_id, databases, users, datastore_manager,
packages, volume_size, backup_id, availability_zone,
root_password, nics, overrides, slave_of_id,
cluster_config, volume_type, locality):
if slave_of_id:
self._create_replication_slave(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)
else:
if type(instance_id) in [list]:
raise AttributeError(_(
"Cannot create multiple non-replica instances."))
instance_tasks = FreshInstanceTasks.load(context, instance_id)
scheduler_hints = None
if locality:
try:
server_group = instance_tasks.create_server_group(locality)
scheduler_hints = self._convert_server_group_to_hint(
server_group)
except Exception as e:
msg = (_("Error creating '%(locality)s' server group for "
"instance %(id)s: $(error)s") %
{'locality': locality, 'id': instance_id,
'error': e.message})
LOG.exception(msg)
raise
instance_tasks.create_instance(flavor, image_id, databases, users,
datastore_manager, packages,
volume_size, backup_id,
availability_zone, root_password,
nics, overrides, cluster_config,
None, volume_type, scheduler_hints)
timeout = (CONF.restore_usage_timeout if backup_id
else CONF.usage_timeout)
instance_tasks.wait_for_instance(timeout, flavor)
def restore_instance(self, context, packages, flavor, datastore_manager,
instance_id, image_id, backup_id):
instance_tasks = models.BuiltInstanceTasks.load(context, instance_id)
new_tasks = FreshInstanceTasks.load(context, instance_id)
volume_info = new_tasks._build_volume_info(datastore_manager, instance_tasks.volume_size)
instance_tasks.reattach_volume(volume_info['volumes'][0]['id'])
files = new_tasks._get_injected_files(datastore_manager)
instance_tasks.rebuild(image_id, files)
backup_info = None
if backup_id is not None:
backup = models.bkup_models.Backup.get_by_id(context, backup_id)
backup_info = {'id': backup_id,
'location': backup.location,
'type': backup.backup_type,
'checksum': backup.checksum,
}
'''
device_path = instance_tasks.device_path
mount_point = CONF.get(datastore_manager).mount_point
volume_info = {'block_device': None,
'device_path': device_path,
'mount_point': mount_point,
'volumes': None,
}
'''
config = new_tasks._render_config(flavor)
LOG.info(_("config is %s") % config)
LOG.info(_("volume info is %s") % volume_info )
new_tasks._guest_prepare(flavor['ram'],
volume_info,
packages=packages,
databases=None,
users=None,
backup_info=backup_info,
config_contents=config.config_contents)
timeout = CONF.restore_usage_timeout
new_tasks.wait_for_restore(timeout, flavor, backup_id)
def _delete_resources(self, fake):
group_item = InstanceGroupItem.get_by_instance_id(self.context, self.id)
group_id = group_item.group_id
inst_type = group_item.type
instance_id = self.db_info.id
if self.server and self.db_info.server_status == "ACTIVE":
# set instance to read only model
LOG.info("Set readonly for instance %s" % self.id)
self._set_instance_readonly(instance_id=self.id)
else:
LOG.info("vm_status is not ACTIVE for %s" % self.id)
if inst_type == DBInstanceType.MASTER:
rrinsts = []
try:
standby = InstanceGroupItem.get_by_gid_type(self.context, group_id, DBInstanceType.STANDBY)
rrinsts = InstanceGroupItem.get_by_gid_type(self.context, group_id, DBInstanceType.READ_REPLI)
standby_inst_id = standby.instance_id
LOG.info("MASTER %s,it hava STANDBY %s,RRS %s",
(self.id, standby_inst_id, [_inst.instance_id for _inst in rrinsts]))
InstanceGroupItem.delete(self.context, standby_inst_id)
except Exception as e:
LOG.error(utils.get_traceback_stack())
# waite replication group db sysnc
if len(rrinsts) > 0:
self.guest.ksc_set_read_only(True)
for _inst in rrinsts:
try:
rr_instance = self.load(self.context, _inst.instance_id)
rr_instance.waite_rpl_synchronize(time_out=CONF.delete_waite_rplg_sync)
except Exception as e:
LOG.error(utils.get_traceback_stack())
# delete standby instance
try:
try:
standby_instance = self.load(self.context, standby_inst_id)
except exception.UnprocessableEntity:
standby_instance = FreshInstanceTasks.load(self.context, standby_inst_id)
standby_instance.update_db(deleted=True, deleted_at=utils.utcnow(), task_status=InstanceTasks.NONE)
standby_instance.set_servicestatus_deleted()
standby_instance._delete_instance_config()
if standby_instance.server:
LOG.info("Delete STANDBY compute server %s" % standby_instance.server.id)
standby_instance.get_guest().delete_queue()
standby_instance.server.delete()
poll_until(standby_instance.server_is_finished, sleep_time=1, time_out=CONF.server_delete_time_out)
else:
LOG.info("standby instance vm_status is not ACTIVE for %s" % standby_inst_id)
except Exception as e:
LOG.error(utils.get_traceback_stack())
if fake is True and self.type == DBInstanceType.MASTER:
try:
LOG.debug("fake is True, %s is MASTER, stop mysqld", self.id)
self.guest.ksc_stop_db(do_not_start_on_reboot=True)
except Exception as e:
msg = "fake_delete, instance: %s, stop mysqld error, exception: %s " % (self.id, str(e))
LOG.error("%s, %s", msg, utils.get_traceback_stack())
AlarmRpc(self.context).alarm(self.tenant_id, level=AlarmRpc.LEVEL_ERROR,
_type=AlarmRpc.TYPE_TASKMANAGER, message=msg)
if self.server:
if fake is True and self.type == DBInstanceType.MASTER:
LOG.debug("fake is True, %s is MASTER, skip delete server", self.id)
else:
try:
LOG.info("Delete compute server %s" % self.server.id)
guest = self.get_guest()
guest.delete_queue()
self.server.delete()
poll_until(self.server_is_finished, sleep_time=1, time_out=CONF.server_delete_time_out)
except Exception as e:
LOG.error(utils.get_traceback_stack())
# delete group_item/autobackup_setting/group
if self.type in [DBInstanceType.MASTER, DBInstanceType.SINGLE]:
try:
LOG.info("Delete autobackup_setting of group_id %s" % group_id)
AutoBackup.delete(self.context, group_id)
except:
LOG.error(utils.get_traceback_stack())
# remove vip.
if CONF.trove_vip_support and \
self.type in [DBInstanceType.MASTER, DBInstanceType.SINGLE, DBInstanceType.READ_REPLI]:
if fake is True and self.type == DBInstanceType.MASTER:
LOG.debug("fake is True, %s is MASTER, skip release vip", self.id)
else:
try:
self.update_db(task_status=InstanceTasks.RELEASE_VIP)
LOG.info("release vip for instance %s" % instance_id)
if inst_type in [DBInstanceType.MASTER, DBInstanceType.SINGLE]:
cur_vip = vipService.InstanceVip.get_by_instance_id(self.context, instance_id)
vipService.InstanceVip.release_vip(self.context, cur_vip)
elif inst_type in [DBInstanceType.READ_REPLI]:
vipService.InstanceVip.deallocate(self.context, instance_id, deleted=False, purge=True)
except Exception as e:
LOG.error(utils.get_traceback_stack())
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)
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)
