Preparing the request payload for calling SO macro flow.

- Added JUnit Test cases and Kararte test for service catalog.
- Added test case for Execution Task for Macro Flow.
- Modified RequestDetails and RequestInfo to match with SO Macro request payload.
- Added k8s configuration in application.properties.

Issue-ID: EXTAPI-368
Signed-off-by: aleemraja <ar00500721@techmahindra.com>
Change-Id: Ibbbbbd2d7021c16ea6291cc899e310ae26200833
Signed-off-by: aleemraja <ar00500721@techmahindra.com>

21 files changed, 3706 insertions, 77 deletions

diff --git a/src/main/java/org/onap/nbi/apis/servicecatalog/ServiceSpecificationResource.java b/src/main/java/org/onap/nbi/apis/servicecatalog/ServiceSpecificationResource.java
index 3651ec8..f9f5e07 100644
--- a/src/main/java/org/onap/nbi/apis/servicecatalog/ServiceSpecificationResource.java
+++ b/src/main/java/org/onap/nbi/apis/servicecatalog/ServiceSpecificationResource.java
@@ -16,6 +16,7 @@
 
 package org.onap.nbi.apis.servicecatalog;
 
+import java.util.ArrayList;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
@@ -43,6 +44,16 @@ public class ServiceSpecificationResource extends ResourceManagement {
     public ResponseEntity<Object> getServiceSpecification(@PathVariable String serviceSpecId,
             @RequestParam MultiValueMap<String, String> params) {
         Map response = serviceSpecificationService.get(serviceSpecId);
+
+        if (response != null) {
+           ArrayList<Map<String, Object>> resourseSpecificationMap= (ArrayList<Map<String, Object>>) response.get("resourceSpecification");
+           for (Map<String, Object> map : resourseSpecificationMap) {
+               map.remove("childResourceSpecification");
+               map.remove("InstanceSpecification");
+           }
+           response.put("resourceSpecification", resourseSpecificationMap);
+        }
+
         JsonRepresentation filter = new JsonRepresentation(params);
         if (response.get("serviceSpecCharacteristic") != null) {
             return this.getResponse(response, filter);
@@ -67,4 +78,4 @@ public class ServiceSpecificationResource extends ResourceManagement {
         return this.getResponse(response, filter);
     }
 
-}
+}
\ No newline at end of file
diff --git a/src/main/java/org/onap/nbi/apis/servicecatalog/ToscaInfosProcessor.java b/src/main/java/org/onap/nbi/apis/servicecatalog/ToscaInfosProcessor.java
index 2153b84..586d0b5 100644
--- a/src/main/java/org/onap/nbi/apis/servicecatalog/ToscaInfosProcessor.java
+++ b/src/main/java/org/onap/nbi/apis/servicecatalog/ToscaInfosProcessor.java
@@ -16,12 +16,22 @@ package org.onap.nbi.apis.servicecatalog;
 
 import java.nio.file.Path;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.HashMap;
+import java.util.HashSet;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
+
+import org.onap.nbi.apis.serviceorder.model.consumer.VFModelInfo;
+import org.onap.sdc.tosca.parser.api.IEntityDetails;
 import org.onap.sdc.tosca.parser.api.ISdcCsarHelper;
+import org.onap.sdc.tosca.parser.elements.queries.EntityQuery;
+import org.onap.sdc.tosca.parser.elements.queries.TopologyTemplateQuery;
+import org.onap.sdc.tosca.parser.enums.SdcTypes;
 import org.onap.sdc.tosca.parser.exceptions.SdcToscaParserException;
+import org.onap.sdc.tosca.parser.impl.SdcPropertyNames;
 import org.onap.sdc.tosca.parser.impl.SdcToscaParserFactory;
 import org.onap.sdc.toscaparser.api.NodeTemplate;
 import org.onap.sdc.toscaparser.api.elements.Metadata;
@@ -47,6 +57,10 @@ public class ToscaInfosProcessor {
     @Autowired
     private ServiceSpecificationDBManager serviceSpecificationDBManager;
 
+    private Set<String> vnfInstanceParams = new HashSet<String>(Arrays.asList("onap_private_net_id",
+        "onap_private_subnet_id", "pub_key", "sec_group", "install_script_version", "demo_artifacts_version",
+        "cloud_env", "public_net_id", "aic-cloud-region", "image_name", "flavor_name"));
+
     final ObjectMapper mapper = new ObjectMapper(new YAMLFactory()); // jackson databind
 
     private static final Logger LOGGER = LoggerFactory.getLogger(ToscaInfosProcessor.class);
@@ -114,81 +128,148 @@ public class ToscaInfosProcessor {
     }
 
     public void buildAndSaveResponseWithSdcToscaParser(Path path, Map serviceCatalogResponse)
-            throws SdcToscaParserException {
+			throws SdcToscaParserException {
 
-        SdcToscaParserFactory factory = SdcToscaParserFactory.getInstance();
-        ISdcCsarHelper sdcCsarHelper = factory.getSdcCsarHelper(path.toFile().getAbsolutePath(), false);
-        List<Input> inputs = sdcCsarHelper.getServiceInputs();
+		SdcToscaParserFactory factory = SdcToscaParserFactory.getInstance();
+		ISdcCsarHelper sdcCsarHelper = factory.getSdcCsarHelper(path.toFile().getAbsolutePath(), false);
+		List<Input> inputs = sdcCsarHelper.getServiceInputs();
 
-        Map<String, Model> definitions = new HashMap<String, Model>();
-        Model model = new ModelImpl();
+		List<IEntityDetails> vfEntityList = sdcCsarHelper.getEntity(EntityQuery.newBuilder(SdcTypes.VF).build(),
+				TopologyTemplateQuery.newBuilder(SdcTypes.SERVICE).build(), false);
 
-        if (inputs != null && inputs.size() > 0) {
-            for (Input input : inputs) {
-                Property property = null;
-                if (input.getType().equals("list") || input.getType().equals("map"))
-                    property = PropertyBuilder.build("array", null, null);
-                else
-                    property = PropertyBuilder.build(input.getType(), null, null);
+		Map<String, String> listOfInstanceParameters = new HashMap<>();
+		if (!vfEntityList.isEmpty()) {
 
-                property.setDescription(input.getDescription());
-                property.setRequired(input.isRequired());
+			IEntityDetails iEntityDetails = vfEntityList.get(0);
+			Map<String, org.onap.sdc.toscaparser.api.Property> groupProperties = iEntityDetails.getProperties();
 
-                if (input.getDefault() != null) {
-                    property.setDefault(input.getDefault().toString());
-                }
-                ((ModelImpl) model).addProperty(input.getName(), property);
-            }
-            definitions.put("ServiceCharacteristics", model);
+			for (String key : groupProperties.keySet()) {
+				org.onap.sdc.toscaparser.api.Property property = groupProperties.get(key);
+				String paramName = property.getName();
+				if (paramName != null) {
+					if (vnfInstanceParams.stream()
+							.filter(vnfInstanceParam -> vnfInstanceParam.equalsIgnoreCase(paramName)).findFirst()
+							.isPresent()) {
+						listOfInstanceParameters.put(paramName, property.getValue().toString());
+					}
+				}
+			}
 
-        }
+		}
 
-        String svcCharacteristicsJson = Json.pretty(definitions);
-        serviceSpecificationDBManager.saveSpecificationInputSchema(svcCharacteristicsJson, serviceCatalogResponse);
+		// it will build Entity as VfModules
+		List<IEntityDetails> vfModuleEntityList = sdcCsarHelper.getEntity(
+				EntityQuery.newBuilder("org.openecomp.groups.VfModule").build(),
+				TopologyTemplateQuery.newBuilder(SdcTypes.SERVICE)
+						.customizationUUID(SdcPropertyNames.PROPERTY_NAME_CUSTOMIZATIONUUID).build(),
+				false);
+		List<VFModelInfo> listOfVfModelInfo = new ArrayList<>();
 
-        Metadata serviceMetadata = sdcCsarHelper.getServiceMetadata();
-        String instantationType = serviceMetadata.getValue("instantiationType");
-        serviceCatalogResponse.put("instantiationType", instantationType);
+		if (!vfModuleEntityList.isEmpty()) {
+			// Fetching vfModule metadata in a loop
+			for (IEntityDetails vfModuleEntity : vfModuleEntityList) {
+				VFModelInfo vfModel = new VFModelInfo();
+				Metadata vfMetadata = vfModuleEntity.getMetadata();
+				// Preparing VFModel
+				vfModel.setModelInvariantUuid(
+						testNull(vfMetadata.getValue(SdcPropertyNames.PROPERTY_NAME_VFMODULEMODELINVARIANTUUID)));
+				vfModel.setModelName(testNull(vfMetadata.getValue(SdcPropertyNames.PROPERTY_NAME_VFMODULEMODELNAME)));
+				vfModel.setModelUuid(testNull(vfMetadata.getValue(SdcPropertyNames.PROPERTY_NAME_VFMODULEMODELUUID)));
+				vfModel.setModelVersion(
+						testNull(vfMetadata.getValue(SdcPropertyNames.PROPERTY_NAME_VFMODULEMODELVERSION)));
+				vfModel.setModelCustomizationUuid(testNull(vfMetadata.getValue("vfModuleModelCustomizationUUID")));
 
-        LinkedHashMap inputSchemaRef = new LinkedHashMap();
-        // use object to match examples in Specifications
-        inputSchemaRef.put("valueType", "object");
-        inputSchemaRef.put("@schemaLocation",
-                "/serviceSpecification/" + serviceCatalogResponse.get("id") + "/specificationInputSchema");
-        inputSchemaRef.put("@type", serviceCatalogResponse.get("name") + "_ServiceCharacteristic");
+				// Adding it to the list
+				listOfVfModelInfo.add(vfModel);
+			}
+		}
 
-        LinkedHashMap serviceSpecCharacteristic = new LinkedHashMap();
-        serviceSpecCharacteristic.put("name", serviceCatalogResponse.get("name") + "_ServiceCharacteristics");
-        serviceSpecCharacteristic.put("description",
-                "This object describes all the inputs needed from the client to interact with the "
-                        + serviceCatalogResponse.get("name") + " Service Topology");
-        serviceSpecCharacteristic.put("valueType", "object");
-        serviceSpecCharacteristic.put("@type", "ONAPServiceCharacteristic");
-        serviceSpecCharacteristic.put("@schemaLocation", "null");
-        serviceSpecCharacteristic.put("serviceSpecCharacteristicValue", inputSchemaRef);
+		Map<String, Model> definitions = new HashMap<String, Model>();
+		Model model = new ModelImpl();
 
-        serviceCatalogResponse.put("serviceSpecCharacteristic", serviceSpecCharacteristic);
+		if (!inputs.isEmpty() && inputs.size() > 0) {
+			for (Input input : inputs) {
+				Property property = null;
+				if (input.getType().equals("list") || input.getType().equals("map"))
+					property = PropertyBuilder.build("array", null, null);
+				else
+					property = PropertyBuilder.build(input.getType(), null, null);
 
-        List<NodeTemplate> nodeTemplates = sdcCsarHelper.getServiceNodeTemplates();
-        List<LinkedHashMap> resourceSpecifications =
-                (List<LinkedHashMap>) serviceCatalogResponse.get("resourceSpecification");
-        for (LinkedHashMap resourceSpecification : resourceSpecifications) {
-            if (resourceSpecification.get("id") != null) {
-                String id = (String) resourceSpecification.get("id");
-                LOGGER.debug("get tosca infos for service id: {}", id);
-                NodeTemplate nodeTemplate = null;
-                for (NodeTemplate node : nodeTemplates) {
-                    if (node.getMetaData().getValue("UUID").equals(id)) {
-                        nodeTemplate = node;
-                        break;
-                    }
-                }
-                if (nodeTemplate == null)
-                    continue;
-                resourceSpecification.put("modelCustomizationId",
-                        sdcCsarHelper.getNodeTemplateCustomizationUuid(nodeTemplate));
-            }
+				property.setDescription(input.getDescription());
+				property.setRequired(input.isRequired());
+
+				if (input.getDefault() != null) {
+					property.setDefault(input.getDefault().toString());
+				}
+				((ModelImpl) model).addProperty(input.getName(), property);
+			}
+			definitions.put("ServiceCharacteristics", model);
+
+		}
+
+		String svcCharacteristicsJson = Json.pretty(definitions);
+		serviceSpecificationDBManager.saveSpecificationInputSchema(svcCharacteristicsJson, serviceCatalogResponse);
+
+		Metadata serviceMetadata = sdcCsarHelper.getServiceMetadata();
+		String instantationType = serviceMetadata.getValue("instantiationType");
+		serviceCatalogResponse.put("instantiationType", instantationType);
+
+		LinkedHashMap inputSchemaRef = new LinkedHashMap();
+		// use object to match examples in Specifications
+		inputSchemaRef.put("valueType", "object");
+		inputSchemaRef.put("@schemaLocation",
+				"/serviceSpecification/" + serviceCatalogResponse.get("id") + "/specificationInputSchema");
+		inputSchemaRef.put("@type", serviceCatalogResponse.get("name") + "_ServiceCharacteristic");
+
+		LinkedHashMap serviceSpecCharacteristic = new LinkedHashMap();
+		serviceSpecCharacteristic.put("name", serviceCatalogResponse.get("name") + "_ServiceCharacteristics");
+		serviceSpecCharacteristic.put("description",
+				"This object describes all the inputs needed from the client to interact with the "
+						+ serviceCatalogResponse.get("name") + " Service Topology");
+		serviceSpecCharacteristic.put("valueType", "object");
+		serviceSpecCharacteristic.put("@type", "ONAPServiceCharacteristic");
+		serviceSpecCharacteristic.put("@schemaLocation", "null");
+		serviceSpecCharacteristic.put("serviceSpecCharacteristicValue", inputSchemaRef);
+
+		serviceCatalogResponse.put("serviceSpecCharacteristic", serviceSpecCharacteristic);
+
+		List<NodeTemplate> nodeTemplates = sdcCsarHelper.getServiceNodeTemplates();
+		List<LinkedHashMap> resourceSpecifications = (List<LinkedHashMap>) serviceCatalogResponse
+				.get("resourceSpecification");
+		for (LinkedHashMap resourceSpecification : resourceSpecifications) {
+			if (resourceSpecification.get("id") != null) {
+				String id = (String) resourceSpecification.get("id");
+				LOGGER.debug("get tosca infos for service id: {}", id);
+				NodeTemplate nodeTemplate = null;
+				for (NodeTemplate node : nodeTemplates) {
+					if (node.getMetaData().getValue("UUID").equals(id)) {
+						nodeTemplate = node;
+						break;
+					}
+				}
+				if (nodeTemplate == null)
+					continue;
+				resourceSpecification.put("modelCustomizationId",
+						sdcCsarHelper.getNodeTemplateCustomizationUuid(nodeTemplate));
+				if (!vfModuleEntityList.isEmpty()) {
+					resourceSpecification.put("childResourceSpecification", listOfVfModelInfo);
+				}
+				resourceSpecification.put("InstanceSpecification", listOfInstanceParameters);
+
+			}
+		}
+	}
+
+    private static String testNull(Object object) {
+        if (object == null) {
+          return "NULL";
+        } else if (object instanceof Integer) {
+          return object.toString();
+        } else if (object instanceof String) {
+          return (String) object;
+        } else {
+          return "Type not recognized";
         }
     }
 
-}
+}
\ No newline at end of file
diff --git a/src/main/java/org/onap/nbi/apis/serviceorder/SoClient.java b/src/main/java/org/onap/nbi/apis/serviceorder/SoClient.java
index c286d60..95009b8 100644
--- a/src/main/java/org/onap/nbi/apis/serviceorder/SoClient.java
+++ b/src/main/java/org/onap/nbi/apis/serviceorder/SoClient.java
@@ -17,6 +17,7 @@ package org.onap.nbi.apis.serviceorder;
 import javax.annotation.PostConstruct;
 import org.onap.nbi.OnapComponentsUrlPaths;
 import org.onap.nbi.apis.serviceorder.model.consumer.CreateE2EServiceInstanceResponse;
+import org.onap.nbi.apis.serviceorder.model.consumer.CreateMacroServiceInstanceResponse;
 import org.onap.nbi.apis.serviceorder.model.consumer.CreateServiceInstanceResponse;
 import org.onap.nbi.apis.serviceorder.model.consumer.DeleteE2EServiceInstanceResponse;
 import org.onap.nbi.apis.serviceorder.model.consumer.GetE2ERequestStatusResponse;
@@ -119,6 +120,27 @@ public class SoClient {
         }
     }
 
+    public ResponseEntity<CreateMacroServiceInstanceResponse> callMacroCreateServiceInstance(MSOPayload msoPayload) {
+
+        if (LOGGER.isDebugEnabled()) {
+          LOGGER.debug("Calling SO CreateServiceInstance with msoPayload : " + msoPayload.toString());
+        }
+
+        try {
+          ResponseEntity<CreateMacroServiceInstanceResponse> response = restTemplate.exchange(createSoUrl,
+                   HttpMethod.POST, new HttpEntity<>(msoPayload, buildRequestHeader()),CreateMacroServiceInstanceResponse.class);
+          
+          logMacroResponsePost(createSoUrl, response);
+          return response;
+        } catch (BackendFunctionalException e) {
+          LOGGER.error(ERROR_ON_CALLING + createSoUrl + " ," + e.getHttpStatus() + " , " + e.getBodyResponse());
+          return new ResponseEntity(e.getBodyResponse(), e.getHttpStatus());
+        } catch (ResourceAccessException e) {
+          LOGGER.error(ERROR_ON_CALLING + createSoUrl + " ," + e.getMessage());
+          return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);
+        }
+    }
+    
     public ResponseEntity<CreateE2EServiceInstanceResponse> callE2ECreateServiceInstance(MSOE2EPayload msoPayloadE2E) {
 
         if (LOGGER.isDebugEnabled()) {
@@ -221,6 +243,18 @@ public class SoClient {
         }
     }
 
+    private void logMacroResponsePost(String url, ResponseEntity<CreateMacroServiceInstanceResponse> response) {
+      LOGGER.info(RESPONSE_STATUS + response.getStatusCodeValue());
+      if (LOGGER.isDebugEnabled()) {
+        LOGGER.debug("response body : {}", response.getBody().toString());
+      }
+      
+      if (LOGGER.isWarnEnabled() && !response.getStatusCode().equals(HttpStatus.CREATED)) {
+        LOGGER.warn("HTTP call SO on {} returns {} , {}", url, response.getStatusCodeValue(),
+                    response.getBody().toString());
+      }
+    }
+    
     private void logE2EResponsePost(String url, ResponseEntity<CreateE2EServiceInstanceResponse> response) {
         LOGGER.info(RESPONSE_STATUS + response.getStatusCodeValue());
         if (LOGGER.isDebugEnabled()) {
@@ -328,4 +362,4 @@ public class SoClient {
         return httpHeaders;
     }
 
-}
+}
\ No newline at end of file
diff --git a/src/main/java/org/onap/nbi/apis/serviceorder/model/consumer/CreateMacroServiceInstanceResponse.java b/src/main/java/org/onap/nbi/apis/serviceorder/model/consumer/CreateMacroServiceInstanceResponse.java
new file mode 100644
index 0000000..bdd7f29
--- /dev/null
+++ b/src/main/java/org/onap/nbi/apis/serviceorder/model/consumer/CreateMacroServiceInstanceResponse.java
@@ -0,0 +1,34 @@
+/**
+ *     Copyright (c) 2020 TechMahindra
+ *
+ *     Licensed under the Apache License, Version 2.0 (the "License");
+ *     you may not use this file except in compliance with the License.
+ *     You may obtain a copy of the License at
+ *
+ *         http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *     Unless required by applicable law or agreed to in writing, software
+ *     distributed under the License is distributed on an "AS IS" BASIS,
+ *     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *     See the License for the specific language governing permissions and
+ *     limitations under the License.
+ */
+package org.onap.nbi.apis.serviceorder.model.consumer;
+
+public class CreateMacroServiceInstanceResponse {
+
+	private RequestReferences requestReferences;
+
+	public RequestReferences getRequestReferences() {
+		return requestReferences;
+	}
+
+	public void setRequestReferences(RequestReferences requestReferences) {
+		this.requestReferences = requestReferences;
+	}
+
+	@Override
+	public String toString() {
+		return "CreateMacroServiceInstanceResponse{" + "requestReferences=" + requestReferences + '}';
+	}
+}
\ No newline at end of file
diff --git a/src/main/java/org/onap/nbi/apis/serviceorder/model/consumer/ModelInfo.java b/src/main/java/org/onap/nbi/apis/serviceorder/model/consumer/ModelInfo.java
index 1d5cc6e..477770a 100644
--- a/src/main/java/org/onap/nbi/apis/serviceorder/model/consumer/ModelInfo.java
+++ b/src/main/java/org/onap/nbi/apis/serviceorder/model/consumer/ModelInfo.java
@@ -16,6 +16,10 @@
 
 package org.onap.nbi.apis.serviceorder.model.consumer;
 
+import com.fasterxml.jackson.annotation.JsonInclude;
+import com.fasterxml.jackson.annotation.JsonInclude.Include;
+
+@JsonInclude(Include.NON_NULL)
 public class ModelInfo {
 
     private String modelType;
diff --git a/src/main/java/org/onap/nbi/apis/serviceorder/model/consumer/RequestDetails.java b/src/main/java/org/onap/nbi/apis/serviceorder/model/consumer/RequestDetails.java
index 4a38369..4e361b4 100644
--- a/src/main/java/org/onap/nbi/apis/serviceorder/model/consumer/RequestDetails.java
+++ b/src/main/java/org/onap/nbi/apis/serviceorder/model/consumer/RequestDetails.java
@@ -24,7 +24,7 @@ public class RequestDetails {
 
     private RequestInfo requestInfo;
 
-    private RequestParameters requestParameters;
+    private Object requestParameters;
 
     private CloudConfiguration cloudConfiguration;
 
@@ -80,11 +80,11 @@ public class RequestDetails {
         this.requestInfo = requestInfo;
     }
 
-    public RequestParameters getRequestParameters() {
+    public Object getRequestParameters() {
         return requestParameters;
     }
 
-    public void setRequestParameters(RequestParameters requestParameters) {
+    public void setRequestParameters(Object requestParameters) {
         this.requestParameters = requestParameters;
     }
 
diff --git a/src/main/java/org/onap/nbi/apis/serviceorder/model/consumer/RequestInfo.java b/src/main/java/org/onap/nbi/apis/serviceorder/model/consumer/RequestInfo.java
index 3aa54cc..6347a18 100644
--- a/src/main/java/org/onap/nbi/apis/serviceorder/model/consumer/RequestInfo.java
+++ b/src/main/java/org/onap/nbi/apis/serviceorder/model/consumer/RequestInfo.java
@@ -26,6 +26,8 @@ public class RequestInfo {
 
     private String requestorId;
 
+    private String productFamilyId;
+
     public String getInstanceName() {
         return instanceName;
     }
@@ -58,9 +60,18 @@ public class RequestInfo {
         this.requestorId = requestorId;
     }
 
+    public String getProductFamilyId() {
+        return productFamilyId;
+    }
+
+    public void setProductFamilyId(String productFamilyId) {
+        this.productFamilyId = productFamilyId;
+    }
+
     @Override
     public String toString() {
         return "RequestInfo{" + "instanceName='" + instanceName + '\'' + ", source='" + source + '\''
-                + ", suppressRollback=" + suppressRollback + ", requestorId='" + requestorId + '\'' + '}';
+                + ", suppressRollback=" + suppressRollback + ", requestorId='" + requestorId + '\'' 
+                + ", productFamilyId='" + productFamilyId + '\'' +'}';
     }
-}
+}
\ No newline at end of file
diff --git a/src/main/java/org/onap/nbi/apis/serviceorder/model/consumer/VFModelInfo.java b/src/main/java/org/onap/nbi/apis/serviceorder/model/consumer/VFModelInfo.java
new file mode 100644
index 0000000..7dc24c5
--- /dev/null
+++ b/src/main/java/org/onap/nbi/apis/serviceorder/model/consumer/VFModelInfo.java
@@ -0,0 +1,95 @@
+/**
+ *     Copyright (c) 2020 TechMahindra
+ *
+ *     Licensed under the Apache License, Version 2.0 (the "License");
+ *     you may not use this file except in compliance with the License.
+ *     You may obtain a copy of the License at
+ *
+ *         http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *     Unless required by applicable law or agreed to in writing, software
+ *     distributed under the License is distributed on an "AS IS" BASIS,
+ *     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *     See the License for the specific language governing permissions and
+ *     limitations under the License.
+ */
+package org.onap.nbi.apis.serviceorder.model.consumer;
+
+import org.apache.commons.lang3.builder.ToStringBuilder;
+
+import com.fasterxml.jackson.annotation.JsonInclude;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.fasterxml.jackson.annotation.JsonPropertyOrder;
+
+@JsonInclude(JsonInclude.Include.NON_NULL)
+@JsonPropertyOrder({ "modelName", "modelUuid", "modelInvariantUuid", "modelVersion", "modelCustomizationUuid" })
+public class VFModelInfo {
+
+  @JsonProperty("modelName")
+  private String modelName;
+  @JsonProperty("modelUuid")
+  private String modelUuid;
+  @JsonProperty("modelInvariantUuid")
+  private String modelInvariantUuid;
+  @JsonProperty("modelVersion")
+  private String modelVersion;
+  @JsonProperty("modelCustomizationUuid")
+  private String modelCustomizationUuid;
+
+    @JsonProperty("modelName")
+    public String getModelName() {
+      return modelName;
+    }
+
+    @JsonProperty("modelName")
+    public void setModelName(String modelName) {
+      this.modelName = modelName;
+    }
+
+    @JsonProperty("modelUuid")
+    public String getModelUuid() {
+      return modelUuid;
+    }
+
+    @JsonProperty("modelUuid")
+    public void setModelUuid(String modelUuid) {
+      this.modelUuid = modelUuid;
+    }
+
+    @JsonProperty("modelInvariantUuid")
+    public String getModelInvariantUuid() {
+      return modelInvariantUuid;
+    }
+
+    @JsonProperty("modelInvariantUuid")
+    public void setModelInvariantUuid(String modelInvariantUuid) {
+      this.modelInvariantUuid = modelInvariantUuid;
+    }
+
+    @JsonProperty("modelVersion")
+    public String getModelVersion() {
+      return modelVersion;
+    }
+
+    @JsonProperty("modelVersion")
+    public void setModelVersion(String modelVersion) {
+      this.modelVersion = modelVersion;
+    }
+
+    @JsonProperty("modelCustomizationUuid")
+    public String getModelCustomizationUuid() {
+      return modelCustomizationUuid;
+    }
+
+    @JsonProperty("modelCustomizationUuid")
+    public void setModelCustomizationUuid(String modelCustomizationUuid) {
+      this.modelCustomizationUuid = modelCustomizationUuid;
+    }
+
+    @Override
+    public String toString() {
+      return new ToStringBuilder(this).append("modelName", modelName).append("modelUuid", modelUuid)
+        .append("modelInvariantUuid", modelInvariantUuid).append("modelVersion", modelVersion)
+        .append("modelCustomizationUuid", modelCustomizationUuid).toString();
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/org/onap/nbi/apis/serviceorder/workflow/PostSoProcessor.java b/src/main/java/org/onap/nbi/apis/serviceorder/workflow/PostSoProcessor.java
index 1b0d77f..e590afc 100644
--- a/src/main/java/org/onap/nbi/apis/serviceorder/workflow/PostSoProcessor.java
+++ b/src/main/java/org/onap/nbi/apis/serviceorder/workflow/PostSoProcessor.java
@@ -20,6 +20,8 @@ import java.util.HashMap;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
+
+import org.onap.nbi.apis.servicecatalog.ServiceSpecificationService;
 import org.onap.nbi.apis.serviceorder.SoClient;
 import org.onap.nbi.apis.serviceorder.model.ServiceCharacteristic;
 import org.onap.nbi.apis.serviceorder.model.ServiceOrder;
@@ -27,6 +29,7 @@ import org.onap.nbi.apis.serviceorder.model.ServiceOrderItem;
 import org.onap.nbi.apis.serviceorder.model.StateType;
 import org.onap.nbi.apis.serviceorder.model.consumer.CloudConfiguration;
 import org.onap.nbi.apis.serviceorder.model.consumer.CreateE2EServiceInstanceResponse;
+import org.onap.nbi.apis.serviceorder.model.consumer.CreateMacroServiceInstanceResponse;
 import org.onap.nbi.apis.serviceorder.model.consumer.CreateServiceInstanceResponse;
 import org.onap.nbi.apis.serviceorder.model.consumer.MSOE2EPayload;
 import org.onap.nbi.apis.serviceorder.model.consumer.MSOPayload;
@@ -41,6 +44,7 @@ import org.onap.nbi.apis.serviceorder.model.consumer.ResourceModel;
 import org.onap.nbi.apis.serviceorder.model.consumer.ServiceModel;
 import org.onap.nbi.apis.serviceorder.model.consumer.SubscriberInfo;
 import org.onap.nbi.apis.serviceorder.model.consumer.UserParams;
+import org.onap.nbi.apis.serviceorder.model.consumer.VFModelInfo;
 import org.onap.nbi.apis.serviceorder.model.orchestrator.ServiceOrderInfo;
 import org.onap.nbi.apis.serviceorder.service.ServiceOrderService;
 import org.slf4j.Logger;
@@ -77,12 +81,24 @@ public class PostSoProcessor {
 
     @Value("${onap.cloudOwner}")
     private String cloudOwner;
+    
+    @Value("${onap.k8sCloudOwner}")
+	private String k8sCloudOwner;
+
+	@Value("${onap.k8sCloudRegionId}")
+	private String k8sCloudRegionId;
+
+	@Value("${k8s-rb-profile-name}")
+	private String k8sRbProfileName;
 
     @Autowired
     private ServiceOrderService serviceOrderService;
 
     @Autowired
     private SoClient soClient;
+    
+    @Autowired
+    ServiceSpecificationService serviceSpecificationService;
 
     public ResponseEntity<CreateServiceInstanceResponse> postServiceOrderItem(ServiceOrderInfo serviceOrderInfo,
             ServiceOrderItem serviceOrderItem) {
@@ -108,6 +124,19 @@ public class PostSoProcessor {
         return response;
     }
 
+    public ResponseEntity<CreateMacroServiceInstanceResponse> postMacroServiceOrderItem(ServiceOrderInfo serviceOrderInfo,
+            ServiceOrderItem serviceOrderItem) {
+        ResponseEntity<CreateMacroServiceInstanceResponse> response = null;
+        try {
+            // For Macro Flow
+            response = postSOMacroRequest(serviceOrderItem, serviceOrderInfo);
+        } catch (NullPointerException e) {
+            LOGGER.error("Unable to create service instance for serviceOrderItem.id=" + serviceOrderItem.getId(), e);
+            response = null;
+        }
+        return response;
+    }
+    
     private ResponseEntity<CreateServiceInstanceResponse> postSORequest(ServiceOrderItem serviceOrderItem,
             ServiceOrderInfo serviceOrderInfo) {
         RequestDetails requestDetails = buildSoRequest(serviceOrderItem, serviceOrderInfo);
@@ -164,6 +193,221 @@ public class PostSoProcessor {
         }
         return response;
     }
+    
+    private ResponseEntity<CreateMacroServiceInstanceResponse> postSOMacroRequest(ServiceOrderItem serviceOrderItem,
+                            ServiceOrderInfo serviceOrderInfo) {
+      
+      String serviceModuleName = (String) serviceOrderInfo.getServiceOrderItemInfos().get(serviceOrderItem.getId())
+            .getCatalogResponse().get("name");
+
+      RequestDetails requestDetails = buildSoMacroRequest(serviceOrderItem, serviceOrderInfo);
+      MSOPayload msoMacroPayload = new MSOPayload(requestDetails);
+      ResponseEntity<CreateMacroServiceInstanceResponse> response = null;
+
+      switch (serviceOrderItem.getAction()) {
+        case ADD:
+          response = soClient.callMacroCreateServiceInstance(msoMacroPayload);
+          break;
+        case DELETE:
+          // response = soClient.callDeleteServiceInstance(msoPayload,
+          // serviceOrderItem.getService().getId());
+          break;
+        case MODIFY:
+          if (StateType.INPROGRESS_MODIFY_ITEM_TO_CREATE == serviceOrderItem.getState()) {
+            // response = soClient.callCreateServiceInstance(msoPayload);
+          }
+          if (StateType.ACKNOWLEDGED == serviceOrderItem.getState()) {
+            // response = soClient.callDeleteServiceInstance(msoPayload,
+            // serviceOrderItem.getService().getId());
+          }
+          break;
+        default:
+          break;
+      }
+      return response;
+    }
+    
+    /**
+     * Build SO MACRO CREATE request from the ServiceOrder and catalog informations from SDC
+     *
+     * @param orderItem
+     * @param serviceOrderInfo
+     * @param subscriberInfo
+     * @return
+     */
+    private RequestDetails buildSoMacroRequest(ServiceOrderItem orderItem, ServiceOrderInfo serviceOrderInfo) {
+      
+    	RequestDetails requestDetails = new RequestDetails();
+		Map<String, Object> sdcInfos = serviceOrderInfo.getServiceOrderItemInfos().get(orderItem.getId())
+				.getCatalogResponse();
+
+		String id = orderItem.getService().getServiceSpecification().getId();
+		Map responseChildRes = serviceSpecificationService.get(id);
+		ArrayList<Map<String, Object>> resourseSpecificationArray = (ArrayList<Map<String, Object>>) responseChildRes
+				.get("resourceSpecification");
+
+		Map<String, Object> resourseSpecificationMap = resourseSpecificationArray.get(0);
+
+		Map instanceSpecification = (Map) resourseSpecificationMap.get("InstanceSpecification");
+		ArrayList<VFModelInfo> childResourceSpecification = (ArrayList<VFModelInfo>) resourseSpecificationMap
+				.get("childResourceSpecification");
+
+		List<Object> serviceObject = new ArrayList<>();
+
+		ArrayList<Object> vnfInstanceParam = new ArrayList<>();
+
+		//Differentiating vnf with cnf(Can be discussed and improved)
+		if (instanceSpecification.get("public_net_id") != null) {
+			vnfInstanceParam.add(instanceSpecification);
+		} else {
+			Map<String, Object> instanceParam = new HashMap<>();
+			instanceParam.put("k8s-rb-profile-name", k8sRbProfileName);
+			vnfInstanceParam.add(instanceParam);
+		}
+
+		List resSpec = (ArrayList) sdcInfos.get("resourceSpecification");
+		Map resSpecMap = (Map) resSpec.get(0);
+
+		Map<String, String> vnfInfoObject = new HashMap<>();
+		vnfInfoObject.put("modelName", (String) resSpecMap.get("name"));
+		vnfInfoObject.put("modelVersionId", (String) resSpecMap.get("id"));
+		vnfInfoObject.put("modelInvariantUuid", (String) resSpecMap.get("resourceInvariantUUID"));
+		vnfInfoObject.put("modelVersion", (String) resSpecMap.get("version"));
+		vnfInfoObject.put("modelCustomizationId", (String) resSpecMap.get("modelCustomizationId"));
+		vnfInfoObject.put("modelInstanceName", (String) resSpecMap.get("resourceInstanceName"));
+
+		//initialization
+		CloudConfiguration cloudConfiguration = null;
+
+		//Differentiating vnf with cnf(Can be discussed and improved)
+		if (instanceSpecification.get("public_net_id") != null) {
+			cloudConfiguration = new CloudConfiguration(lcpCloudRegionId, tenantId, cloudOwner);
+		} else {
+			cloudConfiguration = new CloudConfiguration(k8sCloudRegionId, tenantId, k8sCloudOwner);
+		}
+
+		Map<String, String> platformName = new HashMap<>();
+		platformName.put("platformName", "test");
+
+		Map<String, String> lob = new HashMap<>();
+		lob.put("lineOfBusinessName", "LOB-Demonstration");
+
+		Map<String, Object> vnfModel = new HashMap<>();
+		vnfModel.put("modelInfo", vnfInfoObject);
+		vnfModel.put("cloudConfiguration", cloudConfiguration);
+		vnfModel.put("platform", platformName);
+		vnfModel.put("lineOfBusiness", lob);
+		vnfModel.put("productFamilyId", "a9a77d5a-123e-4ca2-9eb9-0b015d2ee0fb");
+		vnfModel.put("instanceName", (String) resSpecMap.get("resourceInstanceName"));
+		vnfModel.put("instanceParams", vnfInstanceParam);
+
+		List<Object> vfModulesObjects = new ArrayList<>();
+		ArrayList<Map<String, Object>> vfInstanceParam = new ArrayList<>();
+
+		//Differentiate CNF from VNF
+		if (instanceSpecification.get("public_net_id") != null) {
+			vfInstanceParam.add(instanceSpecification);
+			
+		} else {
+			Map<String, Object> instanceParam = new HashMap<>();
+			instanceParam.put("k8s-rb-profile-name", k8sRbProfileName);
+			vfInstanceParam.add(instanceParam);
+		}
+		
+		for (VFModelInfo crsObject : childResourceSpecification) {
+			Map<String, Object> vfModuleObject = new HashMap<>();
+			Map<String, String> vfModuleInfo = new HashMap<>();
+
+			vfModuleInfo.put("modelName", crsObject.getModelName());
+			vfModuleInfo.put("modelVersionId", crsObject.getModelUuid());
+			vfModuleInfo.put("modelInvariantUuid", crsObject.getModelInvariantUuid());
+			vfModuleInfo.put("modelVersion", crsObject.getModelVersion());
+			vfModuleInfo.put("modelCustomizationId", crsObject.getModelCustomizationUuid());
+			vfModuleObject.put("modelInfo", vfModuleInfo);
+			vfModuleObject.put("instanceName", crsObject.getModelName());
+			vfModuleObject.put("instanceParams", vfInstanceParam);
+
+			vfModulesObjects.add(vfModuleObject);
+		}
+		vnfModel.put("vfModules", vfModulesObjects);
+
+		List<Object> vnfObjects = new ArrayList<>();
+		vnfObjects.add(vnfModel);
+
+		Map<String, Object> vnfData = new HashMap<>();
+		vnfData.put("vnfs", vnfObjects);
+
+		ModelInfo serviceModelInfo = new ModelInfo();
+		serviceModelInfo.setModelType("service");
+		serviceModelInfo.setModelInvariantId((String) sdcInfos.get("invariantUUID"));
+		serviceModelInfo.setModelVersionId(orderItem.getService().getServiceSpecification().getId());
+		serviceModelInfo.setModelName((String) sdcInfos.get("name"));
+		serviceModelInfo.setModelVersion((String) sdcInfos.get("version"));
+
+		// Adding List of instanceParams for service
+		// We can add instanceParams Key Value in Map Object and add it to the List, for
+		// For now it is empty to comply with so request
+
+		List<Map<String, String>> listOfServiceLevelInstanceParams = new ArrayList<>();
+		Map<String, String> serviceInstanceParams= new HashMap<>();
+		listOfServiceLevelInstanceParams.add(serviceInstanceParams);
+		
+		Map<String, Object> serviceData = new HashMap<>();
+		serviceData.put("instanceParams", listOfServiceLevelInstanceParams);
+		serviceData.put("instanceName", orderItem.getService().getName());
+		serviceData.put("resources", vnfData);
+		serviceData.put("modelInfo", serviceModelInfo);
+
+		Map<String, String> homingObject = new HashMap<>();
+		homingObject.put("Homing_Solution", "none");
+		serviceObject.add(homingObject);
+
+		Map<String, Object> serviceObject1 = new HashMap<>();
+		serviceObject1.put("service", serviceData);
+		serviceObject.add(serviceObject1);
+		requestDetails.setSubscriberInfo(serviceOrderInfo.getSubscriberInfo());
+
+		ModelInfo modelInfo = new ModelInfo();
+		modelInfo.setModelType("service");
+		modelInfo.setModelInvariantId((String) sdcInfos.get("invariantUUID"));
+		modelInfo.setModelVersionId(orderItem.getService().getServiceSpecification().getId());
+		modelInfo.setModelName((String) sdcInfos.get("name"));
+		modelInfo.setModelVersion((String) sdcInfos.get("version"));
+		requestDetails.setModelInfo(modelInfo);
+
+		RequestInfo requestInfo = new RequestInfo();
+		requestInfo.setInstanceName(orderItem.getService().getName());
+		requestInfo.setSource("VID");
+		requestInfo.setSuppressRollback(false);
+		requestInfo.setRequestorId("NBI");
+		requestInfo.setProductFamilyId("a9a77d5a-123e-4ca2-9eb9-0b015d2ee0fb");
+		requestDetails.setRequestInfo(requestInfo);
+
+		// We are taking RequestParameters as map because it has UserParams which gives value as
+		// "name" : "service"
+		// "value" : "", which SO is not accepting
+		Map<String, Object> requestParameters = new HashMap<>();
+
+		// Get value from serviceOrder request or generate one
+		String serviceTypeFromJson = orderItem.getService().getServicetype();
+		requestParameters.put("subscriptionServiceType",
+				serviceTypeFromJson != null ? serviceTypeFromJson : (String) sdcInfos.get("name"));
+		requestParameters.put("userParams", serviceObject);
+		requestParameters.put("aLaCarte", false);
+		requestDetails.setRequestParameters(requestParameters);
+		requestDetails.setCloudConfiguration(cloudConfiguration);
+
+		OwningEntity owningEntity = new OwningEntity();
+		owningEntity.setOwningEntityId(soOwningEntityId);
+		owningEntity.setOwningEntityName(soOwningEntityName);
+		requestDetails.setOwningEntity(owningEntity);
+
+		Project project = new Project();
+		project.setProjectName(soProjectName);
+
+		requestDetails.setProject(project);
+        return requestDetails;
+	}
 
     /**
      * Build SO CREATE request from the ServiceOrder and catalog informations from SDC
@@ -262,7 +506,7 @@ public class PostSoProcessor {
         if (!userParams.isEmpty()) {
             Map<String, String> requestInputs = new HashMap<String, String>();
             for (int i = 0; i < userParams.size(); i++) {
-                requestInputs.put(userParams.get(i).getName(), userParams.get(i).getValue());
+                requestInputs.put(userParams.get(i).getName(), (String) userParams.get(i).getValue());
             }
 
             parameters.setRequestInputs(requestInputs);
@@ -320,4 +564,4 @@ public class PostSoProcessor {
         return userParams;
     }
 
-}
+}
\ No newline at end of file
diff --git a/src/main/java/org/onap/nbi/apis/serviceorder/workflow/SOTaskProcessor.java b/src/main/java/org/onap/nbi/apis/serviceorder/workflow/SOTaskProcessor.java
index d63d122..fe0938d 100644
--- a/src/main/java/org/onap/nbi/apis/serviceorder/workflow/SOTaskProcessor.java
+++ b/src/main/java/org/onap/nbi/apis/serviceorder/workflow/SOTaskProcessor.java
@@ -24,6 +24,7 @@ import org.onap.nbi.apis.serviceorder.model.ServiceOrder;
 import org.onap.nbi.apis.serviceorder.model.ServiceOrderItem;
 import org.onap.nbi.apis.serviceorder.model.StateType;
 import org.onap.nbi.apis.serviceorder.model.consumer.CreateE2EServiceInstanceResponse;
+import org.onap.nbi.apis.serviceorder.model.consumer.CreateMacroServiceInstanceResponse;
 import org.onap.nbi.apis.serviceorder.model.consumer.CreateServiceInstanceResponse;
 import org.onap.nbi.apis.serviceorder.model.orchestrator.ExecutionTask;
 import org.onap.nbi.apis.serviceorder.model.orchestrator.ServiceOrderInfo;
@@ -92,8 +93,10 @@ public class SOTaskProcessor {
                 updateE2EServiceOrderItem(response, serviceOrderItem, serviceOrder);
             } else if (macroService) {
               LOGGER.info("Mode type macro");
-              //TODO: Add logic to construct SO macro request body and call SO macro flow.(EXTAPI-368)
-
+              // call SO macro flow.(EXTAPI-368)
+              ResponseEntity<CreateMacroServiceInstanceResponse> response = postSoProcessor
+                  .postMacroServiceOrderItem(serviceOrderInfo, serviceOrderItem);
+              updateMacroServiceOrderItem(response, serviceOrderItem, serviceOrder);
             } else {
 
                 ResponseEntity<CreateServiceInstanceResponse> response =
@@ -216,6 +219,35 @@ public class SOTaskProcessor {
         }
     }
 
+    /**
+     * Update ServiceOrderItem with SO response by using serviceOrderRepository with the serviceOrderId
+     */
+    private void updateMacroServiceOrderItem(ResponseEntity<CreateMacroServiceInstanceResponse> response,
+        ServiceOrderItem orderItem, ServiceOrder serviceOrder) {
+
+        if (response == null || !response.getStatusCode().is2xxSuccessful()) {
+            LOGGER.warn("response ko for serviceOrderItem.id=" + orderItem.getId());
+            serviceOrderService.updateOrderItemState(serviceOrder, orderItem, StateType.FAILED);
+            buildOrderMessageIfNeeded(orderItem, serviceOrder, response);
+        } else {
+            CreateMacroServiceInstanceResponse createMacroServiceInstanceResponse = response.getBody();
+            if (createMacroServiceInstanceResponse != null && !orderItem.getState().equals(StateType.FAILED)) {
+                orderItem.getService().setId(createMacroServiceInstanceResponse.getRequestReferences().getInstanceId());
+                orderItem.setRequestId(createMacroServiceInstanceResponse.getRequestReferences().getRequestId());
+            }
+
+            if (!response.getStatusCode().is2xxSuccessful() || response.getBody() == null
+                        || response.getBody().getRequestReferences() == null) {
+                serviceOrderService.updateOrderItemState(serviceOrder, orderItem, StateType.FAILED);
+                LOGGER
+                    .warn("order item {} failed , status {} , response {}", orderItem.getId(), response.getStatusCode(),
+                        response.getBody());
+            } else {
+                serviceOrderService.updateOrderItemState(serviceOrder, orderItem, StateType.INPROGRESS);
+            }
+        }
+    }
+    
     private void updateOrderItemToInProgress(ServiceOrder serviceOrder, ServiceOrderItem serviceOrderItem) {
         if (serviceOrderItem.getAction() != ActionType.MODIFY) {
             serviceOrderService.updateOrderItemState(serviceOrder, serviceOrderItem, StateType.INPROGRESS);
@@ -341,4 +373,4 @@ public class SOTaskProcessor {
         LOGGER.debug("Difference {} and Polling Duration {}", differenceInMillis, pollingDurationInMins);
         return (differenceInMillis > pollingDurationInMillis);
     }
-}
+}
\ No newline at end of file
diff --git a/src/main/resources/application-test.properties b/src/main/resources/application-test.properties
index 1a73f16..ac3efec 100644
--- a/src/main/resources/application-test.properties
+++ b/src/main/resources/application-test.properties
@@ -30,12 +30,17 @@ onap.lcpCloudRegionId               = RegionOne
 onap.tenantId                       = 31047205ce114b60833b23e400d6a535
 onap.cloudOwner                     = CloudOwner
 
+# k8s
+onap.k8sCloudRegionId               = k8sregionfour
+onap.k8sCloudOwner                  = k8scloudowner4
+k8s-rb-profile-name				 	= default
+
 # NBI
 nbi.url                             = http://localhost:${server.port}${server.servlet.context-path}
 nbi.callForVNF                      = false
 
 # SCHEDULER
-scheduler.pollingDurationInMins     = 0.1
+scheduler.pollingDurationInMins     = 0.2
 serviceOrder.schedule               = 5000
 serviceOrder.initial                = 1
 executionTask.schedule              = 2000
diff --git a/src/main/resources/application.properties b/src/main/resources/application.properties
index e719c6f..b010f50 100644
--- a/src/main/resources/application.properties
+++ b/src/main/resources/application.properties
@@ -40,6 +40,11 @@ onap.lcpCloudRegionId                = RegionOne
 onap.tenantId                        = 6e97a2bd51d74f6db5671d8dc1517d82
 onap.cloudOwner                      = CloudOwner
 
+# k8s
+onap.k8sCloudRegionId                = k8sregionfour
+onap.k8sCloudOwner                   = k8scloudowner4
+k8s-rb-profile-name				 	 = default
+
 # NBI
 nbi.url                              = https://localhost:${server.port}${server.servlet.context-path}
 nbi.public.url                       = https://${server.public.ip}:${server.port}${server.servlet.context-path}
diff --git a/src/test/java/org/onap/nbi/apis/assertions/ServiceOrderExecutionTaskAssertions.java b/src/test/java/org/onap/nbi/apis/assertions/ServiceOrderExecutionTaskAssertions.java
index b09cf1d..621a938 100644
--- a/src/test/java/org/onap/nbi/apis/assertions/ServiceOrderExecutionTaskAssertions.java
+++ b/src/test/java/org/onap/nbi/apis/assertions/ServiceOrderExecutionTaskAssertions.java
@@ -162,6 +162,76 @@ public class ServiceOrderExecutionTaskAssertions {
 
     }
 
+    public static ServiceOrder createTestServiceOrderForMacro(ActionType actionType) {
+	ServiceOrder serviceOrder = new ServiceOrder();
+	serviceOrder.setExternalId("LudONAP001");
+	serviceOrder.setPriority("1");
+	serviceOrder.setDescription("Ludo first ONAP Order");
+	serviceOrder.setCategory("Consumer");
+	serviceOrder.setRequestedStartDate(new Date());
+	serviceOrder.setRequestedCompletionDate(new Date());
+	serviceOrder.setBaseType("toto");
+	serviceOrder.setCompletionDateTime(new Date());
+	serviceOrder.setExpectedCompletionDate(new Date());
+	serviceOrder.setSchemaLocation("/tutu");
+
+	OrderRelationship orderRelationship = new OrderRelationship();
+	orderRelationship.setId("test");
+	orderRelationship.setHref("test");
+	orderRelationship.setReferredType("test");
+	orderRelationship.setType("type");
+	List<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
new 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
new 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