"vlanTransparent": str(self.vl_properties.get("vlan_transparent", "")),
"routerExternal": self.route_external,
"resourceProviderType": "",
- "resourceProviderId": ""}
+ "resourceProviderId": "",
+ "subnet_list": [{
+ "subnet_name": self.vl_properties.get("name", ""),
+ "cidr": self.vl_properties.get("cidr", "192.168.0.0/24"),
+ "ip_version": self.vl_properties.get("ip_version", const.IPV4),
+ "enable_dhcp": self.vl_properties.get("dhcp_enabled", False),
+ "gateway_ip": self.vl_properties.get("gateway_ip", ""),
+ "dns_nameservers": self.vl_properties.get("dns_nameservers", ""),
+ "host_routes": self.vl_properties.get("host_routes", "")
+ }]
+ }
resmgr.create_vl(req_param)
def create_vl_inst_id_in_vnffg(self):
import traceback
import uuid
from threading import Thread
-from lcm.ns.const import OWNER_TYPE
+from lcm.ns.const import OWNER_TYPE
from lcm.ns.vnfs.const import VNF_STATUS, NFVO_VNF_INST_TIMEOUT_SECOND, INST_TYPE, INST_TYPE_NAME
from lcm.ns.vnfs.wait_job import wait_job_finish
from lcm.pub.config.config import REPORT_TO_AAI
"vnf-type": "vnf-type-test111",
"service-id": self.ns_inst_id,
"in-maint": True,
- "is-closed-loop-disabled": False
+ "is-closed-loop-disabled": False,
+ "relationship-list": {
+ "relationship": [
+ {
+ "related-to": "service-instance",
+ "relationship-data": [
+ {
+ "relationship-key": "customer.global-customer-id",
+ "relationship-value": "global-customer-id-" + self.ns_inst_id
+ },
+ {
+ "relationship-key": "service-subscription.service-type",
+ "relationship-value": "service-type-" + self.ns_inst_id
+ },
+ {
+ "relationship-key": "service-instance.service-instance-id",
+ "relationship-value": self.ns_inst_id
+ }
+ ]
+ }
+ ]
+ }
}
resp_data, resp_status = create_vnf_aai(self.nf_inst_id, data)
if resp_data:
- logger.debug("Fail to create vnf instance[%s] to aai, resp_status: [%s]." % (self.nf_inst_id, resp_status))
+ logger.debug("Fail to create vnf instance[%s] to aai, vnf instance=[%s], resp_status: [%s]."
+ % (self.nf_inst_id, self.ns_inst_id, resp_status))
else:
- logger.debug("Success to create vnf instance[%s] to aai, resp_status: [%s]." % (self.nf_inst_id, resp_status))
+ logger.debug("Success to create vnf instance[%s] to aai, vnf instance=[%s], resp_status: [%s]."
+ % (self.nf_inst_id, self.ns_inst_id, resp_status))
def create_vserver_in_aai(self):
- logger.debug("create_vserver_in_aai start!")
+ logger.debug("CreateVnfs::create_vserver_in_aai::report vserver instance to aai.")
cloud_owner, cloud_region_id = split_vim_to_owner_region(self.vim_id)
# query vim_info from aai
"prov-status": "ACTIVE",
"vserver-selflink": "",
"in-maint": True,
- "is-closed-loop-disabled": False
+ "is-closed-loop-disabled": False,
+ "relationship-list": {
+ "relationship": [
+ {
+ "related-to": "generic-vnf",
+ "relationship-data": [
+ {
+ "relationship-key": "generic-vnf.vnf-id",
+ "relationship-value": self.nf_inst_id
+ }
+ ]
+ }
+ ]
+ }
}
# create vserver instance in aai
resp_data, resp_status = create_vserver_aai(cloud_owner, cloud_region_id, tenant_id, vserver_id, data)
if resp_data:
- logger.debug(
- "Fail to create vserver instance[%s] to aai, resp_status: [%s]." % (vserver_id, resp_status))
+ logger.debug("Fail to create vserver instance[%s] to aai, vnf instance=[%s], resp_status: [%s]."
+ % (vserver_id, self.nf_inst_id, resp_status))
else:
- logger.debug(
- "Success to create vserver instance[%s] to aai, resp_status: [%s]." % (vserver_id, resp_status))
-
- logger.debug("create_vserver_in_aai end!")
+ logger.debug("Success to create vserver instance[%s] to aai, vnf instance=[%s], resp_status: [%s]."
+ % (vserver_id, self.nf_inst_id, resp_status))
import copy
import ftplib
import json
+import logging
import os
import re
import shutil
from lcm.pub.utils.toscaparser.dataentityext import DataEntityExt
+logger = logging.getLogger(__name__)
+
class BaseInfoModel(object):
valid_params = self._validate_input_params(file_name, params)
return self._create_tosca_template(file_name, valid_params)
finally:
- if file_name != None and file_name != path and os.path.exists(file_name):
+ if file_name is not None and file_name != path and os.path.exists(file_name):
try:
os.remove(file_name)
- except Exception, e:
- pass
+ except Exception as e:
+ logger.error("Failed to parse package, error: %s", e.message)
def _validate_input_params(self, path, params):
valid_params = {}
if params and len(params) > 0:
tmp = self._create_tosca_template(path, None)
- for key,value in params.items():
+ for key, value in params.items():
if hasattr(tmp, 'inputs') and len(tmp.inputs) > 0:
for input_def in tmp.inputs:
if (input_def.name == key):
print "-----------------------------"
return tosca_tpl
finally:
- if tosca_tpl != None and hasattr(tosca_tpl, "temp_dir") and os.path.exists(tosca_tpl.temp_dir):
+ if tosca_tpl is not None and hasattr(tosca_tpl, "temp_dir") and os.path.exists(tosca_tpl.temp_dir):
try:
shutil.rmtree(tosca_tpl.temp_dir)
- except Exception, e:
- pass
+ except Exception as e:
+ logger.error("Failed to create tosca template, error: %s", e.message)
def _check_download_file(self, path):
if (path.startswith("ftp") or path.startswith("sftp")):
sftp = paramiko.SFTPClient.from_transport(t)
sftp.get(remoteFileName, localFileName)
finally:
- if t != None:
+ if t is not None:
t.close()
-
def ftp_get(self, userName, userPwd, hostIp, hostPort, remoteFileName, localFileName):
f = None
try:
ftp.retrbinary('RETR ' + remoteFileName, f.write, 1024)
f.close()
finally:
- if f != None:
+ if f is not None:
f.close()
def buidMetadata(self, tosca):
properties[k] = str(item)
return properties
-
def verify_properties(self, props, inputs, parsed_params):
ret_props = {}
if (props and len(props) > 0):
if (isinstance(req_value, dict)):
if ('node' in req_value and req_value['node'] not in node_template.templates):
continue # No target requirement for aria parser, not add to result.
- rets.append({req_name : req_value})
+ rets.append({req_name: req_value})
return rets
def buildCapabilities(self, nodeTemplate, inputs, ret):
capabilities = json.dumps(nodeTemplate.entity_tpl.get('capabilities', None))
- match = re.findall(r'\{"get_input":\s*"([\w|\-]+)"\}',capabilities)
+ match = re.findall(r'\{"get_input":\s*"([\w|\-]+)"\}', capabilities)
for m in match:
- aa= [input_def for input_def in inputs
- if m == input_def.name][0]
- capabilities = re.sub(r'\{"get_input":\s*"([\w|\-]+)"\}', json.dumps(aa.default), capabilities,1)
+ aa = [input_def for input_def in inputs if m == input_def.name][0]
+ capabilities = re.sub(r'\{"get_input":\s*"([\w|\-]+)"\}', json.dumps(aa.default), capabilities, 1)
if capabilities != 'null':
ret['capabilities'] = json.loads(capabilities)
def buildArtifacts(self, nodeTemplate, inputs, ret):
artifacts = json.dumps(nodeTemplate.entity_tpl.get('artifacts', None))
- match = re.findall(r'\{"get_input":\s*"([\w|\-]+)"\}',artifacts)
+ match = re.findall(r'\{"get_input":\s*"([\w|\-]+)"\}', artifacts)
for m in match:
- aa= [input_def for input_def in inputs
- if m == input_def.name][0]
- artifacts = re.sub(r'\{"get_input":\s*"([\w|\-]+)"\}', json.dumps(aa.default), artifacts,1)
+ aa = [input_def for input_def in inputs if m == input_def.name][0]
+ artifacts = re.sub(r'\{"get_input":\s*"([\w|\-]+)"\}', json.dumps(aa.default), artifacts, 1)
if artifacts != 'null':
ret['artifacts'] = json.loads(artifacts)
return node['nodeType'].upper().find('.CP.') >= 0 or node['nodeType'].upper().endswith('.CP')
def isVl(self, node):
- return node['nodeType'].upper().find('.VIRTUALLINK.') >= 0 or node['nodeType'].upper().find('.VL.') >= 0 or \
- node['nodeType'].upper().endswith('.VIRTUALLINK') or node['nodeType'].upper().endswith('.VL')
+ isvl = node['nodeType'].upper().find('.VIRTUALLINK.') >= 0 or node['nodeType'].upper().find('.VL.') >= 0
+ isvl = isvl or node['nodeType'].upper().endswith('.VIRTUALLINK') or node['nodeType'].upper().endswith('.VL')
+ return isvl
def isService(self, node):
return node['nodeType'].upper().find('.SERVICE.') >= 0 or node['nodeType'].upper().endswith('.SERVICE')
def getVirtualbindings(self, node):
return self.getRequirementByName(node, 'virtualbinding')
-
def getRequirementByName(self, node, requirementName):
requirements = []
if 'requirements' in node:
if 'requirements' in node:
for item in node['requirements']:
for key, value in item.items():
- if key.upper().find('VIRTUALLINK') >=0:
- rets.append({"key_name":key, "vl_id":self.get_requirement_node_name(value)})
+ if key.upper().find('VIRTUALLINK') >= 0:
+ rets.append({"key_name": key, "vl_id": self.get_requirement_node_name(value)})
return rets
def _verify_value(self, value, inputs, parsed_params):
from toscaparser.elements.constraints import Schema
from toscaparser.common.exception import ExceptionCollector
-class DataEntityExt(object):
+class DataEntityExt(object):
'''A complex data value entity ext.'''
@staticmethod
def validate_datatype(type, value, entry_schema=None, custom_def=None):
return float(value)
except Exception:
ExceptionCollector.appendException(ValueError(('"%s" is not an float.') % value))
-
return DataEntity.validate_datatype(type, value, entry_schema, custom_def)
return value
self.ns_flavours = self.get_all_flavour(tosca.topology_template.groups)
self.nested_ns = self.get_all_nested_ns(nodeTemplates)
-
def buildInputs(self, top_inputs):
ret = {}
for tmpinput in top_inputs:
return ret
def buildNode(self, nodeTemplate, inputs, parsed_params):
- ret ={}
+ ret = {}
ret['name'] = nodeTemplate.name
ret['nodeType'] = nodeTemplate.type
if 'description' in nodeTemplate.entity_tpl:
self.buildCapabilities(nodeTemplate, inputs, ret)
self.buildArtifacts(nodeTemplate, inputs, ret)
interfaces = self.build_interfaces(nodeTemplate)
- if interfaces: ret['interfaces'] = interfaces
+ if interfaces:
+ ret['interfaces'] = interfaces
return ret
def _get_all_vnf(self, nodeTemplates):
for key, value in item.items():
if key.upper().startswith('VIRTUALBINDING'):
req_node_name = self.get_requirement_node_name(value)
- if req_node_name != None and req_node_name == node['name']:
+ if req_node_name is not None and req_node_name == node['name']:
cps.append(tmpnode)
return cps
cp_vl = {}
cp_vl['vl_id'] = self.get_prop_from_obj(req, 'node')
relationship = self.get_prop_from_obj(req, 'relationship')
- if relationship != None:
+ if relationship is not None:
properties = self.get_prop_from_obj(relationship, 'properties')
- if properties != None and isinstance(properties, dict):
+ if properties is not None and isinstance(properties, dict):
for key, value in properties.items():
cp_vl[key] = value
return cp_vl
self.vnf_exposed = self.get_all_endpoint_exposed(tosca.topology_template)
self.vnf_flavours = self.get_all_flavour(tosca.topology_template.groups)
-
def _get_all_services(self, nodeTemplates):
ret = []
for node in nodeTemplates:
ret['dependencies'] = map(lambda x: self.get_requirement_node_name(x), self.getNodeDependencys(node))
nfv_compute = self.getCapabilityByName(node, 'nfv_compute')
- if nfv_compute != None and 'properties' in nfv_compute:
+ if nfv_compute is not None and 'properties' in nfv_compute:
ret['nfv_compute'] = nfv_compute['properties']
ret['vls'] = self.get_linked_vl_ids(node, nodeTemplates)
scalable = self.getCapabilityByName(node, 'scalable')
- if scalable != None and 'properties' in scalable:
+ if scalable is not None and 'properties' in scalable:
ret['scalable'] = scalable['properties']
ret['cps'] = self.getVirtalBindingCpIds(node, nodeTemplates)
policies = []
scaling_policies = self.get_scaling_policies(top_policies)
healing_policies = self.get_healing_policies(top_policies)
- policies.append({"scaling":scaling_policies, 'healing':healing_policies})
+ policies.append({"scaling": scaling_policies, 'healing': healing_policies})
return policies
def get_healing_policies(self, top_policies):
- return self.get_policies_by_keyword(top_policies,'.HEALING')
+ return self.get_policies_by_keyword(top_policies, '.HEALING')
if old_key.upper() == key.upper():
return args[old_key]
return def_val
-
import logging
import traceback
-from rest_framework.views import APIView
-from rest_framework.response import Response
from rest_framework import status
-from lcm.pub.database import models
-
+from rest_framework.response import Response
+from rest_framework.views import APIView
logger = logging.getLogger(__name__)
logger.debug("get")
return Response({"status": "active"})
+
class TablesList(APIView):
def delete(self, request, modelName):
logger.debug("Start delete model %s", modelName)
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
return Response(data={}, status=status.HTTP_204_NO_CONTENT)
-
def get(self, request, modelName):
logger.debug("Get model %s", modelName)
count = 0
return Response(data={"error": "failed"},
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
return Response(data={"count": count}, status=status.HTTP_200_OK)
-
-
-
-
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
import unittest
-import json
+
from django.test import Client
from rest_framework import status
import json
import logging
import os
-import traceback
-from rest_framework import status
from rest_framework.response import Response
from rest_framework.views import APIView
-
logger = logging.getLogger(__name__)
class SwaggerJsonView(APIView):
def get(self, request):
-
json_file = os.path.join(os.path.dirname(__file__), 'vfc.nslcm.swagger.json')
f = open(json_file)
json_data = json.JSONDecoder().decode(f.read())
json_data["paths"].update(json_data_temp["paths"])
json_data["definitions"].update(json_data_temp["definitions"])
-
json_file = os.path.join(os.path.dirname(__file__), 'vfc.sfclcm.swagger.json')
f = open(json_file)
json_data_temp = json.JSONDecoder().decode(f.read())
json_data["paths"].update(json_data_temp["paths"])
json_data["definitions"].update(json_data_temp["definitions"])
-
json_file = os.path.join(os.path.dirname(__file__), 'vfc.others.swagger.json')
f = open(json_file)
json_data_temp = json.JSONDecoder().decode(f.read())
f.close()
- json_data_jobtemp=json_data["paths"]["/jobs/{jobId}"]
+ json_data_jobtemp = json_data["paths"]["/jobs/{jobId}"]
json_data["paths"].update(json_data_temp["paths"])
json_data["paths"]["/jobs/{jobId}"].update(json_data_jobtemp)
json_data["definitions"].update(json_data_temp["definitions"])
-
return Response(json_data)
-
-
-
logger = logging.getLogger(__name__)
+
def deploy_workflow_on_startup():
try:
if WFPlanModel.objects.filter():
logger.info("Deploy workflow successfully.")
except:
logger.error(traceback.format_exc())
-
"sdnControllerId": uuid of SDN controller
}
"""
+
+
def run_ns_instantiate(input_data):
logger.debug("Enter %s, input_data is %s", fun_name(), input_data)
ns_instantiate_ok = False
logger.debug("Create VL(%s) successfully.", vl_id)
+
def create_vnf(ns_inst_id, vnf_index, nf_param):
uri = "api/nslcm/v1/ns/vnfs"
data = json.JSONEncoder().encode({
logger.debug("Create VNF(%s) started.", vnf_inst_id)
return vnf_inst_id, job_id, vnf_index - 1
+
def create_sfc(ns_inst_id, fp_index, nsd_json, sdnc_id):
uri = "api/nslcm/v1/ns/sfcs"
data = json.JSONEncoder().encode({
logger.debug("Create SFC(%s) started.", sfc_inst_id)
return sfc_inst_id, job_id, fp_index - 1
+
def post_deal(ns_inst_id, status):
uri = "api/nslcm/v1/ns/{nsInstanceId}/postdeal".format(nsInstanceId=ns_inst_id)
data = json.JSONEncoder().encode({
logger.error("Failed to call post_deal(%s): %s", ns_inst_id, ret[1])
logger.debug("Call post_deal(%s, %s) successfully.", ns_inst_id, status)
+
def update_job(job_id, progress, errcode, desc):
uri = "api/nslcm/v1/jobs/{jobId}".format(jobId=job_id)
data = json.JSONEncoder().encode({
})
restcall.req_by_msb(uri, "POST", data)
+
class JobWaitThread(Thread):
"""
Job Wait
"""
-
def __init__(self, inst_id, job_id, ns_job_id, index):
Thread.__init__(self)
self.inst_id = inst_id
if job_end_normal:
g_jobs_status[self.ns_job_id][self.index] = 0
+
def wait_until_jobs_done(g_job_id, jobs):
job_threads = []
for inst_id, job_id, index in jobs:
logger.error("g_jobs_status[%s]: %s", g_job_id, g_jobs_status[g_job_id])
raise NSLCMException("Some jobs failed!")
+
def confirm_vnf_status(vnf_inst_id):
uri = "api/nslcm/v1/ns/vnfs/{vnfInstId}".format(vnfInstId=vnf_inst_id)
ret = restcall.req_by_msb(uri, "GET")
if vnf_status != "active":
raise NSLCMException("Status of VNF(%s) is not active" % vnf_inst_id)
+
def confirm_sfc_status(sfc_inst_id):
uri = "api/nslcm/v1/ns/sfcs/{sfcInstId}".format(sfcInstId=sfc_inst_id)
ret = restcall.req_by_msb(uri, "GET")
sfc_status = ret[1]["sfcStatus"]
if sfc_status != "active":
raise NSLCMException("Status of SFC(%s) is not active" % sfc_inst_id)
-
-
-
-
-
-
-
# See the License for the specific language governing permissions and
# limitations under the License.
-import unittest
import json
-import mock
import os
+import unittest
+
+import mock
from django.test import Client
from rest_framework import status
+from lcm.pub.database.models import WFPlanModel
from lcm.pub.utils import restcall
-from lcm.pub.database.models import WFPlanModel, JobStatusModel
-from lcm.pub.utils.jobutil import JobUtil
from lcm.workflows import build_in
+
class WorkflowViewTest(unittest.TestCase):
def setUp(self):
self.client = Client()
@mock.patch.object(restcall, 'upload_by_msb')
def test_deploy_workflow(self, mock_upload_by_msb):
- mock_upload_by_msb.return_value = [0, json.JSONEncoder().encode({
+ res_data = {
"status": "1",
"message": "2",
"deployedId": "3",
"processId": "4"
- }), '202']
+ }
+ mock_upload_by_msb.return_value = [0, json.JSONEncoder().encode(res_data), '202']
response = self.client.post("/api/nslcm/v1/workflow",
{"filePath": os.path.abspath(__file__)}, format='json')
self.assertEqual(status.HTTP_202_ACCEPTED, response.status_code, response.content)
mock_call_req.return_value = [0, json.JSONEncoder().encode({
"status": "1",
"message": "2"
- }), '202']
+ }), '202']
mock_upload_by_msb.return_value = [0, json.JSONEncoder().encode({
"status": "2",
"message": "3",
"deployedId": "4",
"processId": "5"
- }), '202']
+ }), '202']
WFPlanModel(deployed_id="1", process_id="2", status="3", message="4").save()
response = self.client.post("/api/nslcm/v1/workflow",
{"filePath": os.path.abspath(__file__), "forceDeploy": "True"}, format='json')
"result": "0",
"detail": "vl1",
"vlId": "1"
- }), '201'],
+ }), '201'],
"api/nslcm/v1/ns/vnfs":
[0, json.JSONEncoder().encode({
"vnfInstId": "2",
"jobId": "11"
- }), '201'],
+ }), '201'],
"api/nslcm/v1/ns/vnfs/2":
[0, json.JSONEncoder().encode({
"vnfStatus": "active"
- }), '201'],
+ }), '201'],
"api/nslcm/v1/ns/sfcs":
[0, json.JSONEncoder().encode({
"sfcInstId": "3",
"jobId": "111"
- }), '201'],
+ }), '201'],
"api/nslcm/v1/ns/sfcs/3":
[0, json.JSONEncoder().encode({
"sfcStatus": "active"
- }), '201'],
+ }), '201'],
"/api/nslcm/v1/jobs/11?responseId=0":
[0, json.JSONEncoder().encode({"responseDescriptor": {
"responseId": "1",
"progress": 100,
"statusDescription": "ok"
- }}), '200'],
+ }}), '200'],
"/api/nslcm/v1/jobs/111?responseId=0":
[0, json.JSONEncoder().encode({"responseDescriptor": {
"responseId": "1",
"progress": 100,
"statusDescription": "ok"
- }}), '200'],
+ }}), '200'],
"api/nslcm/v1/jobs/{jobId}".format(jobId=job_id):
[0, '{}', '201'],
"api/nslcm/v1/ns/{nsInstanceId}/postdeal".format(nsInstanceId=ns_inst_id):
mock_call_req.side_effect = side_effect
self.assertTrue(build_in.run_ns_instantiate(wf_input))
-
-
-
-
-
-
-
-
-
-
-
-
return Response(data={'error': str(sys.exc_info())}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
logger.debug("Leave %s", fun_name())
return Response(data={'msg': 'OK'}, status=status.HTTP_202_ACCEPTED)
-
-
-
-
-
Code Review / vfc / nfvo / lcm.git / commitdiff