def modify_net(payload):
NetsModel.update_nets_model()
net_id = payload.pop("net_id")
net_name = payload.pop("net_name")
payload.update({"subnet_id": net_id})
payload.update({"name": net_name})
# call api
# resp = api.get(payload=payload, timeout=10)
resp = api.post(payload=payload)
code = resp["code"]
msg = resp["msg"]
api_code = resp["data"].get('ret_code', -1)
api_status = resp['api_status']
if code != Code.OK:
logger.error(
"ModifyNet error: api_ret_code (%d), api_status (%d), msg (%s)" %
(api_code, api_status, msg))
code = convert_api_code(api_code)
return console_response(code=code, msg=msg)
net_info = resp["data"]["ret_set"][0]
net_info = filter_needed_net_info(net_info)
return console_response(code=Code.OK,
msg=msg,
total_count=len(net_info),
ret_set=net_info)
def base_post_api_calling(dataparams, params, payload, optional_params,
**kwargs):
payload, kwargs = base_prepared(params, payload, optional_params, **kwargs)
urlparams = []
for k in dict(payload).keys():
if k not in dataparams:
urlparams.append(k)
resp = api.post(payload=payload, urlparams=urlparams, **kwargs)
return resp
def set_policy(cls, policy_list):
payload = {
"zone": "policy",
"action": "SetPolicy",
"policy_list": policy_list
}
resp = api.post(payload)
if resp['code'] != 0:
ret_code = AdminErrorCode.SET_POLICY_FAILED
logger.error("set_policy failed: %s" % resp["msg"])
return console_response(ret_code, resp["msg"])
return console_response(resp['code'], resp["msg"])
def set_drs(cls, CPU, RAM, switch):
payload = {
"zone": "drs",
"action": "SetDrs",
"CPU": CPU,
"RAM": RAM,
"switch": switch
}
resp = api.post(payload)
if resp["code"] != 0:
ret_code = AdminErrorCode.SET_DRS_FAILED
logger.error("set_drs failed %s" % resp["msg"])
return console_response(ret_code, resp["msg"])
return console_response(0, resp["msg"])
def get_osapi_result(payload, item_name, params):
rs_resp = api.post(payload=payload, urlparams=params)
logger.debug("the osapi resp for describe_screen_pm_loads is " +
str(rs_resp))
if rs_resp['code'] != 0:
return []
rs_resp = rs_resp['data']
if rs_resp['ret_code'] != 0:
return []
rs_ret_set = rs_resp['ret_set']
if len(rs_ret_set) > 0:
rs = rs_ret_set[0].get(item_name)
return rs
else:
return []
def get_lb_monitor_info(payload, resources):
resource_ids = []
resource_type = payload.get("resource_type")
sort_method = payload("sort_method")
if resource_type == 'loadbalancer':
for resource in resources:
resource_ids.append(resource['id'])
elif resource_type == 'listener':
for resource in resources:
listeners = resource['statuses']['loadbalancer']['listeners']
for listener in listeners:
resource_ids.append(listener['id'])
else:
for resource in resources:
listeners = resource['statuses']['loadbalancer']['listeners']
for listener in listeners:
members = listener['pools'][0]['members']
for member in members:
resource_ids.append(member['id'])
payload.update({"resource_ids": resource_ids})
urlparams = ["resource_type", "monitor_timestamp", "format"]
resp = api.post(payload=deepcopy(payload), urlparams=urlparams)
logger.debug("the osapi resp for multi monitor is " + str(resp))
code = resp.get('code', 1)
msg = resp.get('msg', 'failed')
if code != 0:
code = CommonErrorCode.REQUEST_API_ERROR
else:
msg = "Success"
ret_set = resp.get('data', {}).get('ret_set', [])
new_monitor_infos = format_lb_monitor_info(ret_set, resources,
resource_type,
payload['items'][0])
new_monitor_infos = sort_monitor_info_version2(new_monitor_infos,
sort_method)
return console_response(code=code,
msg=msg,
total_count=len(new_monitor_infos),
ret_set=new_monitor_infos)
def describe_screen_pmvr_rate(payload, urlparams):
try:
rs_resp = api.post(payload=payload, urlparams=urlparams)
logger.debug("the osapi resp for describe_screen_pmvr_rate is " +
str(rs_resp))
if rs_resp['code'] != 0:
return []
rs_resp = rs_resp['data']
if rs_resp['ret_code'] != 0:
return []
rs_ret_set = rs_resp['ret_set']
except Exception:
return []
for ret in rs_ret_set:
ret['v_cpu'] = Decimal(ret.get('v_cpu', 0)).quantize(Decimal('0.0'))
ret['v_mem'] = Decimal(ret.get('v_mem', 0)).quantize(Decimal('0.0'))
num = len(rs_ret_set) if payload['num'] == 0 else payload['num']
return rs_ret_set[0:num]
def get_rds_monitor_info(payload, resources):
uuid_list = []
for resource in resources:
uuid_list.append(resource['id'])
payload.update({"uuid": uuid_list})
resp = api.post(payload=deepcopy(payload))
logger.debug("the osapi resp for multi monitor is " + str(resp))
sort_method = payload.get("sort_method")
code = resp.get('code', 1)
msg = resp.get('msg', 'failed')
if code != 0:
code = CommonErrorCode.REQUEST_API_ERROR
else:
msg = "Success"
ret_set = resp.get('data', {}).get('ret_set', [])
timestamp = payload.get("timestamp")
new_monitor_infos = format_rds_monitor_info(ret_set, resources,
payload['item'], timestamp)
new_monitor_infos = sort_monitor_info_version2(new_monitor_infos,
sort_method)
return console_response(code=code,
msg=msg,
total_count=len(new_monitor_infos),
ret_set=new_monitor_infos)
def create_keypairs(payload):
"""
Create Keypairs Synchronously
"""
count = payload.pop("count")
name_base = payload.pop("name")
zone = payload["zone"]
owner = payload["owner"]
ret_set = []
private_keypair = {}
succ_num = 0
ret_code, ret_msg = 0, "succ"
for n in xrange(count):
_payload = deepcopy(payload)
keypair_name = get_keypair_name(name_base, n)
keypair_id = make_keypair_id()
_payload.update({"name": keypair_id}) # use kp_id as keypair-name
if _payload.get("public_key") is not None:
url_params = deepcopy(_payload)
url_params.pop("public_key")
resp = api.post(_payload, urlparams=url_params.keys()) # call api
else:
# resp = api.get(_payload, timeout=10)
resp = api.get(_payload)
if resp.get("code") != 0:
ret_code = KeypairErrorCode.CREATE_KEYPAIR_FAILED
ret_msg = resp["msg"]
logger.error("keypair get failed, %d, %s" %
(resp["code"], resp["msg"]))
continue
private_key = resp["data"]["ret_set"][0].get("private_key", None)
private_keypair = {
"keypair_id": keypair_id,
"private_key": private_key
}
if not cache_private_key_file(private_keypair):
ret_code = KeypairErrorCode.CREATE_KEYPAIR_FAILED
ret_msg = "Save keypairs failed"
continue
# save to backend db
keypair, err = KeypairsModel.save_keypair(zone=zone,
owner=owner,
name=keypair_name,
keypair_id=keypair_id)
if err is not None:
ret_code = KeypairErrorCode.CREATE_KEYPAIR_FAILED
ret_msg = resp["msg"]
logger.error("Save keypair error, %s" % str(err))
continue
# # make response
# keypair_info = resp["data"]["ret_set"][0]
# keypair_info["keypair_name"] = keypair_name
# keypair_info["create_datetime"] = keypair.create_datetime
# keypair_info = filter_needed_keypair_info(keypair_info)
# keypair_info = keypair_info[0]
ret_set.append(keypair_id)
succ_num += 1
return console_response(ret_code, ret_msg, succ_num, ret_set)
def collect_virtual_machine_data(date, account, zone):
if VirtualMachineUseRecord.objects.filter(
zone=zone, time=date.strftime("%Y%m%d00")).exists():
return
vms = get_all_vms(account, zone)
vm_ids = [
vm["id"] for vm in vms if vm.get("OS-EXT-STS:vm_state") == "active"
] # 只获取运行中的vm的数据
db_vms = InstancesModel.objects.filter(seen_flag=1,
deleted=False,
zone=zone,
uuid__in=vm_ids)
vm_dict = {vm.uuid: vm for vm in db_vms}
vm_ids = vm_dict.keys()
items = [{'memory.usage': None}, {'cpu_util': None}]
data_set = [{"item": items, "uuid": vm_id} for vm_id in vm_ids]
timestamp = datetime_to_timestamp(date + timedelta(days=1)) # 接口参数是截止时间
payload = {
"owner": account.user.username,
"zone": zone.name,
"action": "ceilometer",
"data_set": data_set,
"data_fmt": "one_day_data",
"timestamp": int(timestamp),
}
params = ["data_fmt", "timestamp"]
res = api.post(payload, urlparams=params)
if res["code"] != 0:
logger.error("%scollect_virtual_machine_data: osapi return %s" %
(EXCEPTION_PREFIX, res))
return []
data = res["data"]["ret_set"]
records = []
date_str = date.strftime("%Y%m%d")
for uuid, items in data.iteritems():
vm = vm_dict[uuid]
vm_memory_total = [vm.instance_type.memory] * 24
vm_cpu_total = [vm.instance_type.vcpus] * 24
vm_memory_usage_rate = list_cal(merge_value(items[0]["memory.usage"]),
100,
"/",
null_as="return_null")
vm_cpu_usage_rate = list_cal(merge_value(items[1]["cpu_util"]),
100,
"/",
null_as="return_null")
vm_memory_used = list_cal(vm_memory_total, vm_memory_usage_rate, "*")
vm_cpu_used = list_cal(vm_cpu_total, vm_cpu_usage_rate, "*")
vm_disk_total = [0] * 24 # TODO lack of disk data
vm_disk_used = [0] * 24
for hour in range(24):
create_params = {
"instance": vm,
"app_system": vm.app_system,
"time": "%s%02d" % (date_str, hour),
"cpu_total": vm_cpu_total[hour],
"cpu_used": vm_cpu_used[hour],
"memory_total": vm_memory_total[hour],
"memory_used": vm_memory_used[hour],
"disk_total": vm_disk_total[hour],
"disk_used": vm_disk_used[hour],
"zone": zone,
}
records.append(VirtualMachineUseRecord(**create_params))
VirtualMachineUseRecord.objects.bulk_create(records)
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 get_nets_info(addresses,
instance_id,
subnet_uuid_info,
ip_info,
zone='yz',
owner='root'):
with Timer() as total_spent:
DEBUG_INFO = '''
get_nets_info_spent ===> {total_spent}
DescribeNets ===> {DescribeNetsSpent}
'''
with Timer() as DescribeNetsSpent:
payload = {'zone': zone, 'owner': owner, 'action': 'DescribeNets'}
resp = api.post(payload=payload)
if resp["code"] == 0:
nets_model = resp["data"]["ret_set"]
else:
logger.error("cannot get the DescribeNets info")
return [], 0
nets = []
net_count = 0
for network_key in addresses.keys():
network_type = "private"
for net_address in addresses[network_key]:
net = {}
net["ip_address"] = net_address["addr"]
net["ip_version"] = net_address["version"]
mac_address = net_address["OS-EXT-IPS-MAC:mac_addr"]
net["mac_address"] = mac_address
net["ip_type"] = net_address.get("OS-EXT-IPS:type", "")
try:
subnet_uuid = subnet_uuid_info[instance_id][
mac_address].get(net_address["addr"])
except:
subnet_uuid = None
subnet_inst = None
for _ in nets_model:
if _["id"] == subnet_uuid:
subnet_inst = _
break
if subnet_inst:
net["net_name"] = subnet_inst["name"]
net["net_id"] = subnet_inst["name"]
net["id"] = subnet_inst["id"]
net["gateway_ip"] = subnet_inst["gateway_ip"]
net["net_type"] = "public" if subnet_inst[
"gateway_ip"] else None
if not net.get("net_type", None):
net["net_type"] = network_type
if network_key == "base-net":
net["net_name"] = network_key
net["net_id"] = network_key
if ip_info and net["ip_address"] in ip_info:
net["ip_id"] = ip_info[net["ip_address"]]["ip_id"]
net["ip_name"] = ip_info[net["ip_address"]]["ip_name"]
if net["ip_type"] != "floating":
net_count += 1
nets.append(net)
logger.debug(
DEBUG_INFO.format(total_spent=total_spent,
DescribeNetsSpent=DescribeNetsSpent))
return nets, net_count
def monitor_multi_host(payload,
instances,
call_source='console',
data_disk_flag=False):
"""
monitor all hosts
"""
item = payload.pop("item")
# timestamp = payload.get("timestamp")
point_num = payload.get("point_num")
item_name = item_mapper.get(item)
data_fmt = payload.pop("data_fmt")
sort_method = payload.pop("sort_method", "name")
# print sort_method
# standard = payload.pop("standard_point_num", True)
info_dict, name_dict = get_multi_monitor_info(instances, item, payload,
data_disk_flag)
post_data_list = []
instance_info_dict = {}
for instance in instances:
post_data_item = {}
uuid = instance.get("id")
instance_info_dict[uuid] = instance
item_info_list = info_dict.get(uuid)
items = []
for item_info in item_info_list:
single_item = {}
single_item[item_name] = item_info
items.append(single_item)
post_data_item["uuid"] = uuid
post_data_item["item"] = items
post_data_list.append(post_data_item)
# if timestamp is None:
# timestamp = get_timestamp(data_fmt)
# timestamp = get_timestamp(timestamp, data_fmt)
timestamp = get_current_timestamp()
data_fmt_para = data_fmt
if data_fmt == "addition_time_data":
data_fmt_para = "real_time_data"
payload.update({"timestamp": timestamp})
payload.update({"data_fmt": data_fmt_para})
payload.update({"data_set": post_data_list})
urlparams = ["timestamp", "data_fmt"]
# urlparams= ["data_fmt"]
# resp = api.post(payload=payload, urlparams=urlparams, timeout=10)
resp = api.post(payload=payload, urlparams=urlparams)
logger.debug("the osapi resp for multi monitor is " + str(resp))
if call_source == 'finance-monitor':
return resp
# resp = format_multi_response(resp, name_dict, point_num, data_fmt,
# timestamp, standard, item)
resp = format_multi_response(resp, name_dict, point_num, data_fmt, item,
sort_method, instance_info_dict, call_source)
code = resp.get('code', 1)
msg = resp.get('msg', 'failed')
if code != 0:
code = CommonErrorCode.REQUEST_API_ERROR
else:
msg = "Success"
ret_set = resp.get('data', {}).get('ret_set', [])
return console_response(code=code,
msg=msg,
total_count=len(ret_set),
ret_set=ret_set)
def create_net(payload):
"""
Create net Synchronously
"""
net_type = payload.pop("net_type")
net_name = payload.pop("net_name")
# is_base = payload.pop("is_base", False)
# zone = payload["zone"]
# owner = payload["owner"]
# network_uuid = payload.get("network_uuid")
# network_id = NetworksModel.get_network_by_uuid(network_uuid)
# net_id = make_net_id(is_base)
payload["net_id"] = net_name
payload = update_request_params(payload, NET_FILTER_MAP)
# call api
# resp = api.get(payload=payload, timeout=10)
resp = api.post(payload=payload)
code = resp["code"]
msg = resp["msg"]
# api_code = resp["data"].get('ret_code', -1)
# api_status = resp['api_status']
create_status = []
if code != Code.OK:
return console_response(code=code, msg=msg)
net_info = resp["data"]["ret_set"][0]
# uuid = net_info["id"]
net_id = net_info["name"]
# save net
'''
net, err = save_net(uuid=uuid,
net_name=net_name,
net_type=net_type,
net_id=net_id,
network_id=network_id,
zone=zone,
owner=owner)
if err is not None:
logger.error("Save net error, %s" % str(err))
return console_response(code=ErrorCode.net.SAVE_NET_FAILED,
msg=msg)
'''
if net_type == 'vlan':
cidr = payload.get("cidr", '').split('/')[0]
BaseNetModel.objects.change_net_used(cidr)
# net_info["create_datetime"] = net.create_datetime
net_info["type"] = net_type
net_info = filter_needed_net_info(net_info)
create_status.append(net_info)
action_record = {"net_id": net_id}
return console_response(code=Code.OK,
msg=msg,
total_count=len(create_status),
ret_set=create_status,
action_record=action_record)
