- 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>
package org.onap.nbi.apis.servicecatalog;
+import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
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);
return this.getResponse(response, filter);
}
-}
+}
\ No newline at end of file
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;
@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);
}
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
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;
}
}
+ 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()) {
}
}
+ 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()) {
return httpHeaders;
}
-}
+}
\ No newline at end of file
--- /dev/null
+/**
+ * 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
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;
private RequestInfo requestInfo;
- private RequestParameters requestParameters;
+ private Object requestParameters;
private CloudConfiguration cloudConfiguration;
this.requestInfo = requestInfo;
}
- public RequestParameters getRequestParameters() {
+ public Object getRequestParameters() {
return requestParameters;
}
- public void setRequestParameters(RequestParameters requestParameters) {
+ public void setRequestParameters(Object requestParameters) {
this.requestParameters = requestParameters;
}
private String requestorId;
+ private String productFamilyId;
+
public String getInstanceName() {
return instanceName;
}
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
--- /dev/null
+/**
+ * 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
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;
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;
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;
@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) {
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);
}
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
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);
return userParams;
}
-}
+}
\ No newline at end of file
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;
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 =
}
}
+ /**
+ * 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);
LOGGER.debug("Difference {} and Polling Duration {}", differenceInMillis, pollingDurationInMins);
return (differenceInMillis > pollingDurationInMillis);
}
-}
+}
\ No newline at end of file
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
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}
}
+ 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);
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
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;
}
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);
+
+ }
}
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 {
}
"""
+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'
--- /dev/null
+{
+ "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
--- /dev/null
+{
+ "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
--- /dev/null
+#
+# 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
Code Review / externalapi / nbi.git / commitdiff