def restore_instance_backup(payload):
resource_id = payload.pop("resource_id", None)
backup_id = payload.pop("backup_id")
action = payload.pop("action")
version = payload.pop("version")
backup_info = InstanceBackupModel.get_backup_by_id(backup_id=backup_id)
backup_uuid = backup_info.uuid
if resource_id is not None:
try:
resource_uuid = InstancesModel.get_instance_by_id(
instance_id=resource_id).uuid
except Exception:
error_info = "cannot find instance with instance_id " \
+ resource_id
return console_response(BackupErrorCode.RESTORE_RESOURCE_NOT_FOUND,
error_info)
else:
payload.update({"action": "DescribeImage", "image_id": backup_uuid})
# resp = api.get(payload=payload, timeout=10)
resp = api.get(payload=payload)
if resp.get("code") != 0:
return console_response(CommonErrorCode.REQUEST_API_ERROR,
resp.get("msg"))
elif resp["data"]["total_count"] <= 0:
return console_response(
BackupErrorCode.ASSOCIATE_INSTANCE_NOT_FOUND,
"the instance related to the backup "
"cannot be found, may be it has already"
" been deleted")
resource_uuid = resp["data"]["ret_set"][0]["instance_uuid"]
resource_record = InstancesModel.get_instance_by_uuid(resource_uuid)
if resource_record:
resource_id = resource_record.instance_id
payload.update({
"action": action,
"version": version,
"instance_id": resource_uuid,
"image_id": backup_uuid
})
# resp = api.get(payload=payload, timeout=10)
resp = api.get(payload=payload)
msg = resp.get("msg")
if msg is None:
msg = "Success"
code = 0
if resp.get("code") != 0:
code = CommonErrorCode.REQUEST_API_ERROR
return console_response(code, msg, 1, [{
"instance_id": resource_id,
"backup_id": backup_id
}], {"source_backup_id": resource_id})
def join_base_net(payload):
instance_id = payload.pop('instance_id')
payload.update({
'instance_id':
InstancesModel.get_instance_by_id(instance_id=instance_id).uuid
})
mode = 'base-net'
payload.update({'mode': mode})
# flag indicate the instance has not join public net
flag = has_joined_ext_network(instance_id)
if flag:
return console_response(code=ErrorCode.net.JOIN_PUBLIC_NET_CONFLICT,
msg=_(u"%s has joined public net or base-net" %
instance_id))
# call api
# resp = api.get(payload=payload, timeout=10)
resp = api.get(payload=payload)
code = resp["code"]
msg = resp["msg"]
api_code = resp.get('data', {}).get("ret_code", -1)
api_status = resp['api_status']
if code != Code.OK:
logger.error(
"%s join base-net error: api_ret_code (%d), api_status (%d), msg (%s)"
% (instance_id, api_code, api_status, msg))
code, msg = ErrorCode.net.JOIN_BASE_NET_FAILED, msg
response = console_response(code=code, msg=msg)
else:
code, msg = Code.OK, "succ"
response = console_response(code=code, msg=msg)
return response
def detach_keypair_impl(payload):
"""
Detach keypair
"""
instances = payload.pop("instances")
ret_set = []
succ_num = 0
ret_code, ret_msg = 0, "succ"
for instance_id in instances:
instance_uuid = InstancesModel.get_instance_by_id(instance_id).uuid
payload["server"] = instance_uuid
_payload = deepcopy(payload)
# call backend api
# resp = api.get(payload=_payload, timeout=60)
resp = api.get(payload=_payload)
if resp["code"] != 0:
ret_code = CommonErrorCode.REQUEST_API_ERROR
ret_msg = resp["msg"]
continue
ret_set.append(instance_id)
succ_num += 1
return console_response(ret_code, ret_msg, succ_num, ret_set)
def get_apply_instance_info(payload):
payload.update({"action": "DescribeSecurityGroupResource"})
# resp = api.get(payload=payload, timeout=10)
resp = api.get(payload=payload)
new_result = []
ret_code = resp.get("code")
if ret_code == 0:
result = resp.get("data").get("ret_set")
ins_uuid_set = set()
for i in range(0, len(result)):
applied_ins_info = result[i]
ins_uuid = applied_ins_info.get("instance_id")
if ins_uuid in ins_uuid_set:
continue
else:
ins_uuid_set.add(ins_uuid)
try:
ins_model = InstancesModel.get_instance_by_uuid(uuid=ins_uuid)
ins_id = ins_model.instance_id
name = ins_model.name
applied_ins_info["instance_id"] = ins_id
applied_ins_info["name"] = name
new_result.append(result[i])
except Exception as exp:
logger.error(str(exp))
return new_result
def get_keypair_instances(zone, owner, keypair_id):
"""
Get keypair related instances
"""
payload = {
"zone": zone,
"owner": owner,
"action": "DescribeKeyPairsResource",
"name": keypair_id
}
instances = []
resp = api.get(payload)
if resp["code"] != 0 and resp["data"].get("total_count", 0) <= 0:
return instances
infos = resp["data"]["ret_set"]
for info in infos:
instance_uuid = info["instance_id"]
instance_inst = InstancesModel.get_instance_by_uuid(instance_uuid)
if instance_inst:
info.update({"instance_id": instance_inst.instance_id})
info.update({"instance_name": instance_inst.name})
instances.append(info)
return instances
def resize_instance_confirm_impl(payload):
"""
Confirm Resize an instance's flavor
"""
if not payload:
return
# update instance_id
instance_id = payload["instance_id"]
instance_uuid = payload.pop("instance_uuid")
payload.update({"instance_id": instance_uuid})
instance_type_id = payload["instance_type_id"]
instance_ins = InstancesModel.get_instance_by_id(instance_id)
charge_mode = instance_ins.charge_mode
# call backend api
# resp = api.get(payload=payload, timeout=10)
resp = api.get(payload=payload)
if resp["code"] != 0:
logger.error("instance resize confirm failed: %s" % resp["msg"])
return
# save the changes
try:
instance_type_ins \
= InstanceTypeModel.get_instance_type_by_id(instance_type_id)
instance_ins.instance_type = instance_type_ins
instance_ins.save()
except Exception as exp:
logger.error("unable to save the flavor changes to db")
return
def leave_base_net(payload):
instance_id = payload.pop('instance_id')
payload.update({
'instance_id':
InstancesModel.get_instance_by_id(instance_id=instance_id).uuid
})
mode = 'base-net'
payload.update({'mode': mode})
# call api
# resp = api.get(payload=payload, timeout=10)
resp = api.get(payload=payload)
code = resp["code"]
msg = resp["msg"]
api_code = resp.get('data', {}).get("ret_code", -1)
api_status = resp['api_status']
if resp["code"] != Code.OK:
logger.error(
"%s leave base-net error: api_ret_code (%d), api_status (%d), msg (%s)"
% (instance_id, api_code, api_status, msg))
code, msg = ErrorCode.net.LEAVE_BASE_NET_FAILED, msg
response = console_response(code=code, msg=msg)
else:
code, msg = Code.OK, "succ"
response = console_response(code=code, msg=msg)
return response
def get_binding_instance(instance_uuid):
instance_inst = InstancesModel.get_instance_by_uuid(instance_uuid)
if not instance_inst:
return {}
instance = {
"instance_id": instance_inst.instance_id,
"instance_name": instance_inst.name
}
return instance
def leave_nets(payload):
"""
leave net
"""
NetsModel.update_nets_model()
instance_id = payload.pop("instance_id", [])
instance_uuid = InstancesModel.get_instance_by_id(
instance_id=instance_id).uuid
payload.update({"instance_id": instance_uuid})
net_id_list = payload.pop("net_id_list", [])
leave_status = []
succ_num = 0
for net_id in net_id_list:
_payload = deepcopy(payload)
inst = NetsModel.objects.get(uuid=net_id)
uuid = inst.uuid
_payload.update({"subnet_id": uuid})
_payload.update({
"network_id":
NetworksModel.get_network_by_id(network_id=inst.network_id).uuid
})
# call api
# resp = api.get(payload=_payload, timeout=10)
resp = api.get(payload=_payload)
code = resp["code"]
msg = resp["msg"]
api_code = resp.get('data', {}).get("ret_code", -1)
api_status = resp['api_status']
if code != Code.OK:
leave_status.append({'net_id': net_id, 'msg': msg})
logger.error(
"LeaveNets %s error: api_ret_code (%d), api_status (%d), msg (%s)"
% (instance_id, api_code, api_status, msg))
continue
leave_status.append({'net_id': net_id, 'msg': "Success"})
succ_num += 1
# judge whether instance leave all nets success
if succ_num != len(net_id_list):
code, msg = Code.ERROR, "error"
response = console_response(code=ErrorCode.net.LEAVE_NETS_FAILED,
msg=msg,
total_count=len(leave_status),
ret_set=leave_status)
else:
code, msg = Code.OK, "succ"
response = console_response(code=code,
msg=msg,
total_count=len(leave_status),
ret_set=leave_status)
return response
def sync_quota(resource, _payload):
ret_set = []
extra_infos = RESOURCE_TO_DESC_EXTRA_PARA.get(resource)
func = RESOURCE_TO_DESC_FUN.get(resource)
for extra_info in extra_infos:
resp = func(dict(_payload, **extra_info))
if resp.get("ret_code") != 0:
logger.error("cannot get the resource list of %s" %
unicode(resource))
return
ret_set += resp.get("ret_set")
if resource != "net":
value = len(ret_set)
# add logic for pre-pay
resource_ids = []
records = []
pre_pay_num = 0
if resource == 'disk':
for disk_info in ret_set:
resource_ids.append(disk_info.get('disk_id'))
records = DisksModel.get_exact_disks_by_ids(resource_ids)
elif resource == 'instance':
for inst_info in ret_set:
resource_ids.append(inst_info.get('instance_id'))
records = InstancesModel.get_exact_instances_by_ids(resource_ids)
elif resource == 'backup':
for backup_info in ret_set:
resource_ids.append(backup_info.get('backup_id'))
records_fir = InstanceBackupModel.\
get_exact_backups_by_ids(resource_ids)
records_sec = DiskBackupModel.get_exact_backups_by_ids(
resource_ids)
for record in records_fir:
records.append(record)
for record in records_sec:
records.append(record)
elif resource == 'pub_ip':
for ip_info in ret_set:
resource_ids.append(ip_info.get('ip_id'))
records = IpsModel.get_exact_ips_by_ids(resource_ids)
if len(records) > 0:
for record in records:
if getattr(record, 'charge_mode') != "pay_on_time":
pre_pay_num += 1
value -= pre_pay_num
payload = deepcopy(_payload)
q_type = RESOURCE_TO_GENERAL_QTYPE.get(resource, None)
if q_type:
payload.update({"quota_type": q_type})
synchronize_visible_to_db(payload, value)
# special quota sync
if resource in SYNC_QUOTA_FUNC.keys():
func = SYNC_QUOTA_FUNC.get(resource)
func(ret_set, _payload["owner"], _payload["zone"])
def create_instance_backup(payload):
_backup_name = payload.pop("backup_name") # 用于前端展示的备份的名称
_resource_id = payload.pop("resource_id")
_version = payload.get("version")
_owner = payload.get("owner")
_zone = payload.get("zone")
_action = payload.get("action")
charge_mode = payload.get("charge_mode")
backup_id = payload["name"]
instance_to_image = payload.get("instance_to_image")
resource_uuid = InstancesModel.get_instance_by_id(
instance_id=_resource_id).uuid
cr = get_backup_instance_info(payload, resource_uuid, logger)
if cr.get("ret_code") != 0:
return cr
image_uuid = cr["ret_set"][0]["image"].get("id", None)
image_info = get_backup_instance_image_info(image_uuid, _zone, logger)
platform = image_info.get("platform", 'linux')
system = image_info.get("system", 'unknown system')
image_name = image_info.get("image_name", system)
payload.update({
"action": _action,
"server": resource_uuid,
"version": _version,
"name": backup_id,
"backup_type": "instance",
"rotation": 100
})
if instance_to_image:
payload.update({"image_base_type": "private_image"})
_resp = api.get(payload=payload)
if _resp.get("code") == 0:
uuid = _resp["data"]["ret_set"][0]["snapshot_uuid"]
_inst, err = InstanceBackupModel.objects.create(
zone=_zone,
owner=_owner,
backup_id=backup_id,
system=system,
backup_name=_backup_name,
uuid=uuid,
backup_type="instance",
platform=platform,
image_name=image_name,
charge_mode=charge_mode)
if err is not None:
return console_response(BackupErrorCode.SAVE_BACKUP_FAILED,
str(err))
# source_backup_id is added for record action
return console_response(0, "Success", 1, [backup_id],
{"source_backup_id": _resource_id})
else:
return console_response(CommonErrorCode.REQUEST_API_ERROR,
_resp.get("msg"))
def list(cls, payload):
data = payload.get('data')
owner = data.get('owner')
zone = data.get('zone')
zone_model = ZoneModel.get_zone_by_name(zone)
account = AccountService.get_by_owner(owner)
jumper_instance_set = InstancesModel.get_instances_by_owner(
owner, zone).filter(role="jumpserver", deleted=1, destroyed=0)
jumper_detail_list, total_count = InstanceService.render_with_detail(
jumper_instance_set, account, zone_model)
return console_response(code=0, ret_set=jumper_detail_list)
def get_resource_name(device_name):
resource_name = device_name
if device_name.startswith("d-"):
resource_name = DisksModel.get_disk_by_id(device_name)
elif device_name.startswith("i-"):
resource_name = InstancesModel.get_instance_by_id(device_name)
elif device_name.startswith("lb-"):
resource_name = LoadbalancerModel.get_lb_by_id(device_name)
elif device_name.startswith("lbl-"):
resource_name = ListenersModel.get_lbl_by_id(device_name)
elif device_name.startswith("rds-"):
resource_name = RdsModel.get_rds_by_id(device_name)
if isinstance(resource_name, BaseModel):
resource_name = resource_name.name
return resource_name
def filter_subnet_pubips(ip_set):
ip_list = list()
for item in ip_set:
ip_addr = item.get("floating_ip_address")
ip_status = item.get("status")
ip_uuid = item.get("id")
binding_resource = item.get("binding_resource")
ip_id = 'Unkonw'
ip_name = 'Unknow'
bandwidth = -1
create_datetime = 0
# 根据 ip 地址的 uuid 查询数据库表 ips ，可以获得 ID、名称、计费模式、带宽、分配时间
ip_obj = IpsModel.get_ip_by_uuid(ip_uuid)
if ip_obj:
ip_id = ip_obj.ip_id
ip_name = ip_obj.name
bandwidth = ip_obj.bandwidth
create_datetime = datetime_to_timestamp(ip_obj.create_datetime)
instance_uuid = binding_resource.get("instance_id")
if instance_uuid:
instance_inst = InstancesModel.get_instance_by_uuid(instance_uuid)
if instance_inst:
instance_id = instance_inst.instance_id
instance_name = instance_inst.name
binding_resource["instance_id"] = instance_id
binding_resource["instance_name"] = instance_name
router_uuid = binding_resource.get("router_id")
if router_uuid:
router_inst = RoutersModel.get_router_by_uuid(router_uuid)
if router_inst:
router_id = router_inst.router_id
router_name = router_inst.name
binding_resource["router_id"] = router_id
binding_resource["router_name"] = router_name
ip_list.append({
"ip_id": ip_id,
"ip_name": ip_name,
"ip_addr": ip_addr,
"ip_status": ip_status,
"bandwidth": bandwidth,
"binding_resource": json.dumps(binding_resource),
"create_datetime": create_datetime
})
return ip_list
def get_resource_inst_by_uuid(backup_type, uuid, zone, deleted=False):
if backup_type == "disk":
try:
inst = DisksModel.get_disk_by_uuid(uuid=uuid,
zone=zone,
deleted=deleted)
return inst
except Exception as exp:
return None
else:
try:
inst = InstancesModel.get_instance_by_uuid(uuid=uuid,
deleted=deleted)
return inst
except Exception as exp:
return None
def resource_id_validator(value):
if not value.startswith(settings.INSTANCE_PREFIX) and \
not value.startswith(settings.DISK_PREFIX):
raise serializers.ValidationError(
"The resource id should be start with %(instance)s(instance) or "
"%(disk)s(disk)" % {
"instance": settings.INSTANCE_PREFIX,
"disk": settings.DISK_PREFIX
})
if value.startswith(settings.DISK_PREFIX) and \
not DisksModel.disk_exists_by_id(disk_id=value):
raise serializers.ValidationError(
"The resource id do not exists in the model")
if value.startswith(settings.INSTANCE_PREFIX) and \
not InstancesModel.instance_exists_by_id(instance_id=value):
raise serializers.ValidationError(
"The resource id do not exists in the model")
def handle(self, *args, **options):
"""
add a VMWare instance into console db
:param args:
:param options:
:return:
"""
info = self.get_fake_info()
info.update(self.get_real_info(options))
instance, err = InstancesModel.save_instance(**info)
if instance:
logger.info("import instance %s success: %s" %
(instance.to_dict(), err))
else:
logger.info("import instance %s error: %s" %
(info.get('uuid'), err))
def get_instances_info(owner, zone, is_basenet, net_id=None, instance_uuid=None):
payload = {
"zone": zone,
"owner": owner
}
if instance_uuid:
payload.update({"instance_id": instance_uuid})
# get instance info from backend
resp = describe_instance_api(payload)
err = resp.get("msg", "failed")
code = resp.get("code", -1)
if code != Code.OK:
logger.error("DescribeInstance Error: %s" % str(err))
return []
ret_set = resp.get("data", {}).get("ret_set", [])
instances_info = []
subnet_uuid_info = get_subnet_uuid_info(zone, owner)
for instance in ret_set:
uuid = instance["id"]
addresses = instance.get("addresses", {})
ins = InstancesModel.get_instance_by_uuid(uuid)
if not ins:
continue
instance_id = ins.instance_id
instance_name = ins.name
if not ins.seen_flag or ins.vhost_type != "KVM":
continue
if is_basenet:
if "base-net" not in addresses:
continue
logger.debug("get one")
instances_info.append(
generate_resource_info("instance", instance_id, instance_name, addresses["base-net"][0].get("addr"))
)
logger.debug(instances_info)
else:
nets, net_count = get_nets_info(addresses, uuid, subnet_uuid_info, None)
net_info = get_net_by_net_id(nets, net_id)
if net_info:
instances_info.append(generate_resource_info("instance", instance_id, instance_name, net_info["ip_address"]))
return instances_info
def apply_or_remove_security_group(payload):
"""
apply the security group to a instance, need to get ins_uuid
"""
ins_ids = payload.pop("resource_id")
sg_ids = payload.pop("sg_id")
action = payload.get("action")
version = payload.get("version")
result_data = {}
code = 0
msg = 'Success'
for ins_id in ins_ids:
sg_results_succ = []
for sg_id in sg_ids:
sg = SecurityGroupModel.get_security_by_id(sg_id=sg_id)
sg_uuid = sg.uuid
instance = InstancesModel.get_instance_by_id(instance_id=ins_id)
ins_uuid = instance.uuid
payload.update({"server": ins_uuid})
payload.update({"security_group": sg_uuid})
payload.update({"version": version})
payload.update({"action": action})
# resp = api.get(payload=payload, timeout=10)
resp = api.get(payload=payload)
if resp.get("code") != 0:
code = CommonErrorCode.REQUEST_API_ERROR
msg = resp.get("msg")
# sg_results.update({sg_id: "failed"})
if action == "GrantSecurityGroup":
logger.error("security_group with sg_id " + sg_id +
" cannot apply to instance with ins_id %s" +
ins_id)
else:
logger.error(
"security_group with sg_id " + sg_id +
" cannot remove from instance with ins_id %s" + ins_id)
else:
sg_results_succ.append(sg_id)
result_data.update({ins_id: sg_results_succ})
resp = console_response(code, msg, len(result_data.keys()), [result_data])
return resp
def resize_instance_confirm(payload, try_times=0):
"""
Check instance resize state and confrim
:param payload:
:param try_times:
:return:
"""
instance_id = payload["instance_id"]
instance_inst = InstancesModel.get_instance_by_id(instance_id)
charge_mode = instance_inst.charge_mode
# check try times
if try_times >= RESIZE_MAX_TRIES:
logger.error("resize comfirm failed after %s tries" % RESIZE_MAX_TRIES)
return
# state
task_state, vm_state = get_instance_state(payload)
logger.debug("instance %s resize task_state: %s, vm_state: %s" %
(instance_id, str(task_state), str(vm_state)))
if vm_state != "resized":
# failed
if task_state is None:
logger.error("[%d] instance %s resize failed" %
(try_times, instance_id))
return
# not finished
logger.info("[%d] instance %s resized task_state %s, vm_state %s" %
(try_times, instance_id, str(task_state), str(vm_state)))
resize_instance_confirm.apply_async((payload, try_times + 1),
countdown=RETRY_INTELVAL)
return
return resize_instance_confirm_impl(payload)
def start_instances(payload):
instance_ids = payload.pop("instances")
vm_types = payload.pop('vm_types')
ret_set = []
ret_code, ret_msg = 0, "succ"
for instance_id, vm_type in zip(instance_ids, vm_types):
instance = InstancesModel.get_instance_by_id(instance_id,
deleted=True)
_payload = deepcopy(payload)
if vm_type == 'POWERVM' and settings.USE_POWERVM_HMC:
_payload.update({'vm_type': 'POWERVM_HMC'})
_payload["instance_id"] = instance.uuid
resp = api.get(payload=_payload)
if resp["code"] != 0:
ret_code = CommonErrorCode.REQUEST_API_ERROR
ret_msg = resp["msg"]
break
resp["data"].pop("action", None)
ret_set.append(instance_id)
return console_response(ret_code, ret_msg, len(ret_set), ret_set)
def format_instance_monitor_info(resp, name_dict, point_num, data_fmt, item,
sort_method):
logger.debug("the osapi resp for multi monitor is " + str(resp))
# resp_timestamp = resp["data"].get("timestamp")
# logger.info("the timestamp of the first point is: " + str(resp_timestamp))
ret_set = resp.get("data").get("ret_set")
ret_set = dict(ret_set)
new_ret_set = []
unit = item_to_unit.get(item)
display_name = item_to_display.get(item)
timestamp = resp.get("data").get("timestamp")
for ins_uuid, ins_info in ret_set.items():
instance_record = InstancesModel.get_instance_by_uuid(uuid=ins_uuid)
if not instance_record:
logger.error("cannot find instance with uuid " + str(ins_uuid))
continue
ins_id = instance_record.instance_id
ins_info = list(ins_info)
for item in ins_info:
item = dict(item)
item_name, result_data = dict(item).popitem()
result_data = process_point_data(result_data, point_num, data_fmt)
instance_name = get_resource_name(ins_id)
new_ret_set.append({
"resource_id": ins_id,
"resource_name": instance_name,
"data": result_data,
"unit": unit,
"display_name": display_name,
"timestamp": timestamp
})
new_ret_set = sort_monitor_info_version2(new_ret_set, sort_method)
resp["data"]["ret_set"] = new_ret_set
return resp
def describe_instance_backups(payload):
backup_id = payload.get("backup_id", None)
resource_id = payload.pop("resource_id", None)
backup_status = payload.pop("status", None)
owner = payload.get("owner")
zone = payload.get("zone")
zone_record = ZoneModel.get_zone_by_name(zone)
availability_zone = payload.get('availability_zone')
search_key = payload.get('search_key')
instance_to_image = payload.get("instance_to_image")
if backup_id is not None:
try:
backup_uuid = InstanceBackupModel.get_backup_by_id(
backup_id=backup_id).uuid
payload.update({"image_id": backup_uuid})
except Exception:
err_msg = "cannot find backup whose backup id is " + backup_id
return console_response(BackupErrorCode.BACKUP_NOT_FOUND, err_msg)
elif resource_id is not None:
try:
instance_uuid = InstancesModel.get_instance_by_id(
instance_id=resource_id).uuid
payload.update({"instance_uuid": instance_uuid})
except Exception:
err_msg = "cannot find instance uuid whose instance id is " \
+ resource_id
return console_response(
BackupErrorCode.ASSOCIATE_INSTANCE_NOT_FOUND, err_msg)
if instance_to_image:
payload.pop("instance_to_image")
payload.update({"private_image": "True"})
resp = api.get(payload=payload)
if resp["code"] == 0:
# 对镜像列表进行过滤
# 接口传入backup_id时，不对镜像进行过滤
resp_data = filter_instance_backup_info(
resp["data"].get("ret_set", []),
backup_status,
owner,
zone_record,
hypervisor_type=availability_zone,
filter_img=not bool(backup_id),
)
if resp_data is None:
return console_response(
1, "The uuid do not found, maybe the "
"disk has been deleted")
result_list = []
if search_key:
for resp_item in resp_data:
for item in resp_item.values():
if search_key in str(item):
if resp_item not in result_list:
result_list.append(resp_item)
else:
result_list = resp_data
result = console_response(0, "Success", len(result_list), result_list)
else:
result = console_response(CommonErrorCode.REQUEST_API_ERROR,
resp.get("msg"))
return result
def handle_args(*args, **kwargs):
_payload = kwargs.get("payload", None)
if _payload is None:
_payload = args[0]
payload = copy.deepcopy(_payload)
owner = payload.get("owner")
zone = payload.get("zone")
capacity = 1
resp = func(*args, **kwargs)
value = resp.get("ret_set")
logger.info("%s, %s, %s" % (str(owner), str(zone), str(quota_type)))
if value is not None:
# add logic for pre-pay
pre_pay_num = 0
if resp.get("ret_code") == 0:
records = []
if quota_type == 'disk':
resource_ids = payload.get("disk_id")
records = DisksModel.get_exact_disks_by_ids(resource_ids)
elif quota_type == 'instance':
resource_ids = payload.get("instances")
records = InstancesModel.get_exact_instances_by_ids(
resource_ids)
elif quota_type == 'backup':
resource_ids = payload.get("backup_id_list")
records_fir = InstanceBackupModel. \
get_exact_backups_by_ids(resource_ids)
records_sec = DiskBackupModel. \
get_exact_backups_by_ids(resource_ids)
for record in records_fir:
records.append(record)
for record in records_sec:
records.append(record)
elif quota_type == 'pub_ip':
resource_ids = payload.get("ips")
records = IpsModel.get_exact_ips_by_ids(resource_ids)
if len(records) > 0:
for record in records:
if getattr(record, 'charge_mode') != "pay_on_time":
pre_pay_num += 1
if isinstance(value, list):
dec_resp = append_quota(
zone=zone, owner=owner, q_type=quota_type,
value=((len(value) - pre_pay_num) * capacity))
if dec_resp.get("ret_code") != 0:
logger.error(QUOTAS_MSG.get(QuotaErrorCode.
QUOTA_MODIFICATION_ERROR))
else:
logger.info("%s quota increased by: %s" %
(str(quota_type), str(len(value) * capacity)))
else:
dec_resp = append_quota(
zone=zone, owner=owner, q_type=quota_type,
value=(1 - pre_pay_num) * capacity)
if dec_resp.get("ret_code") != 0:
logger.error(QUOTAS_MSG.get(QuotaErrorCode.
QUOTA_MODIFICATION_ERROR))
else:
logger.info("%s quota increased by: %s" %
(str(quota_type), str(capacity)))
return resp
def restore_instance(instance_id):
InstancesModel.restore_instance(instance_id)
InstanceTrash.restore_instance(instance_id)
def restore(cls, jumper_ids):
ret_set = []
for instance_id in jumper_ids:
InstancesModel.restore_instance(instance_id)
ret_set.append(instance_id)
return console_response(code=0, ret_set=ret_set)
def format_multi_response(resp,
name_dict,
point_num,
data_fmt,
item,
sort_method,
instance_info_dict,
call_source='console'):
logger.debug("the osapi resp for multi monitor is " + str(resp))
# resp_timestamp = resp["data"].get("timestamp")
# logger.info("the timestamp of the first point is: " + str(resp_timestamp))
ret_set = resp.get("data").get("ret_set")
ret_set = dict(ret_set)
new_ret_set = []
unit = item_to_unit.get(item)
display_name = item_to_display.get(item)
timestamp = resp.get("data").get("timestamp")
id_str = 'instance_id'
name_str = 'instance_name'
for ins_uuid, ins_info in ret_set.items():
if call_source == 'console':
instance_record = InstancesModel.get_instance_by_uuid(
uuid=ins_uuid)
if not instance_record:
logger.error("cannot find instance with uuid " + str(ins_uuid))
continue
ins_id = instance_record.instance_id
elif call_source == 'finance':
ins_id = instance_info_dict[ins_uuid]['name']
ins_info = list(ins_info)
new_ins_info = {}
for item in ins_info:
item = dict(item)
if call_source == 'finance':
item.pop('unit')
device_name = name_dict.get(item.pop("device_name", "NOVALUE"),
"default")
item_name, result_data = dict(item).popitem()
result_data = process_point_data(result_data, point_num, data_fmt)
resource_name = get_resource_name(device_name)
result_data = {"resource_name": resource_name, "data": result_data}
if new_ins_info is None:
new_ins_info = {device_name: result_data}
else:
new_ins_info.update({device_name: result_data})
instance_name = get_resource_name(ins_id) or None
if call_source == 'finance':
if not instance_name:
instance_name = instance_info_dict[ins_uuid][
'OS-EXT-SRV-ATTR:instance_name']
id_str = 'id'
name_str = 'name'
if new_ins_info:
new_ret_set.append({
id_str: ins_id,
name_str: instance_name,
"monitor_info": new_ins_info,
"unit": unit,
"display_name": display_name,
"timestamp": timestamp
})
if sort_method:
if sort_method == "increase":
new_ret_set = sort_monitor_info(new_ret_set, id_str, False)
elif sort_method == "decrease":
new_ret_set = sort_monitor_info(new_ret_set, id_str, True)
else:
new_ret_set = sort_by_name(new_ret_set, "instance_name")
resp["data"]["ret_set"] = new_ret_set
return resp
def post(self, request, *args, **kwargs):
form = SingleMonitorValidator(data=request.data)
if not form.is_valid():
return Response(console_response(code=90001, msg=form.errors))
_data = form.validated_data
ins_id = _data.get("instance_id")
instance_record = InstancesModel.get_instance_by_id(instance_id=ins_id)
uuid = instance_record.uuid
_payload = Payload(
request=request,
action=None,
)
_payload = _payload.dumps()
resp = get_resources_info(_payload, 'Instance')
ret_code = resp.get("ret_code")
if ret_code is None or ret_code != 0:
return Response(resp)
instances = resp.get("ret_set")
instance = None
for ins in instances:
if ins.get("id").strip() == uuid.strip():
instance = ins
break
if instance is None:
msg = "instance with uuid " + uuid + " not found"
return Response(
console_response(InstanceErrorCode.INSTANCE_NOT_FOUND, msg))
data_fmt = _data.get("data_fmt")
item_set = request.data.get("item_set")
timestamp = _data.get("timestamp")
point_num = _data.get("point_num")
standard_point_num = _data.get("standard_point_num")
standard_point_num = False if standard_point_num else True
timestamp = get_current_timestamp()
if item_set is None:
item_set = get_all_item_for_single_mintor(instance)
item_set = dict(item_set)
post_data_list = []
post_data_item = {}
name_dict = {}
items = []
for k, v in item_set.items():
item_name = item_mapper.get(k)
data_list = list(v)
data_list, partial_name_dict = format_data_list(
k, data_list, instance, _payload)
name_dict.update(partial_name_dict)
for item_data in data_list:
item = {}
item[item_name] = item_data
items.append(item)
post_data_item["uuid"] = uuid # 主机uuid
post_data_item["item"] = items
post_data_list.append(post_data_item)
data_fmt_para = data_fmt
if data_fmt_para == "addition_time_data":
data_fmt_para = "real_time_data"
_payload = Payload(request=request,
action='ceilometer',
timestamp=timestamp,
data_fmt=data_fmt_para,
data_set=post_data_list)
urlparams = ["timestamp", "data_fmt"]
resp = api.post(payload=_payload.dumps(), urlparams=urlparams)
code = resp.get('code', 1)
msg = "Success"
if resp.get("code") == 0 and resp.get("data").get("ret_code") == 0:
resp = format_single_response(resp, name_dict, point_num, data_fmt)
code = resp.get('code')
msg = resp.get('msg')
else:
code = CommonErrorCode.REQUEST_API_ERROR
msg = resp.get('msg')
ret_set = resp.get('data', {}).get('ret_set', [])
resp = console_response(code=code,
msg=msg,
total_count=len(ret_set),
ret_set=ret_set)
return Response(resp)
def create_instance_from_backup(payload):
backup_id = payload.pop("backup_id")
version = payload.pop("version")
resource_name = payload.pop("resource_name")
owner = payload.get("owner")
zone = payload.get("zone")
charge_mode = payload.get("charge_mode")
pool_name = payload.pop("pool_name")
nets = payload.pop("nets")
image_uuid = InstanceBackupModel.get_backup_by_id(backup_id).uuid
instance_name = resource_name
flavor_resp = get_flavor_info_through_backup(payload, image_uuid)
if flavor_resp.get("ret_code") != 0:
return flavor_resp
ins_image_info = flavor_resp["ret_set"][0]
flavor = int(ins_image_info.get("flavor_id"))
instance_type = InstanceTypeModel. \
get_instance_type_by_flavor_id(str(flavor))
if instance_type is None:
logger.error("cannot find instance type with flavor id " + str(flavor))
return console_response(
BackupErrorCode.ASSOCIATE_INSTANCE_NOT_FOUND,
"cannot find instance type with flavor" + flavor)
instance_id = make_instance_id()
security_group_resp = get_default_security_group(payload, logger)
if security_group_resp.get("ret_code") != 0:
return security_group_resp
default_security_group_uuid = security_group_resp["ret_set"][0]
nets_info = format_payload_nets(nets, False)
payload.update({
"action": "CreateInstance",
"name": instance_id,
"flavor": flavor,
"version": version,
"image": image_uuid,
"secgroup": default_security_group_uuid,
"net_info": nets_info,
"availability_zone": pool_name
})
urlparams = [
"name", "flavor", "image", "secgroup", "zone", "owner",
"availability_zone"
]
# resp = api.post(payload=payload, urlparams=urlparams, timeout=10)
resp = api.post(payload=payload, urlparams=urlparams)
if resp.get("code") != 0:
return console_response(CommonErrorCode.REQUEST_API_ERROR,
resp.get("msg"))
instance_ret = resp["data"]["ret_set"]
if isinstance(instance_ret, list):
instance_ret = instance_ret[0]
instance_uuid = instance_ret.get("id")
instance, err = InstancesModel.save_instance(
uuid=instance_uuid,
instance_name=instance_name,
instance_id=instance_id,
zone=zone,
owner=owner,
instance_type=instance_type.instance_type_id,
charge_mode=charge_mode,
backup_id=backup_id,
seen_flag=1)
if err is not None:
logger.error("save instance error, %s" % str(err))
return console_response(InstanceErrorCode.RUN_INSTANCES_FAILED,
str(err))
return console_response(0, "Success", 1, [{
"instance_id": instance_id
}], {"resource_id": instance_id})
def modify_security_group(payload):
"""
apply the security group to a instance, if the instance already
has a security group replace the old with the new
"""
version = payload.get("version")
ins_ids = payload.pop("resource_id")
sg_ids = payload.pop("sg_id")
apply_action = "GrantSecurityGroup"
remove_action = "RemoveSecurityGroup"
check_instance_security_action = "DescribeSecurityGroupByInstance"
version = payload.get("version")
result_data = {}
if len(sg_ids) > 1:
return console_response(
SecurityErrorCode.ONE_SECURITY_PER_INSTANCE_ERROR, "modify failed")
sg_id = sg_ids[0]
code = 0
msg = 'Success'
for ins_id in ins_ids:
sg_results_succ = []
sg = SecurityGroupModel.get_security_by_id(sg_id=sg_id)
sg_uuid = sg.uuid
instance = InstancesModel.get_instance_by_id(instance_id=ins_id)
ins_uuid = instance.uuid
payload.update({
"action": check_instance_security_action,
"version": version,
"server": ins_uuid
})
# check_resp = api.get(payload=payload, timeout=10)
check_resp = api.get(payload=payload)
if check_resp.get("code") != 0:
code = CommonErrorCode.REQUEST_API_ERROR
msg = check_resp.get("msg")
continue
# if the instance already has a security group, remove it
if check_resp["data"]["total_count"] > 0:
old_sg_uuid = check_resp["data"]["ret_set"][0]["id"]
payload.update({
"action": remove_action,
"version": version,
"server": ins_uuid,
"security_group": old_sg_uuid
})
# remove_resp = api.get(payload=payload, timeout=10)
remove_resp = api.get(payload=payload)
if remove_resp.get("code") != 0:
logger.debug("the resp of removing the old securty group is:" +
str(remove_resp))
code = CommonErrorCode.REQUEST_API_ERROR
msg = remove_resp.get("msg")
continue
# grant the new security group to the instance
payload.update({
"action": apply_action,
"version": version,
"server": ins_uuid,
"security_group": sg_uuid
})
# grant_resp = api.get(payload=payload, timeout=10)
grant_resp = api.get(payload=payload)
if grant_resp.get("code") != 0:
logger.debug("the resp of granting the new securty group is:" +
str(grant_resp))
code = CommonErrorCode.REQUEST_API_ERROR
msg = grant_resp.get("msg")
logger.error("security_group with sg_id " + sg_id +
" cannot apply to instance with ins_id " + ins_id)
else:
sg_results_succ.append(sg_id)
result_data.update({ins_id: sg_results_succ})
resp = console_response(code, msg, len(result_data.keys()), [result_data])
return resp
