Create flavor refer to new datamodel

Change-Id: If96e765649b7caacf93f3e75cc48e771efb8fc93
Issue-ID: VFC-657
Signed-off-by: Huang Haibin <haibin.huang@intel.com>

6 files changed, 225 insertions, 61 deletions

diff --git a/lcm/lcm/nf/tests/test_vnf_cancel.py b/lcm/lcm/nf/tests/test_vnf_cancel.py
index 6e431e06..ef0c7cf2 100644
--- a/lcm/lcm/nf/tests/test_vnf_cancel.py
+++ b/lcm/lcm/nf/tests/test_vnf_cancel.py
@@ -161,7 +161,8 @@ class TestNFTerminate(TestCase):
                 "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",
diff --git a/lcm/lcm/pub/msapi/aai.py b/lcm/lcm/pub/msapi/aai.py
index 3dffa58b..e229628b 100644
--- a/lcm/lcm/pub/msapi/aai.py
+++ b/lcm/lcm/pub/msapi/aai.py
@@ -51,5 +51,19 @@ def get_flavor_info(vim_id):
     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]
diff --git a/lcm/lcm/pub/vimapi/adaptor.py b/lcm/lcm/pub/vimapi/adaptor.py
index d07a3569..34856197 100644
--- a/lcm/lcm/pub/vimapi/adaptor.py
+++ b/lcm/lcm/pub/vimapi/adaptor.py
@@ -33,6 +33,7 @@ RES_SUBNET = "subnet"
 RES_PORT = "port"
 RES_FLAVOR = "flavor"
 RES_VM = "vm"
+NOT_PREDEFINED = 1
 
 
 def get_tenant_id(vim_cache, vim_id, tenant_name):
@@ -73,10 +74,12 @@ def create_vim_res(data, do_notify):
         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):
@@ -86,7 +89,7 @@ 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"])
@@ -199,57 +202,70 @@ def create_port(vim_cache, res_cache, data, port, do_notify, res_type):
     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):
diff --git a/lcm/lcm/pub/vimapi/api.py b/lcm/lcm/pub/vimapi/api.py
index f5bd7b6c..0090d66f 100644
--- a/lcm/lcm/pub/vimapi/api.py
+++ b/lcm/lcm/pub/vimapi/api.py
@@ -14,6 +14,7 @@
 
 import json
 
+from lcm.pub.msapi.aai import delete_aai_flavor
 from lcm.pub.utils.restcall import req_by_msb
 from .exceptions import VimException
 
@@ -113,7 +114,10 @@ def create_flavor(vim_id, tenant_id, data):
 
 
 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):
diff --git a/lcm/lcm/samples/tests.py b/lcm/lcm/samples/tests.py
index efb5b108..e34f6a1f 100644
--- a/lcm/lcm/samples/tests.py
+++ b/lcm/lcm/samples/tests.py
@@ -12,18 +12,38 @@
 # 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",
@@ -43,12 +63,6 @@ inst_res_data = {
                     "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"
@@ -208,7 +222,7 @@ inst_res_data = {
             "vl_id": "vl_vNat",
             "description": "",
             "cp_id": "cp_vNat",
-            "vdu_id": "vdu_vNat"
+            "vdu_id": "VDU_vbng_0"
         }
     ],
     "metadata": {
@@ -231,19 +245,100 @@ inst_res_data = {
         "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
@@ -254,10 +349,38 @@ class SampleViewTest(unittest.TestCase):
         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)
diff --git a/lcm/lcm/samples/views.py b/lcm/lcm/samples/views.py
index 5e804a73..de4e1bdd 100644
--- a/lcm/lcm/samples/views.py
+++ b/lcm/lcm/samples/views.py
@@ -18,7 +18,8 @@ from drf_yasg.utils import swagger_auto_schema
 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__)
 
@@ -36,10 +37,15 @@ class ResourceList(APIView):
     @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)