def __init__(self, test_param):
test_input = {}
test_input["param1"] = test_param
test_input["param2"] = generate_dummy_string()
test_input["param3"] = generate_dummy_date()
super().__init__(test_input)
class LicenseModel(Resource):
resource_name = "LICENSE_MODEL"
spec = {
"vendor_name": {
"type": str,
"required": False,
"default": generate_dummy_string("test_vendor_"),
},
"manufacturer_reference_number": {
"type": str,
"required": False,
"default": generate_dummy_string("mfref"),
},
"entitlement_pool_name": {
"type": str,
"required": False,
"default": generate_dummy_string("test_kg_"),
},
"key_group_name": {
"type": str,
"required": False,
"default": generate_dummy_string("test_ep_"),
},
"feature_group_name": {
"type": str,
"required": False,
"default": generate_dummy_string("test_fg_"),
},
"license_agreement_name": {
"type": str,
"required": False,
"default": generate_dummy_string("test_la_"),
},
"license_start_date": {
"type": str,
"required": False,
"default": generate_dummy_date(days=1),
},
"license_end_date": {
"type": str,
"required": False,
"default": generate_dummy_date(days=365),
},
}
def _create(self, license_input):
"""Creates a license model object in SDC"""
return create_license_model(license_input, oc=self.oc)
def _submit(self):
"""Submits the license model in SDC"""
self.oc.sdc.license_model.submit_license_model(**self.attributes, action="Submit")
license_model = self.oc.sdc.license_model.get_license_model(**self.attributes)
self.attributes["tosca"] = license_model.response_data
def _output(self):
return self.tosca
class Service(Resource):
resource_name = "SERVICE"
spec = {
"instantiation_type": {
"type": str,
"required": False,
"default": "A-la-carte",
},
"service_name": {
"type": str,
"required": False,
"default": generate_dummy_string("test_service_"),
},
"contact_id": {
"type": str,
"required": False,
"default": "cs0008"
},
"category_name": {
"type": str,
"required": False,
"default": "Network L1-3"
},
"tag": {
"type": str,
"required": False,
"default": "robot-ete"
},
"project_code": {
"type": str,
"required": False,
"default": "123456"
},
"environment_context": {
"type": str,
"required": False,
"default": "General_Revenue-Bearing",
},
"ecomp_generated_naming": {
"type": str,
"required": False,
"default": "true"
},
"description": {
"type": str,
"required": False,
"default": "Brand New Service",
},
"service_type": {
"type": str,
"required": False,
"default": ""
},
"service_role": {
"type": str,
"required": False,
"default": ""
},
"naming_policy": {
"type": str,
"required": False,
"default": ""
},
"resources": {
"type": list,
"list_item": dict,
"required": False,
"default": [],
"nested": {
"resource_name": {
"type": str,
"required": True
},
"resource_id": {
"type": str,
"required": False
},
"catalog_resource_name": {
"type": str,
"required": False
},
"origin_type": {
"type": str,
"required": False,
"default": "VF"
},
"properties": {
"type": dict,
"required": False,
"default": {}
},
},
},
"allow_update": {
"type": bool,
"required": False,
"default": False
},
"wait_for_distribution": {
"type": bool,
"required": False,
"default": False
},
}
def __init__(
self,
instantiation_type,
service_name,
contact_id,
category_name,
tag,
project_code,
environment_context,
ecomp_generated_naming,
description,
service_type,
service_role,
naming_policy,
resources=[],
wait_for_distribution=False,
allow_update=False,
):
service_input = {}
category_name_lower = category_name.lower()
category_name_icon = normalize_category_icon(category_name)
category_id = "serviceNewCategory.{}".format(category_name_lower)
service_input["service_name"] = service_name
service_input["instantiation_type"] = instantiation_type
service_input["contact_id"] = contact_id
service_input["category_name"] = category_name
service_input["category_id"] = category_id
service_input["category_name_lower"] = category_name_lower
service_input["category_name_icon"] = category_name_icon
service_input["tag"] = tag
service_input["project_code"] = project_code
service_input["environment_context"] = environment_context
service_input["ecomp_generated_naming"] = ecomp_generated_naming
service_input["description"] = description
service_input["service_type"] = service_type
service_input["service_role"] = service_role
service_input["naming_policy"] = naming_policy
service_input["resources"] = resources
service_input["wait_for_distribution"] = wait_for_distribution
service_input["allow_update"] = allow_update
super().__init__(service_input)
def _create(self, service_input):
"""Creates a service object in SDC"""
service = None
existing = get_service_id(service_input.get("service_name"))
if existing is None:
service = create_service(service_input)
elif service_input.get("allow_update"):
service = update_service(existing, service_input)
else:
raise exceptions.ResourceAlreadyExistsException(
"Service resource {} already exists".format(
service_input.get("service_name")))
return service
def _post_create(self):
resources = self.resources
for resource in resources:
resource_name = resource.get("resource_name")
catalog_resource_name = resource.get("catalog_resource_name")
resource_id = resource.get("resource_id")
resource_properties = resource.get("properties")
if not resource_id:
resource_id = get_vnf_id(catalog_resource_name)
if not resource_id:
raise exceptions.ResourceIDNotFoundException(
"resource ID was not passed, and resource lookup by name was not found {}"
.format(resource_name))
resource_origin = resource.get("origin_type")
self.add_resource(resource_id,
resource_name,
origin_type=resource_origin)
for k, v in resource_properties.items():
if isinstance(v, dict):
v = json.dumps(v).replace('"', '\\"')
self.add_property_value(resource_name, k, v)
def _submit(self):
"""Submits the service in SDC and distributes the model"""
DISTRIBUTION_STEPS = sdc_properties.SERVICE_DISTRIBUTION or []
service_client.checkin_service(**self.attributes,
user_remarks="checking in")
if (not DISTRIBUTION_STEPS
or "request_service_certification" in DISTRIBUTION_STEPS):
service_client.request_service_certification(
**self.attributes, user_remarks="requesting certification")
if (not DISTRIBUTION_STEPS
or "start_service_certification" in DISTRIBUTION_STEPS):
service_client.start_service_certification(
**self.attributes, user_remarks="certifying")
if (not DISTRIBUTION_STEPS
or "finish_service_certification" in DISTRIBUTION_STEPS):
catalog_service = service_client.finish_service_certification(
**self.attributes, user_remarks="certified")
self.attributes[
"catalog_service_id"] = catalog_service.catalog_service_id
if (not DISTRIBUTION_STEPS
or "approve_service_certification" in DISTRIBUTION_STEPS):
service_client.approve_service_certification(
**self.attributes, user_remarks="approved")
headers = {"X-TransactionId": str(uuid.uuid4())}
service_client.distribute_sdc_service(**self.attributes, **headers)
if self.wait_for_distribution:
poll_distribution(self.service_name)
self._refresh()
def add_resource(self,
catalog_resource_id,
catalog_resource_name,
origin_type="VF"):
"""Attaches a resource to a Service in SDC
:catalog_resource_id: ID of a resource in the SDC catalog
:catalog_resource_name: name to give to the resource when attaching to service
:origin_type: specifies the origin of the attached resource
"""
milli_timestamp = int(time.time() * 1000)
component_instances = self.tosca.get("componentInstances", [])
if component_instances:
for component in component_instances:
if component.get("componentName") == catalog_resource_name:
service_client.delete_resource_from_service(
catalog_service_id=self.catalog_service_id,
resource_instance_id=component.get("uniqueId"))
break
resource_instance = service_client.add_resource_instance(
**self.attributes,
posX=random.randrange(150, 550), # nosec
posY=random.randrange(150, 450), # nosec
milli_timestamp=milli_timestamp,
catalog_resource_id=catalog_resource_id,
catalog_resource_name=catalog_resource_name,
originType=origin_type,
).response_data
response = {
"id": resource_instance.get("uniqueId"),
"tosca": resource_instance,
}
self.attributes[catalog_resource_name] = response
self._refresh()
def add_property_value(self, resource_name, property_name, input_value):
"""Updates an property value on a resource attached to a Service
:resource_name: Name of a resource attached to a service
:property_name: property name to update
:input_value: value to update property with
"""
resource = self.attributes.get(resource_name)
if not resource:
raise exceptions.ResourceNotFoundException(
"Resource {} was not found on Service {}".format(
resource_name, self.service_name))
resource_id = resource["id"]
instance_inputs = self.tosca.get("componentInstancesProperties",
{}).get(resource_id, [])
for prop in instance_inputs:
if prop.get("name") == property_name:
unique_id = prop.get("uniqueId")
parent_unique_id = prop.get("parentUniqueId")
owner_id = prop.get("ownerId")
schemaType = prop.get("schemaType", "")
property_type = prop.get("type")
return service_client.add_catalog_service_property(
**self.attributes,
unique_id=unique_id,
parent_unique_id=parent_unique_id,
owner_id=owner_id,
catalog_resource_instance_id=resource_id,
input_name=property_name,
input_value=input_value,
schema_type=schemaType,
property_type=property_type,
)
raise exceptions.PropertyNotFoundException(
"Property {} was not found in VF Instance {}".format(
property_name, resource_id))
def _refresh(self):
self.tosca = service_client.get_sdc_service(
catalog_service_id=self.catalog_service_id).response_data
class ServiceInstance(Resource):
resource_name = "SERVICE_INSTANCE"
spec = {
"service_instance_name": {
"type": str,
"required": False,
"default": generate_dummy_string("SI_"),
},
"requestor_id": {"type": str, "required": False, "default": "cs0008"},
"model_name": {"type": str, "required": True},
"model_version": {"type": str, "required": False, "default": "1.0"},
"tenant_name": {"type": str, "required": True},
"cloud_owner": {"type": str, "required": True},
"cloud_region": {"type": str, "required": True},
"api_type": {"type": str, "required": False, "default": "GR_API"},
"service_type": {"type": str, "required": True},
"customer_name": {"type": str, "required": True},
"project_name": {"type": str, "required": True},
"owning_entity_name": {"type": str, "required": True},
}
def __init__(
self,
service_instance_name,
requestor_id,
model_name,
model_version,
tenant_name,
cloud_owner,
cloud_region,
api_type,
service_type,
customer_name,
project_name,
owning_entity_name,
):
instance_input = {}
tenant_id = get_tenant_id(cloud_region, cloud_owner, tenant_name)
instance_input["service_instance_name"] = service_instance_name
instance_input["requestor_id"] = requestor_id
instance_input["model_name"] = model_name
instance_input["model_version"] = model_version
instance_input["tenant_id"] = tenant_id
instance_input["cloud_owner"] = cloud_owner
instance_input["cloud_region"] = cloud_region
instance_input["api_type"] = api_type
instance_input["service_type"] = service_type
instance_input["customer_id"] = customer_name
instance_input["project_name"] = project_name
instance_input["owning_entity_name"] = owning_entity_name
super().__init__(instance_input)
def _create(self, instance_input):
service_model = sdc_client.service.get_sdc_service(
catalog_service_id=sdc.service.get_service_id(
instance_input.get("model_name")
)
).response_data
instance_input["model_invariant_id"] = service_model["invariantUUID"]
instance_input["model_version_id"] = service_model["uniqueId"]
category_parameters = vid_client.maintenance.get_category_parameters().response_data
for entity in category_parameters.get("categoryParameters", {}).get("owningEntity", []):
if entity.get("name") == instance_input.get("owning_entity_name"):
instance_input["owning_entity_id"] = entity.get("id")
break
return create_service_instance(instance_input)
def _post_create(self):
pass
def _submit(self):
pass
class VNFInstance(Resource):
resource_name = "VNF_INSTANCE"
spec = {
"vnf_instance_name": {
"type": str,
"required": False,
"default": generate_dummy_string("VNF_"),
},
"service_instance_name": {
"type": str,
"required": True
},
"requestor_id": {
"type": str,
"required": False,
"default": "cs0008"
},
"model_name": {
"type": str,
"required": True
},
"tenant_name": {
"type": str,
"required": True
},
"cloud_owner": {
"type": str,
"required": True
},
"cloud_region": {
"type": str,
"required": True
},
"api_type": {
"type": str,
"required": False,
"default": "GR_API"
},
"platform": {
"type": str,
"required": True
},
"line_of_business": {
"type": str,
"required": True
},
}
def __init__(
self,
vnf_instance_name,
service_instance_name,
requestor_id,
model_name,
tenant_name,
cloud_owner,
cloud_region,
api_type,
platform,
line_of_business,
):
instance_input = {}
tenant_id = so.service_instance.get_tenant_id(cloud_region,
cloud_owner, tenant_name)
instance_input["vnf_instance_name"] = vnf_instance_name
instance_input["service_instance_name"] = service_instance_name
instance_input["requestor_id"] = requestor_id
instance_input["model_name"] = model_name
instance_input["tenant_id"] = tenant_id
instance_input["cloud_owner"] = cloud_owner
instance_input["cloud_region"] = cloud_region
instance_input["api_type"] = api_type
instance_input["platform"] = platform
instance_input["line_of_business"] = line_of_business
super().__init__(instance_input)
def _create(self, instance_input):
service_instance = get_service_instance(
instance_input.get("service_instance_name"))
if not service_instance:
raise ServiceInstanceNotFound(
"No service instance found for {}".format(
instance_input.get("service_instance_name")))
service_instance_id = service_instance.get("service-instance-id")
model_information = (service_instance.get("service-data").get(
"service-information").get("onap-model-information"))
service_invariant_id = model_information["model-invariant-uuid"]
service_model_id = model_information["model-uuid"]
service_model_version = model_information["model-version"]
service_model_name = model_information["model-name"]
vnf_component = get_vnf_model_component(
service_model_name, instance_input.get("model_name"))
if not vnf_component:
raise VNFComponentNotFound("No component found for {}".format(
instance_input.get("model_name")))
vnf_model_customization_id = vnf_component["customizationUUID"]
vnf_model_version_id = vnf_component["actualComponentUid"]
vnf_model_version = vnf_component["componentVersion"]
vnf_model = sdc_client.vnf.get_catalog_resource(
catalog_resource_id=vnf_model_version_id, ).response_data
vnf_model_invariant_id = vnf_model["invariantUUID"]
instance_input["model_invariant_id"] = vnf_model_invariant_id
instance_input["model_version_id"] = vnf_model_version_id
instance_input["model_customization_id"] = vnf_model_customization_id
instance_input["model_version"] = vnf_model_version
instance_input["service_model_name"] = service_model_name
instance_input["service_model_invariant_id"] = service_invariant_id
instance_input["service_model_version"] = service_model_version
instance_input["service_model_version_id"] = service_model_id
instance_input["service_instance_id"] = service_instance_id
return create_vnf_instance(instance_input)
def _post_create(self):
pass
def _submit(self):
pass
class VNFInstance(Resource):
resource_name = "VNF_INSTANCE"
spec = {
"vnf_instance_name": {
"type": str,
"required": False,
"default": generate_dummy_string("VNF_"),
},
"service_instance_name": {
"type": str,
"required": True
},
"requestor_id": {
"type": str,
"required": False,
"default": "cs0008"
},
"model_name": {
"type": str,
"required": True
},
"tenant_name": {
"type": str,
"required": True
},
"cloud_owner": {
"type": str,
"required": True
},
"cloud_region": {
"type": str,
"required": True
},
"api_type": {
"type": str,
"required": False,
"default": "GR_API"
},
"platform": {
"type": str,
"required": True
},
"line_of_business": {
"type": str,
"required": True
},
}
def _create(self, instance_input):
tenant_id = so.service_instance.get_tenant_id(
instance_input.get("cloud_region"),
instance_input.get("cloud_owner"),
instance_input.get("tenant_name"),
oc=self.oc)
instance_input["tenant_id"] = tenant_id
service_instance = so.service_instance.get_service_instance(
instance_input.get("service_instance_name"), oc=self.oc)
service_instance_id = service_instance.get("service-instance-id")
model_information = (service_instance.get("service-data").get(
"service-information").get("onap-model-information"))
service_invariant_id = model_information["model-invariant-uuid"]
service_model_id = model_information["model-uuid"]
service_model_version = model_information["model-version"]
service_model_name = model_information["model-name"]
vnf_component = get_vnf_model_component(
service_model_name, instance_input.get("model_name"), oc=self.oc)
if not vnf_component:
raise VNFComponentNotFound("No component found for {}".format(
instance_input.get("model_name")))
vnf_model_customization_id = vnf_component["customizationUUID"]
vnf_model_version_id = vnf_component["actualComponentUid"]
vnf_model_version = vnf_component["componentVersion"]
vnf_model = self.oc.sdc.vnf.get_catalog_resource(
catalog_resource_id=vnf_model_version_id, ).response_data
vnf_model_invariant_id = vnf_model["invariantUUID"]
instance_input["model_invariant_id"] = vnf_model_invariant_id
instance_input["model_version_id"] = vnf_model_version_id
instance_input["model_customization_id"] = vnf_model_customization_id
instance_input["model_version"] = vnf_model_version
instance_input["service_model_name"] = service_model_name
instance_input["service_model_invariant_id"] = service_invariant_id
instance_input["service_model_version"] = service_model_version
instance_input["service_model_version_id"] = service_model_id
instance_input["service_instance_id"] = service_instance_id
return create_vnf_instance(instance_input, oc=self.oc)
def _delete(self, instance_input):
request = delete_vnf_instance(
instance_input.get("service_instance_name"),
instance_input.get("vnf_instance_name"),
instance_input.get("api_type"),
oc=self.oc)
request_id = request.get("requestReferences", {}).get("requestId")
so.service_instance.poll_request(request_id, oc=self.oc)
class VNF(Resource):
resource_name = "VNF"
spec = {
"software_product_name": {"type": str, "required": True},
"description": {"type": str, "required": False, "default": "VNF"},
"vnf_name": {
"type": str,
"required": False,
"default": generate_dummy_string("test_vnf_"),
},
"resource_type": {"type": str, "required": False, "default": "VF"},
"inputs": {"type": dict, "required": False, "default": {}},
"vm_types": {
"type": list,
"list_item": dict,
"required": False,
"default": [],
"nested": {
"vm_type": {"type": str, "required": True},
"properties": {"type": dict, "required": True, "default": {}},
"resources": {
"type": list,
"list_item": dict,
"required": False,
"default": [],
"nested": {
"resource_name": {"type": str, "required": True},
"resource_id": {"type": str, "required": False},
"catalog_resource_name": {"type": str, "required": False},
"origin_type": {"type": str, "required": False, "default": "VF"},
"properties": {"type": dict, "required": False, "default": {}},
"relationship": {
"type": dict,
"required": False,
"default": {},
"nested": {
"relationship_type": {"type": str, "required": True},
"requirement": {"type": str, "required": True},
"requirement_id": {"type": str, "required": True},
"properties": {"type": dict, "required": False, "default": {}},
}
},
},
},
},
},
"network_roles": {
"type": list,
"list_item": dict,
"required": False,
"default": [],
"nested": {
"network_role_tag": {"type": str, "required": True},
"network_role": {"type": str, "required": True},
"related_networks": {
"type": list,
"list_item": str,
"required": False,
"default": [],
},
},
},
"policies": {
"type": list,
"list_item": dict,
"required": False,
"default": [],
"nested": {
"policy_name": {"type": str, "required": True},
"properties": {"type": dict, "required": False, "default": {}},
},
},
"allow_update": {"type": bool, "required": False, "default": False},
}
def _create(self, vnf_input):
"""Creates a vnf object in SDC"""
vnf = None
existing = get_vnf_id(vnf_input.get("vnf_name"))
if not existing:
vnf = create_vnf(vnf_input)
elif vnf_input.get("allow_update"):
vnf = update_vnf(existing, vnf_input)
else:
raise exceptions.ResourceAlreadyExistsException(
"VNF resource {} already exists".format(vnf_input.get("vnf_name"))
)
return vnf
def _post_create(self):
inputs = self.inputs
vm_types = self.vm_types
network_roles = self.network_roles
policies = self.policies
model = self.tosca
vm_type_instances = []
for vm_type in vm_types:
vm_type_tag = vm_type.get("vm_type")
properties = vm_type.get("properties")
resources = vm_type.get("resources", [])
instance_ids = instance_ids_for_property(model, "vm_type_tag", vm_type_tag)
x = 0
for instance_id in instance_ids:
name_index = ""
if x > 0:
name_index = x
vm_type_instances.append(instance_id)
self._add_instance_properties(instance_id, properties)
self._add_resources(instance_id, resources, resource_name_index=name_index)
self._add_vm_type_network_role(instance_id, network_roles)
x += 1
for policy in policies:
policy_name = policy.get("policy_name")
policy_id = self.policy_exists(policy_name)
if not policy_id:
policy_id = self.add_policy_resource(policy_name)
self.associate_policy(policy_id, vm_type_instances)
for k, v in policy.get("properties", {}).items():
self.add_policy_property(policy_id, k, v)
for k, v in inputs.items():
self.add_input_value(k, v)
def _submit(self):
"""Submits the vnf in SDC"""
certification = self.oc.sdc.vnf.certify_catalog_resource(
**self.attributes, user_remarks="Ready!"
)
self.attributes["catalog_resource_id"] = certification.catalog_resource_id
vnf = self.oc.sdc.vnf.get_catalog_resource(**self.attributes)
self.attributes["catalog_resource_name"] = vnf.catalog_resource_name
self.attributes["tosca"] = vnf.response_data
def _add_instance_properties(self, instance_id, properties_dict):
for k, v in properties_dict.items():
# updating vm_type properties
self.add_instance_property(instance_id, k, v)
def _add_resources(self, instance_id, resources_dict, resource_name_index=""):
for resource in resources_dict:
resource_name = resource.get("resource_name")
if resource_name_index:
resource_name = "{}-{}".format(resource_name, resource_name_index)
if self.resource_exists(resource_name):
continue
catalog_resource_name = resource.get("catalog_resource_name")
resource_id = resource.get("resource_id")
resource_origin = resource.get("origin_type")
resource_relationship = resource.get("relationship", {})
if not resource_id:
resource_id = get_vnf_id(catalog_resource_name)
if not resource_id:
raise exceptions.ResourceIDNotFoundException(
"resource ID was not passed, and resource lookup by name was not found {}".format(
resource_name
)
)
new_resource = add_resource(self.catalog_resource_id, resource_id, resource_name, origin_type=resource_origin)
self._refresh()
new_resource_id = new_resource["id"]
if resource_relationship:
relationship_type = resource_relationship.get("relationship_type")
relationship_requirement = resource_relationship.get("requirement")
relationship_requirement_id = resource_relationship.get("requirement_id")
self.add_resource_relationship(new_resource_id, instance_id, relationship_type, relationship_requirement, relationship_requirement_id)
for k, v in resource_relationship.get("properties", {}).items():
self.add_instance_property_non_vf(new_resource_id, k, v, origin_section="componentInstancesProperties")
def add_resource_relationship(self, from_node, to_node, relationship_type, relationship_requirement, relationship_requirement_id):
components = self.tosca.get("componentInstances", [])
for component in components:
if component.get("uniqueId") == to_node:
capabilities = component.get("capabilities", {}).get(relationship_type, [])
for capability in capabilities:
capability_owner_id = capability.get("ownerId")
capability_name = capability.get("name")
capability_uid = capability.get("uniqueId")
self.oc.sdc.vnf.add_resource_relationship(
**self.attributes,
from_node_resource_id=from_node,
to_node_resource_id=to_node,
relationship_type=relationship_type,
capability_name=capability_name,
capability_owner_id=capability_owner_id,
capability_id=capability_uid,
requirement_name=relationship_requirement,
requirement_id=relationship_requirement_id,
)
def _add_vm_type_network_role(self, instance_id, network_roles_dict):
model = self.tosca
for network_role in network_roles_dict:
# checking if abstract node has matching network role,
# and updating if found
nrt = network_role.get("network_role_tag")
nr = network_role.get("network_role")
related_networks = network_role.get("related_networks")
instance_properties = network_role_property_for_instance(
nrt, model, instance_id
)
for instance_property in instance_properties:
self.add_instance_property(instance_id, instance_property, nr)
if related_networks:
property_val = [
{"related_network_role": related_network_role}
for related_network_role in related_networks
]
rnr_instance_property = instance_property.replace(
"_network_role", "_related_networks"
)
self.add_instance_property(
instance_id,
rnr_instance_property,
str(property_val).replace("'", '\\"'),
)
def resource_exists(self, resource_name):
"""Checking the tosca model for a VF to see if a resource
has already been added"""
component_instances = self.tosca.get("componentInstances", [])
for component in component_instances:
if component.get("name") == resource_name:
return True
return False
def policy_exists(self, policy_name):
"""Checking the tosca model for a VF to see if a resource
has already been added
The policy name in the tosca model is all lowercase,
and if there are dashes in the VNF name they are
removed in the policy name.
"""
policies = self.tosca.get("policies", {})
for p_name, policy in policies.items():
tosca_policy_name = policy.get("name").lower()
if tosca_policy_name.find("{}..{}".format(self.vnf_name.lower().replace("-", ""), policy_name.lower())) != -1:
return policy.get("uniqueId")
return None
def add_input_value(self, input_name, input_default_value):
"""Updates an input value on a VNF
:input_name: input name to update
:property_value: value to update input with
"""
inputs = self.tosca.get("inputs", [])
for item in inputs:
if item["name"] == input_name:
unique_id = item["uniqueId"]
parent_unique_id = item["parentUniqueId"]
owner_id = item["ownerId"]
default_value = item.get("defaultValue", "")
if default_value != input_default_value:
return self.oc.sdc.vnf.add_catalog_resource_input(
**self.attributes,
input_default_value=input_default_value,
input_name=input_name,
input_parent_unique_id=parent_unique_id,
input_unique_id=unique_id,
input_owner_id=owner_id,
)
else:
return None
raise exceptions.InputNotFoundException(
"Input {} was not found in VF".format(input_name)
)
# TODO
# instance, policy, and group properties can probably be merged
# rn there is a lot of dup
def add_instance_property(self, instance_id, property_name, property_value, origin_section="componentInstancesInputs"):
"""Updates an instance property on a abstract instance attached to a VNF
:instance_id: ID of a instance attached to a VNF
:property_name: property name to update
:property_value: value to update property with
"""
instance_inputs = self.tosca.get(origin_section, {}).get(
instance_id, {}
)
for prop in instance_inputs:
if prop.get("name") == property_name:
unique_id = prop.get("uniqueId")
parent_unique_id = prop.get("parentUniqueId")
owner_id = prop.get("ownerId")
schemaType = prop.get("schemaType", "")
property_type = prop.get("type")
value = prop.get("value", "")
if value != property_value:
return self.oc.sdc.vnf.add_catalog_resource_property(
**self.attributes,
unique_id=unique_id,
parent_unique_id=parent_unique_id,
owner_id=owner_id,
catalog_resource_instance_id=instance_id,
property_name=property_name,
property_default_value=property_value,
schema_type=schemaType,
property_type=property_type,
)
else:
return None
raise exceptions.PropertyNotFoundException(
"Property {} was not found in Instance {}".format(
property_name, instance_id
)
)
def add_instance_property_non_vf(self, instance_id, property_name, property_value, origin_section="componentInstancesProperties"):
"""Updates an instance property on a abstract instance attached to a VNF
:instance_id: ID of a instance attached to a VNF
:property_name: property name to update
:property_value: value to update property with
"""
instance_inputs = self.tosca.get(origin_section, {}).get(
instance_id, {}
)
for prop in instance_inputs:
if prop.get("name") == property_name:
unique_id = prop.get("uniqueId")
parent_unique_id = prop.get("parentUniqueId")
owner_id = prop.get("ownerId")
schemaType = prop.get("schemaType", "")
property_type = prop.get("type")
value = prop.get("value", "")
if value != property_value:
return self.oc.sdc.vnf.add_catalog_resource_property_non_vf(
**self.attributes,
unique_id=unique_id,
parent_unique_id=parent_unique_id,
owner_id=owner_id,
catalog_resource_instance_id=instance_id,
property_name=property_name,
property_default_value=property_value,
schema_type=schemaType,
property_type=property_type,
)
else:
return None
raise exceptions.PropertyNotFoundException(
"Property {} was not found in Instance {}".format(
property_name, instance_id
)
)
def add_policy_property(self, policy_id, property_name, property_value):
"""Updates a policy property on a polic attached to a VNF
:policy_id: ID of a policy attached to a VNF
:property_name: property name to update
:property_value: value to update property with
"""
policies = (
self.tosca.get("policies", {}).get(policy_id, {}).get("properties", {})
)
for prop in policies:
if prop.get("name") == property_name:
unique_id = prop.get("uniqueId")
property_type = prop.get("type")
description = prop.get("description")
value = prop.get("value", "")
if value != property_value:
return self.oc.sdc.vnf.add_catalog_policy_property(
catalog_resource_id=self.catalog_resource_id,
unique_id=unique_id,
catalog_policy_id=policy_id,
property_name=property_name,
property_default_value=property_value,
description=description,
property_type=property_type,
)
else:
return None
raise exceptions.PropertyNotFoundException(
"Property {} was not found in policy {}".format(property_name, policy_id)
)
def add_policy_resource(self, policy_name):
"""Adds an SDC policy resource to a VNF
:policy_name: name of the policy, matching onap-client.conf
"""
oc = Client()
policy = oc.config.sdc.POLICIES.get(policy_name)
if not policy:
raise exceptions.UnknownPolicyException(
"Policy {} was not found in configuration file".format(policy_name)
)
new_policy = self.oc.sdc.vnf.add_catalog_resource_policy(
**self.attributes, catalog_policy_name=policy
)
self._refresh()
return new_policy.catalog_resource_id
def associate_policy(self, policy_id, instance_ids):
"""associates an SDC policy resource to an VNF instance resource
:policy_id: ID of policy resource from catalog
:instance_ids: list of instance ids to associate policy with
"""
return self.oc.sdc.vnf.add_policy_to_instance(
**self.attributes, catalog_policy_id=policy_id, instance_ids=instance_ids
)
def _refresh(self):
"""GETs the VNF model from SDC and updates the VNF object"""
vnf = self.oc.sdc.vnf.get_catalog_resource(**self.attributes)
self.attributes["tosca"] = vnf.response_data
def _output(self):
return self.tosca
class VSP(Resource):
resource_name = "VSP"
spec = {
"vendor_name": {
"type": str,
"required": True
},
"license_model_name": {
"type": str,
"required": True
},
"file_path": {
"type": str,
"required": True
},
"file_type": {
"type": str,
"required": False,
"default": "application/zip"
},
"software_product_name": {
"type": str,
"required": False,
"default": generate_dummy_string("test_vsp_"),
},
"description": {
"type": str,
"required": False,
"default": "new software product",
},
"category": {
"type": str,
"required": False,
"default": "generic"
},
"sub_category": {
"type": str,
"required": False,
"default": "abstract"
},
"contributers": {
"type": list,
"list_item": str,
"required": False,
"default": [],
},
"allow_update": {
"type": bool,
"required": False,
"default": False
},
}
def __init__(
self,
vendor_name,
license_model_name,
file_path,
file_type,
software_product_name,
description,
category,
sub_category,
contributers=[],
allow_update=False,
):
vsp_input = {}
license_model_id = sdc.license_model.get_license_model_id(
license_model_name)
license_model_version_id = sdc.license_model.get_license_model_version_id(
license_model_id)
feature_group = sdc.license_model.get_license_model_attribute(
license_model_id, license_model_version_id, "feature-groups")
license_agreement = sdc.license_model.get_license_model_attribute(
license_model_id, license_model_version_id, "license-agreements")
vsp_input["software_product_name"] = software_product_name
vsp_input["feature_group_id"] = feature_group["id"]
vsp_input["license_agreement_id"] = license_agreement["id"]
vsp_input["vendor_name"] = vendor_name
vsp_input["license_model_id"] = license_model_id
vsp_input["license_model_version_id"] = license_model_version_id
vsp_input["file_path"] = file_path
vsp_input["file_type"] = file_type
vsp_input["description"] = description
vsp_input["category"] = category.lower()
vsp_input["sub_category"] = sub_category.lower()
vsp_input["contributers"] = contributers
vsp_input["allow_update"] = allow_update
super().__init__(vsp_input)
def _create(self, kwargs):
"""Creates a vsp object in SDC"""
vsp = None
existing = get_vsp(kwargs.get("software_product_name"))
if not existing:
vsp = create_vsp(kwargs)
elif kwargs.get("allow_update"):
vsp = update_vsp(existing, kwargs)
else:
raise ResourceAlreadyExistsException(
"VSP resource {} already exists".format(
kwargs.get("software_product_name")))
return vsp
def _post_create(self):
for contributer in self.contributers:
vsp_client.add_vsp_contributer(
user_id=contributer,
software_product_id=self.software_product_id)
def _submit(self):
"""Submits the vsp in SDC"""
vsp_client.submit_software_product(**self.attributes, action="Submit")
vsp_client.package_software_product(**self.attributes,
action="Create_Package")
vsp = vsp_client.get_software_product(**self.attributes)
self.attributes["tosca"] = vsp.response_data
class LicenseModel(Resource):
resource_name = "LICENSE_MODEL"
spec = {
"vendor_name": {
"type": str,
"required": False,
"default": generate_dummy_string("test_vendor_"),
},
"mfr_ref_number": {
"type": str,
"required": False,
"default": generate_dummy_string("mfref"),
},
"entitlement_pool_name": {
"type": str,
"required": False,
"default": generate_dummy_string("test_kg_"),
},
"key_group_name": {
"type": str,
"required": False,
"default": generate_dummy_string("test_ep_"),
},
"feature_group_name": {
"type": str,
"required": False,
"default": generate_dummy_string("test_fg_"),
},
"license_agreement_name": {
"type": str,
"required": False,
"default": generate_dummy_string("test_la_"),
},
"license_start_date": {
"type": str,
"required": False,
"default": generate_dummy_date(days=1),
},
"license_end_date": {
"type": str,
"required": False,
"default": generate_dummy_date(days=365),
},
}
def __init__(
self,
vendor_name,
mfr_ref_number,
entitlement_pool_name,
key_group_name,
feature_group_name,
license_agreement_name,
license_start_date,
license_end_date,
):
license_input = {}
license_input["vendor_name"] = vendor_name
license_input["manufacturer_reference_number"] = mfr_ref_number
license_input["entitlement_pool_name"] = entitlement_pool_name
license_input["key_group_name"] = key_group_name
license_input["feature_group_name"] = feature_group_name
license_input["license_agreement_name"] = license_agreement_name
license_input["license_start_date"] = license_start_date
license_input["license_end_date"] = license_end_date
super().__init__(license_input)
def _create(self, license_input):
"""Creates a license model object in SDC"""
return create_license_model(license_input)
def _post_create(self):
pass
def _submit(self):
"""Submits the license model in SDC"""
license_model_client.submit_license_model(**self.attributes,
action="Submit")
license_model = license_model_client.get_license_model(
**self.attributes)
self.attributes["tosca"] = license_model.response_data
class VSP(Resource):
resource_name = "VSP"
spec = {
"owner": {
"type": str,
"required": False,
"default": ""
},
"vendor_name": {
"type": str,
"required": True
},
"license_model_name": {
"type": str,
"required": True
},
"file_path": {
"type": str,
"required": True
},
"file_type": {
"type": str,
"required": False,
"default": "application/zip"
},
"software_product_name": {
"type": str,
"required": False,
"default": generate_dummy_string("test_vsp_"),
},
"description": {
"type": str,
"required": False,
"default": "new software product",
},
"update_message": {
"type": str,
"required": False,
"default": "New VSP Version",
},
"category": {
"type": str,
"required": False,
"default": "generic"
},
"sub_category": {
"type": str,
"required": False,
"default": "abstract"
},
"contributers": {
"type": list,
"list_item": str,
"required": False,
"default": [],
},
"allow_update": {
"type": bool,
"required": False,
"default": False
},
}
def _create(self, vsp_input):
"""Creates a vsp object in SDC"""
vsp = None
existing = get_vsp(vsp_input.get("software_product_name"), oc=self.oc)
if not existing:
vsp = create_vsp(vsp_input, oc=self.oc)
elif vsp_input.get("allow_update"):
vsp = update_vsp(existing, vsp_input, oc=self.oc)
else:
raise ResourceAlreadyExistsException(
"VSP resource {} already exists".format(
vsp_input.get("software_product_name")))
return vsp
def _post_create(self):
vsp_permissions = self.oc.sdc.vsp.get_vsp_permissions(
software_product_id=self.software_product_id).response_data.get(
"results", [])
requestor_id = self.oc.sdc.vsp.catalog_resources[
"MODIFY_VSP_OWNER"].get("headers").get("USER_ID")
if user_exists(requestor_id, vsp_permissions, permission="Owner"):
for contributer in self.contributers:
if (not user_exists(
contributer, vsp_permissions, permission="Contributor")
and contributer != requestor_id):
self.oc.sdc.vsp.add_vsp_contributer(
user_id=contributer,
software_product_id=self.software_product_id)
if self.owner and self.owner != requestor_id:
self.oc.sdc.vsp.modify_vsp_owner(
user_id=self.owner,
software_product_id=self.software_product_id)
def _submit(self):
"""Submits the vsp in SDC"""
self.oc.sdc.vsp.submit_software_product(**self.attributes,
action="Submit")
self.oc.sdc.vsp.package_software_product(**self.attributes,
action="Create_Package")
vsp = self.oc.sdc.vsp.get_software_product(**self.attributes)
self.attributes["tosca"] = vsp.response_data
def _output(self):
return self.tosca
class ServiceInstance(Resource):
resource_name = "SERVICE_INSTANCE"
spec = {
"service_instance_name": {
"type": str,
"required": False,
"default": generate_dummy_string("SI_"),
},
"requestor_id": {
"type": str,
"required": False,
"default": "cs0008"
},
"model_name": {
"type": str,
"required": True
},
"model_version": {
"type": str,
"required": False,
"default": "1.0"
},
"tenant_name": {
"type": str,
"required": True
},
"cloud_owner": {
"type": str,
"required": True
},
"cloud_region": {
"type": str,
"required": True
},
"api_type": {
"type": str,
"required": False,
"default": "GR_API"
},
"service_type": {
"type": str,
"required": True
},
"customer_name": {
"type": str,
"required": True
},
"project_name": {
"type": str,
"required": True
},
"owning_entity_name": {
"type": str,
"required": True
},
}
def _create(self, instance_input):
tenant_id = get_tenant_id(instance_input.get("cloud_region"),
instance_input.get("cloud_owner"),
instance_input.get("tenant_name"),
oc=self.oc)
instance_input["tenant_id"] = tenant_id
instance_input["customer_id"] = instance_input.get("customer_name")
service_model = self.oc.sdc.service.get_sdc_service(
catalog_service_id=sdc.service.get_service_id(
instance_input.get("model_name"), oc=self.oc)).response_data
instance_input["model_invariant_id"] = service_model["invariantUUID"]
instance_input["model_version_id"] = service_model["uniqueId"]
category_parameters = self.oc.vid.maintenance.get_category_parameters(
).response_data
for entity in category_parameters.get("categoryParameters",
{}).get("owningEntity", []):
if entity.get("name") == instance_input.get("owning_entity_name"):
instance_input["owning_entity_id"] = entity.get("id")
break
return create_service_instance(instance_input, oc=self.oc)
def _delete(self, instance_input):
request = delete_service_instance(
instance_input.get("service_instance_name"),
instance_input.get("api_type"),
oc=self.oc)
request_id = request.get("requestReferences", {}).get("requestId")
poll_request(request_id, oc=self.oc)