From: aleemraja Date: Thu, 16 Jul 2020 16:16:19 +0000 (+0530) Subject: Preparing the request payload for calling SO macro flow. X-Git-Tag: 7.0.0~2 X-Git-Url: https://gerrit.onap.org/r/gitweb?p=externalapi%2Fnbi.git;a=commitdiff_plain;h=4dbd4fc629c4c3e8c491ed7fdd904e2ecfa4c0e0 Preparing the request payload for calling SO macro flow. - Added JUnit Test cases and Kararte test for service catalog. - Added test case for Execution Task for Macro Flow. - Modified RequestDetails and RequestInfo to match with SO Macro request payload. - Added k8s configuration in application.properties. Issue-ID: EXTAPI-368 Signed-off-by: aleemraja Change-Id: Ibbbbbd2d7021c16ea6291cc899e310ae26200833 Signed-off-by: aleemraja --- diff --git a/src/main/java/org/onap/nbi/apis/servicecatalog/ServiceSpecificationResource.java b/src/main/java/org/onap/nbi/apis/servicecatalog/ServiceSpecificationResource.java index 3651ec8..f9f5e07 100644 --- a/src/main/java/org/onap/nbi/apis/servicecatalog/ServiceSpecificationResource.java +++ b/src/main/java/org/onap/nbi/apis/servicecatalog/ServiceSpecificationResource.java @@ -16,6 +16,7 @@ package org.onap.nbi.apis.servicecatalog; +import java.util.ArrayList; import java.util.LinkedHashMap; import java.util.List; import java.util.Map; @@ -43,6 +44,16 @@ public class ServiceSpecificationResource extends ResourceManagement { public ResponseEntity getServiceSpecification(@PathVariable String serviceSpecId, @RequestParam MultiValueMap params) { Map response = serviceSpecificationService.get(serviceSpecId); + + if (response != null) { + ArrayList> resourseSpecificationMap= (ArrayList>) response.get("resourceSpecification"); + for (Map map : resourseSpecificationMap) { + map.remove("childResourceSpecification"); + map.remove("InstanceSpecification"); + } + response.put("resourceSpecification", resourseSpecificationMap); + } + JsonRepresentation filter = new JsonRepresentation(params); if (response.get("serviceSpecCharacteristic") != null) { return this.getResponse(response, filter); @@ -67,4 +78,4 @@ public class ServiceSpecificationResource extends ResourceManagement { return this.getResponse(response, filter); } -} +} \ No newline at end of file diff --git a/src/main/java/org/onap/nbi/apis/servicecatalog/ToscaInfosProcessor.java b/src/main/java/org/onap/nbi/apis/servicecatalog/ToscaInfosProcessor.java index 2153b84..586d0b5 100644 --- a/src/main/java/org/onap/nbi/apis/servicecatalog/ToscaInfosProcessor.java +++ b/src/main/java/org/onap/nbi/apis/servicecatalog/ToscaInfosProcessor.java @@ -16,12 +16,22 @@ package org.onap.nbi.apis.servicecatalog; import java.nio.file.Path; import java.util.ArrayList; +import java.util.Arrays; import java.util.HashMap; +import java.util.HashSet; import java.util.LinkedHashMap; import java.util.List; import java.util.Map; +import java.util.Set; + +import org.onap.nbi.apis.serviceorder.model.consumer.VFModelInfo; +import org.onap.sdc.tosca.parser.api.IEntityDetails; import org.onap.sdc.tosca.parser.api.ISdcCsarHelper; +import org.onap.sdc.tosca.parser.elements.queries.EntityQuery; +import org.onap.sdc.tosca.parser.elements.queries.TopologyTemplateQuery; +import org.onap.sdc.tosca.parser.enums.SdcTypes; import org.onap.sdc.tosca.parser.exceptions.SdcToscaParserException; +import org.onap.sdc.tosca.parser.impl.SdcPropertyNames; import org.onap.sdc.tosca.parser.impl.SdcToscaParserFactory; import org.onap.sdc.toscaparser.api.NodeTemplate; import org.onap.sdc.toscaparser.api.elements.Metadata; @@ -47,6 +57,10 @@ public class ToscaInfosProcessor { @Autowired private ServiceSpecificationDBManager serviceSpecificationDBManager; + private Set vnfInstanceParams = new HashSet(Arrays.asList("onap_private_net_id", + "onap_private_subnet_id", "pub_key", "sec_group", "install_script_version", "demo_artifacts_version", + "cloud_env", "public_net_id", "aic-cloud-region", "image_name", "flavor_name")); + final ObjectMapper mapper = new ObjectMapper(new YAMLFactory()); // jackson databind private static final Logger LOGGER = LoggerFactory.getLogger(ToscaInfosProcessor.class); @@ -114,81 +128,148 @@ public class ToscaInfosProcessor { } public void buildAndSaveResponseWithSdcToscaParser(Path path, Map serviceCatalogResponse) - throws SdcToscaParserException { + throws SdcToscaParserException { - SdcToscaParserFactory factory = SdcToscaParserFactory.getInstance(); - ISdcCsarHelper sdcCsarHelper = factory.getSdcCsarHelper(path.toFile().getAbsolutePath(), false); - List inputs = sdcCsarHelper.getServiceInputs(); + SdcToscaParserFactory factory = SdcToscaParserFactory.getInstance(); + ISdcCsarHelper sdcCsarHelper = factory.getSdcCsarHelper(path.toFile().getAbsolutePath(), false); + List inputs = sdcCsarHelper.getServiceInputs(); - Map definitions = new HashMap(); - Model model = new ModelImpl(); + List vfEntityList = sdcCsarHelper.getEntity(EntityQuery.newBuilder(SdcTypes.VF).build(), + TopologyTemplateQuery.newBuilder(SdcTypes.SERVICE).build(), false); - if (inputs != null && inputs.size() > 0) { - for (Input input : inputs) { - Property property = null; - if (input.getType().equals("list") || input.getType().equals("map")) - property = PropertyBuilder.build("array", null, null); - else - property = PropertyBuilder.build(input.getType(), null, null); + Map listOfInstanceParameters = new HashMap<>(); + if (!vfEntityList.isEmpty()) { - property.setDescription(input.getDescription()); - property.setRequired(input.isRequired()); + IEntityDetails iEntityDetails = vfEntityList.get(0); + Map groupProperties = iEntityDetails.getProperties(); - if (input.getDefault() != null) { - property.setDefault(input.getDefault().toString()); - } - ((ModelImpl) model).addProperty(input.getName(), property); - } - definitions.put("ServiceCharacteristics", model); + for (String key : groupProperties.keySet()) { + org.onap.sdc.toscaparser.api.Property property = groupProperties.get(key); + String paramName = property.getName(); + if (paramName != null) { + if (vnfInstanceParams.stream() + .filter(vnfInstanceParam -> vnfInstanceParam.equalsIgnoreCase(paramName)).findFirst() + .isPresent()) { + listOfInstanceParameters.put(paramName, property.getValue().toString()); + } + } + } - } + } - String svcCharacteristicsJson = Json.pretty(definitions); - serviceSpecificationDBManager.saveSpecificationInputSchema(svcCharacteristicsJson, serviceCatalogResponse); + // it will build Entity as VfModules + List vfModuleEntityList = sdcCsarHelper.getEntity( + EntityQuery.newBuilder("org.openecomp.groups.VfModule").build(), + TopologyTemplateQuery.newBuilder(SdcTypes.SERVICE) + .customizationUUID(SdcPropertyNames.PROPERTY_NAME_CUSTOMIZATIONUUID).build(), + false); + List listOfVfModelInfo = new ArrayList<>(); - Metadata serviceMetadata = sdcCsarHelper.getServiceMetadata(); - String instantationType = serviceMetadata.getValue("instantiationType"); - serviceCatalogResponse.put("instantiationType", instantationType); + if (!vfModuleEntityList.isEmpty()) { + // Fetching vfModule metadata in a loop + for (IEntityDetails vfModuleEntity : vfModuleEntityList) { + VFModelInfo vfModel = new VFModelInfo(); + Metadata vfMetadata = vfModuleEntity.getMetadata(); + // Preparing VFModel + vfModel.setModelInvariantUuid( + testNull(vfMetadata.getValue(SdcPropertyNames.PROPERTY_NAME_VFMODULEMODELINVARIANTUUID))); + vfModel.setModelName(testNull(vfMetadata.getValue(SdcPropertyNames.PROPERTY_NAME_VFMODULEMODELNAME))); + vfModel.setModelUuid(testNull(vfMetadata.getValue(SdcPropertyNames.PROPERTY_NAME_VFMODULEMODELUUID))); + vfModel.setModelVersion( + testNull(vfMetadata.getValue(SdcPropertyNames.PROPERTY_NAME_VFMODULEMODELVERSION))); + vfModel.setModelCustomizationUuid(testNull(vfMetadata.getValue("vfModuleModelCustomizationUUID"))); - LinkedHashMap inputSchemaRef = new LinkedHashMap(); - // use object to match examples in Specifications - inputSchemaRef.put("valueType", "object"); - inputSchemaRef.put("@schemaLocation", - "/serviceSpecification/" + serviceCatalogResponse.get("id") + "/specificationInputSchema"); - inputSchemaRef.put("@type", serviceCatalogResponse.get("name") + "_ServiceCharacteristic"); + // Adding it to the list + listOfVfModelInfo.add(vfModel); + } + } - LinkedHashMap serviceSpecCharacteristic = new LinkedHashMap(); - serviceSpecCharacteristic.put("name", serviceCatalogResponse.get("name") + "_ServiceCharacteristics"); - serviceSpecCharacteristic.put("description", - "This object describes all the inputs needed from the client to interact with the " - + serviceCatalogResponse.get("name") + " Service Topology"); - serviceSpecCharacteristic.put("valueType", "object"); - serviceSpecCharacteristic.put("@type", "ONAPServiceCharacteristic"); - serviceSpecCharacteristic.put("@schemaLocation", "null"); - serviceSpecCharacteristic.put("serviceSpecCharacteristicValue", inputSchemaRef); + Map definitions = new HashMap(); + Model model = new ModelImpl(); - serviceCatalogResponse.put("serviceSpecCharacteristic", serviceSpecCharacteristic); + if (!inputs.isEmpty() && inputs.size() > 0) { + for (Input input : inputs) { + Property property = null; + if (input.getType().equals("list") || input.getType().equals("map")) + property = PropertyBuilder.build("array", null, null); + else + property = PropertyBuilder.build(input.getType(), null, null); - List nodeTemplates = sdcCsarHelper.getServiceNodeTemplates(); - List resourceSpecifications = - (List) serviceCatalogResponse.get("resourceSpecification"); - for (LinkedHashMap resourceSpecification : resourceSpecifications) { - if (resourceSpecification.get("id") != null) { - String id = (String) resourceSpecification.get("id"); - LOGGER.debug("get tosca infos for service id: {}", id); - NodeTemplate nodeTemplate = null; - for (NodeTemplate node : nodeTemplates) { - if (node.getMetaData().getValue("UUID").equals(id)) { - nodeTemplate = node; - break; - } - } - if (nodeTemplate == null) - continue; - resourceSpecification.put("modelCustomizationId", - sdcCsarHelper.getNodeTemplateCustomizationUuid(nodeTemplate)); - } + property.setDescription(input.getDescription()); + property.setRequired(input.isRequired()); + + if (input.getDefault() != null) { + property.setDefault(input.getDefault().toString()); + } + ((ModelImpl) model).addProperty(input.getName(), property); + } + definitions.put("ServiceCharacteristics", model); + + } + + String svcCharacteristicsJson = Json.pretty(definitions); + serviceSpecificationDBManager.saveSpecificationInputSchema(svcCharacteristicsJson, serviceCatalogResponse); + + Metadata serviceMetadata = sdcCsarHelper.getServiceMetadata(); + String instantationType = serviceMetadata.getValue("instantiationType"); + serviceCatalogResponse.put("instantiationType", instantationType); + + LinkedHashMap inputSchemaRef = new LinkedHashMap(); + // use object to match examples in Specifications + inputSchemaRef.put("valueType", "object"); + inputSchemaRef.put("@schemaLocation", + "/serviceSpecification/" + serviceCatalogResponse.get("id") + "/specificationInputSchema"); + inputSchemaRef.put("@type", serviceCatalogResponse.get("name") + "_ServiceCharacteristic"); + + LinkedHashMap serviceSpecCharacteristic = new LinkedHashMap(); + serviceSpecCharacteristic.put("name", serviceCatalogResponse.get("name") + "_ServiceCharacteristics"); + serviceSpecCharacteristic.put("description", + "This object describes all the inputs needed from the client to interact with the " + + serviceCatalogResponse.get("name") + " Service Topology"); + serviceSpecCharacteristic.put("valueType", "object"); + serviceSpecCharacteristic.put("@type", "ONAPServiceCharacteristic"); + serviceSpecCharacteristic.put("@schemaLocation", "null"); + serviceSpecCharacteristic.put("serviceSpecCharacteristicValue", inputSchemaRef); + + serviceCatalogResponse.put("serviceSpecCharacteristic", serviceSpecCharacteristic); + + List nodeTemplates = sdcCsarHelper.getServiceNodeTemplates(); + List resourceSpecifications = (List) serviceCatalogResponse + .get("resourceSpecification"); + for (LinkedHashMap resourceSpecification : resourceSpecifications) { + if (resourceSpecification.get("id") != null) { + String id = (String) resourceSpecification.get("id"); + LOGGER.debug("get tosca infos for service id: {}", id); + NodeTemplate nodeTemplate = null; + for (NodeTemplate node : nodeTemplates) { + if (node.getMetaData().getValue("UUID").equals(id)) { + nodeTemplate = node; + break; + } + } + if (nodeTemplate == null) + continue; + resourceSpecification.put("modelCustomizationId", + sdcCsarHelper.getNodeTemplateCustomizationUuid(nodeTemplate)); + if (!vfModuleEntityList.isEmpty()) { + resourceSpecification.put("childResourceSpecification", listOfVfModelInfo); + } + resourceSpecification.put("InstanceSpecification", listOfInstanceParameters); + + } + } + } + + private static String testNull(Object object) { + if (object == null) { + return "NULL"; + } else if (object instanceof Integer) { + return object.toString(); + } else if (object instanceof String) { + return (String) object; + } else { + return "Type not recognized"; } } -} +} \ No newline at end of file diff --git a/src/main/java/org/onap/nbi/apis/serviceorder/SoClient.java b/src/main/java/org/onap/nbi/apis/serviceorder/SoClient.java index c286d60..95009b8 100644 --- a/src/main/java/org/onap/nbi/apis/serviceorder/SoClient.java +++ b/src/main/java/org/onap/nbi/apis/serviceorder/SoClient.java @@ -17,6 +17,7 @@ package org.onap.nbi.apis.serviceorder; import javax.annotation.PostConstruct; import org.onap.nbi.OnapComponentsUrlPaths; import org.onap.nbi.apis.serviceorder.model.consumer.CreateE2EServiceInstanceResponse; +import org.onap.nbi.apis.serviceorder.model.consumer.CreateMacroServiceInstanceResponse; import org.onap.nbi.apis.serviceorder.model.consumer.CreateServiceInstanceResponse; import org.onap.nbi.apis.serviceorder.model.consumer.DeleteE2EServiceInstanceResponse; import org.onap.nbi.apis.serviceorder.model.consumer.GetE2ERequestStatusResponse; @@ -119,6 +120,27 @@ public class SoClient { } } + public ResponseEntity callMacroCreateServiceInstance(MSOPayload msoPayload) { + + if (LOGGER.isDebugEnabled()) { + LOGGER.debug("Calling SO CreateServiceInstance with msoPayload : " + msoPayload.toString()); + } + + try { + ResponseEntity response = restTemplate.exchange(createSoUrl, + HttpMethod.POST, new HttpEntity<>(msoPayload, buildRequestHeader()),CreateMacroServiceInstanceResponse.class); + + logMacroResponsePost(createSoUrl, response); + return response; + } catch (BackendFunctionalException e) { + LOGGER.error(ERROR_ON_CALLING + createSoUrl + " ," + e.getHttpStatus() + " , " + e.getBodyResponse()); + return new ResponseEntity(e.getBodyResponse(), e.getHttpStatus()); + } catch (ResourceAccessException e) { + LOGGER.error(ERROR_ON_CALLING + createSoUrl + " ," + e.getMessage()); + return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR); + } + } + public ResponseEntity callE2ECreateServiceInstance(MSOE2EPayload msoPayloadE2E) { if (LOGGER.isDebugEnabled()) { @@ -221,6 +243,18 @@ public class SoClient { } } + private void logMacroResponsePost(String url, ResponseEntity response) { + LOGGER.info(RESPONSE_STATUS + response.getStatusCodeValue()); + if (LOGGER.isDebugEnabled()) { + LOGGER.debug("response body : {}", response.getBody().toString()); + } + + if (LOGGER.isWarnEnabled() && !response.getStatusCode().equals(HttpStatus.CREATED)) { + LOGGER.warn("HTTP call SO on {} returns {} , {}", url, response.getStatusCodeValue(), + response.getBody().toString()); + } + } + private void logE2EResponsePost(String url, ResponseEntity response) { LOGGER.info(RESPONSE_STATUS + response.getStatusCodeValue()); if (LOGGER.isDebugEnabled()) { @@ -328,4 +362,4 @@ public class SoClient { return httpHeaders; } -} +} \ No newline at end of file diff --git a/src/main/java/org/onap/nbi/apis/serviceorder/model/consumer/CreateMacroServiceInstanceResponse.java b/src/main/java/org/onap/nbi/apis/serviceorder/model/consumer/CreateMacroServiceInstanceResponse.java new file mode 100644 index 0000000..bdd7f29 --- /dev/null +++ b/src/main/java/org/onap/nbi/apis/serviceorder/model/consumer/CreateMacroServiceInstanceResponse.java @@ -0,0 +1,34 @@ +/** + * Copyright (c) 2020 TechMahindra + * + * 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. + */ +package org.onap.nbi.apis.serviceorder.model.consumer; + +public class CreateMacroServiceInstanceResponse { + + private RequestReferences requestReferences; + + public RequestReferences getRequestReferences() { + return requestReferences; + } + + public void setRequestReferences(RequestReferences requestReferences) { + this.requestReferences = requestReferences; + } + + @Override + public String toString() { + return "CreateMacroServiceInstanceResponse{" + "requestReferences=" + requestReferences + '}'; + } +} \ No newline at end of file diff --git a/src/main/java/org/onap/nbi/apis/serviceorder/model/consumer/ModelInfo.java b/src/main/java/org/onap/nbi/apis/serviceorder/model/consumer/ModelInfo.java index 1d5cc6e..477770a 100644 --- a/src/main/java/org/onap/nbi/apis/serviceorder/model/consumer/ModelInfo.java +++ b/src/main/java/org/onap/nbi/apis/serviceorder/model/consumer/ModelInfo.java @@ -16,6 +16,10 @@ package org.onap.nbi.apis.serviceorder.model.consumer; +import com.fasterxml.jackson.annotation.JsonInclude; +import com.fasterxml.jackson.annotation.JsonInclude.Include; + +@JsonInclude(Include.NON_NULL) public class ModelInfo { private String modelType; diff --git a/src/main/java/org/onap/nbi/apis/serviceorder/model/consumer/RequestDetails.java b/src/main/java/org/onap/nbi/apis/serviceorder/model/consumer/RequestDetails.java index 4a38369..4e361b4 100644 --- a/src/main/java/org/onap/nbi/apis/serviceorder/model/consumer/RequestDetails.java +++ b/src/main/java/org/onap/nbi/apis/serviceorder/model/consumer/RequestDetails.java @@ -24,7 +24,7 @@ public class RequestDetails { private RequestInfo requestInfo; - private RequestParameters requestParameters; + private Object requestParameters; private CloudConfiguration cloudConfiguration; @@ -80,11 +80,11 @@ public class RequestDetails { this.requestInfo = requestInfo; } - public RequestParameters getRequestParameters() { + public Object getRequestParameters() { return requestParameters; } - public void setRequestParameters(RequestParameters requestParameters) { + public void setRequestParameters(Object requestParameters) { this.requestParameters = requestParameters; } diff --git a/src/main/java/org/onap/nbi/apis/serviceorder/model/consumer/RequestInfo.java b/src/main/java/org/onap/nbi/apis/serviceorder/model/consumer/RequestInfo.java index 3aa54cc..6347a18 100644 --- a/src/main/java/org/onap/nbi/apis/serviceorder/model/consumer/RequestInfo.java +++ b/src/main/java/org/onap/nbi/apis/serviceorder/model/consumer/RequestInfo.java @@ -26,6 +26,8 @@ public class RequestInfo { private String requestorId; + private String productFamilyId; + public String getInstanceName() { return instanceName; } @@ -58,9 +60,18 @@ public class RequestInfo { this.requestorId = requestorId; } + public String getProductFamilyId() { + return productFamilyId; + } + + public void setProductFamilyId(String productFamilyId) { + this.productFamilyId = productFamilyId; + } + @Override public String toString() { return "RequestInfo{" + "instanceName='" + instanceName + '\'' + ", source='" + source + '\'' - + ", suppressRollback=" + suppressRollback + ", requestorId='" + requestorId + '\'' + '}'; + + ", suppressRollback=" + suppressRollback + ", requestorId='" + requestorId + '\'' + + ", productFamilyId='" + productFamilyId + '\'' +'}'; } -} +} \ No newline at end of file diff --git a/src/main/java/org/onap/nbi/apis/serviceorder/model/consumer/VFModelInfo.java b/src/main/java/org/onap/nbi/apis/serviceorder/model/consumer/VFModelInfo.java new file mode 100644 index 0000000..7dc24c5 --- /dev/null +++ b/src/main/java/org/onap/nbi/apis/serviceorder/model/consumer/VFModelInfo.java @@ -0,0 +1,95 @@ +/** + * Copyright (c) 2020 TechMahindra + * + * 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. + */ +package org.onap.nbi.apis.serviceorder.model.consumer; + +import org.apache.commons.lang3.builder.ToStringBuilder; + +import com.fasterxml.jackson.annotation.JsonInclude; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonPropertyOrder; + +@JsonInclude(JsonInclude.Include.NON_NULL) +@JsonPropertyOrder({ "modelName", "modelUuid", "modelInvariantUuid", "modelVersion", "modelCustomizationUuid" }) +public class VFModelInfo { + + @JsonProperty("modelName") + private String modelName; + @JsonProperty("modelUuid") + private String modelUuid; + @JsonProperty("modelInvariantUuid") + private String modelInvariantUuid; + @JsonProperty("modelVersion") + private String modelVersion; + @JsonProperty("modelCustomizationUuid") + private String modelCustomizationUuid; + + @JsonProperty("modelName") + public String getModelName() { + return modelName; + } + + @JsonProperty("modelName") + public void setModelName(String modelName) { + this.modelName = modelName; + } + + @JsonProperty("modelUuid") + public String getModelUuid() { + return modelUuid; + } + + @JsonProperty("modelUuid") + public void setModelUuid(String modelUuid) { + this.modelUuid = modelUuid; + } + + @JsonProperty("modelInvariantUuid") + public String getModelInvariantUuid() { + return modelInvariantUuid; + } + + @JsonProperty("modelInvariantUuid") + public void setModelInvariantUuid(String modelInvariantUuid) { + this.modelInvariantUuid = modelInvariantUuid; + } + + @JsonProperty("modelVersion") + public String getModelVersion() { + return modelVersion; + } + + @JsonProperty("modelVersion") + public void setModelVersion(String modelVersion) { + this.modelVersion = modelVersion; + } + + @JsonProperty("modelCustomizationUuid") + public String getModelCustomizationUuid() { + return modelCustomizationUuid; + } + + @JsonProperty("modelCustomizationUuid") + public void setModelCustomizationUuid(String modelCustomizationUuid) { + this.modelCustomizationUuid = modelCustomizationUuid; + } + + @Override + public String toString() { + return new ToStringBuilder(this).append("modelName", modelName).append("modelUuid", modelUuid) + .append("modelInvariantUuid", modelInvariantUuid).append("modelVersion", modelVersion) + .append("modelCustomizationUuid", modelCustomizationUuid).toString(); + } +} \ No newline at end of file diff --git a/src/main/java/org/onap/nbi/apis/serviceorder/workflow/PostSoProcessor.java b/src/main/java/org/onap/nbi/apis/serviceorder/workflow/PostSoProcessor.java index 1b0d77f..e590afc 100644 --- a/src/main/java/org/onap/nbi/apis/serviceorder/workflow/PostSoProcessor.java +++ b/src/main/java/org/onap/nbi/apis/serviceorder/workflow/PostSoProcessor.java @@ -20,6 +20,8 @@ import java.util.HashMap; import java.util.Iterator; import java.util.List; import java.util.Map; + +import org.onap.nbi.apis.servicecatalog.ServiceSpecificationService; import org.onap.nbi.apis.serviceorder.SoClient; import org.onap.nbi.apis.serviceorder.model.ServiceCharacteristic; import org.onap.nbi.apis.serviceorder.model.ServiceOrder; @@ -27,6 +29,7 @@ import org.onap.nbi.apis.serviceorder.model.ServiceOrderItem; import org.onap.nbi.apis.serviceorder.model.StateType; import org.onap.nbi.apis.serviceorder.model.consumer.CloudConfiguration; import org.onap.nbi.apis.serviceorder.model.consumer.CreateE2EServiceInstanceResponse; +import org.onap.nbi.apis.serviceorder.model.consumer.CreateMacroServiceInstanceResponse; import org.onap.nbi.apis.serviceorder.model.consumer.CreateServiceInstanceResponse; import org.onap.nbi.apis.serviceorder.model.consumer.MSOE2EPayload; import org.onap.nbi.apis.serviceorder.model.consumer.MSOPayload; @@ -41,6 +44,7 @@ import org.onap.nbi.apis.serviceorder.model.consumer.ResourceModel; import org.onap.nbi.apis.serviceorder.model.consumer.ServiceModel; import org.onap.nbi.apis.serviceorder.model.consumer.SubscriberInfo; import org.onap.nbi.apis.serviceorder.model.consumer.UserParams; +import org.onap.nbi.apis.serviceorder.model.consumer.VFModelInfo; import org.onap.nbi.apis.serviceorder.model.orchestrator.ServiceOrderInfo; import org.onap.nbi.apis.serviceorder.service.ServiceOrderService; import org.slf4j.Logger; @@ -77,12 +81,24 @@ public class PostSoProcessor { @Value("${onap.cloudOwner}") private String cloudOwner; + + @Value("${onap.k8sCloudOwner}") + private String k8sCloudOwner; + + @Value("${onap.k8sCloudRegionId}") + private String k8sCloudRegionId; + + @Value("${k8s-rb-profile-name}") + private String k8sRbProfileName; @Autowired private ServiceOrderService serviceOrderService; @Autowired private SoClient soClient; + + @Autowired + ServiceSpecificationService serviceSpecificationService; public ResponseEntity postServiceOrderItem(ServiceOrderInfo serviceOrderInfo, ServiceOrderItem serviceOrderItem) { @@ -108,6 +124,19 @@ public class PostSoProcessor { return response; } + public ResponseEntity postMacroServiceOrderItem(ServiceOrderInfo serviceOrderInfo, + ServiceOrderItem serviceOrderItem) { + ResponseEntity response = null; + try { + // For Macro Flow + response = postSOMacroRequest(serviceOrderItem, serviceOrderInfo); + } catch (NullPointerException e) { + LOGGER.error("Unable to create service instance for serviceOrderItem.id=" + serviceOrderItem.getId(), e); + response = null; + } + return response; + } + private ResponseEntity postSORequest(ServiceOrderItem serviceOrderItem, ServiceOrderInfo serviceOrderInfo) { RequestDetails requestDetails = buildSoRequest(serviceOrderItem, serviceOrderInfo); @@ -164,6 +193,221 @@ public class PostSoProcessor { } return response; } + + private ResponseEntity postSOMacroRequest(ServiceOrderItem serviceOrderItem, + ServiceOrderInfo serviceOrderInfo) { + + String serviceModuleName = (String) serviceOrderInfo.getServiceOrderItemInfos().get(serviceOrderItem.getId()) + .getCatalogResponse().get("name"); + + RequestDetails requestDetails = buildSoMacroRequest(serviceOrderItem, serviceOrderInfo); + MSOPayload msoMacroPayload = new MSOPayload(requestDetails); + ResponseEntity response = null; + + switch (serviceOrderItem.getAction()) { + case ADD: + response = soClient.callMacroCreateServiceInstance(msoMacroPayload); + break; + case DELETE: + // response = soClient.callDeleteServiceInstance(msoPayload, + // serviceOrderItem.getService().getId()); + break; + case MODIFY: + if (StateType.INPROGRESS_MODIFY_ITEM_TO_CREATE == serviceOrderItem.getState()) { + // response = soClient.callCreateServiceInstance(msoPayload); + } + if (StateType.ACKNOWLEDGED == serviceOrderItem.getState()) { + // response = soClient.callDeleteServiceInstance(msoPayload, + // serviceOrderItem.getService().getId()); + } + break; + default: + break; + } + return response; + } + + /** + * Build SO MACRO CREATE request from the ServiceOrder and catalog informations from SDC + * + * @param orderItem + * @param serviceOrderInfo + * @param subscriberInfo + * @return + */ + private RequestDetails buildSoMacroRequest(ServiceOrderItem orderItem, ServiceOrderInfo serviceOrderInfo) { + + RequestDetails requestDetails = new RequestDetails(); + Map sdcInfos = serviceOrderInfo.getServiceOrderItemInfos().get(orderItem.getId()) + .getCatalogResponse(); + + String id = orderItem.getService().getServiceSpecification().getId(); + Map responseChildRes = serviceSpecificationService.get(id); + ArrayList> resourseSpecificationArray = (ArrayList>) responseChildRes + .get("resourceSpecification"); + + Map resourseSpecificationMap = resourseSpecificationArray.get(0); + + Map instanceSpecification = (Map) resourseSpecificationMap.get("InstanceSpecification"); + ArrayList childResourceSpecification = (ArrayList) resourseSpecificationMap + .get("childResourceSpecification"); + + List serviceObject = new ArrayList<>(); + + ArrayList vnfInstanceParam = new ArrayList<>(); + + //Differentiating vnf with cnf(Can be discussed and improved) + if (instanceSpecification.get("public_net_id") != null) { + vnfInstanceParam.add(instanceSpecification); + } else { + Map instanceParam = new HashMap<>(); + instanceParam.put("k8s-rb-profile-name", k8sRbProfileName); + vnfInstanceParam.add(instanceParam); + } + + List resSpec = (ArrayList) sdcInfos.get("resourceSpecification"); + Map resSpecMap = (Map) resSpec.get(0); + + Map vnfInfoObject = new HashMap<>(); + vnfInfoObject.put("modelName", (String) resSpecMap.get("name")); + vnfInfoObject.put("modelVersionId", (String) resSpecMap.get("id")); + vnfInfoObject.put("modelInvariantUuid", (String) resSpecMap.get("resourceInvariantUUID")); + vnfInfoObject.put("modelVersion", (String) resSpecMap.get("version")); + vnfInfoObject.put("modelCustomizationId", (String) resSpecMap.get("modelCustomizationId")); + vnfInfoObject.put("modelInstanceName", (String) resSpecMap.get("resourceInstanceName")); + + //initialization + CloudConfiguration cloudConfiguration = null; + + //Differentiating vnf with cnf(Can be discussed and improved) + if (instanceSpecification.get("public_net_id") != null) { + cloudConfiguration = new CloudConfiguration(lcpCloudRegionId, tenantId, cloudOwner); + } else { + cloudConfiguration = new CloudConfiguration(k8sCloudRegionId, tenantId, k8sCloudOwner); + } + + Map platformName = new HashMap<>(); + platformName.put("platformName", "test"); + + Map lob = new HashMap<>(); + lob.put("lineOfBusinessName", "LOB-Demonstration"); + + Map vnfModel = new HashMap<>(); + vnfModel.put("modelInfo", vnfInfoObject); + vnfModel.put("cloudConfiguration", cloudConfiguration); + vnfModel.put("platform", platformName); + vnfModel.put("lineOfBusiness", lob); + vnfModel.put("productFamilyId", "a9a77d5a-123e-4ca2-9eb9-0b015d2ee0fb"); + vnfModel.put("instanceName", (String) resSpecMap.get("resourceInstanceName")); + vnfModel.put("instanceParams", vnfInstanceParam); + + List vfModulesObjects = new ArrayList<>(); + ArrayList> vfInstanceParam = new ArrayList<>(); + + //Differentiate CNF from VNF + if (instanceSpecification.get("public_net_id") != null) { + vfInstanceParam.add(instanceSpecification); + + } else { + Map instanceParam = new HashMap<>(); + instanceParam.put("k8s-rb-profile-name", k8sRbProfileName); + vfInstanceParam.add(instanceParam); + } + + for (VFModelInfo crsObject : childResourceSpecification) { + Map vfModuleObject = new HashMap<>(); + Map vfModuleInfo = new HashMap<>(); + + vfModuleInfo.put("modelName", crsObject.getModelName()); + vfModuleInfo.put("modelVersionId", crsObject.getModelUuid()); + vfModuleInfo.put("modelInvariantUuid", crsObject.getModelInvariantUuid()); + vfModuleInfo.put("modelVersion", crsObject.getModelVersion()); + vfModuleInfo.put("modelCustomizationId", crsObject.getModelCustomizationUuid()); + vfModuleObject.put("modelInfo", vfModuleInfo); + vfModuleObject.put("instanceName", crsObject.getModelName()); + vfModuleObject.put("instanceParams", vfInstanceParam); + + vfModulesObjects.add(vfModuleObject); + } + vnfModel.put("vfModules", vfModulesObjects); + + List vnfObjects = new ArrayList<>(); + vnfObjects.add(vnfModel); + + Map vnfData = new HashMap<>(); + vnfData.put("vnfs", vnfObjects); + + ModelInfo serviceModelInfo = new ModelInfo(); + serviceModelInfo.setModelType("service"); + serviceModelInfo.setModelInvariantId((String) sdcInfos.get("invariantUUID")); + serviceModelInfo.setModelVersionId(orderItem.getService().getServiceSpecification().getId()); + serviceModelInfo.setModelName((String) sdcInfos.get("name")); + serviceModelInfo.setModelVersion((String) sdcInfos.get("version")); + + // Adding List of instanceParams for service + // We can add instanceParams Key Value in Map Object and add it to the List, for + // For now it is empty to comply with so request + + List> listOfServiceLevelInstanceParams = new ArrayList<>(); + Map serviceInstanceParams= new HashMap<>(); + listOfServiceLevelInstanceParams.add(serviceInstanceParams); + + Map serviceData = new HashMap<>(); + serviceData.put("instanceParams", listOfServiceLevelInstanceParams); + serviceData.put("instanceName", orderItem.getService().getName()); + serviceData.put("resources", vnfData); + serviceData.put("modelInfo", serviceModelInfo); + + Map homingObject = new HashMap<>(); + homingObject.put("Homing_Solution", "none"); + serviceObject.add(homingObject); + + Map serviceObject1 = new HashMap<>(); + serviceObject1.put("service", serviceData); + serviceObject.add(serviceObject1); + requestDetails.setSubscriberInfo(serviceOrderInfo.getSubscriberInfo()); + + ModelInfo modelInfo = new ModelInfo(); + modelInfo.setModelType("service"); + modelInfo.setModelInvariantId((String) sdcInfos.get("invariantUUID")); + modelInfo.setModelVersionId(orderItem.getService().getServiceSpecification().getId()); + modelInfo.setModelName((String) sdcInfos.get("name")); + modelInfo.setModelVersion((String) sdcInfos.get("version")); + requestDetails.setModelInfo(modelInfo); + + RequestInfo requestInfo = new RequestInfo(); + requestInfo.setInstanceName(orderItem.getService().getName()); + requestInfo.setSource("VID"); + requestInfo.setSuppressRollback(false); + requestInfo.setRequestorId("NBI"); + requestInfo.setProductFamilyId("a9a77d5a-123e-4ca2-9eb9-0b015d2ee0fb"); + requestDetails.setRequestInfo(requestInfo); + + // We are taking RequestParameters as map because it has UserParams which gives value as + // "name" : "service" + // "value" : "", which SO is not accepting + Map requestParameters = new HashMap<>(); + + // Get value from serviceOrder request or generate one + String serviceTypeFromJson = orderItem.getService().getServicetype(); + requestParameters.put("subscriptionServiceType", + serviceTypeFromJson != null ? serviceTypeFromJson : (String) sdcInfos.get("name")); + requestParameters.put("userParams", serviceObject); + requestParameters.put("aLaCarte", false); + requestDetails.setRequestParameters(requestParameters); + requestDetails.setCloudConfiguration(cloudConfiguration); + + OwningEntity owningEntity = new OwningEntity(); + owningEntity.setOwningEntityId(soOwningEntityId); + owningEntity.setOwningEntityName(soOwningEntityName); + requestDetails.setOwningEntity(owningEntity); + + Project project = new Project(); + project.setProjectName(soProjectName); + + requestDetails.setProject(project); + return requestDetails; + } /** * Build SO CREATE request from the ServiceOrder and catalog informations from SDC @@ -262,7 +506,7 @@ public class PostSoProcessor { if (!userParams.isEmpty()) { Map requestInputs = new HashMap(); for (int i = 0; i < userParams.size(); i++) { - requestInputs.put(userParams.get(i).getName(), userParams.get(i).getValue()); + requestInputs.put(userParams.get(i).getName(), (String) userParams.get(i).getValue()); } parameters.setRequestInputs(requestInputs); @@ -320,4 +564,4 @@ public class PostSoProcessor { return userParams; } -} +} \ No newline at end of file diff --git a/src/main/java/org/onap/nbi/apis/serviceorder/workflow/SOTaskProcessor.java b/src/main/java/org/onap/nbi/apis/serviceorder/workflow/SOTaskProcessor.java index d63d122..fe0938d 100644 --- a/src/main/java/org/onap/nbi/apis/serviceorder/workflow/SOTaskProcessor.java +++ b/src/main/java/org/onap/nbi/apis/serviceorder/workflow/SOTaskProcessor.java @@ -24,6 +24,7 @@ import org.onap.nbi.apis.serviceorder.model.ServiceOrder; import org.onap.nbi.apis.serviceorder.model.ServiceOrderItem; import org.onap.nbi.apis.serviceorder.model.StateType; import org.onap.nbi.apis.serviceorder.model.consumer.CreateE2EServiceInstanceResponse; +import org.onap.nbi.apis.serviceorder.model.consumer.CreateMacroServiceInstanceResponse; import org.onap.nbi.apis.serviceorder.model.consumer.CreateServiceInstanceResponse; import org.onap.nbi.apis.serviceorder.model.orchestrator.ExecutionTask; import org.onap.nbi.apis.serviceorder.model.orchestrator.ServiceOrderInfo; @@ -92,8 +93,10 @@ public class SOTaskProcessor { updateE2EServiceOrderItem(response, serviceOrderItem, serviceOrder); } else if (macroService) { LOGGER.info("Mode type macro"); - //TODO: Add logic to construct SO macro request body and call SO macro flow.(EXTAPI-368) - + // call SO macro flow.(EXTAPI-368) + ResponseEntity response = postSoProcessor + .postMacroServiceOrderItem(serviceOrderInfo, serviceOrderItem); + updateMacroServiceOrderItem(response, serviceOrderItem, serviceOrder); } else { ResponseEntity response = @@ -216,6 +219,35 @@ public class SOTaskProcessor { } } + /** + * Update ServiceOrderItem with SO response by using serviceOrderRepository with the serviceOrderId + */ + private void updateMacroServiceOrderItem(ResponseEntity response, + ServiceOrderItem orderItem, ServiceOrder serviceOrder) { + + if (response == null || !response.getStatusCode().is2xxSuccessful()) { + LOGGER.warn("response ko for serviceOrderItem.id=" + orderItem.getId()); + serviceOrderService.updateOrderItemState(serviceOrder, orderItem, StateType.FAILED); + buildOrderMessageIfNeeded(orderItem, serviceOrder, response); + } else { + CreateMacroServiceInstanceResponse createMacroServiceInstanceResponse = response.getBody(); + if (createMacroServiceInstanceResponse != null && !orderItem.getState().equals(StateType.FAILED)) { + orderItem.getService().setId(createMacroServiceInstanceResponse.getRequestReferences().getInstanceId()); + orderItem.setRequestId(createMacroServiceInstanceResponse.getRequestReferences().getRequestId()); + } + + if (!response.getStatusCode().is2xxSuccessful() || response.getBody() == null + || response.getBody().getRequestReferences() == null) { + serviceOrderService.updateOrderItemState(serviceOrder, orderItem, StateType.FAILED); + LOGGER + .warn("order item {} failed , status {} , response {}", orderItem.getId(), response.getStatusCode(), + response.getBody()); + } else { + serviceOrderService.updateOrderItemState(serviceOrder, orderItem, StateType.INPROGRESS); + } + } + } + private void updateOrderItemToInProgress(ServiceOrder serviceOrder, ServiceOrderItem serviceOrderItem) { if (serviceOrderItem.getAction() != ActionType.MODIFY) { serviceOrderService.updateOrderItemState(serviceOrder, serviceOrderItem, StateType.INPROGRESS); @@ -341,4 +373,4 @@ public class SOTaskProcessor { LOGGER.debug("Difference {} and Polling Duration {}", differenceInMillis, pollingDurationInMins); return (differenceInMillis > pollingDurationInMillis); } -} +} \ No newline at end of file diff --git a/src/main/resources/application-test.properties b/src/main/resources/application-test.properties index 1a73f16..ac3efec 100644 --- a/src/main/resources/application-test.properties +++ b/src/main/resources/application-test.properties @@ -30,12 +30,17 @@ onap.lcpCloudRegionId = RegionOne onap.tenantId = 31047205ce114b60833b23e400d6a535 onap.cloudOwner = CloudOwner +# k8s +onap.k8sCloudRegionId = k8sregionfour +onap.k8sCloudOwner = k8scloudowner4 +k8s-rb-profile-name = default + # NBI nbi.url = http://localhost:${server.port}${server.servlet.context-path} nbi.callForVNF = false # SCHEDULER -scheduler.pollingDurationInMins = 0.1 +scheduler.pollingDurationInMins = 0.2 serviceOrder.schedule = 5000 serviceOrder.initial = 1 executionTask.schedule = 2000 diff --git a/src/main/resources/application.properties b/src/main/resources/application.properties index e719c6f..b010f50 100644 --- a/src/main/resources/application.properties +++ b/src/main/resources/application.properties @@ -40,6 +40,11 @@ onap.lcpCloudRegionId = RegionOne onap.tenantId = 6e97a2bd51d74f6db5671d8dc1517d82 onap.cloudOwner = CloudOwner +# k8s +onap.k8sCloudRegionId = k8sregionfour +onap.k8sCloudOwner = k8scloudowner4 +k8s-rb-profile-name = default + # NBI nbi.url = https://localhost:${server.port}${server.servlet.context-path} nbi.public.url = https://${server.public.ip}:${server.port}${server.servlet.context-path} diff --git a/src/test/java/org/onap/nbi/apis/assertions/ServiceOrderExecutionTaskAssertions.java b/src/test/java/org/onap/nbi/apis/assertions/ServiceOrderExecutionTaskAssertions.java index b09cf1d..621a938 100644 --- a/src/test/java/org/onap/nbi/apis/assertions/ServiceOrderExecutionTaskAssertions.java +++ b/src/test/java/org/onap/nbi/apis/assertions/ServiceOrderExecutionTaskAssertions.java @@ -162,6 +162,76 @@ public class ServiceOrderExecutionTaskAssertions { } + public static ServiceOrder createTestServiceOrderForMacro(ActionType actionType) { + ServiceOrder serviceOrder = new ServiceOrder(); + serviceOrder.setExternalId("LudONAP001"); + serviceOrder.setPriority("1"); + serviceOrder.setDescription("Ludo first ONAP Order"); + serviceOrder.setCategory("Consumer"); + serviceOrder.setRequestedStartDate(new Date()); + serviceOrder.setRequestedCompletionDate(new Date()); + serviceOrder.setBaseType("toto"); + serviceOrder.setCompletionDateTime(new Date()); + serviceOrder.setExpectedCompletionDate(new Date()); + serviceOrder.setSchemaLocation("/tutu"); + + OrderRelationship orderRelationship = new OrderRelationship(); + orderRelationship.setId("test"); + orderRelationship.setHref("test"); + orderRelationship.setReferredType("test"); + orderRelationship.setType("type"); + List relationships = new ArrayList<>(); + serviceOrder.setOrderRelationship(relationships); + + RelatedParty party = new RelatedParty(); + party.setId("6490"); + party.setRole("ONAPcustomer"); + party.setReferredType("individual"); + party.setName("Jean Pontus"); + List relatedPartyList = new ArrayList<>(); + relatedPartyList.add(party); + serviceOrder.setRelatedParty(relatedPartyList); + + List items = new ArrayList<>(); + + ServiceOrderItem itemA = new ServiceOrderItem(); + itemA.id("A"); + itemA.action(actionType); + Service serviceA = new Service(); + if (actionType != ActionType.ADD) { + serviceA.setId("e4688e5f-61a0-4f8b-ae02-a2fbde623bcb"); + } + serviceA.setServiceState("active"); + ServiceSpecificationRef serviceSpecificationRefA = new ServiceSpecificationRef(); + serviceSpecificationRefA.setId("82c9fbb4-656c-4973-8c7f-172b22b5fa8f"); + serviceA.setServiceSpecification(serviceSpecificationRefA); + itemA.setService(serviceA); + items.add(itemA); + + ServiceOrderItem itemB = new ServiceOrderItem(); + itemB.id("B"); + itemB.action(actionType); + Service serviceB = new Service(); + if (actionType != ActionType.ADD) { + serviceB.setId("e4688e5f-61a0-4f8b-ae02-a2fbde623bcb"); + } + serviceB.setServiceState("active"); + ServiceSpecificationRef serviceSpecificationRefB = new ServiceSpecificationRef(); + serviceSpecificationRefB.setId("82c9fbb4-656c-4973-8c7f-172b22b5fa8f"); + serviceB.setServiceSpecification(serviceSpecificationRefB); + itemB.setService(serviceB); + List orderItemRelationships = new ArrayList<>(); + OrderItemRelationship orderItemRelationship = new OrderItemRelationship(); + orderItemRelationship.setId("A"); + orderItemRelationship.setType(RelationshipType.RELIESON); + orderItemRelationships.add(orderItemRelationship); + itemB.setOrderItemRelationship(orderItemRelationships); + items.add(itemB); + serviceOrder.setOrderItem(items); + return serviceOrder; + + } + public static ExecutionTask setUpBddForExecutionTaskSucess(ServiceOrderRepository serviceOrderRepository, ExecutionTaskRepository executionTaskRepository, ActionType actionType) { ServiceOrder testServiceOrder = createTestServiceOrder(actionType); @@ -437,4 +507,235 @@ public class ServiceOrderExecutionTaskAssertions { executionTaskRepository.save(executionTaskB); return executionTaskA; } -} + + public static ExecutionTask setUpBddForMacroExecutionTaskSucess(ServiceOrderRepository serviceOrderRepository, + ExecutionTaskRepository executionTaskRepository, ActionType actionType) { + + ServiceOrder testServiceOrder = createTestServiceOrderForMacro(actionType); + + for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) { + serviceOrderItem.setState(StateType.ACKNOWLEDGED); + List serviceCharacteristics = new ArrayList(); + ServiceCharacteristic serviceCharacteristic1 = new ServiceCharacteristic(); + serviceCharacteristic1.setName("access-site-id"); + Value value1 = new Value(); + value1.setServiceCharacteristicValue("1234765"); + serviceCharacteristic1.setValue(value1); + serviceCharacteristics.add(serviceCharacteristic1); + ServiceCharacteristic serviceCharacteristic2 = new ServiceCharacteristic(); + serviceCharacteristic2.setName("provider-site-id"); + Value value2 = new Value(); + value2.setServiceCharacteristicValue("654321"); + serviceCharacteristic2.setValue(value2); + serviceCharacteristics.add(serviceCharacteristic2); + serviceOrderItem.getService().setServiceCharacteristic(serviceCharacteristics); + } + + testServiceOrder.setState(StateType.ACKNOWLEDGED); + testServiceOrder.setId("test"); + serviceOrderRepository.save(testServiceOrder); + + LinkedHashMap sdcResponse = new LinkedHashMap<>(); + sdcResponse.put("invariantUUID", "uuid"); + sdcResponse.put("name", "VLB_Service"); + sdcResponse.put("version", "1.0"); + sdcResponse.put("category", "Network Service"); + sdcResponse.put("instantiationType", "Macro"); + + List resourceSpecs = new ArrayList<>(); + ResourceSpecification resourceSpecificationA = new ResourceSpecification(); + resourceSpecificationA.setId("35d7887d-3c35-4fb4-aed1-d15b4d9f4ccc"); + resourceSpecificationA.setInstanceName("vLB_VSP"); + resourceSpecificationA.setName("vLB_VSP"); + resourceSpecificationA.setType("VF"); + resourceSpecificationA.setVersion("1.0"); + resourceSpecificationA.setResourceInvariantUUID("368371e6-1d2f-4f4a-b992-a9053c7c2f1e"); + resourceSpecs.add(resourceSpecificationA); + + sdcResponse.put("resourceSpecification", resourceSpecs); + + ServiceOrderInfo serviceOrderInfo = new ServiceOrderInfo(); + serviceOrderInfo.setServiceOrderId("test"); + SubscriberInfo subscriberInfo = new SubscriberInfo(); + subscriberInfo.setGlobalSubscriberId("6490"); + subscriberInfo.setSubscriberName("edgar"); + serviceOrderInfo.setSubscriberInfo(subscriberInfo); + + ServiceOrderItemInfo serviceOrderItemInfoA = new ServiceOrderItemInfo(); + serviceOrderItemInfoA.setId("A"); + serviceOrderItemInfoA.setCatalogResponse(sdcResponse); + + ServiceOrderItemInfo serviceOrderItemInfoB = new ServiceOrderItemInfo(); + serviceOrderItemInfoB.setId("B"); + serviceOrderItemInfoB.setCatalogResponse(sdcResponse); + serviceOrderInfo.addServiceOrderItemInfos("A", serviceOrderItemInfoA); + serviceOrderInfo.addServiceOrderItemInfos("B", serviceOrderItemInfoB); + + + + String json = JsonEntityConverter.convertServiceOrderInfoToJson(serviceOrderInfo); + + ExecutionTask executionTaskA = new ExecutionTask(); + executionTaskA.setCreateDate(new Date()); + executionTaskA.setOrderItemId("A"); + executionTaskA.setServiceOrderInfoJson(json); + executionTaskA = executionTaskRepository.save(executionTaskA); + ExecutionTask executionTaskB = new ExecutionTask(); + executionTaskB.setCreateDate(new Date()); + executionTaskB.setOrderItemId("B"); + executionTaskB.setReliedTasks(String.valueOf(executionTaskA.getInternalId())); + executionTaskB.setServiceOrderInfoJson(json); + executionTaskRepository.save(executionTaskB); + return executionTaskA; + } + + public static ExecutionTask setUpBddForMacroExecutionTaskSucessWithObject( + ServiceOrderRepository serviceOrderRepository, ExecutionTaskRepository executionTaskRepository, + ActionType actionType) { + ServiceOrder testServiceOrder = createTestServiceOrderForMacro(actionType); + + for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) { + serviceOrderItem.setState(StateType.ACKNOWLEDGED); + List serviceCharacteristics = new ArrayList(); + ServiceCharacteristic serviceCharacteristic1 = new ServiceCharacteristic(); + serviceCharacteristic1.setName("ServiceCharacteristics"); + serviceCharacteristic1.setValueType("object"); + Value value1 = new Value(); + value1.setServiceCharacteristicValue("{ \"key1\":\"value1\", \"key2\":\"value2\"}"); + serviceCharacteristic1.setValue(value1); + serviceCharacteristics.add(serviceCharacteristic1); + serviceOrderItem.getService().setServiceCharacteristic(serviceCharacteristics); + } + + testServiceOrder.setState(StateType.ACKNOWLEDGED); + testServiceOrder.setId("test"); + serviceOrderRepository.save(testServiceOrder); + + LinkedHashMap sdcResponse = new LinkedHashMap<>(); + sdcResponse.put("invariantUUID", "uuid"); + sdcResponse.put("name", "VLB_Service"); + sdcResponse.put("version", "1"); + sdcResponse.put("category", "Network Service"); + sdcResponse.put("instantiationType", "Macro"); + + List resourceSpecs = new ArrayList<>(); + ResourceSpecification resourceSpecificationA = new ResourceSpecification(); + resourceSpecificationA.setId("35d7887d-3c35-4fb4-aed1-d15b4d9f4ccc"); + resourceSpecificationA.setInstanceName("vLB_VSP"); + resourceSpecificationA.setName("vFW-SINK"); + resourceSpecificationA.setType("ONAPresource"); + resourceSpecificationA.setVersion("2.0"); + resourceSpecificationA.setResourceInvariantUUID("368371e6-1d2f-4f4a-b992-a9053c7c2f1e"); + resourceSpecs.add(resourceSpecificationA); + + sdcResponse.put("resourceSpecification", resourceSpecs); + + ServiceOrderInfo serviceOrderInfo = new ServiceOrderInfo(); + serviceOrderInfo.setServiceOrderId("test"); + SubscriberInfo subscriberInfo = new SubscriberInfo(); + subscriberInfo.setGlobalSubscriberId("6490"); + subscriberInfo.setSubscriberName("edgar"); + serviceOrderInfo.setSubscriberInfo(subscriberInfo); + + ServiceOrderItemInfo serviceOrderItemInfoA = new ServiceOrderItemInfo(); + serviceOrderItemInfoA.setId("A"); + serviceOrderItemInfoA.setCatalogResponse(sdcResponse); + + ServiceOrderItemInfo serviceOrderItemInfoB = new ServiceOrderItemInfo(); + serviceOrderItemInfoB.setId("B"); + serviceOrderItemInfoB.setCatalogResponse(sdcResponse); + serviceOrderInfo.addServiceOrderItemInfos("A", serviceOrderItemInfoA); + serviceOrderInfo.addServiceOrderItemInfos("B", serviceOrderItemInfoB); + + String json = JsonEntityConverter.convertServiceOrderInfoToJson(serviceOrderInfo); + + ExecutionTask executionTaskA = new ExecutionTask(); + executionTaskA.setCreateDate(new Date()); + executionTaskA.setOrderItemId("A"); + executionTaskA.setServiceOrderInfoJson(json); + executionTaskA = executionTaskRepository.save(executionTaskA); + ExecutionTask executionTaskB = new ExecutionTask(); + executionTaskB.setCreateDate(new Date()); + executionTaskB.setOrderItemId("B"); + executionTaskB.setReliedTasks(String.valueOf(executionTaskA.getInternalId())); + executionTaskB.setServiceOrderInfoJson(json); + executionTaskRepository.save(executionTaskB); + return executionTaskA; + } + + public static ExecutionTask setUpBddForMacroExecutionTaskSucessWithComplexObject( + ServiceOrderRepository serviceOrderRepository, ExecutionTaskRepository executionTaskRepository, + ActionType actionType) { + ServiceOrder testServiceOrder = createTestServiceOrderForMacro(actionType); + + for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) { + serviceOrderItem.setState(StateType.ACKNOWLEDGED); + List serviceCharacteristics = new ArrayList<>(); + ServiceCharacteristic serviceCharacteristic1 = new ServiceCharacteristic(); + serviceCharacteristic1.setName("ServiceCharacteristics"); + serviceCharacteristic1.setValueType("object"); + Value value1 = new Value(); + // Three parameters , one is an array of child objects + value1.setServiceCharacteristicValue( + "{\"key1\":\"value1\", \"key2\":\"value2\", \"key3\":[ {\"lat1\":\"value1\",\"lon1\":\"value1\"}, { \"lat2\":\"value2\", \"lon2\":\"value2\"}]}"); + serviceCharacteristic1.setValue(value1); + serviceCharacteristics.add(serviceCharacteristic1); + serviceOrderItem.getService().setServiceCharacteristic(serviceCharacteristics); + } + + testServiceOrder.setState(StateType.ACKNOWLEDGED); + testServiceOrder.setId("test"); + serviceOrderRepository.save(testServiceOrder); + + LinkedHashMap sdcResponse = new LinkedHashMap<>(); + sdcResponse.put("invariantUUID", "uuid"); + sdcResponse.put("name", "VLB_Service"); + sdcResponse.put("version", "1"); + sdcResponse.put("category", "Network Services"); + sdcResponse.put("instantiationType", "Macro"); + + List resourceSpecs = new ArrayList<>(); + ResourceSpecification resourceSpecificationA = new ResourceSpecification(); + resourceSpecificationA.setId("35d7887d-3c35-4fb4-aed1-d15b4d9f4ccc"); + resourceSpecificationA.setInstanceName("vLB_VSP"); + resourceSpecificationA.setName("vLB_VSP"); + resourceSpecificationA.setType("ONAPresource"); + resourceSpecificationA.setVersion("2.0"); + resourceSpecificationA.setResourceInvariantUUID("368371e6-1d2f-4f4a-b992-a9053c7c2f1e"); + resourceSpecs.add(resourceSpecificationA); + + sdcResponse.put("resourceSpecification", resourceSpecs); + + ServiceOrderInfo serviceOrderInfo = new ServiceOrderInfo(); + serviceOrderInfo.setServiceOrderId("test"); + SubscriberInfo subscriberInfo = new SubscriberInfo(); + subscriberInfo.setGlobalSubscriberId("6490"); + subscriberInfo.setSubscriberName("edgar"); + serviceOrderInfo.setSubscriberInfo(subscriberInfo); + + ServiceOrderItemInfo serviceOrderItemInfoA = new ServiceOrderItemInfo(); + serviceOrderItemInfoA.setId("A"); + serviceOrderItemInfoA.setCatalogResponse(sdcResponse); + + ServiceOrderItemInfo serviceOrderItemInfoB = new ServiceOrderItemInfo(); + serviceOrderItemInfoB.setId("B"); + serviceOrderItemInfoB.setCatalogResponse(sdcResponse); + serviceOrderInfo.addServiceOrderItemInfos("A", serviceOrderItemInfoA); + serviceOrderInfo.addServiceOrderItemInfos("B", serviceOrderItemInfoB); + + String json = JsonEntityConverter.convertServiceOrderInfoToJson(serviceOrderInfo); + + ExecutionTask executionTaskA = new ExecutionTask(); + executionTaskA.setCreateDate(new Date()); + executionTaskA.setOrderItemId("A"); + executionTaskA.setServiceOrderInfoJson(json); + executionTaskA = executionTaskRepository.save(executionTaskA); + ExecutionTask executionTaskB = new ExecutionTask(); + executionTaskB.setCreateDate(new Date()); + executionTaskB.setOrderItemId("B"); + executionTaskB.setReliedTasks(String.valueOf(executionTaskA.getInternalId())); + executionTaskB.setServiceOrderInfoJson(json); + executionTaskRepository.save(executionTaskB); + return executionTaskA; + } +} \ No newline at end of file diff --git a/src/test/java/org/onap/nbi/apis/servicecatalog/ToscaInfosProcessorTest.java b/src/test/java/org/onap/nbi/apis/servicecatalog/ToscaInfosProcessorTest.java index e02cdc0..026c81f 100644 --- a/src/test/java/org/onap/nbi/apis/servicecatalog/ToscaInfosProcessorTest.java +++ b/src/test/java/org/onap/nbi/apis/servicecatalog/ToscaInfosProcessorTest.java @@ -18,10 +18,13 @@ import static org.assertj.core.api.Assertions.assertThat; import java.io.File; import java.nio.file.Path; import java.util.ArrayList; +import java.util.HashMap; import java.util.LinkedHashMap; import java.util.List; +import java.util.Map; import org.junit.Test; import org.junit.runner.RunWith; +import org.onap.nbi.apis.serviceorder.model.consumer.VFModelInfo; import org.onap.nbi.exceptions.TechnicalException; import org.onap.sdc.tosca.parser.exceptions.SdcToscaParserException; import org.springframework.beans.factory.annotation.Autowired; @@ -237,4 +240,143 @@ public class ToscaInfosProcessorTest { } assertThat(response.get("serviceSpecCharacteristic")).isEqualTo(serviceSpecCharacteristic); } + + + @Test + public void testBuildAndSaveResponseWithSdcToscaParserWithVFModule() { + + ClassLoader classLoader = getClass().getClassLoader(); + + // Adding Path to TOSCA File to provide as parameter + Path path = new File(classLoader.getResource("toscafile/service-VlbService-csar.csar").getFile()).toPath() + .toAbsolutePath(); + + // Preparing Response Data + LinkedHashMap response = new LinkedHashMap<>(); + response.put("version", "1.0"); + response.put("name", "VLB_Service"); + response.put("description", "VLB_Service"); + response.put("id", "82c9fbb4-656c-4973-8c7f-172b22b5fa8f"); + + // Resources + List> resources = new ArrayList<>(); + LinkedHashMap resource1 = new LinkedHashMap<>(); + resource1.put("id", "35d7887d-3c35-4fb4-aed1-d15b4d9f4ccc"); + resources.add(resource1); + + // Resources to put in response as resourceSpecification + response.put("resourceSpecification", resources); + + // Test Data for VFModule 1:: An object of vFModelInfo1 + VFModelInfo vFModelInfo1 = new VFModelInfo(); + vFModelInfo1.setModelName("VlbVsp..dnsscaling..module-1"); + vFModelInfo1.setModelUuid("9bfd197c-7e18-41bd-927d-57102a6fda7e"); + vFModelInfo1.setModelInvariantUuid("888b6342-8aea-4416-b485-e24726c1f964"); + vFModelInfo1.setModelVersion("1"); + vFModelInfo1.setModelCustomizationUuid("4c387136-2fa2-420f-94e9-3312f863a352"); + + // Test Data for VFModule 2:: An object of vFModelInfo2 + VFModelInfo vFModelInfo2 = new VFModelInfo(); + vFModelInfo2.setModelName("VlbVsp..base_vlb..module-0"); + vFModelInfo2.setModelUuid("d0325d26-43f2-4c6f-aff5-2832ac2d8ab0"); + vFModelInfo2.setModelInvariantUuid("bcbdfc80-4fb1-4c3e-b4e3-77721bac61db"); + vFModelInfo2.setModelVersion("1"); + vFModelInfo2.setModelCustomizationUuid("0895caa9-b7d3-4e02-9a3c-8337c4076948"); + + // Test data for list of vFModelInfo + List vfModelInfoListTestData = new ArrayList<>(); + vfModelInfoListTestData.add(vFModelInfo1); + vfModelInfoListTestData.add(vFModelInfo2); + + // Calling buildAndSaveResponseWithSdcToscaParser with tosca file and prepared + // response as parameter + try { + toscaInfosProcessor.buildAndSaveResponseWithSdcToscaParser(path, response); + } catch (SdcToscaParserException e) { + throw new TechnicalException("unable to build response from tosca csar using sdc-parser : " + + path.toString() + " " + e.getMessage()); + } + + // Getting resourceSpecifications from response + List resourceSpecifications = (List) response.get("resourceSpecification"); + + // Getting childResourceSpecifications from resourceSpecifications that we got + // from response + List childResourceSpecifications = (ArrayList) (resourceSpecifications.get(0)) + .get("childResourceSpecification"); + + // Asserting childResourceSpecifications with our vfModelInfoListTestData :: + // CSAR has two vfModules + + for (int i = 0; i < vfModelInfoListTestData.size(); i++) { + assertThat(childResourceSpecifications.get(i)).hasFieldOrPropertyWithValue("modelName", + vfModelInfoListTestData.get(i).getModelName()); + assertThat(childResourceSpecifications.get(i)).hasFieldOrPropertyWithValue("modelUuid", + vfModelInfoListTestData.get(i).getModelUuid()); + assertThat(childResourceSpecifications.get(i)).hasFieldOrPropertyWithValue("modelInvariantUuid", + vfModelInfoListTestData.get(i).getModelInvariantUuid()); + assertThat(childResourceSpecifications.get(i)).hasFieldOrPropertyWithValue("modelVersion", + vfModelInfoListTestData.get(i).getModelVersion()); + assertThat(childResourceSpecifications.get(i)).hasFieldOrPropertyWithValue("modelCustomizationUuid", + vfModelInfoListTestData.get(i).getModelCustomizationUuid()); + } + + } + + @Test + public void testBuildAndSaveResponseWithSdcToscaParserWithInstanceSpecification() { + + ClassLoader classLoader = getClass().getClassLoader(); + + // Adding Path to TOSCA File to provide as parameter + Path path = new File(classLoader.getResource("toscafile/service-VlbService-csar.csar").getFile()).toPath() + .toAbsolutePath(); + + // Creating response to provide as parameter + LinkedHashMap response = new LinkedHashMap(); + response.put("version", "1.0"); + response.put("name", "VLB_Service"); + response.put("description", "VLB_Service"); + response.put("id", "82c9fbb4-656c-4973-8c7f-172b22b5fa8f"); + + // Resources + List resources = new ArrayList<>(); + LinkedHashMap resource1 = new LinkedHashMap(); + resource1.put("id", "35d7887d-3c35-4fb4-aed1-d15b4d9f4ccc"); + resources.add(resource1); + + // instanceSpecification Test Data + Map instanceSpecificationTestData = new LinkedHashMap<>(); + instanceSpecificationTestData.put("cloud_env", "openstack"); + instanceSpecificationTestData.put("demo_artifacts_version", "1.2.1"); + instanceSpecificationTestData.put("install_script_version", "1.2.1"); + instanceSpecificationTestData.put("onap_private_net_id", "09407156-5e6e-45a7-b4aa-6eeb7ad4aba9"); + instanceSpecificationTestData.put("onap_private_subnet_id", "8c6df8fa-2735-49ad-ba04-24701d85ba79"); + instanceSpecificationTestData.put("pub_key", + "ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQC/EnxIi7fcHMEi9VPtCGCOpQYblj9r0M/CaD5U15Cb5qHzcHiPtJpVsDMlPGzN9VHxWZG6FqQv1s6oE+PmG1xeahhb+ofrY6s8zvlUCcWGIo/bPexzb2ErvkGyd+1tQo9oLrxNdUG0xeWUX3oFkiw3RBRyxf9n4E5ajZr4cEFQ0sqJkslj87XViw/h555ydIYTY5cPNmIlsIXTObC/2z3muVWYUzaaZE8omfYJE442+UhYLHgb7Cl1JMk/SNu/r+bLrsXeBSPB+/bxVKqjpd659AQ7GRNXvBrgfq6EKNiVjrI76AbpeTM2D/LXbENuUUkvJBWptSd0gPAGkEyc9w2n"); + instanceSpecificationTestData.put("public_net_id", + "60dc8a1c-86b8-4cc4-b5c8-9b0272113c1f0f1c389d-e9db-4c14-b3a2-11dca2d104ed"); + + // Resources to put in response as resourceSpecification + response.put("resourceSpecification", resources); + + // List vfModelInfoListTestData = new ArrayList(); + + try { + toscaInfosProcessor.buildAndSaveResponseWithSdcToscaParser(path, response); + } catch (SdcToscaParserException e) { + throw new TechnicalException("unable to build response from tosca csar using sdc-parser : " + + path.toString() + " " + e.getMessage()); + } + + // Getting + List resourceSpecifications = (List) response.get("resourceSpecification"); + + Map instanceSpecification = (HashMap) (resourceSpecifications.get(0)).get("InstanceSpecification"); + + // Test against test data and returned response's data for instanceSpecification + // instanceSpecificationTestData = new HashMap(); + assertThat(instanceSpecificationTestData).isEqualTo(instanceSpecification); + + } } diff --git a/src/test/java/org/onap/nbi/test/ExecutionTaskTest.java b/src/test/java/org/onap/nbi/test/ExecutionTaskTest.java index 5b39600..2b28eff 100644 --- a/src/test/java/org/onap/nbi/test/ExecutionTaskTest.java +++ b/src/test/java/org/onap/nbi/test/ExecutionTaskTest.java @@ -330,7 +330,42 @@ public class ExecutionTaskTest { assertThat(executionTaskRepository.count()).isEqualTo(0); } + + // Macro Flow Execution Task + @Test + public void testMacroExecutionTaskSuccess() throws Exception { + + ExecutionTask executionTaskA = + ServiceOrderExecutionTaskAssertions.setUpBddForMacroExecutionTaskSucess( + serviceOrderRepository, executionTaskRepository, ActionType.ADD); + ExecutionTask executionTaskB; + + SoTaskProcessor.processOrderItem(executionTaskA); + ServiceOrder serviceOrderChecked = getServiceOrder("test"); + assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS); + for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) { + if (serviceOrderItem.getId().equals("A")) { + assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED); + } else { + assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED); + } + } + + executionTaskB = getExecutionTask("B"); + assertThat(executionTaskB.getReliedTasks()).isNullOrEmpty(); + executionTaskA = getExecutionTask("A"); + assertThat(executionTaskA).isNull(); + SoTaskProcessor.processOrderItem(executionTaskB); + serviceOrderChecked = getServiceOrder("test"); + + assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.COMPLETED); + for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) { + assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED); + + } + } + @Test public void testExecutionTaskFailed() throws Exception { diff --git a/src/test/resources/__files/toscafile/service-VlbService-csar.csar b/src/test/resources/__files/toscafile/service-VlbService-csar.csar new file mode 100644 index 0000000..0c5fcdd Binary files /dev/null and b/src/test/resources/__files/toscafile/service-VlbService-csar.csar differ diff --git a/src/test/resources/karatetest/features/00--ServiceCatalog.feature b/src/test/resources/karatetest/features/00--ServiceCatalog.feature index 25f15df..4894c99 100644 --- a/src/test/resources/karatetest/features/00--ServiceCatalog.feature +++ b/src/test/resources/karatetest/features/00--ServiceCatalog.feature @@ -81,6 +81,25 @@ And match $ contains } """ +Scenario: testServiceCatalogGetServiceWithoutInstanceParamsAndVFModules +Given path 'serviceSpecification','82c9fbb4-656c-4973-8c7f-172b22b5fa8f' +When method get +Then status 200 +And match $.resourceSpecification contains +""" +[{ + "id": "35d7887d-3c35-4fb4-aed1-d15b4d9f4ccc", + "version": "1.0", + "name": "vLB_VSP", + "resourceInstanceName": "vLB_VSP 0", + "modelCustomizationName": "vLB_VSP 0", + "resourceInvariantUUID": "368371e6-1d2f-4f4a-b992-a9053c7c2f1e", + "resourceType": "VF", + "@type": "ONAPresource", + "modelCustomizationId": "86dcf0b6-5f76-4444-8392-23ca325fd1d9" +}] +""" + Scenario: findServiceCatalog Given path 'serviceSpecification' diff --git a/src/test/resources/mappings/sdc/sdc_get_82c9fbb4-656c-4973-8c7f-172b22b5fa8f.json b/src/test/resources/mappings/sdc/sdc_get_82c9fbb4-656c-4973-8c7f-172b22b5fa8f.json new file mode 100644 index 0000000..2480421 --- /dev/null +++ b/src/test/resources/mappings/sdc/sdc_get_82c9fbb4-656c-4973-8c7f-172b22b5fa8f.json @@ -0,0 +1,117 @@ +{ + "request": { + "method": "GET", + "url": "/sdc/v1/catalog/services/82c9fbb4-656c-4973-8c7f-172b22b5fa8f/metadata" + }, + "response": { + "status": 200, + "jsonBody": { + "uuid": "82c9fbb4-656c-4973-8c7f-172b22b5fa8f", + "invariantUUID": "3d3aa59d-d0b4-4663-b4bb-dc16f518acea", + "name": "VLB_Service", + "version": "1.0", + "toscaModelURL": "/sdc/v1/catalog/services/82c9fbb4-656c-4973-8c7f-172b22b5fa8f/toscaModel", + "category": "Network Service", + "lifecycleState": "CERTIFIED", + "lastUpdaterUserId": "jm0007", + "distributionStatus": "DISTRIBUTED", + "lastUpdaterFullName": "Joni Mitchell", + "resources": [ + { + "resourceInstanceName": "vLB_VSP 0", + "resourceName": "vLB_VSP", + "resourceInvariantUUID": "368371e6-1d2f-4f4a-b992-a9053c7c2f1e", + "resourceVersion": "1.0", + "resoucreType": "VF", + "resourceUUID": "35d7887d-3c35-4fb4-aed1-d15b4d9f4ccc", + "artifacts": [ + { + "artifactName": "vf-license-model.xml", + "artifactType": "VF_LICENSE", + "artifactURL": "/sdc/v1/catalog/services/82c9fbb4-656c-4973-8c7f-172b22b5fa8f/resourceInstances/vlb_vsp0/artifacts/ecb35123-2160-4a1f-8e10-0f9ae0233024", + "artifactDescription": "VF license file", + "artifactChecksum": "ZTdhOGFmMTUzNGFiNjlhYTUzOTgxMmM4NzQ3OGJlOGI=", + "artifactUUID": "ecb35123-2160-4a1f-8e10-0f9ae0233024", + "artifactVersion": "1", + "artifactLabel": "vflicense", + "artifactGroupType": "DEPLOYMENT" + }, + { + "artifactName": "vlb_vsp0_modules.json", + "artifactType": "VF_MODULES_METADATA", + "artifactURL": "/sdc/v1/catalog/services/82c9fbb4-656c-4973-8c7f-172b22b5fa8f/resourceInstances/vlb_vsp0/artifacts/21e0c3e3-ab55-4fc0-9e73-78a1815510d8", + "artifactDescription": "Auto-generated VF Modules information artifact", + "artifactChecksum": "NWU2NDNjNWVmMjM2YWRjNjc5NTNlNjZhMTQ3Mjk4MmY=", + "artifactUUID": "21e0c3e3-ab55-4fc0-9e73-78a1815510d8", + "artifactVersion": "1", + "artifactLabel": "vfModulesMetadata", + "artifactGroupType": "DEPLOYMENT" + }, + { + "artifactName": "dnsscaling.yaml", + "artifactType": "HEAT", + "artifactURL": "/sdc/v1/catalog/services/82c9fbb4-656c-4973-8c7f-172b22b5fa8f/resourceInstances/vlb_vsp0/artifacts/f82b2ecb-d1ff-49a9-84c9-123968e1cd94", + "artifactDescription": "created from csar", + "artifactTimeout": 60, + "artifactChecksum": "NWU2MWY2NzFjOWM3NDRhMDU2ZjlhMDFiNWRiOWI4Mzc=", + "artifactUUID": "f82b2ecb-d1ff-49a9-84c9-123968e1cd94", + "artifactVersion": "2", + "artifactLabel": "heat1", + "artifactGroupType": "DEPLOYMENT" + }, + { + "artifactName": "base_vlb.yaml", + "artifactType": "HEAT", + "artifactURL": "/sdc/v1/catalog/services/82c9fbb4-656c-4973-8c7f-172b22b5fa8f/resourceInstances/vlb_vsp0/artifacts/d06da981-1f0c-4868-bd35-caefa60dd062", + "artifactDescription": "created from csar", + "artifactTimeout": 60, + "artifactChecksum": "MzY5NWZkZDJiNWJmMzY0ODdiOWY1ZDZjNWQ3MDVjM2E=", + "artifactUUID": "d06da981-1f0c-4868-bd35-caefa60dd062", + "artifactVersion": "2", + "artifactLabel": "heat2", + "artifactGroupType": "DEPLOYMENT" + }, + { + "artifactName": "base_vlb.env", + "artifactType": "HEAT_ENV", + "artifactURL": "/sdc/v1/catalog/services/82c9fbb4-656c-4973-8c7f-172b22b5fa8f/resourceInstances/vlb_vsp0/artifacts/970c7177-cf5d-41ba-a2f8-594ec760f825", + "artifactDescription": "Auto-generated HEAT Environment deployment artifact", + "artifactChecksum": "MDE1NGNlMGM2ZmI3YTZkMmQ0MGM4YmVmNzg5YWQ1MGQ=", + "artifactUUID": "970c7177-cf5d-41ba-a2f8-594ec760f825", + "artifactVersion": "2", + "generatedFromUUID": "5bcc6eb1-5d95-403b-a796-31777480b1c5.heat2", + "artifactLabel": "heat2env", + "artifactGroupType": "DEPLOYMENT" + }, + { + "artifactName": "vendor-license-model.xml", + "artifactType": "VENDOR_LICENSE", + "artifactURL": "/sdc/v1/catalog/services/82c9fbb4-656c-4973-8c7f-172b22b5fa8f/resourceInstances/vlb_vsp0/artifacts/9f0320dd-16ab-4ff3-972e-f9faabaa7d54", + "artifactDescription": " Vendor license file", + "artifactChecksum": "MjY3N2M0YmRmZmRiMzNiMWU1NGRlNjU5YTYwZWFmOWI=", + "artifactUUID": "9f0320dd-16ab-4ff3-972e-f9faabaa7d54", + "artifactVersion": "1", + "artifactLabel": "vendorlicense", + "artifactGroupType": "DEPLOYMENT" + }, + { + "artifactName": "dnsscaling.env", + "artifactType": "HEAT_ENV", + "artifactURL": "/sdc/v1/catalog/services/82c9fbb4-656c-4973-8c7f-172b22b5fa8f/resourceInstances/vlb_vsp0/artifacts/778c22db-5ac8-4bd3-a294-24e1d1c1fd43", + "artifactDescription": "Auto-generated HEAT Environment deployment artifact", + "artifactChecksum": "MzEwMjI4YTNiNDU0MTFmZDkwODFhZGNjYzE0MTI1ZTc=", + "artifactUUID": "778c22db-5ac8-4bd3-a294-24e1d1c1fd43", + "artifactVersion": "2", + "generatedFromUUID": "5bcc6eb1-5d95-403b-a796-31777480b1c5.heat1", + "artifactLabel": "heat1env", + "artifactGroupType": "DEPLOYMENT" + } + ] + } + ] + }, + "headers": { + "Content-Type": "application/json" + } + } +} \ No newline at end of file diff --git a/src/test/resources/mappings/sdc/sdc_get_82c9fbb4-656c-4973-8c7f-172b22b5fa8f_tosca.json b/src/test/resources/mappings/sdc/sdc_get_82c9fbb4-656c-4973-8c7f-172b22b5fa8f_tosca.json new file mode 100644 index 0000000..e9b3391 --- /dev/null +++ b/src/test/resources/mappings/sdc/sdc_get_82c9fbb4-656c-4973-8c7f-172b22b5fa8f_tosca.json @@ -0,0 +1,10 @@ +{ + "request": { + "method": "GET", + "url": "/sdc/v1/catalog/services/82c9fbb4-656c-4973-8c7f-172b22b5fa8f/toscaModel" + }, + "response": { + "status": 200, + "bodyFileName": "toscafile/service-VlbService-csar.csar" + } +} \ No newline at end of file diff --git a/src/test/resources/toscafile/service-VlbService-csar.csar b/src/test/resources/toscafile/service-VlbService-csar.csar new file mode 100644 index 0000000..0c5fcdd Binary files /dev/null and b/src/test/resources/toscafile/service-VlbService-csar.csar differ diff --git a/src/test/resources/toscafile/service-VlbService-template.yml b/src/test/resources/toscafile/service-VlbService-template.yml new file mode 100644 index 0000000..716d48e --- /dev/null +++ b/src/test/resources/toscafile/service-VlbService-template.yml @@ -0,0 +1,2449 @@ +# +# Copyright (c) 2018 Orange +# +# 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. +# + +tosca_definitions_version: tosca_simple_yaml_1_1 +metadata: + invariantUUID: 3d3aa59d-d0b4-4663-b4bb-dc16f518acea + UUID: 82c9fbb4-656c-4973-8c7f-172b22b5fa8f + name: VLB_Service + description: VLB_Service + type: Service + category: Network Service + serviceType: '' + serviceRole: '' + instantiationType: Macro + serviceEcompNaming: true + ecompGeneratedNaming: true + namingPolicy: '' + environmentContext: General_Revenue-Bearing +imports: +- nodes: + file: nodes.yml +- datatypes: + file: data.yml +- capabilities: + file: capabilities.yml +- relationships: + file: relationships.yml +- groups: + file: groups.yml +- policies: + file: policies.yml +- annotations: + file: annotations.yml +- service-VLB_Service-interface: + file: service-VlbService-template-interface.yml +- resource-vLB_VSP: + file: resource-VlbVsp-template.yml +- resource-vLB_VSP-interface: + file: resource-VlbVsp-template-interface.yml +# +# Copyright (c) 2018 Orange +# +# 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. +# + +topology_template: + inputs: + ServiceProp1: + default: ServiceProp1Value + type: string + description: ServiceProp1 + required: false + ServiceProp2: + default: ServiceProp2Value + type: string + description: ServiceProp2 + required: false + node_templates: + vLB_VSP 0: + type: org.openecomp.resource.vf.VlbVsp + metadata: + invariantUUID: 368371e6-1d2f-4f4a-b992-a9053c7c2f1e + UUID: 35d7887d-3c35-4fb4-aed1-d15b4d9f4ccc + customizationUUID: 86dcf0b6-5f76-4444-8392-23ca325fd1d9 + version: '1.0' + name: vLB_VSP + description: vLB_VSP + type: VF + category: Generic + subcategory: Infrastructure + resourceVendor: tutorial-license + resourceVendorRelease: '1.0' + resourceVendorModelNumber: '' + properties: + vf_module_id: vLoadBalancer + skip_post_instantiation_configuration: true + repo_url_blob: https://nexus.onap.org/content/sites/raw + vlb_private_net_cidr: 192.168.10.0/24 + vlb_private_net_id: zdfw1lb01_private + VFProp3: VFProp3Value + public_net_id: 60dc8a1c-86b8-4cc4-b5c8-9b0272113c1f0f1c389d-e9db-4c14-b3a2-11dca2d104ed + onap_private_subnet_id: 8c6df8fa-2735-49ad-ba04-24701d85ba79 + gre_ipaddr: 192.168.10.112 + onap_private_net_cidr: 10.0.0.0/16 + vdns_name_0: zdfw1lb01dns02 + pg_int: 192.168.9.109 + vdns_private_ip_0: 192.168.10.212 + dcae_collector_ip: 10.42.135.166 + vnf_id: vLoadBalancer_demo_app + vdns_private_ip_1: 10.0.200.204 + dcae_collector_port: '8081' + vpg_name_0: zdfw1lb01pg01 + vip: 192.168.9.112 + vpg_private_ip_1: 10.0.200.203 + vpg_private_ip_0: 192.168.9.110 + vlb_flavor_name: m1.medium + pktgen_private_net_cidr: 192.168.9.0/24 + nf_naming: + ecomp_generated_naming: true + multi_stage_design: 'false' + onap_private_net_id: 09407156-5e6e-45a7-b4aa-6eeb7ad4aba9 + availability_zone_max_count: 1 + demo_artifacts_version: 1.2.1 + vlb_private_subnet_id: zdfw1lb01_private_subnet + pub_key: ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQC/EnxIi7fcHMEi9VPtCGCOpQYblj9r0M/CaD5U15Cb5qHzcHiPtJpVsDMlPGzN9VHxWZG6FqQv1s6oE+PmG1xeahhb+ofrY6s8zvlUCcWGIo/bPexzb2ErvkGyd+1tQo9oLrxNdUG0xeWUX3oFkiw3RBRyxf9n4E5ajZr4cEFQ0sqJkslj87XViw/h555ydIYTY5cPNmIlsIXTObC/2z3muVWYUzaaZE8omfYJE442+UhYLHgb7Cl1JMk/SNu/r+bLrsXeBSPB+/bxVKqjpd659AQ7GRNXvBrgfq6EKNiVjrI76AbpeTM2D/LXbENuUUkvJBWptSd0gPAGkEyc9w2n + key_name: vlb_key_scaling + vlb_private_ip_1: 10.0.200.201 + vlb_private_ip_2: 192.168.9.111 + repo_url_artifacts: https://nexus.onap.org/content/repositories/releases + vlb_name_0: zdfw1lb01lb01 + pktgen_private_net_id: zdfw1pktgen01_private + install_script_version: 1.2.1 + VFProp2: VFProp2Value + VFProp1: VFProp1Value + cloud_env: openstack + vlb_image_name: Ubuntu_1604 + vlb_private_ip_0: 192.168.10.111 + capabilities: + abstract_vpg.memory.resident_vpg: + properties: + unit: MB + description: Volume of RAM used by the instance on the physical machine + type: Gauge + category: compute + abstract_vdns_0.disk.read.bytes.rate_vdns: + properties: + unit: B/s + description: Average rate of reads + type: Gauge + category: compute + abstract_vdns_0.cpu.delta_vdns: + properties: + unit: ns + description: CPU time used since previous datapoint + type: Delta + category: compute + abstract_vlb.network.outgoing.packets.rate_vlb_vlb_private_1_port: + properties: + unit: packet/s + description: Average rate of outgoing packets + type: Gauge + category: network + abstract_vdns_0.network.incoming.packets.rate_vdns_vdns_private_0_port: + properties: + unit: packet/s + description: Average rate of incoming packets + type: Gauge + category: network + abstract_vlb.disk.allocation_vlb: + properties: + unit: B + description: The amount of disk occupied by the instance on the host machine + type: Gauge + category: disk + abstract_vlb.instance_vlb: + properties: + unit: instance + description: Existence of instance + type: Gauge + category: compute + abstract_vdns_0.network.outpoing.packets_vdns_vdns_private_0_port: + properties: + unit: packet + description: Number of outgoing packets + type: Cumulative + category: network + abstract_vdns_0.network.incoming.bytes.rate_vdns_vdns_private_0_port: + properties: + unit: B/s + description: Average rate of incoming bytes + type: Gauge + category: network + abstract_vdns_0.network.outgoing.bytes.rate_vdns_vdns_private_1_port: + properties: + unit: B/s + description: Average rate of outgoing bytes + type: Gauge + category: network + abstract_vdns_0.network.outgoing.bytes_vdns_vdns_private_0_port: + properties: + unit: B + description: Number of outgoing bytes + type: Cumulative + category: network + abstract_vdns_0.network.outgoing.packets.rate_vdns_vdns_private_1_port: + properties: + unit: packet/s + description: Average rate of outgoing packets + type: Gauge + category: network + abstract_vdns_1.disk.device.latency_vdns: + properties: + unit: ms + description: Average disk latency per device + type: Gauge + category: disk + abstract_vdns_0.port_mirroring_vdns_vdns_private_1_port: + properties: + connection_point: + network_role: + get_input: port_vdns_private_1_port_network_role + nfc_naming_code: vdns + abstract_vlb.disk.device.read.bytes.rate_vlb: + properties: + unit: B/s + description: Average rate of reads + type: Gauge + category: disk + abstract_vlb.network.incoming.packets.rate_vlb_vlb_private_2_port: + properties: + unit: packet/s + description: Average rate of incoming packets + type: Gauge + category: network + abstract_vdns_1.disk.usage_vdns: + properties: + unit: B + description: The physical size in bytes of the image container on the host + type: Gauge + category: disk + abstract_vlb.vcpus_vlb: + properties: + unit: vcpu + description: Number of virtual CPUs allocated to the instance + type: Gauge + category: compute + abstract_vdns_0.disk.device.write.requests.rate_vdns: + properties: + unit: request/s + description: Average rate of write requests + type: Gauge + category: disk + abstract_vdns_0.disk.ephemeral.size_vdns: + properties: + unit: GB + description: Size of ephemeral disk + type: Gauge + category: compute + abstract_vdns_1.disk.device.read.bytes_vdns: + properties: + unit: B + description: Volume of reads + type: Cumulative + category: disk + abstract_vpg.memory.usage_vpg: + properties: + unit: MB + description: Volume of RAM used by the instance from the amount of its allocated memory + type: Gauge + category: compute + abstract_vpg.network.incoming.bytes_vpg_vpg_private_0_port: + properties: + unit: B + description: Number of incoming bytes + type: Cumulative + category: network + abstract_vpg.disk.iops_vpg: + properties: + unit: count/s + description: Average disk iops + type: Gauge + category: disk + abstract_vpg.disk.device.capacity_vpg: + properties: + unit: B + description: The amount of disk per device that the instance can see + type: Gauge + category: disk + abstract_vdns_0.disk.device.capacity_vdns: + properties: + unit: B + description: The amount of disk per device that the instance can see + type: Gauge + category: disk + abstract_vdns_1.disk.device.allocation_vdns: + properties: + unit: B + description: The amount of disk per device occupied by the instance on the host machine + type: Gauge + category: disk + abstract_vpg.disk.write.requests.rate_vpg: + properties: + unit: request/s + description: Average rate of write requests + type: Gauge + category: compute + abstract_vdns_0.network.incoming.packets_vdns_vdns_private_0_port: + properties: + unit: packet + description: Number of incoming packets + type: Cumulative + category: network + abstract_vpg.disk.read.bytes_vpg: + properties: + unit: B + description: Volume of reads + type: Cumulative + category: compute + abstract_vdns_0.endpoint_vdns: + properties: + secure: true + abstract_vlb.disk.write.requests_vlb: + properties: + unit: request + description: Number of write requests + type: Cumulative + category: compute + abstract_vlb.disk.write.bytes_vlb: + properties: + unit: B + description: Volume of writes + type: Cumulative + category: compute + abstract_vpg.disk.capacity_vpg: + properties: + unit: B + description: The amount of disk that the instance can see + type: Gauge + category: disk + abstract_vdns_1.cpu.delta_vdns: + properties: + unit: ns + description: CPU time used since previous datapoint + type: Delta + category: compute + abstract_vpg.scalable_vpg: + properties: + min_instances: 1 + max_instances: 1 + abstract_vlb.endpoint_vlb: + properties: + secure: true + abstract_vdns_1.disk.read.requests_vdns: + properties: + unit: request + description: Number of read requests + type: Cumulative + category: compute + abstract_vpg.disk.device.allocation_vpg: + properties: + unit: B + description: The amount of disk per device occupied by the instance on the host machine + type: Gauge + category: disk + abstract_vdns_0.disk.root.size_vdns: + properties: + unit: GB + description: Size of root disk + type: Gauge + category: compute + abstract_vlb.network.outgoing.bytes_vlb_vlb_private_1_port: + properties: + unit: B + description: Number of outgoing bytes + type: Cumulative + category: network + abstract_vdns_1.disk.write.requests_vdns: + properties: + unit: request + description: Number of write requests + type: Cumulative + category: compute + abstract_vlb.network.incoming.packets_vlb_vlb_private_2_port: + properties: + unit: packet + description: Number of incoming packets + type: Cumulative + category: network + abstract_vdns_0.disk.write.requests.rate_vdns: + properties: + unit: request/s + description: Average rate of write requests + type: Gauge + category: compute + abstract_vdns_0.disk.write.bytes_vdns: + properties: + unit: B + description: Volume of writes + type: Cumulative + category: compute + abstract_vdns_0.instance_vdns: + properties: + unit: instance + description: Existence of instance + type: Gauge + category: compute + abstract_vdns_0.disk.iops_vdns: + properties: + unit: count/s + description: Average disk iops + type: Gauge + category: disk + abstract_vpg.disk.device.iops_vpg: + properties: + unit: count/s + description: Average disk iops per device + type: Gauge + category: disk + pktgen_private_network.end_point: + properties: + protocol: tcp + initiator: source + network_name: PRIVATE + secure: false + abstract_vlb.network.outpoing.packets_vlb_vlb_private_0_port: + properties: + unit: packet + description: Number of outgoing packets + type: Cumulative + category: network + abstract_vlb.disk.write.requests.rate_vlb: + properties: + unit: request/s + description: Average rate of write requests + type: Gauge + category: compute + abstract_vdns_1.disk.write.requests.rate_vdns: + properties: + unit: request/s + description: Average rate of write requests + type: Gauge + category: compute + abstract_vlb.network.incoming.bytes.rate_vlb_vlb_private_2_port: + properties: + unit: B/s + description: Average rate of incoming bytes + type: Gauge + category: network + abstract_vdns_1.network.incoming.packets_vdns_vdns_private_0_port: + properties: + unit: packet + description: Number of incoming packets + type: Cumulative + category: network + abstract_vlb.network.incoming.packets.rate_vlb_vlb_private_0_port: + properties: + unit: packet/s + description: Average rate of incoming packets + type: Gauge + category: network + abstract_vdns_1.disk.write.bytes.rate_vdns: + properties: + unit: B/s + description: Average rate of writes + type: Gauge + category: compute + abstract_vdns_1.disk.device.usage_vdns: + properties: + unit: B + description: The physical size in bytes of the image container on the host per device + type: Gauge + category: disk + abstract_vdns_0.disk.device.read.bytes.rate_vdns: + properties: + unit: B/s + description: Average rate of reads + type: Gauge + category: disk + abstract_vlb.network.outgoing.bytes.rate_vlb_vlb_private_2_port: + properties: + unit: B/s + description: Average rate of outgoing bytes + type: Gauge + category: network + abstract_vlb.disk.write.bytes.rate_vlb: + properties: + unit: B/s + description: Average rate of writes + type: Gauge + category: compute + abstract_vdns_1.disk.device.capacity_vdns: + properties: + unit: B + description: The amount of disk per device that the instance can see + type: Gauge + category: disk + abstract_vlb.disk.device.read.requests_vlb: + properties: + unit: request + description: Number of read requests + type: Cumulative + category: disk + abstract_vdns_1.network.outgoing.bytes.rate_vdns_vdns_private_1_port: + properties: + unit: B/s + description: Average rate of outgoing bytes + type: Gauge + category: network + abstract_vpg.network.outgoing.packets.rate_vpg_vpg_private_0_port: + properties: + unit: packet/s + description: Average rate of outgoing packets + type: Gauge + category: network + abstract_vdns_0.disk.device.write.bytes_vdns: + properties: + unit: B + description: Volume of writes + type: Cumulative + category: disk + vlb_private_network.end_point: + properties: + protocol: tcp + initiator: source + network_name: PRIVATE + secure: false + abstract_vpg.network.outgoing.bytes.rate_vpg_vpg_private_1_port: + properties: + unit: B/s + description: Average rate of outgoing bytes + type: Gauge + category: network + abstract_vdns_0.disk.write.requests_vdns: + properties: + unit: request + description: Number of write requests + type: Cumulative + category: compute + abstract_vdns_1.disk.read.bytes_vdns: + properties: + unit: B + description: Volume of reads + type: Cumulative + category: compute + abstract_vpg.disk.read.bytes.rate_vpg: + properties: + unit: B/s + description: Average rate of reads + type: Gauge + category: compute + abstract_vpg.disk.device.read.requests_vpg: + properties: + unit: request + description: Number of read requests + type: Cumulative + category: disk + abstract_vpg.port_mirroring_vpg_vpg_private_1_port: + properties: + connection_point: + network_role: + get_input: port_vpg_private_1_port_network_role + nfc_naming_code: vpg + abstract_vlb.disk.root.size_vlb: + properties: + unit: GB + description: Size of root disk + type: Gauge + category: compute + abstract_vdns_1.network.outgoing.bytes.rate_vdns_vdns_private_0_port: + properties: + unit: B/s + description: Average rate of outgoing bytes + type: Gauge + category: network + abstract_vlb.cpu_util_vlb: + properties: + unit: '%' + description: Average CPU utilization + type: Gauge + category: compute + abstract_vdns_1.network.outgoing.bytes_vdns_vdns_private_0_port: + properties: + unit: B + description: Number of outgoing bytes + type: Cumulative + category: network + abstract_vdns_1.disk.device.write.bytes_vdns: + properties: + unit: B + description: Volume of writes + type: Cumulative + category: disk + abstract_vpg.disk.device.write.bytes_vpg: + properties: + unit: B + description: Volume of writes + type: Cumulative + category: disk + abstract_vdns_0.disk.latency_vdns: + properties: + unit: ms + description: Average disk latency + type: Gauge + category: disk + abstract_vpg.network.incoming.packets_vpg_vpg_private_1_port: + properties: + unit: packet + description: Number of incoming packets + type: Cumulative + category: network + abstract_vdns_1.disk.ephemeral.size_vdns: + properties: + unit: GB + description: Size of ephemeral disk + type: Gauge + category: compute + abstract_vpg.disk.device.write.bytes.rate_vpg: + properties: + unit: B/s + description: Average rate of writes + type: Gauge + category: disk + abstract_vlb.scalable_vlb: + properties: + min_instances: 1 + max_instances: 1 + abstract_vdns_1.network.incoming.bytes.rate_vdns_vdns_private_0_port: + properties: + unit: B/s + description: Average rate of incoming bytes + type: Gauge + category: network + abstract_vlb.disk.device.write.requests_vlb: + properties: + unit: request + description: Number of write requests + type: Cumulative + category: disk + abstract_vdns_1.disk.allocation_vdns: + properties: + unit: B + description: The amount of disk occupied by the instance on the host machine + type: Gauge + category: disk + abstract_vpg.cpu_util_vpg: + properties: + unit: '%' + description: Average CPU utilization + type: Gauge + category: compute + abstract_vdns_0.disk.device.read.requests.rate_vdns: + properties: + unit: request/s + description: Average rate of read requests + type: Gauge + category: disk + abstract_vpg.vcpus_vpg: + properties: + unit: vcpu + description: Number of virtual CPUs allocated to the instance + type: Gauge + category: compute + abstract_vpg.network.outgoing.bytes_vpg_vpg_private_1_port: + properties: + unit: B + description: Number of outgoing bytes + type: Cumulative + category: network + abstract_vlb.network.incoming.bytes_vlb_vlb_private_2_port: + properties: + unit: B + description: Number of incoming bytes + type: Cumulative + category: network + abstract_vpg.disk.device.usage_vpg: + properties: + unit: B + description: The physical size in bytes of the image container on the host per device + type: Gauge + category: disk + abstract_vpg.disk.device.write.requests.rate_vpg: + properties: + unit: request/s + description: Average rate of write requests + type: Gauge + category: disk + abstract_vlb.disk.device.read.bytes_vlb: + properties: + unit: B + description: Volume of reads + type: Cumulative + category: disk + abstract_vdns_0.disk.device.write.requests_vdns: + properties: + unit: request + description: Number of write requests + type: Cumulative + category: disk + abstract_vdns_1.network.incoming.packets.rate_vdns_vdns_private_0_port: + properties: + unit: packet/s + description: Average rate of incoming packets + type: Gauge + category: network + abstract_vpg.memory_vpg: + properties: + unit: MB + description: Volume of RAM allocated to the instance + type: Gauge + category: compute + abstract_vdns_1.network.incoming.packets_vdns_vdns_private_1_port: + properties: + unit: packet + description: Number of incoming packets + type: Cumulative + category: network + abstract_vdns_1.disk.iops_vdns: + properties: + unit: count/s + description: Average disk iops + type: Gauge + category: disk + abstract_vpg.network.incoming.packets_vpg_vpg_private_0_port: + properties: + unit: packet + description: Number of incoming packets + type: Cumulative + category: network + abstract_vdns_1.network.outpoing.packets_vdns_vdns_private_0_port: + properties: + unit: packet + description: Number of outgoing packets + type: Cumulative + category: network + abstract_vdns_0.disk.device.read.requests_vdns: + properties: + unit: request + description: Number of read requests + type: Cumulative + category: disk + abstract_vpg.disk.device.write.requests_vpg: + properties: + unit: request + description: Number of write requests + type: Cumulative + category: disk + abstract_vpg.disk.device.latency_vpg: + properties: + unit: ms + description: Average disk latency per device + type: Gauge + category: disk + abstract_vpg.network.outgoing.bytes_vpg_vpg_private_0_port: + properties: + unit: B + description: Number of outgoing bytes + type: Cumulative + category: network + abstract_vlb.network.outpoing.packets_vlb_vlb_private_2_port: + properties: + unit: packet + description: Number of outgoing packets + type: Cumulative + category: network + abstract_vlb.disk.device.write.requests.rate_vlb: + properties: + unit: request/s + description: Average rate of write requests + type: Gauge + category: disk + abstract_vlb.disk.capacity_vlb: + properties: + unit: B + description: The amount of disk that the instance can see + type: Gauge + category: disk + abstract_vdns_0.network.incoming.bytes_vdns_vdns_private_1_port: + properties: + unit: B + description: Number of incoming bytes + type: Cumulative + category: network + abstract_vlb.network.outgoing.packets.rate_vlb_vlb_private_0_port: + properties: + unit: packet/s + description: Average rate of outgoing packets + type: Gauge + category: network + abstract_vdns_1.disk.device.read.requests_vdns: + properties: + unit: request + description: Number of read requests + type: Cumulative + category: disk + abstract_vpg.cpu.delta_vpg: + properties: + unit: ns + description: CPU time used since previous datapoint + type: Delta + category: compute + abstract_vlb.disk.read.bytes.rate_vlb: + properties: + unit: B/s + description: Average rate of reads + type: Gauge + category: compute + abstract_vdns_0.memory.resident_vdns: + properties: + unit: MB + description: Volume of RAM used by the instance on the physical machine + type: Gauge + category: compute + abstract_vdns_1.disk.read.bytes.rate_vdns: + properties: + unit: B/s + description: Average rate of reads + type: Gauge + category: compute + abstract_vpg.disk.write.bytes.rate_vpg: + properties: + unit: B/s + description: Average rate of writes + type: Gauge + category: compute + abstract_vdns_1.port_mirroring_vdns_vdns_private_1_port: + properties: + connection_point: + network_role: + get_input: port_vdns_private_1_port_network_role + nfc_naming_code: vdns + abstract_vlb.memory_vlb: + properties: + unit: MB + description: Volume of RAM allocated to the instance + type: Gauge + category: compute + abstract_vdns_0.vcpus_vdns: + properties: + unit: vcpu + description: Number of virtual CPUs allocated to the instance + type: Gauge + category: compute + abstract_vdns_0.disk.device.allocation_vdns: + properties: + unit: B + description: The amount of disk per device occupied by the instance on the host machine + type: Gauge + category: disk + abstract_vpg.disk.write.bytes_vpg: + properties: + unit: B + description: Volume of writes + type: Cumulative + category: compute + abstract_vdns_0.cpu_vdns: + properties: + unit: ns + description: CPU time used + type: Cumulative + category: compute + abstract_vpg.disk.usage_vpg: + properties: + unit: B + description: The physical size in bytes of the image container on the host + type: Gauge + category: disk + abstract_vlb.network.incoming.packets.rate_vlb_vlb_private_1_port: + properties: + unit: packet/s + description: Average rate of incoming packets + type: Gauge + category: network + abstract_vdns_0.network.outgoing.bytes_vdns_vdns_private_1_port: + properties: + unit: B + description: Number of outgoing bytes + type: Cumulative + category: network + abstract_vdns_0.disk.device.read.bytes_vdns: + properties: + unit: B + description: Volume of reads + type: Cumulative + category: disk + abstract_vdns_0.network.incoming.packets.rate_vdns_vdns_private_1_port: + properties: + unit: packet/s + description: Average rate of incoming packets + type: Gauge + category: network + abstract_vdns_1.disk.device.write.requests_vdns: + properties: + unit: request + description: Number of write requests + type: Cumulative + category: disk + abstract_vdns_0.cpu_util_vdns: + properties: + unit: '%' + description: Average CPU utilization + type: Gauge + category: compute + abstract_vdns_0.network.outpoing.packets_vdns_vdns_private_1_port: + properties: + unit: packet + description: Number of outgoing packets + type: Cumulative + category: network + abstract_vlb.port_mirroring_vlb_vlb_private_1_port: + properties: + connection_point: + network_role: + get_input: port_vlb_private_1_port_network_role + nfc_naming_code: vlb + abstract_vdns_0.network.outgoing.bytes.rate_vdns_vdns_private_0_port: + properties: + unit: B/s + description: Average rate of outgoing bytes + type: Gauge + category: network + abstract_vdns_0.network.incoming.bytes.rate_vdns_vdns_private_1_port: + properties: + unit: B/s + description: Average rate of incoming bytes + type: Gauge + category: network + abstract_vdns_0.disk.device.usage_vdns: + properties: + unit: B + description: The physical size in bytes of the image container on the host per device + type: Gauge + category: disk + abstract_vdns_0.memory.usage_vdns: + properties: + unit: MB + description: Volume of RAM used by the instance from the amount of its allocated memory + type: Gauge + category: compute + abstract_vdns_1.network.outpoing.packets_vdns_vdns_private_1_port: + properties: + unit: packet + description: Number of outgoing packets + type: Cumulative + category: network + abstract_vlb.network.outgoing.packets.rate_vlb_vlb_private_2_port: + properties: + unit: packet/s + description: Average rate of outgoing packets + type: Gauge + category: network + abstract_vdns_1.memory.usage_vdns: + properties: + unit: MB + description: Volume of RAM used by the instance from the amount of its allocated memory + type: Gauge + category: compute + abstract_vdns_0.network.incoming.bytes_vdns_vdns_private_0_port: + properties: + unit: B + description: Number of incoming bytes + type: Cumulative + category: network + abstract_vdns_1.disk.device.read.bytes.rate_vdns: + properties: + unit: B/s + description: Average rate of reads + type: Gauge + category: disk + abstract_vlb.cpu_vlb: + properties: + unit: ns + description: CPU time used + type: Cumulative + category: compute + abstract_vlb.network.outpoing.packets_vlb_vlb_private_1_port: + properties: + unit: packet + description: Number of outgoing packets + type: Cumulative + category: network + abstract_vlb.network.outgoing.bytes_vlb_vlb_private_0_port: + properties: + unit: B + description: Number of outgoing bytes + type: Cumulative + category: network + abstract_vlb.memory.usage_vlb: + properties: + unit: MB + description: Volume of RAM used by the instance from the amount of its allocated memory + type: Gauge + category: compute + abstract_vdns_0.scalable_vdns: + properties: + min_instances: 1 + max_instances: 1 + abstract_vpg.disk.device.read.bytes_vpg: + properties: + unit: B + description: Volume of reads + type: Cumulative + category: disk + abstract_vlb.disk.device.latency_vlb: + properties: + unit: ms + description: Average disk latency per device + type: Gauge + category: disk + abstract_vpg.disk.device.read.bytes.rate_vpg: + properties: + unit: B/s + description: Average rate of reads + type: Gauge + category: disk + abstract_vdns_0.disk.device.latency_vdns: + properties: + unit: ms + description: Average disk latency per device + type: Gauge + category: disk + abstract_vdns_1.network.outgoing.packets.rate_vdns_vdns_private_0_port: + properties: + unit: packet/s + description: Average rate of outgoing packets + type: Gauge + category: network + abstract_vdns_1.disk.device.write.bytes.rate_vdns: + properties: + unit: B/s + description: Average rate of writes + type: Gauge + category: disk + abstract_vdns_0.memory_vdns: + properties: + unit: MB + description: Volume of RAM allocated to the instance + type: Gauge + category: compute + abstract_vdns_1.memory_vdns: + properties: + unit: MB + description: Volume of RAM allocated to the instance + type: Gauge + category: compute + abstract_vdns_1.scalable_vdns: + properties: + min_instances: 1 + max_instances: 1 + abstract_vdns_1.network.incoming.bytes_vdns_vdns_private_1_port: + properties: + unit: B + description: Number of incoming bytes + type: Cumulative + category: network + abstract_vlb.disk.device.iops_vlb: + properties: + unit: count/s + description: Average disk iops per device + type: Gauge + category: disk + abstract_vdns_0.disk.device.iops_vdns: + properties: + unit: count/s + description: Average disk iops per device + type: Gauge + category: disk + abstract_vpg.disk.latency_vpg: + properties: + unit: ms + description: Average disk latency + type: Gauge + category: disk + abstract_vdns_0.disk.read.bytes_vdns: + properties: + unit: B + description: Volume of reads + type: Cumulative + category: compute + abstract_vpg.network.incoming.bytes.rate_vpg_vpg_private_1_port: + properties: + unit: B/s + description: Average rate of incoming bytes + type: Gauge + category: network + abstract_vdns_0.network.incoming.packets_vdns_vdns_private_1_port: + properties: + unit: packet + description: Number of incoming packets + type: Cumulative + category: network + abstract_vpg.instance_vpg: + properties: + unit: instance + description: Existence of instance + type: Gauge + category: compute + abstract_vpg.network.outpoing.packets_vpg_vpg_private_0_port: + properties: + unit: packet + description: Number of outgoing packets + type: Cumulative + category: network + abstract_vlb.disk.device.capacity_vlb: + properties: + unit: B + description: The amount of disk per device that the instance can see + type: Gauge + category: disk + abstract_vdns_1.network.incoming.packets.rate_vdns_vdns_private_1_port: + properties: + unit: packet/s + description: Average rate of incoming packets + type: Gauge + category: network + abstract_vdns_1.disk.root.size_vdns: + properties: + unit: GB + description: Size of root disk + type: Gauge + category: compute + abstract_vdns_1.cpu_util_vdns: + properties: + unit: '%' + description: Average CPU utilization + type: Gauge + category: compute + abstract_vdns_0.network.outgoing.packets.rate_vdns_vdns_private_0_port: + properties: + unit: packet/s + description: Average rate of outgoing packets + type: Gauge + category: network + abstract_vlb.network.incoming.bytes_vlb_vlb_private_0_port: + properties: + unit: B + description: Number of incoming bytes + type: Cumulative + category: network + abstract_vlb.disk.read.bytes_vlb: + properties: + unit: B + description: Volume of reads + type: Cumulative + category: compute + abstract_vlb.disk.device.usage_vlb: + properties: + unit: B + description: The physical size in bytes of the image container on the host per device + type: Gauge + category: disk + abstract_vpg.disk.allocation_vpg: + properties: + unit: B + description: The amount of disk occupied by the instance on the host machine + type: Gauge + category: disk + abstract_vpg.network.incoming.packets.rate_vpg_vpg_private_1_port: + properties: + unit: packet/s + description: Average rate of incoming packets + type: Gauge + category: network + abstract_vdns_1.disk.device.read.requests.rate_vdns: + properties: + unit: request/s + description: Average rate of read requests + type: Gauge + category: disk + abstract_vlb.network.incoming.bytes_vlb_vlb_private_1_port: + properties: + unit: B + description: Number of incoming bytes + type: Cumulative + category: network + abstract_vdns_1.network.incoming.bytes.rate_vdns_vdns_private_1_port: + properties: + unit: B/s + description: Average rate of incoming bytes + type: Gauge + category: network + abstract_vdns_0.disk.allocation_vdns: + properties: + unit: B + description: The amount of disk occupied by the instance on the host machine + type: Gauge + category: disk + abstract_vdns_1.instance_vdns: + properties: + unit: instance + description: Existence of instance + type: Gauge + category: compute + abstract_vpg.disk.read.requests_vpg: + properties: + unit: request + description: Number of read requests + type: Cumulative + category: compute + abstract_vpg.network.outpoing.packets_vpg_vpg_private_1_port: + properties: + unit: packet + description: Number of outgoing packets + type: Cumulative + category: network + abstract_vlb.disk.iops_vlb: + properties: + unit: count/s + description: Average disk iops + type: Gauge + category: disk + abstract_vpg.network.outgoing.packets.rate_vpg_vpg_private_1_port: + properties: + unit: packet/s + description: Average rate of outgoing packets + type: Gauge + category: network + abstract_vlb.network.incoming.packets_vlb_vlb_private_0_port: + properties: + unit: packet + description: Number of incoming packets + type: Cumulative + category: network + abstract_vlb.disk.ephemeral.size_vlb: + properties: + unit: GB + description: Size of ephemeral disk + type: Gauge + category: compute + abstract_vdns_1.disk.write.bytes_vdns: + properties: + unit: B + description: Volume of writes + type: Cumulative + category: compute + abstract_vlb.cpu.delta_vlb: + properties: + unit: ns + description: CPU time used since previous datapoint + type: Delta + category: compute + abstract_vdns_1.disk.device.write.requests.rate_vdns: + properties: + unit: request/s + description: Average rate of write requests + type: Gauge + category: disk + abstract_vlb.disk.usage_vlb: + properties: + unit: B + description: The physical size in bytes of the image container on the host + type: Gauge + category: disk + abstract_vdns_0.disk.write.bytes.rate_vdns: + properties: + unit: B/s + description: Average rate of writes + type: Gauge + category: compute + abstract_vlb.disk.device.read.requests.rate_vlb: + properties: + unit: request/s + description: Average rate of read requests + type: Gauge + category: disk + abstract_vpg.endpoint_vpg: + properties: + secure: true + abstract_vdns_1.disk.latency_vdns: + properties: + unit: ms + description: Average disk latency + type: Gauge + category: disk + abstract_vdns_1.network.outgoing.bytes_vdns_vdns_private_1_port: + properties: + unit: B + description: Number of outgoing bytes + type: Cumulative + category: network + abstract_vlb.memory.resident_vlb: + properties: + unit: MB + description: Volume of RAM used by the instance on the physical machine + type: Gauge + category: compute + abstract_vdns_1.network.incoming.bytes_vdns_vdns_private_0_port: + properties: + unit: B + description: Number of incoming bytes + type: Cumulative + category: network + abstract_vpg.network.outgoing.bytes.rate_vpg_vpg_private_0_port: + properties: + unit: B/s + description: Average rate of outgoing bytes + type: Gauge + category: network + abstract_vpg.cpu_vpg: + properties: + unit: ns + description: CPU time used + type: Cumulative + category: compute + abstract_vpg.network.incoming.packets.rate_vpg_vpg_private_0_port: + properties: + unit: packet/s + description: Average rate of incoming packets + type: Gauge + category: network + abstract_vdns_0.disk.read.requests_vdns: + properties: + unit: request + description: Number of read requests + type: Cumulative + category: compute + abstract_vlb.network.outgoing.bytes.rate_vlb_vlb_private_1_port: + properties: + unit: B/s + description: Average rate of outgoing bytes + type: Gauge + category: network + abstract_vlb.network.incoming.bytes.rate_vlb_vlb_private_0_port: + properties: + unit: B/s + description: Average rate of incoming bytes + type: Gauge + category: network + abstract_vpg.disk.root.size_vpg: + properties: + unit: GB + description: Size of root disk + type: Gauge + category: compute + abstract_vlb.disk.device.write.bytes.rate_vlb: + properties: + unit: B/s + description: Average rate of writes + type: Gauge + category: disk + abstract_vlb.disk.latency_vlb: + properties: + unit: ms + description: Average disk latency + type: Gauge + category: disk + abstract_vdns_1.network.outgoing.packets.rate_vdns_vdns_private_1_port: + properties: + unit: packet/s + description: Average rate of outgoing packets + type: Gauge + category: network + abstract_vdns_0.disk.usage_vdns: + properties: + unit: B + description: The physical size in bytes of the image container on the host + type: Gauge + category: disk + abstract_vlb.network.incoming.packets_vlb_vlb_private_1_port: + properties: + unit: packet + description: Number of incoming packets + type: Cumulative + category: network + abstract_vdns_0.disk.device.write.bytes.rate_vdns: + properties: + unit: B/s + description: Average rate of writes + type: Gauge + category: disk + abstract_vdns_1.endpoint_vdns: + properties: + secure: true + abstract_vpg.disk.ephemeral.size_vpg: + properties: + unit: GB + description: Size of ephemeral disk + type: Gauge + category: compute + abstract_vpg.network.incoming.bytes.rate_vpg_vpg_private_0_port: + properties: + unit: B/s + description: Average rate of incoming bytes + type: Gauge + category: network + abstract_vdns_1.memory.resident_vdns: + properties: + unit: MB + description: Volume of RAM used by the instance on the physical machine + type: Gauge + category: compute + abstract_vlb.network.incoming.bytes.rate_vlb_vlb_private_1_port: + properties: + unit: B/s + description: Average rate of incoming bytes + type: Gauge + category: network + abstract_vlb.disk.device.allocation_vlb: + properties: + unit: B + description: The amount of disk per device occupied by the instance on the host machine + type: Gauge + category: disk + abstract_vlb.disk.device.write.bytes_vlb: + properties: + unit: B + description: Volume of writes + type: Cumulative + category: disk + abstract_vdns_1.disk.capacity_vdns: + properties: + unit: B + description: The amount of disk that the instance can see + type: Gauge + category: disk + abstract_vpg.disk.device.read.requests.rate_vpg: + properties: + unit: request/s + description: Average rate of read requests + type: Gauge + category: disk + abstract_vdns_0.disk.capacity_vdns: + properties: + unit: B + description: The amount of disk that the instance can see + type: Gauge + category: disk + abstract_vdns_1.vcpus_vdns: + properties: + unit: vcpu + description: Number of virtual CPUs allocated to the instance + type: Gauge + category: compute + abstract_vlb.network.outgoing.bytes.rate_vlb_vlb_private_0_port: + properties: + unit: B/s + description: Average rate of outgoing bytes + type: Gauge + category: network + abstract_vdns_1.cpu_vdns: + properties: + unit: ns + description: CPU time used + type: Cumulative + category: compute + abstract_vlb.disk.read.requests_vlb: + properties: + unit: request + description: Number of read requests + type: Cumulative + category: compute + abstract_vpg.network.incoming.bytes_vpg_vpg_private_1_port: + properties: + unit: B + description: Number of incoming bytes + type: Cumulative + category: network + abstract_vlb.network.outgoing.bytes_vlb_vlb_private_2_port: + properties: + unit: B + description: Number of outgoing bytes + type: Cumulative + category: network + abstract_vdns_1.disk.device.iops_vdns: + properties: + unit: count/s + description: Average disk iops per device + type: Gauge + category: disk + abstract_vpg.disk.write.requests_vpg: + properties: + unit: request + description: Number of write requests + type: Cumulative + category: compute + groups: + vlb_vsp0..VlbVsp..dnsscaling..module-1: + type: org.openecomp.groups.VfModule + metadata: + vfModuleModelName: VlbVsp..dnsscaling..module-1 + vfModuleModelInvariantUUID: 888b6342-8aea-4416-b485-e24726c1f964 + vfModuleModelUUID: 9bfd197c-7e18-41bd-927d-57102a6fda7e + vfModuleModelVersion: '1' + vfModuleModelCustomizationUUID: 4c387136-2fa2-420f-94e9-3312f863a352 + properties: + min_vf_module_instances: 0 + vf_module_label: dnsscaling + vf_module_type: Expansion + isBase: false + initial_count: 0 + volume_group: false + vlb_vsp0..VlbVsp..base_vlb..module-0: + type: org.openecomp.groups.VfModule + metadata: + vfModuleModelName: VlbVsp..base_vlb..module-0 + vfModuleModelInvariantUUID: bcbdfc80-4fb1-4c3e-b4e3-77721bac61db + vfModuleModelUUID: d0325d26-43f2-4c6f-aff5-2832ac2d8ab0 + vfModuleModelVersion: '1' + vfModuleModelCustomizationUUID: 0895caa9-b7d3-4e02-9a3c-8337c4076948 + properties: + min_vf_module_instances: 1 + vf_module_label: base_vlb + max_vf_module_instances: 1 + vf_module_type: Base + isBase: true + initial_count: 1 + volume_group: false + substitution_mappings: + node_type: org.openecomp.service.VlbService + capabilities: + vlb_vsp0.abstract_vlb.binding_vlb_vlb_private_2_port: + - vLB_VSP 0 + - abstract_vlb.binding_vlb_vlb_private_2_port + vlb_vsp0.abstract_vdns_1.network.outgoing.bytes.rate_vdns_vdns_private_1_port: + - vLB_VSP 0 + - abstract_vdns_1.network.outgoing.bytes.rate_vdns_vdns_private_1_port + vlb_vsp0.abstract_vlb.disk.device.read.requests_vlb: + - vLB_VSP 0 + - abstract_vlb.disk.device.read.requests_vlb + vlb_vsp0.abstract_vdns_1.feature_vdns_vdns_private_1_port: + - vLB_VSP 0 + - abstract_vdns_1.feature_vdns_vdns_private_1_port + vlb_vsp0.abstract_vlb.network.outgoing.bytes.rate_vlb_vlb_private_2_port: + - vLB_VSP 0 + - abstract_vlb.network.outgoing.bytes.rate_vlb_vlb_private_2_port + vlb_vsp0.abstract_vlb.feature_vlb: + - vLB_VSP 0 + - abstract_vlb.feature_vlb + vlb_vsp0.abstract_vdns_1.binding_vdns_vdns_private_1_port: + - vLB_VSP 0 + - abstract_vdns_1.binding_vdns_vdns_private_1_port + vlb_vsp0.abstract_vdns_1.vcpus_vdns: + - vLB_VSP 0 + - abstract_vdns_1.vcpus_vdns + vlb_vsp0.abstract_vpg.disk.device.read.requests_vpg: + - vLB_VSP 0 + - abstract_vpg.disk.device.read.requests_vpg + vlb_vsp0.abstract_vdns_1.network.incoming.packets.rate_vdns_vdns_private_1_port: + - vLB_VSP 0 + - abstract_vdns_1.network.incoming.packets.rate_vdns_vdns_private_1_port + vlb_vsp0.vlb_private_network.link: + - vLB_VSP 0 + - vlb_private_network.link + vlb_vsp0.abstract_vlb.disk.device.write.bytes.rate_vlb: + - vLB_VSP 0 + - abstract_vlb.disk.device.write.bytes.rate_vlb + vlb_vsp0.abstract_vlb.network.outpoing.packets_vlb_vlb_private_1_port: + - vLB_VSP 0 + - abstract_vlb.network.outpoing.packets_vlb_vlb_private_1_port + vlb_vsp0.abstract_vdns_0.network.incoming.packets_vdns_vdns_private_0_port: + - vLB_VSP 0 + - abstract_vdns_0.network.incoming.packets_vdns_vdns_private_0_port + vlb_vsp0.abstract_vdns_0.disk.device.latency_vdns: + - vLB_VSP 0 + - abstract_vdns_0.disk.device.latency_vdns + vlb_vsp0.abstract_vdns_0.attachment_vdns_vdns_private_0_port: + - vLB_VSP 0 + - abstract_vdns_0.attachment_vdns_vdns_private_0_port + vlb_vsp0.abstract_vdns_0.instance_vdns: + - vLB_VSP 0 + - abstract_vdns_0.instance_vdns + vlb_vsp0.abstract_vpg.binding_vpg: + - vLB_VSP 0 + - abstract_vpg.binding_vpg + vlb_vsp0.abstract_vlb.network.incoming.packets.rate_vlb_vlb_private_0_port: + - vLB_VSP 0 + - abstract_vlb.network.incoming.packets.rate_vlb_vlb_private_0_port + vlb_vsp0.abstract_vlb.network.incoming.packets_vlb_vlb_private_1_port: + - vLB_VSP 0 + - abstract_vlb.network.incoming.packets_vlb_vlb_private_1_port + vlb_vsp0.abstract_vdns_1.network.incoming.bytes.rate_vdns_vdns_private_0_port: + - vLB_VSP 0 + - abstract_vdns_1.network.incoming.bytes.rate_vdns_vdns_private_0_port + vlb_vsp0.abstract_vdns_1.disk.root.size_vdns: + - vLB_VSP 0 + - abstract_vdns_1.disk.root.size_vdns + vlb_vsp0.abstract_vlb.disk.device.usage_vlb: + - vLB_VSP 0 + - abstract_vlb.disk.device.usage_vlb + vlb_vsp0.abstract_vpg.disk.write.requests_vpg: + - vLB_VSP 0 + - abstract_vpg.disk.write.requests_vpg + vlb_vsp0.abstract_vdns_1.network.incoming.bytes_vdns_vdns_private_0_port: + - vLB_VSP 0 + - abstract_vdns_1.network.incoming.bytes_vdns_vdns_private_0_port + vlb_vsp0.abstract_vdns_0.os_vdns: + - vLB_VSP 0 + - abstract_vdns_0.os_vdns + vlb_vsp0.abstract_vdns_1.feature_vdns: + - vLB_VSP 0 + - abstract_vdns_1.feature_vdns + vlb_vsp0.abstract_vpg.network.outgoing.bytes.rate_vpg_vpg_private_0_port: + - vLB_VSP 0 + - abstract_vpg.network.outgoing.bytes.rate_vpg_vpg_private_0_port + vlb_vsp0.abstract_vlb.network.outgoing.bytes_vlb_vlb_private_1_port: + - vLB_VSP 0 + - abstract_vlb.network.outgoing.bytes_vlb_vlb_private_1_port + vlb_vsp0.abstract_vdns_1.network.outgoing.packets.rate_vdns_vdns_private_0_port: + - vLB_VSP 0 + - abstract_vdns_1.network.outgoing.packets.rate_vdns_vdns_private_0_port + vlb_vsp0.abstract_vpg.network.incoming.bytes_vpg_vpg_private_0_port: + - vLB_VSP 0 + - abstract_vpg.network.incoming.bytes_vpg_vpg_private_0_port + vlb_vsp0.abstract_vdns_1.network.outgoing.bytes_vdns_vdns_private_1_port: + - vLB_VSP 0 + - abstract_vdns_1.network.outgoing.bytes_vdns_vdns_private_1_port + vlb_vsp0.abstract_vlb.endpoint_vlb: + - vLB_VSP 0 + - abstract_vlb.endpoint_vlb + vlb_vsp0.abstract_vdns_1.forwarder_vdns_vdns_private_1_port: + - vLB_VSP 0 + - abstract_vdns_1.forwarder_vdns_vdns_private_1_port + vlb_vsp0.abstract_vdns_0.network.outpoing.packets_vdns_vdns_private_0_port: + - vLB_VSP 0 + - abstract_vdns_0.network.outpoing.packets_vdns_vdns_private_0_port + vlb_vsp0.abstract_vpg.disk.device.allocation_vpg: + - vLB_VSP 0 + - abstract_vpg.disk.device.allocation_vpg + vlb_vsp0.abstract_vdns_1.port_mirroring_vdns_vdns_private_1_port: + - vLB_VSP 0 + - abstract_vdns_1.port_mirroring_vdns_vdns_private_1_port + vlb_vsp0.abstract_vdns_1.cpu_vdns: + - vLB_VSP 0 + - abstract_vdns_1.cpu_vdns + vlb_vsp0.abstract_vdns_1.disk.device.write.bytes.rate_vdns: + - vLB_VSP 0 + - abstract_vdns_1.disk.device.write.bytes.rate_vdns + vlb_vsp0.abstract_vlb.vcpus_vlb: + - vLB_VSP 0 + - abstract_vlb.vcpus_vlb + vlb_vsp0.abstract_vpg.vcpus_vpg: + - vLB_VSP 0 + - abstract_vpg.vcpus_vpg + vlb_vsp0.abstract_vdns_1.disk.read.bytes_vdns: + - vLB_VSP 0 + - abstract_vdns_1.disk.read.bytes_vdns + vlb_vsp0.abstract_vdns_0.memory_vdns: + - vLB_VSP 0 + - abstract_vdns_0.memory_vdns + vlb_vsp0.abstract_vpg.network.outgoing.packets.rate_vpg_vpg_private_1_port: + - vLB_VSP 0 + - abstract_vpg.network.outgoing.packets.rate_vpg_vpg_private_1_port + vlb_vsp0.abstract_vlb.forwarder_vlb_vlb_private_1_port: + - vLB_VSP 0 + - abstract_vlb.forwarder_vlb_vlb_private_1_port + vlb_vsp0.abstract_vlb.memory.resident_vlb: + - vLB_VSP 0 + - abstract_vlb.memory.resident_vlb + vlb_vsp0.abstract_vlb.disk.read.bytes_vlb: + - vLB_VSP 0 + - abstract_vlb.disk.read.bytes_vlb + vlb_vsp0.abstract_vpg.disk.iops_vpg: + - vLB_VSP 0 + - abstract_vpg.disk.iops_vpg + vlb_vsp0.abstract_vdns_0.disk.device.write.bytes_vdns: + - vLB_VSP 0 + - abstract_vdns_0.disk.device.write.bytes_vdns + vlb_vsp0.abstract_vdns_0.disk.write.requests_vdns: + - vLB_VSP 0 + - abstract_vdns_0.disk.write.requests_vdns + vlb_vsp0.abstract_vdns_0.endpoint_vdns: + - vLB_VSP 0 + - abstract_vdns_0.endpoint_vdns + vlb_vsp0.abstract_vdns_1.memory_vdns: + - vLB_VSP 0 + - abstract_vdns_1.memory_vdns + vlb_vsp0.abstract_vpg.cpu_vpg: + - vLB_VSP 0 + - abstract_vpg.cpu_vpg + vlb_vsp0.abstract_vlb.memory_vlb: + - vLB_VSP 0 + - abstract_vlb.memory_vlb + vlb_vsp0.abstract_vpg.disk.device.capacity_vpg: + - vLB_VSP 0 + - abstract_vpg.disk.device.capacity_vpg + vlb_vsp0.abstract_vlb.disk.device.allocation_vlb: + - vLB_VSP 0 + - abstract_vlb.disk.device.allocation_vlb + vlb_vsp0.abstract_vpg.network.incoming.packets.rate_vpg_vpg_private_0_port: + - vLB_VSP 0 + - abstract_vpg.network.incoming.packets.rate_vpg_vpg_private_0_port + vlb_vsp0.abstract_vdns_0.feature_vdns_vdns_private_0_port: + - vLB_VSP 0 + - abstract_vdns_0.feature_vdns_vdns_private_0_port + vlb_vsp0.vlb_private_network.feature: + - vLB_VSP 0 + - vlb_private_network.feature + vlb_vsp0.abstract_vlb.os_vlb: + - vLB_VSP 0 + - abstract_vlb.os_vlb + vlb_vsp0.abstract_vlb.disk.device.read.bytes.rate_vlb: + - vLB_VSP 0 + - abstract_vlb.disk.device.read.bytes.rate_vlb + vlb_vsp0.abstract_vpg.network.incoming.bytes.rate_vpg_vpg_private_1_port: + - vLB_VSP 0 + - abstract_vpg.network.incoming.bytes.rate_vpg_vpg_private_1_port + vlb_vsp0.abstract_vdns_1.endpoint_vdns: + - vLB_VSP 0 + - abstract_vdns_1.endpoint_vdns + vlb_vsp0.abstract_vdns_1.memory.usage_vdns: + - vLB_VSP 0 + - abstract_vdns_1.memory.usage_vdns + vlb_vsp0.abstract_vlb.disk.latency_vlb: + - vLB_VSP 0 + - abstract_vlb.disk.latency_vlb + vlb_vsp0.abstract_vdns_1.network.outpoing.packets_vdns_vdns_private_0_port: + - vLB_VSP 0 + - abstract_vdns_1.network.outpoing.packets_vdns_vdns_private_0_port + vlb_vsp0.abstract_vlb.instance_vlb: + - vLB_VSP 0 + - abstract_vlb.instance_vlb + vlb_vsp0.abstract_vdns_1.disk.device.usage_vdns: + - vLB_VSP 0 + - abstract_vdns_1.disk.device.usage_vdns + vlb_vsp0.abstract_vlb.network.incoming.bytes_vlb_vlb_private_1_port: + - vLB_VSP 0 + - abstract_vlb.network.incoming.bytes_vlb_vlb_private_1_port + vlb_vsp0.abstract_vpg.feature_vpg_vpg_private_1_port: + - vLB_VSP 0 + - abstract_vpg.feature_vpg_vpg_private_1_port + vlb_vsp0.abstract_vdns_0.network.outgoing.bytes.rate_vdns_vdns_private_1_port: + - vLB_VSP 0 + - abstract_vdns_0.network.outgoing.bytes.rate_vdns_vdns_private_1_port + vlb_vsp0.abstract_vpg.os_vpg: + - vLB_VSP 0 + - abstract_vpg.os_vpg + vlb_vsp0.abstract_vdns_0.network.incoming.bytes.rate_vdns_vdns_private_1_port: + - vLB_VSP 0 + - abstract_vdns_0.network.incoming.bytes.rate_vdns_vdns_private_1_port + vlb_vsp0.abstract_vdns_0.network.outgoing.packets.rate_vdns_vdns_private_0_port: + - vLB_VSP 0 + - abstract_vdns_0.network.outgoing.packets.rate_vdns_vdns_private_0_port + vlb_vsp0.abstract_vpg.network.outpoing.packets_vpg_vpg_private_0_port: + - vLB_VSP 0 + - abstract_vpg.network.outpoing.packets_vpg_vpg_private_0_port + vlb_vsp0.abstract_vdns_1.disk.device.iops_vdns: + - vLB_VSP 0 + - abstract_vdns_1.disk.device.iops_vdns + vlb_vsp0.abstract_vdns_1.host_vdns: + - vLB_VSP 0 + - abstract_vdns_1.host_vdns + vlb_vsp0.abstract_vlb.disk.write.requests_vlb: + - vLB_VSP 0 + - abstract_vlb.disk.write.requests_vlb + vlb_vsp0.abstract_vlb.network.incoming.bytes_vlb_vlb_private_0_port: + - vLB_VSP 0 + - abstract_vlb.network.incoming.bytes_vlb_vlb_private_0_port + vlb_vsp0.abstract_vdns_1.disk.capacity_vdns: + - vLB_VSP 0 + - abstract_vdns_1.disk.capacity_vdns + vlb_vsp0.abstract_vpg.binding_vpg_vpg_private_0_port: + - vLB_VSP 0 + - abstract_vpg.binding_vpg_vpg_private_0_port + vlb_vsp0.abstract_vdns_0.disk.device.capacity_vdns: + - vLB_VSP 0 + - abstract_vdns_0.disk.device.capacity_vdns + vlb_vsp0.abstract_vdns_0.host_vdns: + - vLB_VSP 0 + - abstract_vdns_0.host_vdns + vlb_vsp0.abstract_vlb.scalable_vlb: + - vLB_VSP 0 + - abstract_vlb.scalable_vlb + vlb_vsp0.abstract_vpg.disk.usage_vpg: + - vLB_VSP 0 + - abstract_vpg.disk.usage_vpg + vlb_vsp0.abstract_vpg.attachment_vpg_vpg_private_1_port: + - vLB_VSP 0 + - abstract_vpg.attachment_vpg_vpg_private_1_port + vlb_vsp0.abstract_vlb.disk.device.write.bytes_vlb: + - vLB_VSP 0 + - abstract_vlb.disk.device.write.bytes_vlb + vlb_vsp0.abstract_vlb.disk.device.capacity_vlb: + - vLB_VSP 0 + - abstract_vlb.disk.device.capacity_vlb + vlb_vsp0.abstract_vpg.endpoint_vpg: + - vLB_VSP 0 + - abstract_vpg.endpoint_vpg + vlb_vsp0.abstract_vdns_0.disk.read.bytes_vdns: + - vLB_VSP 0 + - abstract_vdns_0.disk.read.bytes_vdns + vlb_vsp0.abstract_vpg.disk.device.iops_vpg: + - vLB_VSP 0 + - abstract_vpg.disk.device.iops_vpg + vlb_vsp0.abstract_vlb.disk.device.iops_vlb: + - vLB_VSP 0 + - abstract_vlb.disk.device.iops_vlb + vlb_vsp0.abstract_vdns_0.network.incoming.packets.rate_vdns_vdns_private_0_port: + - vLB_VSP 0 + - abstract_vdns_0.network.incoming.packets.rate_vdns_vdns_private_0_port + vlb_vsp0.abstract_vlb.feature_vlb_vlb_private_2_port: + - vLB_VSP 0 + - abstract_vlb.feature_vlb_vlb_private_2_port + vlb_vsp0.abstract_vpg.disk.device.read.bytes.rate_vpg: + - vLB_VSP 0 + - abstract_vpg.disk.device.read.bytes.rate_vpg + vlb_vsp0.abstract_vpg.cpu_util_vpg: + - vLB_VSP 0 + - abstract_vpg.cpu_util_vpg + vlb_vsp0.abstract_vdns_1.disk.device.read.requests.rate_vdns: + - vLB_VSP 0 + - abstract_vdns_1.disk.device.read.requests.rate_vdns + vlb_vsp0.pktgen_private_network.end_point: + - vLB_VSP 0 + - pktgen_private_network.end_point + vlb_vsp0.abstract_vlb.disk.iops_vlb: + - vLB_VSP 0 + - abstract_vlb.disk.iops_vlb + vlb_vsp0.abstract_vdns_0.feature_vdns: + - vLB_VSP 0 + - abstract_vdns_0.feature_vdns + vlb_vsp0.abstract_vdns_1.disk.usage_vdns: + - vLB_VSP 0 + - abstract_vdns_1.disk.usage_vdns + vlb_vsp0.abstract_vlb.port_mirroring_vlb_vlb_private_1_port: + - vLB_VSP 0 + - abstract_vlb.port_mirroring_vlb_vlb_private_1_port + vlb_vsp0.abstract_vdns_1.instance_vdns: + - vLB_VSP 0 + - abstract_vdns_1.instance_vdns + vlb_vsp0.abstract_vpg.binding_vpg_vpg_private_1_port: + - vLB_VSP 0 + - abstract_vpg.binding_vpg_vpg_private_1_port + vlb_vsp0.abstract_vlb.attachment_vlb_vlb_private_0_port: + - vLB_VSP 0 + - abstract_vlb.attachment_vlb_vlb_private_0_port + vlb_vsp0.abstract_vdns_0.network.incoming.bytes_vdns_vdns_private_0_port: + - vLB_VSP 0 + - abstract_vdns_0.network.incoming.bytes_vdns_vdns_private_0_port + vlb_vsp0.abstract_vdns_0.memory.resident_vdns: + - vLB_VSP 0 + - abstract_vdns_0.memory.resident_vdns + vlb_vsp0.abstract_vlb.disk.read.requests_vlb: + - vLB_VSP 0 + - abstract_vlb.disk.read.requests_vlb + vlb_vsp0.abstract_vpg.memory.usage_vpg: + - vLB_VSP 0 + - abstract_vpg.memory.usage_vpg + vlb_vsp0.abstract_vlb.attachment_vlb_vlb_private_1_port: + - vLB_VSP 0 + - abstract_vlb.attachment_vlb_vlb_private_1_port + vlb_vsp0.abstract_vpg.network.incoming.bytes_vpg_vpg_private_1_port: + - vLB_VSP 0 + - abstract_vpg.network.incoming.bytes_vpg_vpg_private_1_port + vlb_vsp0.abstract_vdns_1.disk.iops_vdns: + - vLB_VSP 0 + - abstract_vdns_1.disk.iops_vdns + vlb_vsp0.abstract_vdns_0.network.incoming.packets.rate_vdns_vdns_private_1_port: + - vLB_VSP 0 + - abstract_vdns_0.network.incoming.packets.rate_vdns_vdns_private_1_port + vlb_vsp0.abstract_vdns_1.disk.device.allocation_vdns: + - vLB_VSP 0 + - abstract_vdns_1.disk.device.allocation_vdns + vlb_vsp0.abstract_vlb.host_vlb: + - vLB_VSP 0 + - abstract_vlb.host_vlb + vlb_vsp0.abstract_vdns_1.disk.device.latency_vdns: + - vLB_VSP 0 + - abstract_vdns_1.disk.device.latency_vdns + vlb_vsp0.abstract_vdns_1.disk.allocation_vdns: + - vLB_VSP 0 + - abstract_vdns_1.disk.allocation_vdns + vlb_vsp0.abstract_vdns_1.disk.device.read.bytes.rate_vdns: + - vLB_VSP 0 + - abstract_vdns_1.disk.device.read.bytes.rate_vdns + vlb_vsp0.abstract_vpg.disk.device.read.requests.rate_vpg: + - vLB_VSP 0 + - abstract_vpg.disk.device.read.requests.rate_vpg + vlb_vsp0.abstract_vdns_0.disk.read.requests_vdns: + - vLB_VSP 0 + - abstract_vdns_0.disk.read.requests_vdns + vlb_vsp0.abstract_vlb.binding_vlb_vlb_private_0_port: + - vLB_VSP 0 + - abstract_vlb.binding_vlb_vlb_private_0_port + vlb_vsp0.abstract_vpg.disk.latency_vpg: + - vLB_VSP 0 + - abstract_vpg.disk.latency_vpg + vlb_vsp0.abstract_vdns_0.disk.latency_vdns: + - vLB_VSP 0 + - abstract_vdns_0.disk.latency_vdns + vlb_vsp0.abstract_vlb.network.incoming.packets_vlb_vlb_private_0_port: + - vLB_VSP 0 + - abstract_vlb.network.incoming.packets_vlb_vlb_private_0_port + vlb_vsp0.abstract_vdns_1.disk.read.bytes.rate_vdns: + - vLB_VSP 0 + - abstract_vdns_1.disk.read.bytes.rate_vdns + vlb_vsp0.abstract_vpg.disk.read.requests_vpg: + - vLB_VSP 0 + - abstract_vpg.disk.read.requests_vpg + vlb_vsp0.abstract_vdns_0.scalable_vdns: + - vLB_VSP 0 + - abstract_vdns_0.scalable_vdns + vlb_vsp0.abstract_vdns_1.disk.device.capacity_vdns: + - vLB_VSP 0 + - abstract_vdns_1.disk.device.capacity_vdns + vlb_vsp0.abstract_vpg.network.outgoing.packets.rate_vpg_vpg_private_0_port: + - vLB_VSP 0 + - abstract_vpg.network.outgoing.packets.rate_vpg_vpg_private_0_port + vlb_vsp0.abstract_vdns_0.network.incoming.bytes_vdns_vdns_private_1_port: + - vLB_VSP 0 + - abstract_vdns_0.network.incoming.bytes_vdns_vdns_private_1_port + vlb_vsp0.abstract_vdns_0.disk.read.bytes.rate_vdns: + - vLB_VSP 0 + - abstract_vdns_0.disk.read.bytes.rate_vdns + vlb_vsp0.abstract_vdns_0.memory.usage_vdns: + - vLB_VSP 0 + - abstract_vdns_0.memory.usage_vdns + vlb_vsp0.abstract_vpg.disk.device.write.requests_vpg: + - vLB_VSP 0 + - abstract_vpg.disk.device.write.requests_vpg + vlb_vsp0.abstract_vdns_0.disk.ephemeral.size_vdns: + - vLB_VSP 0 + - abstract_vdns_0.disk.ephemeral.size_vdns + vlb_vsp0.abstract_vdns_1.attachment_vdns_vdns_private_0_port: + - vLB_VSP 0 + - abstract_vdns_1.attachment_vdns_vdns_private_0_port + vlb_vsp0.abstract_vpg.disk.allocation_vpg: + - vLB_VSP 0 + - abstract_vpg.disk.allocation_vpg + vlb_vsp0.abstract_vpg.host_vpg: + - vLB_VSP 0 + - abstract_vpg.host_vpg + vlb_vsp0.abstract_vdns_1.disk.device.write.bytes_vdns: + - vLB_VSP 0 + - abstract_vdns_1.disk.device.write.bytes_vdns + vlb_vsp0.abstract_vlb.disk.capacity_vlb: + - vLB_VSP 0 + - abstract_vlb.disk.capacity_vlb + vlb_vsp0.abstract_vpg.network.outpoing.packets_vpg_vpg_private_1_port: + - vLB_VSP 0 + - abstract_vpg.network.outpoing.packets_vpg_vpg_private_1_port + vlb_vsp0.abstract_vlb.network.outgoing.packets.rate_vlb_vlb_private_1_port: + - vLB_VSP 0 + - abstract_vlb.network.outgoing.packets.rate_vlb_vlb_private_1_port + vlb_vsp0.abstract_vlb.cpu.delta_vlb: + - vLB_VSP 0 + - abstract_vlb.cpu.delta_vlb + vlb_vsp0.abstract_vdns_1.disk.write.bytes_vdns: + - vLB_VSP 0 + - abstract_vdns_1.disk.write.bytes_vdns + vlb_vsp0.abstract_vdns_0.disk.device.allocation_vdns: + - vLB_VSP 0 + - abstract_vdns_0.disk.device.allocation_vdns + vlb_vsp0.abstract_vdns_0.disk.device.write.bytes.rate_vdns: + - vLB_VSP 0 + - abstract_vdns_0.disk.device.write.bytes.rate_vdns + vlb_vsp0.abstract_vpg.scalable_vpg: + - vLB_VSP 0 + - abstract_vpg.scalable_vpg + vlb_vsp0.abstract_vdns_0.network.incoming.bytes.rate_vdns_vdns_private_0_port: + - vLB_VSP 0 + - abstract_vdns_0.network.incoming.bytes.rate_vdns_vdns_private_0_port + vlb_vsp0.abstract_vlb.network.outgoing.bytes_vlb_vlb_private_2_port: + - vLB_VSP 0 + - abstract_vlb.network.outgoing.bytes_vlb_vlb_private_2_port + vlb_vsp0.abstract_vlb.disk.write.requests.rate_vlb: + - vLB_VSP 0 + - abstract_vlb.disk.write.requests.rate_vlb + vlb_vsp0.abstract_vlb.network.outpoing.packets_vlb_vlb_private_2_port: + - vLB_VSP 0 + - abstract_vlb.network.outpoing.packets_vlb_vlb_private_2_port + vlb_vsp0.abstract_vdns_0.attachment_vdns_vdns_private_1_port: + - vLB_VSP 0 + - abstract_vdns_0.attachment_vdns_vdns_private_1_port + vlb_vsp0.abstract_vdns_0.network.incoming.packets_vdns_vdns_private_1_port: + - vLB_VSP 0 + - abstract_vdns_0.network.incoming.packets_vdns_vdns_private_1_port + vlb_vsp0.abstract_vdns_0.feature_vdns_vdns_private_1_port: + - vLB_VSP 0 + - abstract_vdns_0.feature_vdns_vdns_private_1_port + vlb_vsp0.abstract_vpg.network.outgoing.bytes.rate_vpg_vpg_private_1_port: + - vLB_VSP 0 + - abstract_vpg.network.outgoing.bytes.rate_vpg_vpg_private_1_port + vlb_vsp0.abstract_vpg.feature_vpg_vpg_private_0_port: + - vLB_VSP 0 + - abstract_vpg.feature_vpg_vpg_private_0_port + vlb_vsp0.abstract_vlb.disk.root.size_vlb: + - vLB_VSP 0 + - abstract_vlb.disk.root.size_vlb + vlb_vsp0.abstract_vlb.network.incoming.packets_vlb_vlb_private_2_port: + - vLB_VSP 0 + - abstract_vlb.network.incoming.packets_vlb_vlb_private_2_port + vlb_vsp0.abstract_vdns_1.network.incoming.bytes.rate_vdns_vdns_private_1_port: + - vLB_VSP 0 + - abstract_vdns_1.network.incoming.bytes.rate_vdns_vdns_private_1_port + vlb_vsp0.abstract_vdns_1.network.outgoing.bytes_vdns_vdns_private_0_port: + - vLB_VSP 0 + - abstract_vdns_1.network.outgoing.bytes_vdns_vdns_private_0_port + vlb_vsp0.abstract_vdns_1.network.incoming.packets.rate_vdns_vdns_private_0_port: + - vLB_VSP 0 + - abstract_vdns_1.network.incoming.packets.rate_vdns_vdns_private_0_port + vlb_vsp0.abstract_vlb.disk.write.bytes_vlb: + - vLB_VSP 0 + - abstract_vlb.disk.write.bytes_vlb + vlb_vsp0.abstract_vdns_0.disk.write.requests.rate_vdns: + - vLB_VSP 0 + - abstract_vdns_0.disk.write.requests.rate_vdns + vlb_vsp0.abstract_vdns_0.binding_vdns_vdns_private_1_port: + - vLB_VSP 0 + - abstract_vdns_0.binding_vdns_vdns_private_1_port + vlb_vsp0.abstract_vdns_1.scalable_vdns: + - vLB_VSP 0 + - abstract_vdns_1.scalable_vdns + vlb_vsp0.abstract_vdns_1.network.incoming.bytes_vdns_vdns_private_1_port: + - vLB_VSP 0 + - abstract_vdns_1.network.incoming.bytes_vdns_vdns_private_1_port + vlb_vsp0.abstract_vdns_1.feature_vdns_vdns_private_0_port: + - vLB_VSP 0 + - abstract_vdns_1.feature_vdns_vdns_private_0_port + vlb_vsp0.abstract_vdns_0.disk.iops_vdns: + - vLB_VSP 0 + - abstract_vdns_0.disk.iops_vdns + vlb_vsp0.abstract_vdns_0.disk.root.size_vdns: + - vLB_VSP 0 + - abstract_vdns_0.disk.root.size_vdns + vlb_vsp0.abstract_vdns_0.disk.device.usage_vdns: + - vLB_VSP 0 + - abstract_vdns_0.disk.device.usage_vdns + vlb_vsp0.abstract_vdns_1.network.outpoing.packets_vdns_vdns_private_1_port: + - vLB_VSP 0 + - abstract_vdns_1.network.outpoing.packets_vdns_vdns_private_1_port + vlb_vsp0.abstract_vdns_1.disk.write.requests_vdns: + - vLB_VSP 0 + - abstract_vdns_1.disk.write.requests_vdns + vlb_vsp0.abstract_vpg.instance_vpg: + - vLB_VSP 0 + - abstract_vpg.instance_vpg + vlb_vsp0.abstract_vdns_1.binding_vdns_vdns_private_0_port: + - vLB_VSP 0 + - abstract_vdns_1.binding_vdns_vdns_private_0_port + vlb_vsp0.abstract_vlb.forwarder_vlb_vlb_private_0_port: + - vLB_VSP 0 + - abstract_vlb.forwarder_vlb_vlb_private_0_port + vlb_vsp0.abstract_vlb.memory.usage_vlb: + - vLB_VSP 0 + - abstract_vlb.memory.usage_vlb + vlb_vsp0.abstract_vpg.disk.root.size_vpg: + - vLB_VSP 0 + - abstract_vpg.disk.root.size_vpg + vlb_vsp0.abstract_vdns_1.network.outgoing.bytes.rate_vdns_vdns_private_0_port: + - vLB_VSP 0 + - abstract_vdns_1.network.outgoing.bytes.rate_vdns_vdns_private_0_port + vlb_vsp0.abstract_vlb.network.outgoing.packets.rate_vlb_vlb_private_0_port: + - vLB_VSP 0 + - abstract_vlb.network.outgoing.packets.rate_vlb_vlb_private_0_port + vlb_vsp0.abstract_vpg.disk.device.latency_vpg: + - vLB_VSP 0 + - abstract_vpg.disk.device.latency_vpg + vlb_vsp0.abstract_vpg.disk.read.bytes.rate_vpg: + - vLB_VSP 0 + - abstract_vpg.disk.read.bytes.rate_vpg + vlb_vsp0.abstract_vdns_0.disk.write.bytes.rate_vdns: + - vLB_VSP 0 + - abstract_vdns_0.disk.write.bytes.rate_vdns + vlb_vsp0.abstract_vlb.network.outgoing.bytes.rate_vlb_vlb_private_1_port: + - vLB_VSP 0 + - abstract_vlb.network.outgoing.bytes.rate_vlb_vlb_private_1_port + vlb_vsp0.abstract_vlb.disk.usage_vlb: + - vLB_VSP 0 + - abstract_vlb.disk.usage_vlb + vlb_vsp0.abstract_vlb.disk.device.write.requests_vlb: + - vLB_VSP 0 + - abstract_vlb.disk.device.write.requests_vlb + vlb_vsp0.abstract_vlb.binding_vlb_vlb_private_1_port: + - vLB_VSP 0 + - abstract_vlb.binding_vlb_vlb_private_1_port + vlb_vsp0.abstract_vdns_0.disk.device.read.requests_vdns: + - vLB_VSP 0 + - abstract_vdns_0.disk.device.read.requests_vdns + vlb_vsp0.abstract_vpg.port_mirroring_vpg_vpg_private_1_port: + - vLB_VSP 0 + - abstract_vpg.port_mirroring_vpg_vpg_private_1_port + vlb_vsp0.abstract_vdns_1.disk.device.read.requests_vdns: + - vLB_VSP 0 + - abstract_vdns_1.disk.device.read.requests_vdns + vlb_vsp0.abstract_vlb.disk.allocation_vlb: + - vLB_VSP 0 + - abstract_vlb.disk.allocation_vlb + vlb_vsp0.abstract_vlb.network.outgoing.packets.rate_vlb_vlb_private_2_port: + - vLB_VSP 0 + - abstract_vlb.network.outgoing.packets.rate_vlb_vlb_private_2_port + vlb_vsp0.abstract_vdns_0.network.outpoing.packets_vdns_vdns_private_1_port: + - vLB_VSP 0 + - abstract_vdns_0.network.outpoing.packets_vdns_vdns_private_1_port + vlb_vsp0.abstract_vdns_0.disk.capacity_vdns: + - vLB_VSP 0 + - abstract_vdns_0.disk.capacity_vdns + vlb_vsp0.abstract_vlb.attachment_vlb_vlb_private_2_port: + - vLB_VSP 0 + - abstract_vlb.attachment_vlb_vlb_private_2_port + vlb_vsp0.abstract_vpg.disk.device.usage_vpg: + - vLB_VSP 0 + - abstract_vpg.disk.device.usage_vpg + vlb_vsp0.abstract_vdns_1.attachment_vdns_vdns_private_1_port: + - vLB_VSP 0 + - abstract_vdns_1.attachment_vdns_vdns_private_1_port + vlb_vsp0.abstract_vpg.disk.capacity_vpg: + - vLB_VSP 0 + - abstract_vpg.disk.capacity_vpg + vlb_vsp0.abstract_vlb.disk.device.read.requests.rate_vlb: + - vLB_VSP 0 + - abstract_vlb.disk.device.read.requests.rate_vlb + vlb_vsp0.abstract_vlb.network.outgoing.bytes_vlb_vlb_private_0_port: + - vLB_VSP 0 + - abstract_vlb.network.outgoing.bytes_vlb_vlb_private_0_port + vlb_vsp0.abstract_vpg.disk.device.write.bytes_vpg: + - vLB_VSP 0 + - abstract_vpg.disk.device.write.bytes_vpg + vlb_vsp0.abstract_vdns_0.binding_vdns: + - vLB_VSP 0 + - abstract_vdns_0.binding_vdns + vlb_vsp0.abstract_vdns_1.forwarder_vdns_vdns_private_0_port: + - vLB_VSP 0 + - abstract_vdns_1.forwarder_vdns_vdns_private_0_port + vlb_vsp0.abstract_vpg.disk.device.write.requests.rate_vpg: + - vLB_VSP 0 + - abstract_vpg.disk.device.write.requests.rate_vpg + vlb_vsp0.abstract_vdns_0.disk.write.bytes_vdns: + - vLB_VSP 0 + - abstract_vdns_0.disk.write.bytes_vdns + vlb_vsp0.abstract_vdns_0.network.outgoing.bytes.rate_vdns_vdns_private_0_port: + - vLB_VSP 0 + - abstract_vdns_0.network.outgoing.bytes.rate_vdns_vdns_private_0_port + vlb_vsp0.abstract_vlb.network.outpoing.packets_vlb_vlb_private_0_port: + - vLB_VSP 0 + - abstract_vlb.network.outpoing.packets_vlb_vlb_private_0_port + vlb_vsp0.abstract_vpg.attachment_vpg_vpg_private_0_port: + - vLB_VSP 0 + - abstract_vpg.attachment_vpg_vpg_private_0_port + vlb_vsp0.abstract_vlb.network.incoming.bytes.rate_vlb_vlb_private_2_port: + - vLB_VSP 0 + - abstract_vlb.network.incoming.bytes.rate_vlb_vlb_private_2_port + vlb_vsp0.abstract_vdns_1.network.outgoing.packets.rate_vdns_vdns_private_1_port: + - vLB_VSP 0 + - abstract_vdns_1.network.outgoing.packets.rate_vdns_vdns_private_1_port + vlb_vsp0.abstract_vlb.feature_vlb_vlb_private_1_port: + - vLB_VSP 0 + - abstract_vlb.feature_vlb_vlb_private_1_port + vlb_vsp0.abstract_vlb.disk.ephemeral.size_vlb: + - vLB_VSP 0 + - abstract_vlb.disk.ephemeral.size_vlb + vlb_vsp0.abstract_vpg.memory_vpg: + - vLB_VSP 0 + - abstract_vpg.memory_vpg + vlb_vsp0.abstract_vdns_1.disk.latency_vdns: + - vLB_VSP 0 + - abstract_vdns_1.disk.latency_vdns + vlb_vsp0.abstract_vdns_1.network.incoming.packets_vdns_vdns_private_1_port: + - vLB_VSP 0 + - abstract_vdns_1.network.incoming.packets_vdns_vdns_private_1_port + vlb_vsp0.abstract_vdns_0.network.outgoing.packets.rate_vdns_vdns_private_1_port: + - vLB_VSP 0 + - abstract_vdns_0.network.outgoing.packets.rate_vdns_vdns_private_1_port + vlb_vsp0.abstract_vlb.network.incoming.packets.rate_vlb_vlb_private_1_port: + - vLB_VSP 0 + - abstract_vlb.network.incoming.packets.rate_vlb_vlb_private_1_port + vlb_vsp0.abstract_vdns_1.cpu.delta_vdns: + - vLB_VSP 0 + - abstract_vdns_1.cpu.delta_vdns + vlb_vsp0.pktgen_private_network.attachment: + - vLB_VSP 0 + - pktgen_private_network.attachment + vlb_vsp0.abstract_vlb.disk.device.read.bytes_vlb: + - vLB_VSP 0 + - abstract_vlb.disk.device.read.bytes_vlb + vlb_vsp0.abstract_vpg.disk.ephemeral.size_vpg: + - vLB_VSP 0 + - abstract_vpg.disk.ephemeral.size_vpg + vlb_vsp0.abstract_vdns_1.disk.device.write.requests_vdns: + - vLB_VSP 0 + - abstract_vdns_1.disk.device.write.requests_vdns + vlb_vsp0.abstract_vlb.cpu_util_vlb: + - vLB_VSP 0 + - abstract_vlb.cpu_util_vlb + vlb_vsp0.abstract_vpg.network.outgoing.bytes_vpg_vpg_private_1_port: + - vLB_VSP 0 + - abstract_vpg.network.outgoing.bytes_vpg_vpg_private_1_port + vlb_vsp0.abstract_vlb.binding_vlb: + - vLB_VSP 0 + - abstract_vlb.binding_vlb + vlb_vsp0.abstract_vpg.feature_vpg: + - vLB_VSP 0 + - abstract_vpg.feature_vpg + vlb_vsp0.abstract_vlb.disk.device.latency_vlb: + - vLB_VSP 0 + - abstract_vlb.disk.device.latency_vlb + vlb_vsp0.abstract_vlb.disk.device.write.requests.rate_vlb: + - vLB_VSP 0 + - abstract_vlb.disk.device.write.requests.rate_vlb + vlb_vsp0.abstract_vpg.forwarder_vpg_vpg_private_1_port: + - vLB_VSP 0 + - abstract_vpg.forwarder_vpg_vpg_private_1_port + vlb_vsp0.abstract_vdns_0.disk.device.write.requests.rate_vdns: + - vLB_VSP 0 + - abstract_vdns_0.disk.device.write.requests.rate_vdns + vlb_vsp0.abstract_vdns_0.disk.device.read.bytes_vdns: + - vLB_VSP 0 + - abstract_vdns_0.disk.device.read.bytes_vdns + vlb_vsp0.abstract_vpg.network.incoming.packets_vpg_vpg_private_1_port: + - vLB_VSP 0 + - abstract_vpg.network.incoming.packets_vpg_vpg_private_1_port + vlb_vsp0.abstract_vdns_0.network.outgoing.bytes_vdns_vdns_private_0_port: + - vLB_VSP 0 + - abstract_vdns_0.network.outgoing.bytes_vdns_vdns_private_0_port + vlb_vsp0.abstract_vlb.disk.write.bytes.rate_vlb: + - vLB_VSP 0 + - abstract_vlb.disk.write.bytes.rate_vlb + vlb_vsp0.abstract_vpg.disk.device.read.bytes_vpg: + - vLB_VSP 0 + - abstract_vpg.disk.device.read.bytes_vpg + vlb_vsp0.abstract_vpg.disk.write.requests.rate_vpg: + - vLB_VSP 0 + - abstract_vpg.disk.write.requests.rate_vpg + vlb_vsp0.abstract_vlb.network.incoming.bytes.rate_vlb_vlb_private_1_port: + - vLB_VSP 0 + - abstract_vlb.network.incoming.bytes.rate_vlb_vlb_private_1_port + vlb_vsp0.abstract_vdns_1.disk.write.requests.rate_vdns: + - vLB_VSP 0 + - abstract_vdns_1.disk.write.requests.rate_vdns + vlb_vsp0.abstract_vdns_1.disk.device.read.bytes_vdns: + - vLB_VSP 0 + - abstract_vdns_1.disk.device.read.bytes_vdns + vlb_vsp0.pktgen_private_network.link: + - vLB_VSP 0 + - pktgen_private_network.link + vlb_vsp0.vlb_private_network.end_point: + - vLB_VSP 0 + - vlb_private_network.end_point + vlb_vsp0.abstract_vlb.forwarder_vlb_vlb_private_2_port: + - vLB_VSP 0 + - abstract_vlb.forwarder_vlb_vlb_private_2_port + vlb_vsp0.abstract_vdns_0.network.outgoing.bytes_vdns_vdns_private_1_port: + - vLB_VSP 0 + - abstract_vdns_0.network.outgoing.bytes_vdns_vdns_private_1_port + vlb_vsp0.abstract_vpg.network.incoming.packets.rate_vpg_vpg_private_1_port: + - vLB_VSP 0 + - abstract_vpg.network.incoming.packets.rate_vpg_vpg_private_1_port + vlb_vsp0.abstract_vdns_0.disk.device.iops_vdns: + - vLB_VSP 0 + - abstract_vdns_0.disk.device.iops_vdns + vlb_vsp0.abstract_vdns_0.cpu_vdns: + - vLB_VSP 0 + - abstract_vdns_0.cpu_vdns + vlb_vsp0.abstract_vdns_0.disk.device.write.requests_vdns: + - vLB_VSP 0 + - abstract_vdns_0.disk.device.write.requests_vdns + vlb_vsp0.abstract_vpg.disk.write.bytes_vpg: + - vLB_VSP 0 + - abstract_vpg.disk.write.bytes_vpg + vlb_vsp0.abstract_vlb.network.incoming.packets.rate_vlb_vlb_private_2_port: + - vLB_VSP 0 + - abstract_vlb.network.incoming.packets.rate_vlb_vlb_private_2_port + vlb_vsp0.abstract_vlb.cpu_vlb: + - vLB_VSP 0 + - abstract_vlb.cpu_vlb + vlb_vsp0.abstract_vdns_1.network.incoming.packets_vdns_vdns_private_0_port: + - vLB_VSP 0 + - abstract_vdns_1.network.incoming.packets_vdns_vdns_private_0_port + vlb_vsp0.vlb_private_network.attachment: + - vLB_VSP 0 + - vlb_private_network.attachment + vlb_vsp0.abstract_vlb.disk.read.bytes.rate_vlb: + - vLB_VSP 0 + - abstract_vlb.disk.read.bytes.rate_vlb + vlb_vsp0.abstract_vdns_0.forwarder_vdns_vdns_private_0_port: + - vLB_VSP 0 + - abstract_vdns_0.forwarder_vdns_vdns_private_0_port + vlb_vsp0.abstract_vdns_1.disk.device.write.requests.rate_vdns: + - vLB_VSP 0 + - abstract_vdns_1.disk.device.write.requests.rate_vdns + vlb_vsp0.abstract_vlb.network.incoming.bytes.rate_vlb_vlb_private_0_port: + - vLB_VSP 0 + - abstract_vlb.network.incoming.bytes.rate_vlb_vlb_private_0_port + vlb_vsp0.abstract_vlb.network.incoming.bytes_vlb_vlb_private_2_port: + - vLB_VSP 0 + - abstract_vlb.network.incoming.bytes_vlb_vlb_private_2_port + vlb_vsp0.abstract_vlb.feature_vlb_vlb_private_0_port: + - vLB_VSP 0 + - abstract_vlb.feature_vlb_vlb_private_0_port + vlb_vsp0.abstract_vdns_0.disk.device.read.bytes.rate_vdns: + - vLB_VSP 0 + - abstract_vdns_0.disk.device.read.bytes.rate_vdns + vlb_vsp0.abstract_vdns_0.disk.allocation_vdns: + - vLB_VSP 0 + - abstract_vdns_0.disk.allocation_vdns + vlb_vsp0.abstract_vdns_0.disk.usage_vdns: + - vLB_VSP 0 + - abstract_vdns_0.disk.usage_vdns + vlb_vsp0.abstract_vpg.cpu.delta_vpg: + - vLB_VSP 0 + - abstract_vpg.cpu.delta_vpg + vlb_vsp0.abstract_vdns_1.memory.resident_vdns: + - vLB_VSP 0 + - abstract_vdns_1.memory.resident_vdns + vlb_vsp0.abstract_vdns_0.vcpus_vdns: + - vLB_VSP 0 + - abstract_vdns_0.vcpus_vdns + vlb_vsp0.abstract_vpg.network.incoming.bytes.rate_vpg_vpg_private_0_port: + - vLB_VSP 0 + - abstract_vpg.network.incoming.bytes.rate_vpg_vpg_private_0_port + vlb_vsp0.abstract_vpg.memory.resident_vpg: + - vLB_VSP 0 + - abstract_vpg.memory.resident_vpg + vlb_vsp0.abstract_vdns_0.forwarder_vdns_vdns_private_1_port: + - vLB_VSP 0 + - abstract_vdns_0.forwarder_vdns_vdns_private_1_port + vlb_vsp0.abstract_vdns_1.cpu_util_vdns: + - vLB_VSP 0 + - abstract_vdns_1.cpu_util_vdns + vlb_vsp0.abstract_vdns_1.disk.read.requests_vdns: + - vLB_VSP 0 + - abstract_vdns_1.disk.read.requests_vdns + vlb_vsp0.abstract_vdns_1.binding_vdns: + - vLB_VSP 0 + - abstract_vdns_1.binding_vdns + vlb_vsp0.abstract_vdns_0.binding_vdns_vdns_private_0_port: + - vLB_VSP 0 + - abstract_vdns_0.binding_vdns_vdns_private_0_port + vlb_vsp0.abstract_vdns_0.port_mirroring_vdns_vdns_private_1_port: + - vLB_VSP 0 + - abstract_vdns_0.port_mirroring_vdns_vdns_private_1_port + vlb_vsp0.abstract_vpg.disk.read.bytes_vpg: + - vLB_VSP 0 + - abstract_vpg.disk.read.bytes_vpg + vlb_vsp0.pktgen_private_network.feature: + - vLB_VSP 0 + - pktgen_private_network.feature + vlb_vsp0.abstract_vlb.network.outgoing.bytes.rate_vlb_vlb_private_0_port: + - vLB_VSP 0 + - abstract_vlb.network.outgoing.bytes.rate_vlb_vlb_private_0_port + vlb_vsp0.abstract_vpg.forwarder_vpg_vpg_private_0_port: + - vLB_VSP 0 + - abstract_vpg.forwarder_vpg_vpg_private_0_port + vlb_vsp0.abstract_vpg.network.outgoing.bytes_vpg_vpg_private_0_port: + - vLB_VSP 0 + - abstract_vpg.network.outgoing.bytes_vpg_vpg_private_0_port + vlb_vsp0.abstract_vpg.disk.device.write.bytes.rate_vpg: + - vLB_VSP 0 + - abstract_vpg.disk.device.write.bytes.rate_vpg + vlb_vsp0.abstract_vdns_0.disk.device.read.requests.rate_vdns: + - vLB_VSP 0 + - abstract_vdns_0.disk.device.read.requests.rate_vdns + vlb_vsp0.abstract_vdns_1.disk.ephemeral.size_vdns: + - vLB_VSP 0 + - abstract_vdns_1.disk.ephemeral.size_vdns + vlb_vsp0.abstract_vdns_0.cpu.delta_vdns: + - vLB_VSP 0 + - abstract_vdns_0.cpu.delta_vdns + vlb_vsp0.abstract_vdns_1.os_vdns: + - vLB_VSP 0 + - abstract_vdns_1.os_vdns + vlb_vsp0.abstract_vpg.network.incoming.packets_vpg_vpg_private_0_port: + - vLB_VSP 0 + - abstract_vpg.network.incoming.packets_vpg_vpg_private_0_port + vlb_vsp0.abstract_vdns_0.cpu_util_vdns: + - vLB_VSP 0 + - abstract_vdns_0.cpu_util_vdns + vlb_vsp0.abstract_vpg.disk.write.bytes.rate_vpg: + - vLB_VSP 0 + - abstract_vpg.disk.write.bytes.rate_vpg + vlb_vsp0.abstract_vdns_1.disk.write.bytes.rate_vdns: + - vLB_VSP 0 + - abstract_vdns_1.disk.write.bytes.rate_vdns + requirements: + vlb_vsp0.abstract_vpg.link_vpg_vpg_private_1_port: + - vLB_VSP 0 + - abstract_vpg.link_vpg_vpg_private_1_port + vlb_vsp0.abstract_vpg.local_storage_vpg: + - vLB_VSP 0 + - abstract_vpg.local_storage_vpg + vlb_vsp0.abstract_vdns_0.link_vdns_vdns_private_0_port: + - vLB_VSP 0 + - abstract_vdns_0.link_vdns_vdns_private_0_port + vlb_vsp0.abstract_vlb.dependency_vlb_vlb_private_0_port: + - vLB_VSP 0 + - abstract_vlb.dependency_vlb_vlb_private_0_port + vlb_vsp0.abstract_vdns_1.link_vdns_vdns_private_1_port: + - vLB_VSP 0 + - abstract_vdns_1.link_vdns_vdns_private_1_port + vlb_vsp0.abstract_vdns_1.local_storage_vdns: + - vLB_VSP 0 + - abstract_vdns_1.local_storage_vdns + vlb_vsp0.abstract_vdns_0.local_storage_vdns: + - vLB_VSP 0 + - abstract_vdns_0.local_storage_vdns + vlb_vsp0.abstract_vlb.link_vlb_vlb_private_2_port: + - vLB_VSP 0 + - abstract_vlb.link_vlb_vlb_private_2_port + vlb_vsp0.pktgen_private_network.dependency: + - vLB_VSP 0 + - pktgen_private_network.dependency + vlb_vsp0.abstract_vdns_1.dependency_vdns_vdns_private_0_port: + - vLB_VSP 0 + - abstract_vdns_1.dependency_vdns_vdns_private_0_port + vlb_vsp0.abstract_vpg.dependency_vpg: + - vLB_VSP 0 + - abstract_vpg.dependency_vpg + vlb_vsp0.abstract_vpg.dependency_vpg_vpg_private_0_port: + - vLB_VSP 0 + - abstract_vpg.dependency_vpg_vpg_private_0_port + vlb_vsp0.abstract_vdns_0.dependency_vdns: + - vLB_VSP 0 + - abstract_vdns_0.dependency_vdns + vlb_vsp0.abstract_vlb.link_vlb_vlb_private_1_port: + - vLB_VSP 0 + - abstract_vlb.link_vlb_vlb_private_1_port + vlb_vsp0.abstract_vpg.link_vpg_vpg_private_0_port: + - vLB_VSP 0 + - abstract_vpg.link_vpg_vpg_private_0_port + vlb_vsp0.vlb_private_network.dependency: + - vLB_VSP 0 + - vlb_private_network.dependency + vlb_vsp0.abstract_vlb.dependency_vlb_vlb_private_1_port: + - vLB_VSP 0 + - abstract_vlb.dependency_vlb_vlb_private_1_port + vlb_vsp0.abstract_vpg.dependency_vpg_vpg_private_1_port: + - vLB_VSP 0 + - abstract_vpg.dependency_vpg_vpg_private_1_port + vlb_vsp0.abstract_vdns_0.link_vdns_vdns_private_1_port: + - vLB_VSP 0 + - abstract_vdns_0.link_vdns_vdns_private_1_port + vlb_vsp0.abstract_vdns_0.dependency_vdns_vdns_private_1_port: + - vLB_VSP 0 + - abstract_vdns_0.dependency_vdns_vdns_private_1_port + vlb_vsp0.abstract_vdns_0.dependency_vdns_vdns_private_0_port: + - vLB_VSP 0 + - abstract_vdns_0.dependency_vdns_vdns_private_0_port + vlb_vsp0.abstract_vlb.link_vlb_vlb_private_0_port: + - vLB_VSP 0 + - abstract_vlb.link_vlb_vlb_private_0_port + vlb_vsp0.abstract_vlb.local_storage_vlb: + - vLB_VSP 0 + - abstract_vlb.local_storage_vlb + vlb_vsp0.abstract_vdns_1.dependency_vdns_vdns_private_1_port: + - vLB_VSP 0 + - abstract_vdns_1.dependency_vdns_vdns_private_1_port + vlb_vsp0.abstract_vlb.dependency_vlb: + - vLB_VSP 0 + - abstract_vlb.dependency_vlb + vlb_vsp0.abstract_vdns_1.dependency_vdns: + - vLB_VSP 0 + - abstract_vdns_1.dependency_vdns + vlb_vsp0.abstract_vdns_1.link_vdns_vdns_private_0_port: + - vLB_VSP 0 + - abstract_vdns_1.link_vdns_vdns_private_0_port + vlb_vsp0.abstract_vlb.dependency_vlb_vlb_private_2_port: + - vLB_VSP 0 + - abstract_vlb.dependency_vlb_vlb_private_2_port