summaryrefslogtreecommitdiffstats
path: root/robotframework-onap/ONAPLibrary/HeatVNFValidation.py
diff options
context:
space:
mode:
Diffstat (limited to 'robotframework-onap/ONAPLibrary/HeatVNFValidation.py')
-rw-r--r--robotframework-onap/ONAPLibrary/HeatVNFValidation.py323
1 files changed, 323 insertions, 0 deletions
diff --git a/robotframework-onap/ONAPLibrary/HeatVNFValidation.py b/robotframework-onap/ONAPLibrary/HeatVNFValidation.py
new file mode 100644
index 0000000..e74fc44
--- /dev/null
+++ b/robotframework-onap/ONAPLibrary/HeatVNFValidation.py
@@ -0,0 +1,323 @@
+# Copyright 2019 AT&T Intellectual Property. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from robot.api.deco import keyword
+
+import json
+import yaml
+import requests
+
+stack_url = "{}/stacks/{}"
+stack_resources_url = "{}/stacks/{}/resources"
+
+
+# use this to import and run validation from robot
+class HeatVNFValidation:
+ def __init__(self):
+ pass
+
+ @keyword
+ def validate(self, orchestration_url, token, manifest, vnf_name):
+ validator = StackValidation(orchestration_url, token, manifest, vnf_name)
+ validator.create_summary()
+ validator.validate_summary()
+
+ return validator.report
+
+
+class StackValidation:
+ def __init__(self, orchestration_url, token, manifest, vnf_name):
+ """retrieves stack and template details, and creates
+ a report for submission to OVP portal.
+
+ :orchestration_url heat service endpoint in openstack
+ :token keystone auth token
+ :manifest json that contains list of heat templates, env,
+ preloads, and stack names for each module in
+ a VNF
+ """
+ self.modules = []
+ self.url = orchestration_url
+ self.token = token
+ self.manifest = manifest
+ self.vnf_name = vnf_name
+ self.report = {}
+
+ self.load_manifest()
+
+ def load_manifest(self):
+ for entry in self.manifest:
+ template = entry.get("template_name")
+ env_file = template.replace(".yaml", ".env").replace(".yml", ".env")
+ preload = entry.get("preload_name")
+ stack = entry.get("stack_name")
+ module = HeatModule(
+ template,
+ env_file,
+ stack,
+ preload
+ )
+ module.get_data(self.url, self.token)
+ self.modules.append(module)
+
+ def create_summary(self):
+ """creates a report dictionary to compare stack
+ resources, parameters, outputs w/ template"""
+ self.report["modules"] = []
+ self.report["VNF Name"] = self.vnf_name
+ for module in self.modules:
+ stack = module.stack
+ preload = module.preload
+ template = module.template
+
+ module_report = {}
+ module_report["stack_details"] = stack.stack_details
+
+ module_report["resources"] = {}
+ module_report["resources"]["summary"] = ""
+
+ module_report["parameters"] = {}
+ module_report["parameters"]["summary"] = ""
+
+ module_report["outputs"] = {}
+ module_report["outputs"]["summary"] = ""
+
+ module_report["resources"]["stack_resources"] = stack.resources
+ module_report["resources"]["template_resources"] = template.resources
+
+ module_report["parameters"]["stack_parameters"] = stack.parameters
+ module_report["parameters"]["template_parameters"] = dict(template.parameters, **preload.parameters)
+
+ module_report["outputs"]["stack_outputs"] = stack.outputs
+ module_report["outputs"]["template_outputs"] = template.outputs
+
+ self.report["modules"].append(module_report)
+
+ def validate_summary(self):
+ # validates resources, parameters, and outputs
+ self.validate_resources()
+ self.validate_parameters()
+ self.validate_outputs()
+
+ self.report["summary"] = "SUCCESS"
+ for module in self.report["modules"]:
+ if module["resources"]["summary"] != "SUCCESS":
+ self.report["summary"] = "FAILED"
+ break
+ if module["parameters"]["summary"] != "SUCCESS":
+ self.report["summary"] = "FAILED"
+ break
+ if module["outputs"]["summary"] != "SUCCESS":
+ self.report["summary"] = "FAILED"
+ break
+
+ def validate_resources(self):
+ """validates that all resources from a heat template
+ are present in instantiated heat stack"""
+ report = self.report
+ for module in report["modules"]:
+ module["resources"]["summary"] = "SUCCESS"
+ resources = module.get("resources", {})
+ template_resources = resources.get("template_resources", [])
+ stack_resources = resources.get("stack_resources", [])
+
+ if len(stack_resources) != len(template_resources):
+ module["resources"]["summary"] = "FAILED"
+ continue
+
+ stack_rids = []
+ for s_resource in stack_resources:
+ stack_rids.append(s_resource.get("resource_id"))
+
+ template_rids = []
+ for t_resource in template_resources:
+ template_rids.append(t_resource.get("resource_id"))
+
+ if stack_rids.sort() != template_rids.sort():
+ module["resources"]["summary"] = "FAILED"
+ continue
+
+ def validate_parameters(self):
+ """validates that parameter name/value from template
+ == values from instantiated heat stack"""
+ report = self.report
+ for module in report["modules"]:
+ module["parameters"]["summary"] = "SUCCESS"
+ parameters = module.get("parameters", {})
+ template_parameters = parameters.get("template_parameters", {})
+ stack_parameters = parameters.get("stack_parameters", {})
+
+ for parameter, parameter_value in template_parameters.items():
+ stack_parameter = stack_parameters.get(parameter)
+ if not stack_parameter:
+ module["parameters"]["summary"] = "FAILED"
+ break
+
+ if stack_parameter != parameter_value:
+ module["parameters"]["summary"] = "FAILED"
+ break
+
+ def validate_outputs(self):
+ """validates that all outputs from a heat template
+ are present in instantiated heat stack"""
+ report = self.report
+ for module in report["modules"]:
+ module["outputs"]["summary"] = "SUCCESS"
+ outputs = module.get("outputs", {})
+ template_outputs = outputs.get("template_outputs", {})
+ stack_outputs = outputs.get("stack_outputs", [])
+
+ for output in stack_outputs:
+ output_key = output.get("output_key")
+ if output_key not in template_outputs:
+ module["outputs"]["summary"] = "FAILED"
+ break
+
+
+class HeatModule:
+ def __init__(self, heat_template, environment_file, stack_name, preload):
+ """
+ creates module object that has stack, preload, and template objects
+
+ :heat_template /path/to/heat/template.yaml
+ :environment_file /path/to/heat/env.env
+ :preload /path/to/preloads/file.json
+ :stack_name name of heat stack in openstack
+ """
+ self.stack = HeatStack(stack_name)
+ self.template = HeatTemplate(heat_template, environment_file)
+ self.preload = HeatPreload(preload)
+
+ def get_data(self, url, token):
+ self.stack.get_data(url, token)
+ self.template.get_data()
+ self.preload.get_data()
+
+
+class HeatTemplate:
+ def __init__(self, heat_template, environment_file):
+ """
+ creates template object that holds template resources,
+ parameters, and outputs of a heat template/env pair.
+
+ :heat_template /path/to/heat/template.yaml
+ :environment_file /path/to/heat/env.env
+ """
+ self.template = heat_template
+ self.env = environment_file
+ self.resources = []
+ self.parameters = {}
+ self.outputs = []
+
+ def get_data(self):
+ with open(self.template, "r") as f:
+ ydata = yaml.safe_load(f)
+
+ resources = ydata.get("resources", {})
+
+ for rid, resource in resources.items():
+ self.resources.append(
+ {"resource_id": rid, "resource_type": resource.get("type", "")}
+ )
+
+ outputs = ydata.get("outputs", {})
+
+ for output, output_value in outputs.items():
+ self.outputs.append(output)
+
+ with open(self.env, "r") as f:
+ ydata = yaml.safe_load(f)
+
+ self.parameters = ydata.get("parameters", {})
+
+
+class HeatPreload:
+ def __init__(self, preload):
+ """
+ creates preload object that holds parameter name/values
+
+ :preload /path/to/preloads/file.json
+ """
+ self.preload = preload
+ self.parameters = {}
+
+ def get_data(self):
+ with open(self.preload, "r") as f:
+ jdata = json.loads(f.read())
+
+ # get parameters regardless of API version
+
+ vnf_api_parameters = (
+ jdata.get("input", {})
+ .get("vnf-topology-information", {})
+ .get("vnf-parameters", [])
+ )
+
+ for parameter in vnf_api_parameters:
+ p_name = parameter.get("vnf-parameter-name")
+ p_value = parameter.get("vnf-parameter-value")
+ self.parameters[p_name] = p_value
+
+ gr_api_parameters = (
+ jdata.get("input", {})
+ .get("preload-vf-module-topology-information", {})
+ .get("vf-module-topology", {})
+ .get("vf-module-parameters", {})
+ .get("param", [])
+ )
+
+ for parameter in gr_api_parameters:
+ p_name = parameter.get("name")
+ p_value = parameter.get("value")
+ self.parameters[p_name] = p_value
+
+
+class HeatStack:
+ def __init__(self, stack_name):
+ """
+ creates stack object that hold stack resources,
+ parameters, and outputs
+
+ :stack_name name of heat stack in openstack
+ """
+ self.stack_name = stack_name
+ self.resources = []
+ self.parameters = {}
+ self.outputs = []
+ self.status = ""
+ self.stack_details = {}
+
+ def get_data(self, orchestration_url, token):
+ url = stack_url.format(orchestration_url, self.stack_name)
+ r = requests.get(headers={"X-Auth-Token": token}, url=url)
+
+ if r.status_code == 200:
+ response = r.json()
+ self.parameters = response.get("stack", {}).get("parameters", {})
+ self.outputs = response.get("stack", {}).get("outputs", {})
+ self.status = response.get("stack", {}).get("stack_status", "")
+ self.stack_details = response.get("stack", {})
+
+ url = stack_resources_url.format(orchestration_url, self.stack_name)
+ r = requests.get(headers={"X-Auth-Token": token}, url=url)
+ if r.status_code == 200:
+ response = r.json()
+ resources = response.get("resources", [])
+ for resource in resources:
+ self.resources.append(
+ {
+ "resource_id": resource.get("resource_name"),
+ "resource_type": resource.get("resource_type"),
+ "resource_status": resource.get("resource_status"),
+ }
+ )