def __check_config_is_right(self):
config = KSC_Configuration.load(utils.get_context(), self.config.id)
if not config:
raise Exception("create config, not write in db")
if self.name != config.name or self.description != config.description:
raise Exception("create config, name or description bad value")
if self.config.config_type != '1':
raise Exception("create config, config_type bad value")
overrides = KSC_Configuration.get_configuration_overrides(utils.get_context(), self.config.id)
diffs = {}
for k, v in self.values.iteritems():
if overrides[k] != v and float(overrides[k]) != float(v):
diffs[k] = (v, overrides[k])
if len(diffs):
raise Exception("create config, values error")
#
# if overrides != self.values:
# raise Exception("create config, values error")
datastore_version = DatastoreVersion.load_by_uuid(self.config.datastore_version_id)
if not datastore_version:
raise Exception("create config, bad value of datastore_version_id")
if datastore_version.name != self.datastore_version:
raise Exception("create config, bad value of datastore_version_id")
def unassign_configuration(self, flavor, configuration_id):
LOG.debug("Unassigning the configuration from the instance %s"
% self.id)
LOG.debug("Unassigning the configuration id %s"
% self.configuration.id)
def _find_item(items, item_name):
LOG.debug("items: %s" % items)
LOG.debug("item_name: %s" % item_name)
# find the item in the list
for i in items:
if i[0] == item_name:
return i
def _convert_value(value):
# split the value and the size e.g. 512M=['512','M']
pattern = re.compile('(\d+)(\w+)')
split = pattern.findall(value)
if len(split) < 2:
return value
digits, size = split
conversions = {
'K': 1024,
'M': 1024 ** 2,
'G': 1024 ** 3,
}
return str(int(digits) * conversions[size])
default_config = self._render_config_dict(flavor)
args = {
"ds_manager": self.ds_version.manager,
"config": default_config,
}
LOG.debug("default %(ds_manager)s section: %(config)s" % args)
LOG.debug("self.configuration: %s" % self.configuration.__dict__)
overrides = {}
config_items = KSC_Configuration.load_items(self.context, configuration_id)
for item in config_items:
LOG.debug("finding item(%s)" % item.__dict__)
try:
key, val = _find_item(default_config, item.configuration_key)
except TypeError:
val = None
#restart_required = inst_models.InstanceTasks.RESTART_REQUIRED
#self.update_db(task_status=restart_required)
if val:
overrides[item.configuration_key] = _convert_value(val)
LOG.debug("setting the default variables in dict: %s" % overrides)
self.update_overrides(overrides, remove=True)
self.update_db(configuration_id=None)
config_group = KSC_Configuration.load(self.context , configuration_id)
KSC_Configuration.delete(self.context, config_group)
def update(self, req, body, tenant_id, id):
LOG.info(_("Updating configuration for tenant id %s") % tenant_id)
context = req.environ[wsgi.CONTEXT_KEY]
group = models.Configuration.load(context, id)
datastore_args = body["configuration"].get("datastore", {})
datastore, datastore_version = ds_models.get_datastore_version(**datastore_args)
instances = instances_models.DBInstance.find_all(
tenant_id=context.tenant, configuration_id=id, deleted=False
).all()
# if name/description are provided in the request body, update the
# model with these values as well.
if "name" in body["configuration"]:
group.name = body["configuration"]["name"]
if "description" in body["configuration"]:
group.description = body["configuration"]["description"]
"""validate if params are valid"""
is_configuration_valid = False
validation_result = KSC_ConfigurationsController.validate_configuration(
context, body["configuration"]["values"], datastore_manager=datastore_version.manager
)
if instances:
current_config = KSC_Configuration.load(context, id)
validation_dynamic_result = KSC_Configuration.validate_dynamic_params(
context, current_config, instances, body["configuration"]["values"], dynamic_param=True
)
if validation_result or validation_dynamic_result:
if validation_dynamic_result:
validation_result.update(validation_dynamic_result)
elif not validation_result and not validation_dynamic_result:
is_configuration_valid = True
else:
if not validation_result:
is_configuration_valid = True
result = {"is_validate_pass": is_configuration_valid, "validation_result": validation_result}
if validation_result:
return wsgi.Result(result, 400)
else:
deleted_at = datetime.utcnow()
models.Configuration.remove_all_items(context, group.id, deleted_at)
LOG.info(_("loaded configuration instances: %s") % instances)
items = self.configuration_items_list(group, body["configuration"])
models.Configuration.save(context, group, items, instances)
result["is_validate_pass"] = is_configuration_valid
return wsgi.Result(result, 202)
def update(self):
self.create()
configuration_id = self.config.id
values = {"myisam_sort_buffer_size":115343360,"join_buffer_size":307200,'sort_buffer_size':327680}
valuesJson = json.dumps(values)
name = 'update_%s' % self.config.name
description = 'update_%s' % self.config.description
utils.configuration_update_byclient(configuration_id, valuesJson, name, description)
config = KSC_Configuration.load(utils.get_context(), configuration_id)
if config == self.config:
raise Exception("update config, something is not update, config = %s" % config)
override = KSC_Configuration.get_configuration_overrides(utils.get_context(), configuration_id)
if values == override:
raise Exception("update config, something is not update, config override = %s" % override)
def patch(self):
if not self.config:
self.create()
configuration_id = self.config.id
values = json.dumps({"myisam_sort_buffer_size":116391936,"join_buffer_size":409600})
utils.configuration_patch_byclient(configuration_id, values)
override = KSC_Configuration.get_configuration_overrides(utils.get_context(), configuration_id)
if values == override:
raise Exception("patch config, something is not update, override = %s" % override)
def edit(self, req, body, tenant_id, id):
context = req.environ[wsgi.CONTEXT_KEY]
group = models.Configuration.load(context, id)
datastore_args = body["configuration"].get("datastore", {})
datastore, datastore_version = ds_models.get_datastore_version(**datastore_args)
instances = instances_models.DBInstance.find_all(
tenant_id=context.tenant, configuration_id=id, deleted=False
).all()
LOG.info(_("loaded configuration instances: %s") % instances)
"""validate if params are valid"""
is_configuration_valid = False
validation_result = KSC_ConfigurationsController.validate_configuration(
context, body["configuration"]["values"], datastore_manager=datastore_version.manager
)
if instances:
current_config = KSC_Configuration.load(context, id)
validation_dynamic_result = (
KSC_Configuration.validate_dynamic_params(
context, current_config, instances, body["configuration"]["values"], dynamic_param=True
)
or {}
)
if validation_result or validation_dynamic_result:
validation_result.update(validation_dynamic_result)
elif not validation_result and not validation_dynamic_result:
is_configuration_valid = True
else:
if not validation_result:
is_configuration_valid = True
result = {"is_validate_pass": is_configuration_valid, "validation_result": validation_result}
if validation_result:
return wsgi.Result(result, 400)
else:
items = self.configuration_items_list(group, body["configuration"])
models.Configuration.save(context, group, items, instances)
result["is_validate_pass"] = is_configuration_valid
return wsgi.Result(result, 202)
def delete(self):
self.create()
#config_type = "1"
#config = utils.get_config_bytenant(config_type)
config = self.config
utils.configuration_delete_byclient(config.id)
is_OK = 0
#check ...
try:
config = KSC_Configuration.load(utils.get_context(), config.id)
except Exception as e:
is_OK = 1
try:
override = KSC_Configuration.get_configuration_overrides(utils.get_context(), config.id)
except Exception as e1:
is_OK = is_OK + 1
if is_OK != 2:
raise Exception("delete config, no delete success..")
def patch_new(self):
if not self.config:
self.create_new()
configuration_id = self.config.id
values = {"myisam_sort_buffer_size":'xxx',"join_buffer_size":'xxx'}
# values = json.dumps({"myisam_sort_buffer_size":116391936,"join_buffer_size":409600})
utils.configuration_patch_byclient(configuration_id, json.dumps(values))
override = KSC_Configuration.get_configuration_overrides(utils.get_context(), configuration_id)
for k, v in values.iteritems():
if override.get(k) != v:
# if values == override:
raise Exception("patch config, something is not update, override = %s" % override)
def create_instance(self, flavor, image_id, databases, users,
service_type, volume_size, security_groups,
backup_id, instance_type, ignore_hosts=None,
master_id=None, extend=None):
if instance_type==DBInstanceType.STANDBY or instance_type==DBInstanceType.READ_REPLI:
if master_id is None:
raise Exception("when instance_type is STANDBY or RR, The master_id can't none")
availability_zone=None
overrides = {}
if extend != None:
availability_zone=extend.get('availability_zone', None)
ds_version_id = extend.get('datastore_version_id', None)
overrides = extend.get('overrides', {})
self.update_db(task_status=InstanceTasks.BUILDING_SERVER)
try:
server, volume_info = self._create_server_volume_individually(
flavor,
image_id,
security_groups,
service_type,
ignore_hosts, availability_zone)
except Exception as e:
self.set_servicestatus(ServiceStatuses.UNKNOWN)
raise e
try:
configuration_id =self.db_info.configuration_id
LOG.debug("Prepare task instance id = %s, configuration id =%s" % (self.id, configuration_id))
overrides = KSC_Configuration.get_configuration_overrides(self.context, configuration_id)
except Exception:
pass
self.update_db(task_status=InstanceTasks.GUEST_PREPARE)
LOG.info("======= > groupid %s" % self.group_id)
group = InstanceGroup.get_by_groupid(self.context, self.group_id)
sys_variables = {"port" : group.db_port, "read_only" : "OFF" if instance_type in (DBInstanceType.MASTER, DBInstanceType.SINGLE) else "ON"}
overrides.update(sys_variables)
config = self._render_config(flavor)
overrides_config = self._render_override_config(flavor, overrides)
self._guest_prepare(server, flavor['ram'], volume_info,
databases, users, backup_id,
config.config_contents,
overrides_contents = overrides_config.config_contents)
try:
utils.poll_until(self._service_is_active,
sleep_time=USAGE_SLEEP_TIME,
time_out=USAGE_TIMEOUT)
except Exception as e:
self.set_servicestatus(ServiceStatuses.UNKNOWN)
raise e
group_item = InstanceGroupItem.get_by_instance_id(self.context, self.id)
group_id = group_item.group_id
self.update_db(task_status=InstanceTasks.CONFIG_MYSQL)
if instance_type==DBInstanceType.STANDBY or instance_type==DBInstanceType.READ_REPLI:
if instance_type==DBInstanceType.STANDBY:
self._update_instance_type(master_id, DBInstanceType.MASTER)
self._update_instance_type(self.id, instance_type)
self._relocate_master(master_id,self.id,backup_id)
#when upgrade single to ha
if instance_type == DBInstanceType.STANDBY:
master_group_item = InstanceGroupItem.get_by_instance_id(self.context,master_id)
InstanceGroupItem.update_type(self.context, item_id=master_group_item.id, type=DBInstanceType.MASTER)
if instance_type==DBInstanceType.SINGLE or instance_type==DBInstanceType.MASTER:
self._create_master_user(instance_id=self.id, user=extend.get('admin_user'), \
password=extend.get('admin_password'))
self._update_instance_type(self.id, instance_type)
if instance_type==DBInstanceType.SINGLE or instance_type==DBInstanceType.MASTER:
try:
self.update_db(task_status=InstanceTasks.BACKUPING)
expiretime = AutoBackup.get_autobackup_expiretime(self.context, group_id)
backup_name = self._backup_name(instance_id=self.id)
# Fore. 2014/07/02 Get Service Image ID from datastore version
# _type = self.service_type
# _image = ServiceImage.find_by(self.context,service_name=_type)
#ds, ds_version = ds_models.get_datastore_version(type = None, version = ds_version_id)
#service_image_id = image_id
desc = 'Init backup for new instance'
Backup.create(context=self.context, instance=self.id,
name=backup_name, description=desc, group_id=group_id,
backup_type=BackupType.AUTOBACKUP, expire_at=expiretime,init=True,service_image_id=image_id)
except Exception as e:
msg = "Error creating backup for instance %s %s" % (self.id,utils.get_traceback_stack())
LOG.error(msg)
self.update_db(task_status=InstanceTasks.SETIOTUNE)
LOG.debug("Set block iotune for instance %s ." % self.id)
self._set_blkiotune(flavor)
if instance_type!=DBInstanceType.STANDBY:
if CONF.trove_vip_support:
self.update_db(task_status=InstanceTasks.ALLOCATE_VIP)
try:
rip = self._get_instance_ip(self.id)
vip = InstanceVip.allocate(self.context,instance_id=self.id,rip = rip)
LOG.debug("Allocated vip %s for instance %s"%(vip, self.id))
except Exception as e:
self.set_servicestatus(ServiceStatuses.UNKNOWN)
raise e
self.update_db(deleted=False,task_status=InstanceTasks.NONE)
LOG.info("create instance_id:%s,notify monitor,autobackup" % self.id)
group_rpcapi.API(self.context).group_update(group_id)
self.send_usage_event('create', instance_size=flavor['ram'])