diff options
Diffstat (limited to 'src/test')
9 files changed, 3074 insertions, 1 deletions
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<OrderRelationship> relationships = new ArrayList<>(); + serviceOrder.setOrderRelationship(relationships); + + RelatedParty party = new RelatedParty(); + party.setId("6490"); + party.setRole("ONAPcustomer"); + party.setReferredType("individual"); + party.setName("Jean Pontus"); + List<RelatedParty> relatedPartyList = new ArrayList<>(); + relatedPartyList.add(party); + serviceOrder.setRelatedParty(relatedPartyList); + + List<ServiceOrderItem> 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<OrderItemRelationship> 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<ServiceCharacteristic> 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<String, Object> 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<ResourceSpecification> 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<ServiceCharacteristic> 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<String, Object> 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<ResourceSpecification> 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<ServiceCharacteristic> 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<String, Object> 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<ResourceSpecification> 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<String, Object> 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<LinkedHashMap<String, Object>> resources = new ArrayList<>(); + LinkedHashMap<String, Object> 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<VFModelInfo> 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<LinkedHashMap> resourceSpecifications = (List<LinkedHashMap>) response.get("resourceSpecification"); + + // Getting childResourceSpecifications from resourceSpecifications that we got + // from response + List childResourceSpecifications = (ArrayList<VFModelInfo>) (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<LinkedHashMap> 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<LinkedHashMap> 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<LinkedHashMap> resourceSpecifications = (List<LinkedHashMap>) 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 Binary files differnew file mode 100644 index 0000000..0c5fcdd --- /dev/null +++ b/src/test/resources/__files/toscafile/service-VlbService-csar.csar 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 Binary files differnew file mode 100644 index 0000000..0c5fcdd --- /dev/null +++ b/src/test/resources/toscafile/service-VlbService-csar.csar 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 |