def create_flavor(vim_cache, res_cache, data, flavor, do_notify, res_type):
location_info = flavor["properties"]["location_info"]
local_storages = ignore_case_get(data, "local_storages")
param = {
"name": "Flavor_%s" % flavor["vdu_id"],
"vcpu": int(flavor["nfv_compute"]["num_cpus"]),
"memory": int(flavor["nfv_compute"]["mem_size"].replace('GB',
'').strip()),
"isPublic": True
}
for local_storage_id in ignore_case_get(flavor, "local_storages"):
for local_storage in local_storages:
if local_storage_id != local_storage["local_storage_id"]:
continue
disk_type = local_storage["properties"]["disk_type"]
disk_size = int(local_storage["properties"]["size"].replace(
'GB', '').strip())
if disk_type == "root":
param["disk"] = disk_size
elif disk_type == "ephemeral":
param["ephemeral"] = disk_size
elif disk_type == "swap":
param["swap"] = disk_size
flavor_extra_specs = ignore_case_get(flavor["nfv_compute"],
"flavor_extra_specs")
extra_specs = []
for es in flavor_extra_specs:
extra_specs.append({"keyName": es, "value": flavor_extra_specs[es]})
set_opt_val(param, "extraSpecs", extra_specs)
vim_id, tenant_name = location_info["vimid"], location_info["tenant"]
tenant_id = get_tenant_id(vim_cache, vim_id, tenant_name)
ret = api.create_flavor(vim_id, tenant_id, param)
do_notify(res_type, ret)
set_res_cache(res_cache, res_type, flavor["vdu_id"], ret["id"])
def create_port(vim_cache, res_cache, data, port, do_notify, res_type):
location_info = None
port_ref_vdu_id = ignore_case_get(port, "vdu_id")
for vdu in ignore_case_get(data, "vdus"):
if vdu["vdu_id"] == port_ref_vdu_id:
location_info = vdu["properties"]["location_info"]
if port["cp_id"] not in vdu["cps"]:
vdu["cps"].append(port["cp_id"])
break
if not location_info:
err_msg = "vdu_id(%s) for cp(%s) is not defined"
raise VimException(err_msg % (port_ref_vdu_id, port["cp_id"]),
ERR_CODE)
network_id = ignore_case_get(port, "networkId")
subnet_id = ignore_case_get(port, "subnetId")
if not network_id:
network_id = get_res_id(res_cache, RES_NETWORK, port["vl_id"])
subnet_id = get_res_id(res_cache, RES_SUBNET, port["vl_id"])
param = {
"networkId": network_id,
"name": port["properties"].get("name", "undefined")
}
set_opt_val(param, "subnetId", subnet_id)
set_opt_val(param, "macAddress",
ignore_case_get(port["properties"], "mac_address"))
set_opt_val(param, "ip", ignore_case_get(port["properties"], "ip_address"))
set_opt_val(param, "vnicType",
ignore_case_get(port["properties"], "vnic_type"))
set_opt_val(param, "securityGroups", "") # TODO
vim_id, tenant_name = location_info["vimid"], location_info["tenant"]
tenant_id = get_tenant_id(vim_cache, vim_id, tenant_name)
ret = api.create_port(vim_id, tenant_id, param)
ret["nodeId"] = port["cp_id"]
do_notify(res_type, ret)
set_res_cache(res_cache, res_type, port["cp_id"], ret["id"])
def create_volume(vim_cache, res_cache, vol, do_notify, res_type):
location_info = vol["properties"]["location_info"]
param = {
"name":
vol["properties"]["volume_name"] if vol["properties"].get(
"volume_name", None) else vol["volume_storage_id"],
"volumeSize":
int(
ignore_case_get(vol["properties"], "size_of_storage",
"0").replace('GB', '').replace('"', '').strip())
}
set_opt_val(param, "imageName", ignore_case_get(vol, "image_file"))
set_opt_val(param, "volumeType",
ignore_case_get(vol["properties"], "type_of_storage"))
set_opt_val(param, "availabilityZone",
ignore_case_get(location_info, "availability_zone"))
vim_id, tenant_name = location_info["vimid"], location_info["tenant"]
tenant_id = get_tenant_id(vim_cache, vim_id, tenant_name)
ret = api.create_volume(vim_id, tenant_id, param)
ret["nodeId"] = vol["volume_storage_id"]
do_notify(res_type, ret)
vol_id, vol_name = ret["id"], ret["name"]
set_res_cache(res_cache, res_type, vol["volume_storage_id"], vol_id)
retry_count, max_retry_count = 0, 300
while retry_count < max_retry_count:
vol_info = api.get_volume(vim_id, tenant_id, vol_id)
if vol_info["status"].upper() == "AVAILABLE":
logger.debug("Volume(%s) is available", vol_id)
return
time.sleep(2)
retry_count = retry_count + 1
raise VimException("Failed to create Volume(%s): Timeout." % vol_name,
ERR_CODE)
def create_network(vim_cache, res_cache, network, do_notify, res_type):
location_info = network["properties"]["location_info"]
param = {
"name":
network["properties"]["network_name"],
"shared":
False,
"networkType":
network["properties"]["network_type"],
"physicalNetwork":
ignore_case_get(network["properties"], "physical_network")
}
set_opt_val(param, "vlanTransparent",
ignore_case_get(network["properties"], "vlan_transparent"))
set_opt_val(
param, "segmentationId",
int(ignore_case_get(network["properties"], "segmentation_id", "0")))
set_opt_val(param, "routerExternal",
ignore_case_get(network, "route_external"))
vim_id, tenant_name = location_info["vimid"], location_info["tenant"]
tenant_id = get_tenant_id(vim_cache, vim_id, tenant_name)
ret = api.create_network(vim_id, tenant_id, param)
ret["nodeId"] = network["vl_id"]
do_notify(res_type, ret)
set_res_cache(res_cache, res_type, network["vl_id"], ret["id"])
def create_vm(vim_cache, res_cache, data, vm, do_notify, res_type):
location_info = vm["properties"]["location_info"]
vim_id, tenant_name = location_info["vimid"], location_info["tenant"]
tenant_id = get_tenant_id(vim_cache, vim_id, tenant_name)
param = {
"name": vm["properties"].get("name", "undefined"),
"flavorId": get_res_id(res_cache, RES_FLAVOR, vm["vdu_id"]),
"boot": {},
"nicArray": [],
"contextArray": [],
"volumeArray": []
}
# set boot param
if "artifacts" in vm and vm["artifacts"]:
param["boot"]["type"] = BOOT_FROM_IMAGE
img_name = ""
for artifact in vm["artifacts"]:
if artifact["artifact_name"] == "sw_image":
# TODO: after DM define
img_name = os.path.basename(artifact["file"])
break
if not img_name:
raise VimException("Undefined image(%s)" % vm["artifacts"],
ERR_CODE)
images = api.list_image(vim_id, tenant_id)
for image in images["images"]:
if img_name == image["name"]:
param["boot"]["imageId"] = image["id"]
break
if "imageId" not in param["boot"]:
raise VimException(
"Undefined artifacts image(%s)" % vm["artifacts"], ERR_CODE)
elif vm["virtual_storages"]:
param["boot"]["type"] = BOOT_FROM_VOLUME
vol_id = vm["virtual_storages"][0]["virtual_storage_id"]
param["boot"]["volumeId"] = get_res_id(res_cache, RES_VOLUME, vol_id)
else:
raise VimException("No image and volume defined", ERR_CODE)
for cp_id in ignore_case_get(vm, "cps"):
param["nicArray"].append(
{"portId": get_res_id(res_cache, RES_PORT, cp_id)})
param["contextArray"] = ignore_case_get(vm["properties"], "inject_files",
[])
logger.debug("contextArray:%s", param["contextArray"])
for vol_data in ignore_case_get(vm, "volume_storages"):
vol_id = vol_data["volume_storage_id"]
param["volumeArray"].append(
{"volumeId": get_res_id(res_cache, RES_VOLUME, vol_id)})
user_data = base64.b64encode(
bytes(ignore_case_get(vm["properties"], "user_data"),
"utf-8")).decode("utf-8")
set_opt_val(param, "availabilityZone",
ignore_case_get(location_info, "availability_zone"))
set_opt_val(param, "userdata", user_data)
set_opt_val(param, "metadata",
ignore_case_get(vm["properties"], "meta_data"))
set_opt_val(param, "securityGroups",
"") # TODO List of names of security group
set_opt_val(param, "serverGroup",
"") # TODO the ServerGroup for anti-affinity and affinity
ret = api.create_vm(vim_id, tenant_id, param)
ret["ports"] = [nic.get("portId") for nic in param["nicArray"]]
ret["vimId"] = vim_id
ret["tenantId"] = tenant_id
do_notify(res_type, ret)
vm_id = ret["id"]
if ignore_case_get(ret, "name"):
vm_name = vm["properties"].get("name", "undefined")
logger.debug("vm_name:%s" % vm_name)
opt_vm_status = "Timeout"
retry_count, max_retry_count = 0, 100
while retry_count < max_retry_count:
vm_info = api.get_vm(vim_id, tenant_id, vm_id)
if vm_info["status"].upper() == "ACTIVE":
logger.debug("Vm(%s) is active", vm_id)
return
if vm_info["status"].upper() == "ERROR":
opt_vm_status = vm_info["status"]
break
time.sleep(2)
retry_count = retry_count + 1
raise VimException(
"Failed to create Vm(%s): %s." % (vm_name, opt_vm_status), ERR_CODE)
def create_port(vim_cache, res_cache, data, port, do_notify, res_type):
location_info = None
port_ref_vdu_id = ignore_case_get(port, "vdu_id")
for vdu in ignore_case_get(data, "vdus"):
if vdu["vdu_id"] == port_ref_vdu_id:
location_info = vdu["properties"]["location_info"]
if port["cp_id"] not in vdu["cps"]:
vdu["cps"].append(port["cp_id"])
break
if not location_info:
err_msg = "vdu_id(%s) for cp(%s) is not defined."
raise VimException(err_msg % (port_ref_vdu_id, port["cp_id"]),
ERR_CODE)
network_id = ignore_case_get(port, "networkId")
subnet_id = ignore_case_get(port, "subnetId")
if not network_id:
if port["vl_id"] == "":
return
network_id = get_res_id(res_cache, RES_NETWORK, port["vl_id"])
subnet_id = get_res_id(res_cache, RES_SUBNET, port["vl_id"])
param = {"networkId": network_id, "name": port["cp_id"]}
set_opt_val(param, "subnetId", subnet_id)
set_opt_val(param, "macAddress",
ignore_case_get(port["properties"], "mac_address"))
ip_address = []
logger.debug("port['properties']:%s" % port["properties"])
for one_protocol_data in port["properties"]["protocol_data"]:
l3_address_data = one_protocol_data["address_data"][
"l3_address_data"] # l3 is not 13
fixed_ip_address = ignore_case_get(l3_address_data, "fixed_ip_address")
ip_address.extend(fixed_ip_address)
for one_virtual_network_interface in port["properties"].get(
"virtual_network_interface_requirements", []):
network_interface_requirements = one_virtual_network_interface[
"network_interface_requirements"]
interfaceTypeString = ignore_case_get(network_interface_requirements,
"interfaceType")
interfaceType = ""
if interfaceTypeString != "":
interfaceType = json.loads(
interfaceTypeString)["configurationValue"]
vnic_type = ignore_case_get(port["properties"], "vnic_type")
if vnic_type == "":
if interfaceType == "SR-IOV":
set_opt_val(param, "vnicType", "direct")
else:
set_opt_val(param, "vnicType", vnic_type)
set_opt_val(param, "ip", ",".join(ip_address))
set_opt_val(param, "securityGroups", "") # TODO
vim_id, tenant_name = location_info["vimid"], location_info["tenant"]
tenant_id = get_tenant_id(vim_cache, vim_id, tenant_name)
ret = api.create_port(vim_id, tenant_id, param)
ret["nodeId"] = port["cp_id"]
do_notify(res_type, ret)
set_res_cache(res_cache, res_type, port["cp_id"], ret["id"])
def create_subnet(vim_cache, res_cache, subnet, do_notify, res_type):
location_info = subnet["properties"]["location_info"]
network_id = get_res_id(res_cache, RES_NETWORK, subnet["vl_id"])
vl_profile = subnet["properties"]["vl_profile"]
layer_protocol = ignore_case_get(subnet["properties"]["connectivity_type"],
"layer_protocol")
param = {
"networkId":
network_id,
"name":
vl_profile["networkName"] + "_subnet",
"cidr":
ignore_case_get(vl_profile, "cidr"),
"ipVersion":
IP_V4 if (layer_protocol == 'ipv4') else
(IP_V6 if (layer_protocol == 'ipv6') else None)
}
set_opt_val(param, "enableDhcp", ignore_case_get(vl_profile,
"dhcpEnabled"))
set_opt_val(param, "gatewayIp", ignore_case_get(vl_profile, "gatewayIp"))
set_opt_val(param, "dnsNameservers",
ignore_case_get(subnet["properties"], "dns_nameservers"))
allocation_pool = {}
set_opt_val(allocation_pool, "start",
ignore_case_get(vl_profile, "startIp"))
set_opt_val(allocation_pool, "end", ignore_case_get(vl_profile, "endIp"))
if allocation_pool:
param["allocationPools"] = [allocation_pool]
set_opt_val(param, "hostRoutes",
ignore_case_get(subnet["properties"], "host_routes"))
vim_id, tenant_name = location_info["vimid"], location_info["tenant"]
tenant_id = get_tenant_id(vim_cache, vim_id, tenant_name)
ret = api.create_subnet(vim_id, tenant_id, param)
do_notify(res_type, ret)
set_res_cache(res_cache, res_type, subnet["vl_id"], ret["id"])
def create_vm(vim_cache, res_cache, data, vm, do_notify, res_type):
location_info = vm["properties"]["location_info"]
vim_id, tenant_name = location_info["vimid"], location_info["tenant"]
tenant_id = get_tenant_id(vim_cache, vim_id, tenant_name)
param = {
"name": vm["properties"].get("name", "undefined"),
"flavorId": get_res_id(res_cache, RES_FLAVOR, vm["vdu_id"]),
"boot": {},
"nicArray": [],
"contextArray": [],
"volumeArray": []
}
# set boot param
if "image_file" in vm and vm["image_file"]:
param["boot"]["type"] = BOOT_FROM_IMAGE
img_name = ""
for img in ignore_case_get(data, "image_files"):
if vm["image_file"] == img["image_file_id"]:
img_name = img["properties"]["name"]
break
if not img_name:
raise VimException("Undefined image(%s)" % vm["image_file"],
ERR_CODE)
images = api.list_image(vim_id, tenant_id)
for image in images["images"]:
if img_name == image["name"]:
param["boot"]["imageId"] = image["id"]
break
if "imageId" not in param["boot"]:
raise VimException(
"Image(%s) not found in Vim(%s)" % (img_name, vim_id),
ERR_CODE)
elif vm["volume_storages"]:
param["boot"]["type"] = BOOT_FROM_VOLUME
vol_id = vm["volume_storages"][0]["volume_storage_id"]
param["boot"]["volumeId"] = get_res_id(res_cache, RES_VOLUME, vol_id)
else:
raise VimException("No image and volume defined", ERR_CODE)
for cp_id in ignore_case_get(vm, "cps"):
param["nicArray"].append(
{"portId": get_res_id(res_cache, RES_PORT, cp_id)})
for inject_data in ignore_case_get(vm["properties"], "inject_data_list"):
param["contextArray"].append({
"fileName": inject_data["file_name"],
"fileData": inject_data["file_data"]
})
for vol_data in ignore_case_get(vm, "volume_storages"):
vol_id = vol_data["volume_storage_id"]
param["volumeArray"].append(
{"volumeId": get_res_id(res_cache, RES_VOLUME, vol_id)})
set_opt_val(param, "availabilityZone",
ignore_case_get(location_info, "availability_zone"))
set_opt_val(
param, "userdata",
"") # TODO Configuration information or scripts to use upon launch
set_opt_val(param, "metadata",
"") # TODO [{"keyName": "foo", "value": "foo value"}]
set_opt_val(param, "securityGroups",
"") # TODO List of names of security group
set_opt_val(param, "serverGroup",
"") # TODO the ServerGroup for anti-affinity and affinity
ret = api.create_vm(vim_id, tenant_id, param)
do_notify(res_type, ret)
#vm_id, vm_name, return_code = ret["id"], ret["name"], ret["returnCode"]
vm_id, return_code = ret["id"], ret["returnCode"]
if ignore_case_get(ret, "name"):
vm_name = vm["properties"].get("name", "undefined")
logger.debug("vm_name:%s" % vm_name)
opt_vm_status = "Timeout"
retry_count, max_retry_count = 0, 100
while retry_count < max_retry_count:
vm_info = api.get_vm(vim_id, tenant_id, vm_id)
if vm_info["status"].upper() == "ACTIVE":
logger.debug("Vm(%s) is active", vim_id)
return
if vm_info["status"].upper() == "ERROR":
opt_vm_status = vm_info["status"]
break
time.sleep(2)
retry_count = retry_count + 1
raise VimException(
"Failed to create Vm(%s): %s." % (vm_name, opt_vm_status), ERR_CODE)
def create_subnet(vim_cache, res_cache, subnet, do_notify, res_type):
location_info = subnet["properties"]["location_info"]
network_id = get_res_id(res_cache, RES_NETWORK, subnet["vl_id"])
param = {
"networkId": network_id,
"name": subnet["properties"]["name"],
"cidr": ignore_case_get(subnet["properties"], "cidr"),
"ipVersion": ignore_case_get(subnet["properties"], "ip_version", IP_V4)
}
set_opt_val(param, "enableDhcp",
ignore_case_get(subnet["properties"], "dhcp_enabled"))
set_opt_val(param, "gatewayIp",
ignore_case_get(subnet["properties"], "gateway_ip"))
set_opt_val(param, "dnsNameservers",
ignore_case_get(subnet["properties"], "dns_nameservers"))
allocation_pool = {}
set_opt_val(allocation_pool, "start",
ignore_case_get(subnet["properties"], "start_ip"))
set_opt_val(allocation_pool, "end",
ignore_case_get(subnet["properties"], "end_ip"))
if allocation_pool:
param["allocationPools"] = [allocation_pool]
set_opt_val(param, "hostRoutes",
ignore_case_get(subnet["properties"], "host_routes"))
vim_id, tenant_name = location_info["vimid"], location_info["tenant"]
tenant_id = get_tenant_id(vim_cache, vim_id, tenant_name)
ret = api.create_subnet(vim_id, tenant_id, param)
do_notify(res_type, ret)
set_res_cache(res_cache, res_type, subnet["vl_id"], ret["id"])