"tenant": 'tenantname_1'
}), '200']
t2_lcm_notify_result = [0, json.JSONEncoder().encode(''), '200']
- mock_call_req.side_effect = [t1_apply_grant_result, t2_lcm_notify_result]
+ t3_delete_flavor = [0, json.JSONEncoder().encode({"vim_id": "vimid_1"}), '200']
+ mock_call_req.side_effect = [t1_apply_grant_result, t2_lcm_notify_result, t3_delete_flavor]
mock_call.return_value = None
data = {
"terminationType": "FORCEFUL",
ret = call_aai(resource, "GET")
if ret[0] != 0:
logger.error("Status code is %s, detail is %s.", ret[2], ret[1])
+ return None
+
+ return json.JSONDecoder().decode(ret[1]) if ret[1] else ret[1]
+
+
+def delete_aai_flavor(vim_id, tenant_id, flavor_id):
+ cloud_owner, cloud_region = split_vim_to_owner_region(vim_id)
+ resource = "/cloud-infrastructure/cloud-regions/cloud-region/%s/%s/flavors/flavor/%s" % \
+ (cloud_owner, cloud_region, flavor_id)
+
+ ret = call_aai(resource, "DELETE")
+ if ret[0] != 0:
+ logger.error("Status code is %s, detail is %s.", ret[2], ret[1])
+ return None
return json.JSONDecoder().decode(ret[1]) if ret[1] else ret[1]
RES_PORT = "port"
RES_FLAVOR = "flavor"
RES_VM = "vm"
+NOT_PREDEFINED = 1
def get_tenant_id(vim_cache, vim_id, tenant_name):
create_subnet(vim_cache, res_cache, subnet, do_notify, RES_SUBNET)
for port in ignore_case_get(data, "cps"):
create_port(vim_cache, res_cache, data, port, do_notify, RES_PORT)
- for flavor in ignore_case_get(data, "vdus"):
- create_flavor(vim_cache, res_cache, data, flavor, do_notify, RES_FLAVOR)
- for vm in ignore_case_get(data, "vdus"):
- create_vm(vim_cache, res_cache, data, vm, do_notify, RES_VM)
+ for vdu in ignore_case_get(data, "vdus"):
+ if vdu["type"] == "tosca.nodes.nfv.Vdu.Compute":
+ create_flavor(vim_cache, res_cache, data, vdu, do_notify, RES_FLAVOR)
+ for vdu in ignore_case_get(data, "vdus"):
+ if vdu["type"] == "tosca.nodes.nfv.Vdu.Compute":
+ create_vm(vim_cache, res_cache, data, vdu, do_notify, RES_VM)
def delete_vim_res(data, do_notify):
for res_type, res_del_fun in zip(res_types, res_del_funs):
for res in ignore_case_get(data, res_type):
try:
- if 1 == res["is_predefined"]:
+ if NOT_PREDEFINED == res["is_predefined"]:
res_del_fun(res["vim_id"], res["tenant_id"], res["res_id"])
except VimException as e:
logger.error("Failed to delete %s(%s)", res_type, res["res_id"])
set_res_cache(res_cache, res_type, port["cp_id"], ret["id"])
+def search_flavor_aai(vim_id, memory_page_size):
+ aai_flavors = get_flavor_info(vim_id)
+ if not aai_flavors:
+ return None
+ logger.debug("aai_flavors:%s" % aai_flavors)
+ aai_flavor = aai_flavors[0]["flavors"]["flavor"]
+ for one_aai_flavor in aai_flavor:
+ hpa_capabilities = one_aai_flavor["hpa-capabilities"]
+ for one_hpa_capa in hpa_capabilities:
+ hpa_feature_attr = one_hpa_capa["hpa-feature-attributes"]
+ for one_hpa_attr in hpa_feature_attr:
+ hpa_key = one_hpa_attr["hpa-attribute-key"]
+ hpa_value = one_hpa_attr["hpa-attribute-value"]["value"]
+ if hpa_key == "memoryPageSize" and int(hpa_value) == memory_page_size:
+ return one_aai_flavor
+
+
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")
+ vim_id, tenant_name = location_info["vimid"], location_info["tenant"]
+ virtual_compute = flavor["virtual_compute"]
param = {
"name": "Flavor_%s" % flavor["vdu_id"],
- "vcpu": int(flavor["nfv_compute"]["num_cpus"]),
- "memory": int(flavor["nfv_compute"]["mem_size"].replace('GB', '').strip()),
+ "vcpu": int(virtual_compute["virtual_cpu"]["num_virtual_cpu"]),
+ "memory": int(virtual_compute["virtual_memory"]["virtual_mem_size"].replace('MB', '').strip()),
"isPublic": True
}
- flavor_extra_specs = ignore_case_get(flavor["nfv_compute"], "flavor_extra_specs")
- vim_id, tenant_name = location_info["vimid"], location_info["tenant"]
+
+ # just do memory huge page
+ flavor_extra_specs = ""
+ vdu_memory_requirements = virtual_compute["virtual_memory"]["vdu_memory_requirements"]
+ if "memoryPageSize" in vdu_memory_requirements:
+ memory_page_size = int(vdu_memory_requirements["memoryPageSize"].replace('MB', '').strip())
+ flavor_extra_specs = ("hw:mem_page_size=%sMB" % memory_page_size)
+ logger.debug("flavor_extra_specs:%s" % flavor_extra_specs)
# search aai flavor
- find = False
- aai_flavors = get_flavor_info(vim_id)
- aai_flavor = aai_flavors["flavors"]["flavor"]
- for i in range(len(aai_flavor)):
- for fes in flavor_extra_specs:
- if (str(aai_flavor[i].find(fes)) != -1):
- find = True
- break
- if find:
- break
+ aai_flavor = search_flavor_aai(vim_id, memory_page_size)
# add aai flavor
- if find:
- ret = aai_flavor[i]
+ if aai_flavor:
+ ret = aai_flavor
+ do_notify(res_type, ret)
+ set_res_cache(res_cache, res_type, flavor["vdu_id"], ret["flavor-id"])
else:
extra_specs = []
- 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
+ disk_type = virtual_compute["virtual_storage"]["type_of_storage"]
+ disk_size = int(virtual_compute["virtual_storage"]["size_of_storage"].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
for es in flavor_extra_specs:
extra_specs.append({"keyName": es, "value": flavor_extra_specs[es]})
set_opt_val(param, "extraSpecs", extra_specs)
tenant_id = get_tenant_id(vim_cache, vim_id, tenant_name)
+ logger.debug("param:%s" % param)
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"])
+ do_notify(res_type, ret)
+ set_res_cache(res_cache, res_type, flavor["vdu_id"], ret["id"])
def create_vm(vim_cache, res_cache, data, vm, do_notify, res_type):
import json
+from lcm.pub.msapi.aai import delete_aai_flavor
from lcm.pub.utils.restcall import req_by_msb
from .exceptions import VimException
def delete_flavor(vim_id, tenant_id, flavor_id):
- return call(vim_id, tenant_id, "flavors/%s" % flavor_id, "DELETE")
+ # first delete aai register info
+ ret = delete_aai_flavor(vim_id, tenant_id, flavor_id)
+ if ret:
+ return call(vim_id, tenant_id, "flavors/%s" % flavor_id, "DELETE")
def get_flavor(vim_id, tenant_id, flavor_id):
# See the License for the specific language governing permissions and
# limitations under the License.
+import mock
import unittest
import json
-from django.test import Client
+from rest_framework.test import APIClient
from rest_framework import status
+from lcm.pub.utils import restcall
inst_res_url = "/api/vnflcm/v1/resources/inst"
term_res_url = "/api/vnflcm/v1/resources/term"
inst_res_data = {
"vdus": [
{
- "description": "",
- "vdu_id": "vdu_vNat",
+ "type": "tosca.nodes.nfv.Vdu.Compute",
+ "description": "vbng",
+ "vdu_id": "VDU_vbng_0",
+ "virtual_compute": {
+ "virtual_memory": {
+ "virtual_mem_size": "4096 MB",
+ "vdu_memory_requirements": {
+ "memoryPageSize": "2 MB",
+ "numberOfPages": "1024"
+ }
+ },
+ "virtual_cpu": {
+ "num_virtual_cpu": "2",
+ "cpu_architecture": "generic"
+ },
+ "virtual_storage": {
+ "type_of_storage": "root",
+ "size_of_storage": "40 GB"
+ },
+ },
"artifacts": [
{
"artifact_name": "cirros.img",
"file": "/swimages/xenial-snat.qcow2"
}
],
- "nfv_compute": {
- "flavor_extra_specs": {
- },
- "mem_size": "2 GB",
- "num_cpus": 2
- },
"image_file": "cirros.img",
"local_storages": [
"intel_local_storages_1"
"vl_id": "vl_vNat",
"description": "",
"cp_id": "cp_vNat",
- "vdu_id": "vdu_vNat"
+ "vdu_id": "VDU_vbng_0"
}
],
"metadata": {
"id": "openNAT-1.0"
}
}
+NOT_PREDEFINED = 1
term_res_data = {
- "volume": [{"vim_id": "1", "tenant_id": "2", "res_id": "3"}],
- "network": [{"vim_id": "2", "tenant_id": "3", "res_id": "4"}],
- "subnet": [{"vim_id": "3", "tenant_id": "4", "res_id": "5"}],
- "port": [{"vim_id": "4", "tenant_id": "5", "res_id": "6"}],
- "flavor": [{"vim_id": "5", "tenant_id": "6", "res_id": "7"}],
- "vm": [{"vim_id": "6", "tenant_id": "7", "res_id": "8"}]
+ "volume": [{"is_predefined": NOT_PREDEFINED, "vim_id": "1", "tenant_id": "2", "res_id": "3"}],
+ "network": [{"is_predefined": NOT_PREDEFINED, "vim_id": "2", "tenant_id": "3", "res_id": "4"}],
+ "subnet": [{"is_predefined": NOT_PREDEFINED, "vim_id": "3", "tenant_id": "4", "res_id": "5"}],
+ "port": [{"is_predefined": NOT_PREDEFINED, "vim_id": "4", "tenant_id": "5", "res_id": "6"}],
+ "flavor": [{"is_predefined": NOT_PREDEFINED, "vim_id": "5", "tenant_id": "6", "res_id": "7"}],
+ "vm": [{"is_predefined": NOT_PREDEFINED, "vim_id": "6", "tenant_id": "7", "res_id": "8"}]
+}
+
+
+c0_data_get_tenant_id = {
+ "tenants": [
+ {
+ "id": "1",
+ "name": "vnfm",
+ }
+ ]
+}
+
+c1_data_create_volume = {
+ "vimId": "f1e33529-4a88-4155-9d7a-893cf2c80527",
+ "nodeId": "",
+ "id": "234",
+ "name": "volume1"
+}
+
+c1_data_get_volume = {
+ "vimId": "f1e33529-4a88-4155-9d7a-893cf2c80527",
+ "status": "AVAILABLE"
+}
+
+c2_data_create_network = {
+ "vimId": "f1e33529-4a88-4155-9d7a-893cf2c80527",
+ "nodeId": "",
+ "id": "234"
+}
+
+c3_data_create_subnet = {
+ "vimId": "f1e33529-4a88-4155-9d7a-893cf2c80527",
+ "id": "345"
+}
+
+c4_data_create_port = {
+ "vimId": "f1e33529-4a88-4155-9d7a-893cf2c80527",
+ "nodeId": "",
+ "id": "456"
+}
+
+c5_data_get_flavor = [{
+ "flavors": {
+ "flavor": [
+ {
+ "flavor-id": "111111",
+ "hpa-capabilities": [
+ {
+ "hpa-capability-id": "1243",
+ "hpa-feature-attributes": [
+ {
+ "hpa-attribute-key": "memoryPageSize",
+ "hpa-attribute-value": {"value": 2, "unit": "MB"}
+ }
+ ]
+ }
+ ]
+ }
+ ]
+ }
+}]
+
+c6_data_list_image = {
+ "images": [
+ {
+ "name": "cirros.img",
+ "id": "678"
+ }
+ ]
+}
+
+c6_data_create_vm = {
+ "id": "789",
+ "name": "vm"
+}
+
+c6_data_get_vm = {
+ "id": "789",
+ "status": "Active",
+ "name": "vm"
}
class SampleViewTest(unittest.TestCase):
def setUp(self):
- self.client = Client()
+ self.client = APIClient()
def tearDown(self):
pass
resp_data = json.loads(response.content)
self.assertEqual({"status": "active"}, resp_data)
- def test_inst_res(self):
+ @mock.patch.object(restcall, 'call_req')
+ def test_inst_res(self, mock_call_req):
+ r0_data_get_tenant_id = [0, json.JSONEncoder().encode(c0_data_get_tenant_id), '200']
+ r1_data_create_volume = [0, json.JSONEncoder().encode(c1_data_create_volume), '200']
+ r1_data_get_volume = [0, json.JSONEncoder().encode(c1_data_get_volume), '200']
+ r2_data_create_network = [0, json.JSONEncoder().encode(c2_data_create_network), '200']
+ r3_data_create_subnet = [0, json.JSONEncoder().encode(c3_data_create_subnet), '200']
+ r4_data_create_port = [0, json.JSONEncoder().encode(c4_data_create_port), '200']
+ r5_data_get_flavor = [0, json.JSONEncoder().encode(c5_data_get_flavor), '200']
+ r6_data_list_image = [0, json.JSONEncoder().encode(c6_data_list_image), '200']
+ r6_data_create_vm = [0, json.JSONEncoder().encode(c6_data_create_vm), '200']
+ r6_data_get_vm = [0, json.JSONEncoder().encode(c6_data_get_vm), '200']
+
+ mock_call_req.side_effect = [r0_data_get_tenant_id,
+ r1_data_create_volume, r1_data_get_volume,
+ r2_data_create_network,
+ r3_data_create_subnet,
+ r4_data_create_port,
+ r5_data_get_flavor,
+ r6_data_list_image, r6_data_create_vm, r6_data_get_vm]
resp = self.client.post(inst_res_url, data=json.dumps(inst_res_data), content_type='application/json')
self.failUnlessEqual(status.HTTP_204_NO_CONTENT, resp.status_code)
- def test_term_res(self):
+ @mock.patch.object(restcall, 'call_req')
+ def test_term_res(self, mock_call_req):
+ r0_data_delete = [0, json.JSONEncoder().encode({"vim_id": "123"}), '200']
+ mock_call_req.side_effect = [r0_data_delete,
+ r0_data_delete,
+ r0_data_delete,
+ r0_data_delete,
+ r0_data_delete,
+ r0_data_delete,
+ r0_data_delete]
resp = self.client.post(term_res_url, data=json.dumps(term_res_data), content_type='application/json')
self.failUnlessEqual(status.HTTP_204_NO_CONTENT, resp.status_code)
from rest_framework import status
from rest_framework.views import APIView
from rest_framework.response import Response
-from .resources import ResCreateThread, ResDeleteThread
+# from .resources import ResCreateThread, ResDeleteThread
+from lcm.pub.vimapi import adaptor
logger = logging.getLogger(__name__)
@swagger_auto_schema(
responses={
status.HTTP_204_NO_CONTENT: 'Successfully'})
+ def do_notify(delf, res_type, ret):
+ logger.debug('ret of [%s] is %s', res_type, ret)
+
def post(self, request, action_type):
logger.debug("ResourceList post(%s): %s", action_type, request.data)
if action_type == "inst":
- ResCreateThread(request.data).start()
+ # ResCreateThread(request.data).start()
+ adaptor.create_vim_res(request.data, self.do_notify)
else:
- ResDeleteThread(request.data).start()
+ # ResDeleteThread(request.data).start()
+ adaptor.delete_vim_res(request.data, self.do_notify)
return Response(data=None, status=status.HTTP_204_NO_CONTENT)
Code Review / vfc / gvnfm / vnflcm.git / commitdiff