checked and evaluated naming policy only if infra bonding.
Updated workflowAction to include vrf configuration for vpn-binding in
resourceIds list.
added in linked resource to service proxy cust
committing the asdc controller classpath change
added some unit tests for vrf validation and updated bbinput setup test
update config resource cust foreign key mapping
Moved mockbean for AssignVrfConfiguration task class into BaseBpmnTest.
added in a check to see if list is empty before access
added unit tests for bbinput setup for vrf config
Update AssignFlows enum with correct AssignVrfConfiguration flow name
Change-Id: Ibf14e36505638b19c1366ecebfce560c02e69e44
Issue-ID: SO-1975
Signed-off-by: Benjamin, Max (mb388a) <mb388a@us.att.com>
--- /dev/null
+USE catalogdb;
+
+ALTER TABLE service
+ADD IF NOT EXISTS ONAP_GENERATED_NAMING tinyint(1) DEFAULT NULL;
+
+ALTER TABLE service
+ADD IF NOT EXISTS NAMING_POLICY varchar(200) DEFAULT NULL;
+
`WORKLOAD_CONTEXT` varchar(200) DEFAULT NULL,
`SERVICE_CATEGORY` varchar(200) DEFAULT NULL,
`RESOURCE_ORDER` varchar(200) default NULL,
- OVERALL_DISTRIBUTION_STATUS varchar(45),
+ `OVERALL_DISTRIBUTION_STATUS` varchar(45),
+ `ONAP_GENERATED_NAMING` TINYINT(1) DEFAULT NULL,
+ `NAMING_POLICY` varchar(200) DEFAULT NULL,
PRIMARY KEY (`MODEL_UUID`),
KEY `fk_service__tosca_csar1_idx` (`TOSCA_CSAR_ARTIFACT_UUID`),
CONSTRAINT `fk_service__tosca_csar1` FOREIGN KEY (`TOSCA_CSAR_ARTIFACT_UUID`) REFERENCES `tosca_csar` (`ARTIFACT_UUID`) ON DELETE CASCADE ON UPDATE CASCADE
toscaResourceStructure.getSdcCsarHelper().getNodeTemplatePropertyLeafValue(nodeTemplate, "role"));
configCustomizationResource.setType(
toscaResourceStructure.getSdcCsarHelper().getNodeTemplatePropertyLeafValue(nodeTemplate, "type"));
- configCustomizationResource
- .setServiceProxyResourceCustomizationUUID(spResourceCustomization.getModelCustomizationUUID());
+ configCustomizationResource.setServiceProxyResourceCustomization(spResourceCustomization);
configCustomizationResource.setConfigurationResource(configResource);
configCustomizationResource.setService(service);
service.setModelInvariantUUID(serviceMetadata.getValue(SdcPropertyNames.PROPERTY_NAME_INVARIANTUUID));
service.setCsar(toscaResourceStructure.getCatalogToscaCsar());
+ service.setNamingPolicy(serviceMetadata.getValue("namingPolicy"));
+ String generateNaming = serviceMetadata.getValue("ecompGeneratedNaming");
+ Boolean generateNamingValue = null;
+ if (generateNaming != null) {
+ generateNamingValue = "true".equalsIgnoreCase(generateNaming);
+ }
+ service.setOnapGeneratedNaming(generateNamingValue);
}
import static org.mockito.Mockito.when;
import java.util.ArrayList;
import java.util.List;
+import java.util.Optional;
import org.hibernate.exception.LockAcquisitionException;
import org.junit.Before;
import org.junit.Rule;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.onap.sdc.api.notification.IArtifactInfo;
+import org.onap.sdc.api.notification.INotificationData;
import org.onap.sdc.api.notification.IResourceInstance;
import org.onap.sdc.tosca.parser.api.ISdcCsarHelper;
import org.onap.sdc.tosca.parser.impl.SdcCsarHelperImpl;
import org.onap.so.asdc.client.test.emulators.ArtifactInfoImpl;
import org.onap.so.asdc.client.test.emulators.JsonStatusData;
import org.onap.so.asdc.client.test.emulators.NotificationDataImpl;
+import org.onap.so.asdc.installer.ResourceStructure;
import org.onap.so.asdc.installer.ToscaResourceStructure;
import org.onap.so.db.catalog.beans.ConfigurationResource;
import org.onap.so.db.catalog.beans.ConfigurationResourceCustomization;
return actualWatchdogComponentDistributionStatus;
}
-
+ @Test
+ public void createServiceTest() {
+ ToscaResourceStructure toscaResourceStructure = mock(ToscaResourceStructure.class);
+ ResourceStructure resourceStructure = mock(ResourceStructure.class);
+ Metadata metadata = mock(Metadata.class);
+ INotificationData notification = mock(INotificationData.class);
+
+ doReturn("e2899e5c-ae35-434c-bada-0fabb7c1b44d").when(toscaResourceStructure).getServiceVersion();
+ doReturn(metadata).when(toscaResourceStructure).getServiceMetadata();
+ doReturn("production").when(notification).getWorkloadContext();
+ doReturn(notification).when(resourceStructure).getNotification();
+
+ String serviceType = "test-type";
+ String serviceRole = "test-role";
+ String category = "Network L4+";
+ String description = "Customer Orderable service description";
+ String name = "Customer Orderable Service";
+ String uuid = "72db5868-4575-4804-b546-0b0d3c3b5ac6";
+ String invariantUUID = "6f30bbe3-4590-4185-a7e0-4f9610926c6f";
+ String namingPolicy = "naming Policy";
+ String ecompGeneratedNaming = "true";
+ String environmentContext = "General_Revenue-Bearing";
+
+ doReturn(serviceType).when(metadata).getValue("serviceType");
+ doReturn(serviceRole).when(metadata).getValue("serviceRole");
+
+ doReturn(category).when(metadata).getValue(SdcPropertyNames.PROPERTY_NAME_CATEGORY);
+ doReturn(description).when(metadata).getValue(SdcPropertyNames.PROPERTY_NAME_DESCRIPTION);
+
+ doReturn(name).when(metadata).getValue(SdcPropertyNames.PROPERTY_NAME_NAME);
+
+ doReturn(uuid).when(metadata).getValue(SdcPropertyNames.PROPERTY_NAME_UUID);
+
+ doReturn(environmentContext).when(metadata).getValue(metadata.getValue("environmentContext"));
+ doReturn(invariantUUID).when(metadata).getValue(SdcPropertyNames.PROPERTY_NAME_INVARIANTUUID);
+ doReturn(namingPolicy).when(metadata).getValue("namingPolicy");
+ doReturn(ecompGeneratedNaming).when(metadata).getValue("ecompGeneratedNaming");
+
+ Service service = toscaInstaller.createService(toscaResourceStructure, resourceStructure);
+
+ assertNotNull(service);
+
+ verify(toscaResourceStructure, times(2)).getServiceVersion();
+ assertNotNull(service.getNamingPolicy());
+ assertEquals(serviceType, service.getServiceType());
+ assertEquals(serviceRole, service.getServiceRole());
+ assertEquals(category, service.getCategory());
+ assertEquals(description, service.getDescription());
+ assertEquals(uuid, service.getModelUUID());
+ assertEquals(invariantUUID, service.getModelInvariantUUID());
+ assertEquals(namingPolicy, service.getNamingPolicy());
+ assertTrue(service.getOnapGeneratedNaming());
+ }
private void prepareConfigurationResource() {
doReturn(metadata).when(nodeTemplate).getMetaData();
assertNotNull(configurationResourceCustomization);
assertNotNull(configurationResourceCustomization.getConfigurationResource());
assertEquals(MockConstants.MODEL_CUSTOMIZATIONUUID,
- configurationResourceCustomization.getServiceProxyResourceCustomizationUUID());
+ configurationResourceCustomization.getServiceProxyResourceCustomization().getModelCustomizationUUID());
}
@Test
`WORKLOAD_CONTEXT` varchar(200) DEFAULT NULL,
`SERVICE_CATEGORY` varchar(200) DEFAULT NULL,
`RESOURCE_ORDER` varchar(200) default NULL,
- OVERALL_DISTRIBUTION_STATUS varchar(45),
+ `OVERALL_DISTRIBUTION_STATUS` varchar(45),
+ `ONAP_GENERATED_NAMING` TINYINT(1) DEFAULT NULL,
+ `NAMING_POLICY` varchar(200) DEFAULT NULL,
PRIMARY KEY (`MODEL_UUID`),
KEY `fk_service__tosca_csar1_idx` (`TOSCA_CSAR_ARTIFACT_UUID`),
CONSTRAINT `fk_service__tosca_csar1` FOREIGN KEY (`TOSCA_CSAR_ARTIFACT_UUID`) REFERENCES `tosca_csar` (`ARTIFACT_UUID`) ON DELETE CASCADE ON UPDATE CASCADE
@JsonProperty("l-interface")
private LInterface lInterface;
+ @JsonProperty("vpn-binding")
+ private VpnBinding vpnBinding;
+
public ModelInfoConfiguration getModelInfoConfiguration() {
return modelInfoConfiguration;
}
this.lInterface = lInterface;
}
+ public VpnBinding getVpnBinding() {
+ return vpnBinding;
+ }
+
+ public void setVpnBinding(VpnBinding vpnBinding) {
+ this.vpnBinding = vpnBinding;
+ }
+
@Override
public boolean equals(final Object other) {
if (!(other instanceof Configuration)) {
@JsonProperty("service-proxies")
private List<ServiceProxy> serviceProxies = new ArrayList<ServiceProxy>();
+ public void setServiceProxies(List<ServiceProxy> serviceProxies) {
+ this.serviceProxies = serviceProxies;
+ }
+
public List<GenericVnf> getVnfs() {
return vnfs;
}
--- /dev/null
+package org.onap.so.bpmn.servicedecomposition.bbobjects.wrappers;
+
+import org.onap.so.bpmn.servicedecomposition.bbobjects.ServiceInstance;
+import org.onap.so.bpmn.servicedecomposition.bbobjects.ServiceProxy;
+import org.onap.so.bpmn.servicedecomposition.bbobjects.wrappers.exceptions.ServiceProxyNotFoundException;
+
+public class ServiceInstanceWrapper {
+
+ private final ServiceInstance serviceInstance;
+ private static final String SERVICE_PROXY_TRANSPORT = "TRANSPORT";
+
+ public ServiceInstanceWrapper(ServiceInstance serviceInstance) {
+ this.serviceInstance = serviceInstance;
+ }
+
+ public ServiceProxy getTransportServiceProxy() throws ServiceProxyNotFoundException {
+ ServiceProxy serviceProxy = null;
+ for (ServiceProxy sp : serviceInstance.getServiceProxies()) {
+ if (SERVICE_PROXY_TRANSPORT.equalsIgnoreCase(sp.getType())) {
+ serviceProxy = sp;
+ break;
+ }
+ }
+ if (serviceProxy == null) {
+ throw new ServiceProxyNotFoundException("Transport Service Proxy not found for service instance: "
+ + serviceInstance.getServiceInstanceId());
+ }
+ return serviceProxy;
+ }
+
+
+}
--- /dev/null
+package org.onap.so.bpmn.servicedecomposition.bbobjects.wrappers.exceptions;
+
+public class ServiceProxyNotFoundException extends Exception {
+
+ private static final long serialVersionUID = 717577158109655720L;
+
+ public ServiceProxyNotFoundException() {
+ super();
+ }
+
+ public ServiceProxyNotFoundException(String message) {
+ super(message);
+ }
+}
private List<Candidate> excludedCandidates = new ArrayList<Candidate>();
@JsonProperty("existingCandidates")
private List<Candidate> existingCandidates = new ArrayList<Candidate>();
+ @JsonProperty("filteringAttributes")
+ private List<Candidate> filteringAttributes = new ArrayList<Candidate>();
public List<Candidate> getRequiredCandidates() {
return existingCandidates;
}
-
+ public List<Candidate> getFilteringAttributes() {
+ return filteringAttributes;
+ }
}
private String environmentContext;
@JsonProperty("workload-context")
private String workloadContext;
+ @JsonProperty("naming-policy")
+ private String namingPolicy;
+ @JsonProperty("onap-generated-naming")
+ private Boolean onapGeneratedNaming;
public String getDescription() {
public void setWorkloadContext(String workloadContext) {
this.workloadContext = workloadContext;
}
+
+
+ public String getNamingPolicy() {
+ return namingPolicy;
+ }
+
+ public void setNamingPolicy(String namingPolicy) {
+ this.namingPolicy = namingPolicy;
+ }
+
+ public Boolean getOnapGeneratedNaming() {
+ return onapGeneratedNaming;
+ }
+
+ public void setOnapGeneratedNaming(Boolean onapGeneratedNaming) {
+ this.onapGeneratedNaming = onapGeneratedNaming;
+ }
}
import java.io.Serializable;
+import com.fasterxml.jackson.annotation.JsonProperty;
public class ModelInfoServiceProxy extends ModelInfoMetadata implements Serializable {
private static final long serialVersionUID = -6256897576261215926L;
+ @JsonProperty("tosca-node-type")
+ private String toscaNodeType;
+ @JsonProperty("description")
+ private String description;
+ public String getToscaNodeType() {
+ return toscaNodeType;
+ }
+
+ public void setToscaNodeType(String toscaNodeType) {
+ this.toscaNodeType = toscaNodeType;
+ }
+
+ public String getDescription() {
+ return description;
+ }
+
+ public void setDescription(String description) {
+ this.description = description;
+ }
}
NETWORK_MACRO("AssignNetworkBB"),
VOLUME_GROUP("AssignVolumeGroupBB"),
NETWORK_COLLECTION("CreateNetworkCollectionBB"),
- FABRIC_CONFIGURATION("AssignFabricConfigurationBB");
+ FABRIC_CONFIGURATION("AssignFabricConfigurationBB"),
+ VRF_CONFIGURATION("AssignVrfConfigurationBBV2");
private final String flowName;
import org.onap.so.bpmn.servicedecomposition.bbobjects.Project;
import org.onap.so.bpmn.servicedecomposition.bbobjects.RouteTableReference;
import org.onap.so.bpmn.servicedecomposition.bbobjects.ServiceInstance;
+import org.onap.so.bpmn.servicedecomposition.bbobjects.ServiceProxy;
import org.onap.so.bpmn.servicedecomposition.bbobjects.ServiceSubscription;
import org.onap.so.bpmn.servicedecomposition.bbobjects.Tenant;
import org.onap.so.bpmn.servicedecomposition.bbobjects.VfModule;
import org.onap.so.bpmn.servicedecomposition.bbobjects.Vnfc;
import org.onap.so.bpmn.servicedecomposition.bbobjects.VolumeGroup;
+import org.onap.so.bpmn.servicedecomposition.bbobjects.VpnBinding;
import org.onap.so.bpmn.servicedecomposition.entities.ConfigurationResourceKeys;
import org.onap.so.bpmn.servicedecomposition.entities.ExecuteBuildingBlock;
import org.onap.so.bpmn.servicedecomposition.entities.GeneralBuildingBlock;
import org.onap.so.db.catalog.beans.NetworkResourceCustomization;
import org.onap.so.db.catalog.beans.OrchestrationStatus;
import org.onap.so.db.catalog.beans.Service;
+import org.onap.so.db.catalog.beans.ServiceProxyResourceCustomization;
import org.onap.so.db.catalog.beans.VfModuleCustomization;
import org.onap.so.db.catalog.beans.VnfResourceCustomization;
import org.onap.so.db.catalog.beans.VnfcInstanceGroupCustomization;
ModelInfo configurationModelInfo = new ModelInfo();
configurationModelInfo.setModelCustomizationUuid(configurationKey);
populateConfiguration(configurationModelInfo, service, bbName, serviceInstance, lookupKeyMap,
- configurationId, instanceName, configurationResourceKeys);
+ configurationId, instanceName, configurationResourceKeys, requestDetails);
} else {
lookupKeyMap.put(ResourceKey.VF_MODULE_ID, resourceId);
this.populateVfModule(modelInfo, service, bbName, serviceInstance, lookupKeyMap, resourceId,
protected void populateConfiguration(ModelInfo modelInfo, Service service, String bbName,
ServiceInstance serviceInstance, Map<ResourceKey, String> lookupKeyMap, String resourceId,
- String instanceName, ConfigurationResourceKeys configurationResourceKeys) {
+ String instanceName, ConfigurationResourceKeys configurationResourceKeys, RequestDetails requestDetails) {
Configuration configuration = null;
for (Configuration configurationTemp : serviceInstance.getConfigurations()) {
if (lookupKeyMap.get(ResourceKey.CONFIGURATION_ID) != null && configurationTemp.getConfigurationId()
}
}
}
- if (configuration == null && bbName.equalsIgnoreCase(AssignFlows.FABRIC_CONFIGURATION.toString())) {
+ if (configuration == null && (bbName.equalsIgnoreCase(AssignFlows.FABRIC_CONFIGURATION.toString())
+ || bbName.equalsIgnoreCase(AssignFlows.VRF_CONFIGURATION.toString()))) {
configuration = this.createConfiguration(lookupKeyMap, instanceName, resourceId);
serviceInstance.getConfigurations().add(configuration);
}
- if (configuration != null) {
+ if (configuration != null && bbName.contains("Fabric")) {
Vnfc vnfc = getVnfcToConfiguration(configurationResourceKeys.getVnfcName());
configuration.setVnfc(vnfc);
this.mapCatalogConfiguration(configuration, modelInfo, service, configurationResourceKeys);
+ } else if (configuration != null && bbName.contains("Vrf")) {
+ configuration.setModelInfoConfiguration(mapperLayer.mapCatalogConfigurationToConfiguration(
+ findConfigurationResourceCustomization(modelInfo, service), null));
+ configuration.setConfigurationType(configuration.getModelInfoConfiguration().getConfigurationType());
+ configuration.setConfigurationSubType(configuration.getModelInfoConfiguration().getConfigurationRole());
}
}
ModelInfo configurationModelInfo = new ModelInfo();
configurationModelInfo.setModelCustomizationUuid(key);
this.populateConfiguration(configurationModelInfo, service, bbName, serviceInstance, lookupKeyMap,
- configurationId, null, executeBB.getConfigurationResourceKeys());
+ configurationId, null, executeBB.getConfigurationResourceKeys(), executeBB.getRequestDetails());
}
if (executeBB.getWorkflowResourceIds() != null) {
this.populateNetworkCollectionAndInstanceGroupAssign(service, bbName, serviceInstance,
executeBB.getWorkflowResourceIds().getNetworkCollectionId(), key);
}
+ RelatedInstance relatedVpnBinding =
+ bbInputSetupUtils.getRelatedInstanceByType(executeBB.getRequestDetails(), ModelType.vpnBinding);
+ RelatedInstance relatedLocalNetwork =
+ bbInputSetupUtils.getRelatedInstanceByType(executeBB.getRequestDetails(), ModelType.network);
+ if (relatedVpnBinding != null && relatedLocalNetwork != null) {
+ org.onap.aai.domain.yang.VpnBinding aaiVpnBinding =
+ bbInputSetupUtils.getAAIVpnBinding(relatedVpnBinding.getInstanceId());
+ org.onap.aai.domain.yang.L3Network aaiLocalNetwork =
+ bbInputSetupUtils.getAAIL3Network(relatedLocalNetwork.getInstanceId());
+ VpnBinding vpnBinding = mapperLayer.mapAAIVpnBinding(aaiVpnBinding);
+ L3Network localNetwork = mapperLayer.mapAAIL3Network(aaiLocalNetwork);
+ Optional<org.onap.aai.domain.yang.VpnBinding> aaiAICVpnBindingOp =
+ bbInputSetupUtils.getAICVpnBindingFromNetwork(aaiLocalNetwork);
+ if (aaiAICVpnBindingOp.isPresent()) {
+ localNetwork.getVpnBindings().add(mapperLayer.mapAAIVpnBinding(aaiAICVpnBindingOp.get()));
+ }
+ ServiceProxy serviceProxy = getServiceProxy(service);
+ gBB.getServiceInstance().getServiceProxies().add(serviceProxy);
+ gBB.getCustomer().getVpnBindings().add(vpnBinding);
+ lookupKeyMap.put(ResourceKey.VPN_ID, vpnBinding.getVpnId());
+ gBB.getServiceInstance().getNetworks().add(localNetwork);
+ lookupKeyMap.put(ResourceKey.NETWORK_ID, localNetwork.getNetworkId());
+ }
return gBB;
}
+ protected ServiceProxy getServiceProxy(Service service) {
+ if (!service.getServiceProxyCustomizations().isEmpty()) {
+ ServiceProxyResourceCustomization serviceProxyCatalog = getServiceProxyResourceCustomization(service);
+ ServiceProxy serviceProxy = new ServiceProxy();
+ serviceProxy.setModelInfoServiceProxy(
+ mapperLayer.mapServiceProxyCustomizationToServiceProxy(serviceProxyCatalog));
+ Service sourceService = serviceProxyCatalog.getSourceService();
+ ServiceInstance sourceServiceShell = new ServiceInstance();
+ sourceServiceShell
+ .setModelInfoServiceInstance(mapperLayer.mapCatalogServiceIntoServiceInstance(sourceService));
+ serviceProxy.setServiceInstance(sourceServiceShell);
+ serviceProxy.setType(sourceService.getServiceType());
+ return serviceProxy;
+ } else {
+ return null;
+ }
+ }
+
+ protected ServiceProxyResourceCustomization getServiceProxyResourceCustomization(Service service) {
+ ServiceProxyResourceCustomization serviceProxyCatalog = null;
+ for (ServiceProxyResourceCustomization serviceProxyTemp : service.getServiceProxyCustomizations()) {
+ if (serviceProxyTemp.getSourceService() != null
+ && serviceProxyTemp.getSourceService().getServiceType().equalsIgnoreCase("TRANSPORT")) {
+ serviceProxyCatalog = serviceProxyTemp;
+ }
+ }
+ return serviceProxyCatalog;
+ }
+
protected L3Network getVirtualLinkL3Network(Map<ResourceKey, String> lookupKeyMap, String bbName, String key,
String networkId, CollectionNetworkResourceCustomization collectionNetworkResourceCust,
ServiceInstance serviceInstance) {
findConfigurationResourceCustomization(configurationModelInfo, service);
if (configurationCust != null) {
this.populateConfiguration(configurationModelInfo, service, bbName, serviceInstance, lookupKeyMap,
- configurationId, null, executeBB.getConfigurationResourceKeys());
+ configurationId, null, executeBB.getConfigurationResourceKeys(), executeBB.getRequestDetails());
} else {
logger.debug("Could not find a configuration customization with key: {}", key);
}
import org.onap.so.bpmn.servicedecomposition.bbobjects.Platform;
import org.onap.so.bpmn.servicedecomposition.bbobjects.Project;
import org.onap.so.bpmn.servicedecomposition.bbobjects.RouteTableReference;
+import org.onap.so.bpmn.servicedecomposition.bbobjects.RouteTarget;
import org.onap.so.bpmn.servicedecomposition.bbobjects.SegmentationAssignment;
import org.onap.so.bpmn.servicedecomposition.bbobjects.ServiceInstance;
import org.onap.so.bpmn.servicedecomposition.bbobjects.ServiceSubscription;
import org.onap.so.bpmn.servicedecomposition.bbobjects.VfModule;
import org.onap.so.bpmn.servicedecomposition.bbobjects.Vnfc;
import org.onap.so.bpmn.servicedecomposition.bbobjects.VolumeGroup;
+import org.onap.so.bpmn.servicedecomposition.bbobjects.VpnBinding;
import org.onap.so.bpmn.servicedecomposition.entities.ResourceKey;
import org.onap.so.bpmn.servicedecomposition.generalobjects.License;
import org.onap.so.bpmn.servicedecomposition.generalobjects.OrchestrationContext;
import org.onap.so.bpmn.servicedecomposition.modelinfo.ModelInfoInstanceGroup;
import org.onap.so.bpmn.servicedecomposition.modelinfo.ModelInfoNetwork;
import org.onap.so.bpmn.servicedecomposition.modelinfo.ModelInfoServiceInstance;
+import org.onap.so.bpmn.servicedecomposition.modelinfo.ModelInfoServiceProxy;
import org.onap.so.bpmn.servicedecomposition.modelinfo.ModelInfoVfModule;
import org.onap.so.db.catalog.beans.CollectionNetworkResourceCustomization;
import org.onap.so.db.catalog.beans.CollectionResource;
import org.onap.so.db.catalog.beans.NetworkResourceCustomization;
import org.onap.so.db.catalog.beans.OrchestrationStatus;
import org.onap.so.db.catalog.beans.Service;
+import org.onap.so.db.catalog.beans.ServiceProxyResourceCustomization;
import org.onap.so.db.catalog.beans.VfModuleCustomization;
import org.onap.so.db.catalog.beans.VnfResourceCustomization;
import org.onap.so.serviceinstancebeans.CloudConfiguration;
protected ModelInfoConfiguration mapCatalogConfigurationToConfiguration(
ConfigurationResourceCustomization configurationResourceCustomization,
CvnfcConfigurationCustomization cvnfcConfigurationCustomization) {
+
ModelInfoConfiguration modelInfoConfiguration = new ModelInfoConfiguration();
modelInfoConfiguration
.setModelVersionId(configurationResourceCustomization.getConfigurationResource().getModelUUID());
modelInfoConfiguration.setModelCustomizationId(configurationResourceCustomization.getModelCustomizationUUID());
modelInfoConfiguration.setModelInvariantId(
configurationResourceCustomization.getConfigurationResource().getModelInvariantUUID());
- modelInfoConfiguration.setPolicyName(cvnfcConfigurationCustomization.getPolicyName());
+ modelInfoConfiguration.setConfigurationRole(configurationResourceCustomization.getRole());
+ modelInfoConfiguration.setConfigurationType(configurationResourceCustomization.getType());
+ if (cvnfcConfigurationCustomization != null) {
+ modelInfoConfiguration.setPolicyName(cvnfcConfigurationCustomization.getPolicyName());
+ }
return modelInfoConfiguration;
}
public Vnfc mapAAIVnfc(org.onap.aai.domain.yang.Vnfc vnfcAAI) {
return modelMapper.map(vnfcAAI, Vnfc.class);
}
+
+ public VpnBinding mapAAIVpnBinding(org.onap.aai.domain.yang.VpnBinding aaiVpnBinding) {
+ VpnBinding vpnBinding = modelMapper.map(aaiVpnBinding, VpnBinding.class);
+ mapAllRouteTargetsToAAIVpnBinding(aaiVpnBinding, vpnBinding);
+ return vpnBinding;
+ }
+
+ protected void mapAllRouteTargetsToAAIVpnBinding(org.onap.aai.domain.yang.VpnBinding aaiVpnBinding,
+ VpnBinding vpnBinding) {
+ if (aaiVpnBinding.getRouteTargets() != null) {
+ for (org.onap.aai.domain.yang.RouteTarget aaiRouteTarget : aaiVpnBinding.getRouteTargets()
+ .getRouteTarget()) {
+ vpnBinding.getRouteTargets().add(mapAAIRouteTarget(aaiRouteTarget));
+ }
+ }
+ }
+
+ public RouteTarget mapAAIRouteTarget(org.onap.aai.domain.yang.RouteTarget aaiRouteTarget) {
+ return modelMapper.map(aaiRouteTarget, RouteTarget.class);
+ }
+
+ protected ModelInfoServiceProxy mapServiceProxyCustomizationToServiceProxy(
+ ServiceProxyResourceCustomization serviceProxyCustomization) {
+ return modelMapper.map(serviceProxyCustomization, ModelInfoServiceProxy.class);
+ }
}
import org.onap.aai.domain.yang.VfModule;
import org.onap.aai.domain.yang.VolumeGroup;
import org.onap.aai.domain.yang.VolumeGroups;
+import org.onap.aai.domain.yang.VpnBinding;
import org.onap.so.bpmn.common.InjectionHelper;
import org.onap.so.bpmn.servicedecomposition.bbobjects.Customer;
import org.onap.so.bpmn.servicedecomposition.tasks.exceptions.MultipleObjectsFoundException;
import org.onap.so.db.request.beans.InfraActiveRequests;
import org.onap.so.db.request.client.RequestsDbClient;
import org.onap.so.serviceinstancebeans.CloudConfiguration;
+import org.onap.so.serviceinstancebeans.ModelType;
+import org.onap.so.serviceinstancebeans.RelatedInstance;
+import org.onap.so.serviceinstancebeans.RelatedInstanceList;
import org.onap.so.serviceinstancebeans.RequestDetails;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@Autowired
protected InjectionHelper injectionHelper;
+ public RelatedInstance getRelatedInstanceByType(RequestDetails requestDetails, ModelType modelType) {
+ if (requestDetails.getRelatedInstanceList() != null) {
+ for (RelatedInstanceList relatedInstanceList : requestDetails.getRelatedInstanceList()) {
+ RelatedInstance relatedInstance = relatedInstanceList.getRelatedInstance();
+ if (relatedInstance != null && relatedInstance.getModelInfo() != null
+ && relatedInstance.getModelInfo().getModelType() != null
+ && relatedInstance.getModelInfo().getModelType().equals(modelType)) {
+ return relatedInstance;
+ }
+ }
+ }
+ return null;
+ }
+
public void updateInfraActiveRequestVnfId(InfraActiveRequests request, String vnfId) {
if (request != null) {
request.setVnfId(vnfId);
});
}
+ public VpnBinding getAAIVpnBinding(String vpnBindingId) {
+
+ return this.injectionHelper.getAaiClient()
+ .get(VpnBinding.class,
+ AAIUriFactory.createResourceUri(AAIObjectType.VPN_BINDING, vpnBindingId).depth(Depth.ONE))
+ .orElseGet(() -> {
+ logger.debug("No VpnBinding matched by id");
+ return null;
+ });
+ }
+
public VolumeGroup getAAIVolumeGroup(String cloudOwnerId, String cloudRegionId, String volumeGroupId) {
return this.injectionHelper.getAaiClient()
.get(VolumeGroup.class, AAIUriFactory
return Optional.of(volumeGroup);
}
}
+
+ public Optional<org.onap.aai.domain.yang.VpnBinding> getAICVpnBindingFromNetwork(
+ org.onap.aai.domain.yang.L3Network aaiLocalNetwork) {
+ AAIResultWrapper networkWrapper = new AAIResultWrapper(aaiLocalNetwork);
+ if (networkWrapper.getRelationships().isPresent()
+ && !networkWrapper.getRelationships().get().getRelatedUris(AAIObjectType.VPN_BINDING).isEmpty()) {
+ return getAAIResourceDepthOne(
+ networkWrapper.getRelationships().get().getRelatedUris(AAIObjectType.VPN_BINDING).get(0))
+ .asBean(org.onap.aai.domain.yang.VpnBinding.class);
+ }
+ return Optional.empty();
+ }
}
modelInfoConfiguration.setModelCustomizationId("testModelCustomizationId" + configurationCounter);
configuration.setModelInfoConfiguration(modelInfoConfiguration);
+ configuration.setVpnBinding(buildVpnBinding());
return configuration;
}
--- /dev/null
+package org.onap.so.bpmn.servicedecomposition.bbobjects.wrappers;
+
+import static org.junit.Assert.assertEquals;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+import org.onap.so.bpmn.servicedecomposition.bbobjects.ServiceInstance;
+import org.onap.so.bpmn.servicedecomposition.bbobjects.ServiceProxy;
+import org.onap.so.bpmn.servicedecomposition.bbobjects.wrappers.exceptions.ServiceProxyNotFoundException;
+
+public class ServiceInstanceWrapperTest {
+
+ @Rule
+ public ExpectedException expectedException = ExpectedException.none();
+
+ @Test
+ public void getTransportServiceProxyTest() throws ServiceProxyNotFoundException {
+ ServiceInstance si = buildServiceInstance();
+ si.getServiceProxies().add(buildServiceProxy());
+ ServiceInstanceWrapper sw = new ServiceInstanceWrapper(si);
+ ServiceProxy sp = sw.getTransportServiceProxy();
+ assertEquals("sp-001", sp.getId());
+ assertEquals("transport", sp.getType());
+ }
+
+ @Test
+ public void getTransportServiceProxyExceptionTest() throws ServiceProxyNotFoundException {
+ expectedException.expect(ServiceProxyNotFoundException.class);
+ ServiceInstanceWrapper sw = new ServiceInstanceWrapper(buildServiceInstance());
+ sw.getTransportServiceProxy();
+ }
+
+ private ServiceInstance buildServiceInstance() {
+ ServiceInstance si = new ServiceInstance();
+ si.setServiceInstanceId("si-001");
+ si.setServiceInstanceName("Test SI");
+ return si;
+ }
+
+ private ServiceProxy buildServiceProxy() {
+ ServiceProxy sp = new ServiceProxy();
+ sp.setId("sp-001");
+ sp.setType("transport");
+ return sp;
+ }
+
+}
import org.onap.so.bpmn.servicedecomposition.bbobjects.Project;
import org.onap.so.bpmn.servicedecomposition.bbobjects.RouteTableReference;
import org.onap.so.bpmn.servicedecomposition.bbobjects.ServiceInstance;
+import org.onap.so.bpmn.servicedecomposition.bbobjects.ServiceProxy;
import org.onap.so.bpmn.servicedecomposition.bbobjects.ServiceSubscription;
import org.onap.so.bpmn.servicedecomposition.bbobjects.VfModule;
import org.onap.so.bpmn.servicedecomposition.bbobjects.Vnfc;
import org.onap.so.bpmn.servicedecomposition.modelinfo.ModelInfoInstanceGroup;
import org.onap.so.bpmn.servicedecomposition.modelinfo.ModelInfoNetwork;
import org.onap.so.bpmn.servicedecomposition.modelinfo.ModelInfoServiceInstance;
+import org.onap.so.bpmn.servicedecomposition.modelinfo.ModelInfoServiceProxy;
import org.onap.so.bpmn.servicedecomposition.modelinfo.ModelInfoVfModule;
import org.onap.so.client.aai.AAICommonObjectMapperProvider;
import org.onap.so.client.aai.AAIObjectType;
import org.onap.so.db.catalog.beans.CollectionResourceInstanceGroupCustomization;
import org.onap.so.db.catalog.beans.ConfigurationResource;
import org.onap.so.db.catalog.beans.ConfigurationResourceCustomization;
+import org.onap.so.db.catalog.beans.CvnfcConfigurationCustomization;
import org.onap.so.db.catalog.beans.InstanceGroupType;
import org.onap.so.db.catalog.beans.NetworkCollectionResourceCustomization;
import org.onap.so.db.catalog.beans.NetworkResourceCustomization;
import org.onap.so.db.catalog.beans.OrchestrationStatus;
import org.onap.so.db.catalog.beans.Service;
+import org.onap.so.db.catalog.beans.ServiceProxyResourceCustomization;
import org.onap.so.db.catalog.beans.VfModuleCustomization;
import org.onap.so.db.catalog.beans.VnfResourceCustomization;
-import org.onap.so.db.catalog.beans.CvnfcConfigurationCustomization;
import org.onap.so.db.catalog.beans.VnfcInstanceGroupCustomization;
import org.onap.so.db.request.beans.InfraActiveRequests;
import org.onap.so.serviceinstancebeans.CloudConfiguration;
configResourceKeys.setVnfcName(vnfcName);
Vnfc vnfc = new Vnfc();
vnfc.setVnfcName(vnfcName);
-
+ RequestDetails requestDetails = new RequestDetails();
doNothing().when(SPY_bbInputSetup).mapCatalogConfiguration(configuration, modelInfo, service,
configResourceKeys);
doReturn(vnfc).when(SPY_bbInputSetup).getVnfcToConfiguration(vnfcName);
SPY_bbInputSetup.populateConfiguration(modelInfo, service, bbName, serviceInstance, lookupKeyMap, resourceId,
- instanceName, configResourceKeys);
+ instanceName, configResourceKeys, requestDetails);
verify(SPY_bbInputSetup, times(1)).mapCatalogConfiguration(configuration, modelInfo, service,
configResourceKeys);
lookupKeyMap.put(ResourceKey.CONFIGURATION_ID, null);
SPY_bbInputSetup.populateConfiguration(modelInfo, service, bbName, serviceInstance, lookupKeyMap, resourceId,
- instanceName, configResourceKeys);
+ instanceName, configResourceKeys, requestDetails);
verify(SPY_bbInputSetup, times(2)).mapCatalogConfiguration(configuration, modelInfo, service,
configResourceKeys);
doNothing().when(SPY_bbInputSetup).mapCatalogConfiguration(configuration2, modelInfo, service,
configResourceKeys);
SPY_bbInputSetup.populateConfiguration(modelInfo, service, bbName, serviceInstance, lookupKeyMap, resourceId,
- instanceName, configResourceKeys);
+ instanceName, configResourceKeys, requestDetails);
verify(SPY_bbInputSetup, times(1)).mapCatalogConfiguration(configuration2, modelInfo, service,
configResourceKeys);
}
configResourceKeys.setVnfcName(vnfcName);
Vnfc vnfc = new Vnfc();
vnfc.setVnfcName(vnfcName);
+ RequestDetails requestDetails = new RequestDetails();
CvnfcConfigurationCustomization vnfVfmoduleCvnfcConfigurationCustomization =
new CvnfcConfigurationCustomization();
doReturn(vnfc).when(SPY_bbInputSetup).getVnfcToConfiguration(vnfcName);
SPY_bbInputSetup.populateConfiguration(modelInfo, service, bbName, serviceInstance, lookupKeyMap, resourceId,
- instanceName, configResourceKeys);
+ instanceName, configResourceKeys, requestDetails);
verify(SPY_bbInputSetup, times(1)).mapCatalogConfiguration(configuration, modelInfo, service,
configResourceKeys);
}
configurationCustList.add(configurationCust);
doNothing().when(SPY_bbInputSetup).populateConfiguration(isA(ModelInfo.class), isA(Service.class),
any(String.class), isA(ServiceInstance.class), any(), any(String.class), ArgumentMatchers.isNull(),
- isA(ConfigurationResourceKeys.class));
+ isA(ConfigurationResourceKeys.class), isA(RequestDetails.class));
executeBB.getBuildingBlock().setBpmnFlowName("AssignFabricConfigurationBB");
executeBB.getBuildingBlock().setKey("72d9d1cd-f46d-447a-abdb-451d6fb05fa9");
SPY_bbInputSetup.getGBBMacro(executeBB, requestDetails, lookupKeyMap, requestAction, resourceId, vnfType);
verify(SPY_bbInputSetup, times(1)).populateConfiguration(isA(ModelInfo.class), isA(Service.class),
any(String.class), isA(ServiceInstance.class), any(), any(String.class), ArgumentMatchers.isNull(),
- isA(ConfigurationResourceKeys.class));
+ isA(ConfigurationResourceKeys.class), isA(RequestDetails.class));
+
+
+ }
+
+ @Test
+ public void testGBBMacroNoUserParamsVrfConfiguration() throws Exception {
+ GeneralBuildingBlock gBB = mapper.readValue(new File(RESOURCE_PATH + "GeneralBuildingBlockExpected.json"),
+ GeneralBuildingBlock.class);
+ ExecuteBuildingBlock executeBB = mapper.readValue(new File(RESOURCE_PATH + "ExecuteBuildingBlockSimple.json"),
+ ExecuteBuildingBlock.class);
+ RequestDetails requestDetails = mapper
+ .readValue(new File(RESOURCE_PATH + "RequestDetailsInput_serviceMacroVrf.json"), RequestDetails.class);
+ InfraActiveRequests request = Mockito.mock(InfraActiveRequests.class);
+ Map<ResourceKey, String> lookupKeyMap = new HashMap<>();
+ lookupKeyMap.put(ResourceKey.SERVICE_INSTANCE_ID, "serviceInstanceId");
+ lookupKeyMap.put(ResourceKey.CONFIGURATION_ID, "configurationId");
+ String resourceId = "123";
+ String vnfType = "vnfType";
+ Service service = Mockito.mock(Service.class);
+ String requestAction = "createInstance";
+
+ ConfigurationResourceKeys configResourceKeys = new ConfigurationResourceKeys();
+ configResourceKeys.setCvnfcCustomizationUUID("cvnfcCustomizationUUID");
+ configResourceKeys.setVfModuleCustomizationUUID("vfModuleCustomizationUUID");
+ configResourceKeys.setVnfResourceCustomizationUUID("vnfResourceCustomizationUUID");
+ executeBB.setConfigurationResourceKeys(configResourceKeys);
+
+ executeBB.setRequestDetails(requestDetails);
+ doReturn(gBB).when(SPY_bbInputSetup).getGBBALaCarteService(executeBB, requestDetails, lookupKeyMap,
+ requestAction, lookupKeyMap.get(ResourceKey.SERVICE_INSTANCE_ID));
+ doReturn(service).when(SPY_bbInputSetupUtils)
+ .getCatalogServiceByModelUUID(gBB.getServiceInstance().getModelInfoServiceInstance().getModelUuid());
+
+ RelatedInstance relatedVpnBinding = new RelatedInstance();
+ relatedVpnBinding.setInstanceId("vpnBindingInstanceId");
+ RelatedInstance relatedLocalNetwork = new RelatedInstance();
+ relatedLocalNetwork.setInstanceId("localNetworkInstanceId");
+ org.onap.aai.domain.yang.VpnBinding aaiVpnBinding = new org.onap.aai.domain.yang.VpnBinding();
+ aaiVpnBinding.setVpnId("vpnBindingId");
+ org.onap.aai.domain.yang.L3Network aaiLocalNetwork = new org.onap.aai.domain.yang.L3Network();
+ aaiLocalNetwork.setNetworkId("localNetworkId");
+ Optional<org.onap.aai.domain.yang.VpnBinding> aaiAICVpnBindingOp =
+ Optional.of(new org.onap.aai.domain.yang.VpnBinding());
+ aaiAICVpnBindingOp.get().setVpnId("AICVpnBindingId");
+ ServiceProxy proxy = new ServiceProxy();
+ proxy.setType("transport");
+ proxy.setServiceInstance(new ServiceInstance());
+ proxy.getServiceInstance().setModelInfoServiceInstance(new ModelInfoServiceInstance());
+ proxy.getServiceInstance().getModelInfoServiceInstance().setModelUuid("sourceServiceModelUUID");
+ doReturn(relatedVpnBinding).when(SPY_bbInputSetupUtils).getRelatedInstanceByType(requestDetails,
+ ModelType.vpnBinding);
+ doReturn(relatedLocalNetwork).when(SPY_bbInputSetupUtils).getRelatedInstanceByType(requestDetails,
+ ModelType.network);
+ doReturn(aaiVpnBinding).when(SPY_bbInputSetupUtils).getAAIVpnBinding(relatedVpnBinding.getInstanceId());
+ doReturn(aaiLocalNetwork).when(SPY_bbInputSetupUtils).getAAIL3Network(relatedLocalNetwork.getInstanceId());
+ doReturn(aaiAICVpnBindingOp).when(SPY_bbInputSetupUtils).getAICVpnBindingFromNetwork(aaiLocalNetwork);
+ doReturn(proxy).when(SPY_bbInputSetup).getServiceProxy(service);
+
+ Configuration configuration = new Configuration();
+ configuration.setConfigurationId("configurationId");
+ gBB.getServiceInstance().getConfigurations().add(configuration);
+ List<ConfigurationResourceCustomization> configurationCustList = new ArrayList<>();
+ ConfigurationResourceCustomization configurationCust = new ConfigurationResourceCustomization();
+ configurationCust.setModelCustomizationUUID("72d9d1cd-f46d-447a-abdb-451d6fb05fa9");
+ configurationCustList.add(configurationCust);
+ doNothing().when(SPY_bbInputSetup).populateConfiguration(isA(ModelInfo.class), isA(Service.class),
+ any(String.class), isA(ServiceInstance.class), any(), any(String.class), ArgumentMatchers.isNull(),
+ isA(ConfigurationResourceKeys.class), isA(RequestDetails.class));
+
+ executeBB.getBuildingBlock().setBpmnFlowName("AssignVrfConfigurationBB");
+ executeBB.getBuildingBlock().setKey("72d9d1cd-f46d-447a-abdb-451d6fb05fa9");
+ gBB = SPY_bbInputSetup.getGBBMacro(executeBB, requestDetails, lookupKeyMap, requestAction, resourceId, vnfType);
+ verify(SPY_bbInputSetup, times(1)).populateConfiguration(isA(ModelInfo.class), isA(Service.class),
+ any(String.class), isA(ServiceInstance.class), any(), any(String.class), ArgumentMatchers.isNull(),
+ isA(ConfigurationResourceKeys.class), isA(RequestDetails.class));
+ assertEquals(gBB.getCustomer().getVpnBindings().get(0).getVpnId(), "vpnBindingId");
+ assertEquals(gBB.getServiceInstance().getNetworks().get(0).getNetworkId(), "localNetworkId");
+ assertEquals(gBB.getServiceInstance().getNetworks().get(0).getVpnBindings().get(0).getVpnId(),
+ "AICVpnBindingId");
+ assertEquals(gBB.getServiceInstance().getServiceProxies().get(0).getType(), "transport");
+ }
+
+ @Test
+ public void testGetServiceProxy() {
+ ServiceProxy expected = new ServiceProxy();
+ expected.setType("TRANSPORT");
+ expected.setModelInfoServiceProxy(new ModelInfoServiceProxy());
+ expected.getModelInfoServiceProxy().setModelCustomizationUuid("modelCustomizationUUID");
+ expected.setServiceInstance(new ServiceInstance());
+ expected.getServiceInstance().setModelInfoServiceInstance(new ModelInfoServiceInstance());
+ expected.getServiceInstance().getModelInfoServiceInstance().setModelUuid("modelUUID");
+ expected.getServiceInstance().getModelInfoServiceInstance().setServiceType("TRANSPORT");
+ Service service = new Service();
+ ServiceProxyResourceCustomization serviceProxyCatalog = new ServiceProxyResourceCustomization();
+ serviceProxyCatalog.setModelCustomizationUUID("modelCustomizationUUID");
+ Service sourceService = new Service();
+ sourceService.setModelUUID("modelUUID");
+ sourceService.setServiceType("TRANSPORT");
+ serviceProxyCatalog.setSourceService(sourceService);
+ service.setServiceProxyCustomizations(new ArrayList<ServiceProxyResourceCustomization>());
+ service.getServiceProxyCustomizations().add(serviceProxyCatalog);
+ ServiceProxy actual = SPY_bbInputSetup.getServiceProxy(service);
+ assertThat(actual, sameBeanAs(expected));
}
@Test
"modelType": "service",
"modelInvariantId": "5d48acb5-097d-4982-aeb2-f4a3bd87d31b",
"modelVersionId": "3c40d244-808e-42ca-b09a-256d83d19d0a",
- "modelName": "MOW AVPN vMX BV vPE 1 Service",
+ "modelName": "Sample Service Model",
"modelVersion": "10.0"
},
"owningEntity": {
"service": {
"modelInfo": {
"modelType": "service",
- "modelName": "MOW AVPN vMX BV vPE 1 Service",
+ "modelName": "Sample Service Model",
"modelVersionId": "3c40d244-808e-42ca-b09a-256d83d19d0a"
},
"instanceName": "vPE_Service",
--- /dev/null
+{
+ "modelInfo": {
+ "modelType": "service",
+ "modelInvariantId": "5d48acb5-097d-4982-aeb2-f4a3bd87d31b",
+ "modelVersionId": "3c40d244-808e-42ca-b09a-256d83d19d0a",
+ "modelName": "Sample Service Model",
+ "modelVersion": "10.0"
+ },
+ "owningEntity": {
+ "owningEntityId": "038d99af-0427-42c2-9d15-971b99b9b489",
+ "owningEntityName": "PACKET CORE"
+ },
+ "project": {
+ "projectName": "projectName"
+ },
+ "subscriberInfo": {
+ "globalSubscriberId": "subscriberId"
+ },
+ "requestInfo": {
+ "instanceName": "vPE_Service",
+ "productFamilyId": "a9a77d5a-123e-4ca2-9eb9-0b015d2ee0fb",
+ "source": "VID",
+ "suppressRollback": true,
+ "requestorId": "xxxxxx"
+ },
+ "requestParameters": {
+ "subscriptionServiceType": "VMX",
+ "aLaCarte": false
+ },
+ "relatedInstanceList": [
+ {
+ "relatedInstance": {
+ "instanceId": "vpnBindingId",
+ "modelInfo": {
+ "modelType": "vpnBinding"
+ }
+ }
+ },
+ {
+ "relatedInstance": {
+ "instanceId": "localNetworkId",
+ "modelInfo": {
+ "modelType": "network"
+ }
+ }
+ }
+ ]
+}
{
"modelInfo": {
"modelType": "service",
- "modelName": "MOW AVPN vMX BV vPE 1 Service",
+ "modelName": "Sample Service Model",
"modelVersionId": "3c40d244-808e-42ca-b09a-256d83d19d0a"
},
"instanceName": "vPE_Service",
{
"modelInfo": {
"modelType": "service",
- "modelName": "MOW AVPN vMX BV vPE 1 Service",
+ "modelName": "Sample Service Model",
"modelVersionId": "3c40d244-808e-42ca-b09a-256d83d19d0a"
},
"instanceName": "vPE_Service",
{
"modelInfo": {
"modelType": "service",
- "modelName": "MOW AVPN vMX BV vPE 1 Service",
+ "modelName": "Sample Service Model",
"modelVersionId": "3c40d244-808e-42ca-b09a-256d83d19d0a"
},
"instanceName": "vPE_Service",
{
"modelInfo": {
"modelType": "service",
- "modelName": "MOW AVPN vMX BV vPE 1 Service",
+ "modelName": "Sample Service Model",
"modelVersionId": "3c40d244-808e-42ca-b09a-256d83d19d0a"
},
"instanceName": "vPE_Service",
"modelType": "service",
"modelInvariantId": "5d48acb5-097d-4982-aeb2-f4a3bd87d31b",
"modelVersionId": "3c40d244-808e-42ca-b09a-256d83d19d0a",
- "modelName": "MOW AVPN vMX BV vPE 1 Service",
+ "modelName": "Sample Service Model",
"modelVersion": "10"
},
"cloudConfiguration": {
{
"service": {
"modelInfo": {
- "modelName": "MOW AVPN vMX BV vPE 1 Service",
+ "modelName": "Sample Service Model",
"modelVersionId": "3c40d244-808e-42ca-b09a-256d83d19d0a"
},
"instanceParams": [],
"modelType": "service",
"modelInvariantId": "5d48acb5-097d-4982-aeb2-f4a3bd87d31b",
"modelVersionId": "3c40d244-808e-42ca-b09a-256d83d19d0a",
- "modelName": "MOW AVPN vMX BV vPE 1 Service",
+ "modelName": "Sample Service Model",
"modelVersion": "10.0"
},
"owningEntity": {
"service": {
"modelInfo": {
"modelType": "service",
- "modelName": "MOW AVPN vMX BV vPE 1 Service",
+ "modelName": "Sample Service Model",
"modelVersionId": "3c40d244-808e-42ca-b09a-256d83d19d0a"
},
"instanceParams": [],
"modelType": "service",
"modelInvariantId": "5d48acb5-097d-4982-aeb2-f4a3bd87d31b",
"modelVersionId": "3c40d244-808e-42ca-b09a-256d83d19d0a",
- "modelName": "MOW AVPN vMX BV vPE 1 Service",
+ "modelName": "Sample Service Model",
"modelVersion": "10"
},
"cloudConfiguration": {
{
"service": {
"modelInfo": {
- "modelName": "MOW AVPN vMX BV vPE 1 Service",
+ "modelName": "Sample Service Model",
"modelVersionId": "3c40d244-808e-42ca-b09a-256d83d19d0a"
},
"instanceParams": [],
"modelType": "service",
"modelInvariantId": "5d48acb5-097d-4982-aeb2-f4a3bd87d31b",
"modelVersionId": "3c40d244-808e-42ca-b09a-256d83d19d0a",
- "modelName": "MOW AVPN vMX BV vPE 1 Service",
+ "modelName": "Sample Service Model",
"modelVersion": "10.0"
},
"owningEntity": {
"service": {
"modelInfo": {
"modelType": "service",
- "modelName": "MOW AVPN vMX BV vPE 1 Service",
+ "modelName": "Sample Service Model",
"modelVersionId": "3c40d244-808e-42ca-b09a-256d83d19d0a"
},
"instanceParams": [],
logger.trace("Started Sniro Homing Process Solution");
try {
// TODO improve handling multiple solutions but is dependent on sniro enhancing api + work with sniro
- // conductor to improve "inventoryType" representation
validateSolution(asyncResponse);
ServiceInstance serviceInstance = execution.getGeneralBuildingBlock().getCustomer().getServiceSubscription()
.getServiceInstances().get(0);
}
/**
- * Adds required, excluded, and existing candidates to a demand
+ * Adds required, excluded, and existing candidates as well as filtering attributes to a demand
*
*/
private void addCandidates(SolutionCandidates candidates, Demand demand) {
List<Candidate> required = candidates.getRequiredCandidates();
List<Candidate> excluded = candidates.getExcludedCandidates();
List<Candidate> existing = candidates.getExistingCandidates();
+ List<Candidate> filtering = candidates.getFilteringAttributes();
List<org.onap.so.client.sniro.beans.Candidate> candidateList = getCandidates(required);
if (!candidateList.isEmpty()) {
if (!candidateList.isEmpty()) {
demand.setExistingCandidates(candidateList);
}
+
+ candidateList = getCandidates(filtering);
+ if (!candidateList.isEmpty()) {
+ demand.setFilteringAttributes(candidateList);
+ }
}
private List<org.onap.so.client.sniro.beans.Candidate> getCandidates(List<Candidate> candidates) {
package org.onap.so.bpmn.infrastructure.namingservice.tasks;
+import java.util.List;
+import java.util.Optional;
+import org.onap.aai.domain.yang.Zone;
import org.onap.so.bpmn.common.BuildingBlockExecution;
+import org.onap.so.bpmn.common.InjectionHelper;
+import org.onap.so.bpmn.servicedecomposition.bbobjects.Configuration;
import org.onap.so.bpmn.servicedecomposition.bbobjects.InstanceGroup;
+import org.onap.so.bpmn.servicedecomposition.bbobjects.L3Network;
+import org.onap.so.bpmn.servicedecomposition.bbobjects.ServiceInstance;
+import org.onap.so.bpmn.servicedecomposition.bbobjects.VpnBinding;
+import org.onap.so.bpmn.servicedecomposition.entities.GeneralBuildingBlock;
import org.onap.so.bpmn.servicedecomposition.entities.ResourceKey;
+import org.onap.so.bpmn.servicedecomposition.tasks.BBInputSetupUtils;
import org.onap.so.bpmn.servicedecomposition.tasks.ExtractPojosForBB;
+import org.onap.so.client.aai.AAIObjectType;
+import org.onap.so.client.aai.entities.AAIResultWrapper;
+import org.onap.so.client.aai.entities.Relationships;
+import org.onap.so.client.aai.entities.uri.AAIResourceUri;
+import org.onap.so.client.aai.entities.uri.AAIUriFactory;
import org.onap.so.client.exception.ExceptionBuilder;
+import org.onap.so.client.namingservice.NamingRequestObject;
+import org.onap.so.client.namingservice.NamingServiceConstants;
import org.onap.so.client.orchestration.NamingServiceResources;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
@Autowired
private NamingServiceResources namingServiceResources;
+ @Autowired
+ protected InjectionHelper injectionHelper;
+ @Autowired
+ protected BBInputSetupUtils bbInputSetupUtils;
+
+ public void setBbInputSetupUtils(BBInputSetupUtils bbInputSetupUtils) {
+ this.bbInputSetupUtils = bbInputSetupUtils;
+ }
public void createInstanceGroupName(BuildingBlockExecution execution) throws Exception {
InstanceGroup instanceGroup = extractPojosForBB.extractByKey(execution, ResourceKey.INSTANCE_GROUP_ID);
}
instanceGroup.setInstanceGroupName(generatedInstanceGroupName);
}
+
+ public void createWanTransportServiceName(BuildingBlockExecution execution) throws Exception {
+ ServiceInstance serviceInstance = extractPojosForBB.extractByKey(execution, ResourceKey.SERVICE_INSTANCE_ID);
+ NamingRequestObject namingRequestObject = new NamingRequestObject();
+ namingRequestObject.setExternalKeyValue(serviceInstance.getServiceInstanceId());
+ namingRequestObject.setNamingTypeValue(NamingServiceConstants.NAMING_TYPE_SERVICE);
+ namingRequestObject.setResourceNameValue(NamingServiceConstants.RESOURCE_NAME_SERVICE_INSTANCE_NAME);
+ namingRequestObject.setPolicyInstanceNameValue(serviceInstance.getModelInfoServiceInstance().getNamingPolicy());
+ namingRequestObject.setServiceModelNameValue(serviceInstance.getModelInfoServiceInstance().getModelName());
+ namingRequestObject.setModelVersionValue(serviceInstance.getModelInfoServiceInstance().getModelVersion());
+ namingRequestObject.setZoneIdValue(this.getRelatedZoneId(execution));
+
+ String generatedWanTransportServiceName = "";
+ try {
+ generatedWanTransportServiceName = namingServiceResources.generateServiceInstanceName(namingRequestObject);
+ } catch (Exception ex) {
+ exceptionUtil.buildAndThrowWorkflowException(execution, 7000, ex);
+ }
+ serviceInstance.setServiceInstanceName(generatedWanTransportServiceName);
+ }
+
+ public void createVpnBondingServiceName(BuildingBlockExecution execution) throws Exception {
+ ServiceInstance serviceInstance = extractPojosForBB.extractByKey(execution, ResourceKey.SERVICE_INSTANCE_ID);
+ L3Network network = extractPojosForBB.extractByKey(execution, ResourceKey.NETWORK_ID);
+ VpnBinding vpnBinding = extractPojosForBB.extractByKey(execution, ResourceKey.VPN_ID);
+ NamingRequestObject namingRequestObject = new NamingRequestObject();
+ namingRequestObject.setExternalKeyValue(serviceInstance.getServiceInstanceId());
+ namingRequestObject.setPolicyInstanceNameValue(serviceInstance.getModelInfoServiceInstance().getNamingPolicy());
+ namingRequestObject.setNamingTypeValue(NamingServiceConstants.NAMING_TYPE_SERVICE);
+ namingRequestObject.setServiceModelNameValue(serviceInstance.getModelInfoServiceInstance().getModelName());
+ namingRequestObject.setModelVersionValue(serviceInstance.getModelInfoServiceInstance().getModelVersion());
+ namingRequestObject.setNetworkNameValue(execution.getVariable(network.getNetworkName()));
+ namingRequestObject.setVpnNameValue(vpnBinding.getVpnName());
+ namingRequestObject.setResourceNameValue(NamingServiceConstants.RESOURCE_NAME_SERVICE_INSTANCE_NAME);
+
+ String generatedVpnBondingServiceName = "";
+ try {
+ generatedVpnBondingServiceName = namingServiceResources.generateServiceInstanceName(namingRequestObject);
+ } catch (Exception ex) {
+ exceptionUtil.buildAndThrowWorkflowException(execution, 7000, ex);
+ }
+ serviceInstance.setServiceInstanceName(generatedVpnBondingServiceName);
+ }
+
+ protected String getRelatedZoneId(BuildingBlockExecution execution) {
+ GeneralBuildingBlock gBBInput = execution.getGeneralBuildingBlock();
+ String cloudRegionId = gBBInput.getCloudRegion().getLcpCloudRegionId();
+ String cloudOwner = gBBInput.getCloudRegion().getCloudOwner();
+ AAIResourceUri uri = AAIUriFactory.createResourceUri(AAIObjectType.CLOUD_REGION, cloudOwner, cloudRegionId);
+ AAIResultWrapper vnfcResultsWrapper = bbInputSetupUtils.getAAIResourceDepthOne(uri);
+ Optional<Relationships> relationshipsOp = this.getRelationshipsFromWrapper(vnfcResultsWrapper);
+ Zone aaiZone = getRelatedZone(relationshipsOp);
+ if (aaiZone == null) {
+ String errMsg = "No relationships for Cloud Region in AAI to extract zone id";
+ exceptionUtil.buildAndThrowWorkflowException(execution, 7000, errMsg);
+ }
+ return aaiZone.getZoneId();
+ }
+
+ protected Optional<Relationships> getRelationshipsFromWrapper(AAIResultWrapper wrapper) {
+ Optional<Relationships> relationshipsOp;
+ relationshipsOp = wrapper.getRelationships();
+ if (relationshipsOp.isPresent()) {
+ return relationshipsOp;
+ }
+ return Optional.empty();
+ }
+
+ protected org.onap.aai.domain.yang.Zone getRelatedZone(Optional<Relationships> relationshipsOp) {
+ Zone aaiZone = null;
+ if (relationshipsOp.isPresent()) {
+ Relationships relationships = relationshipsOp.get();
+ if (!relationships.getAll().isEmpty()) {
+ List<AAIResultWrapper> zones = relationships.getByType(AAIObjectType.ZONE);
+ AAIResultWrapper zoneWrapper = zones.get(0);
+ Optional<Zone> aaiZoneOp = zoneWrapper.asBean(Zone.class);
+ if (aaiZoneOp.isPresent()) {
+ aaiZone = aaiZoneOp.get();
+ }
+ }
+ }
+ return aaiZone;
+ }
}
import org.onap.so.bpmn.common.BuildingBlockExecution;
import org.onap.so.bpmn.servicedecomposition.bbobjects.InstanceGroup;
+import org.onap.so.bpmn.servicedecomposition.bbobjects.ServiceInstance;
import org.onap.so.bpmn.servicedecomposition.entities.ResourceKey;
import org.onap.so.bpmn.servicedecomposition.tasks.ExtractPojosForBB;
import org.onap.so.client.exception.ExceptionBuilder;
+import org.onap.so.client.namingservice.NamingRequestObject;
import org.onap.so.client.orchestration.NamingServiceResources;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
exceptionUtil.buildAndThrowWorkflowException(execution, 7000, ex);
}
}
+
+ public void deleteServiceInstanceName(BuildingBlockExecution execution) throws Exception {
+ ServiceInstance serviceInstance = extractPojosForBB.extractByKey(execution, ResourceKey.SERVICE_INSTANCE_ID);
+ NamingRequestObject namingRequestObject = new NamingRequestObject();
+ namingRequestObject.setExternalKeyValue(serviceInstance.getServiceInstanceId());
+ try {
+ namingServiceResources.deleteServiceInstanceName(namingRequestObject);
+ } catch (Exception ex) {
+ exceptionUtil.buildAndThrowWorkflowException(execution, 7000, ex);
+ }
+ }
+
}
--- /dev/null
+package org.onap.so.bpmn.infrastructure.workflow.tasks;
+
+public class VrfBondingServiceException extends Exception {
+ /**
+ *
+ */
+ private static final long serialVersionUID = -4277883464681291740L;
+
+ public VrfBondingServiceException(String errorMessage) {
+ super(errorMessage);
+ }
+}
--- /dev/null
+package org.onap.so.bpmn.infrastructure.workflow.tasks;
+
+import java.util.List;
+import java.util.Optional;
+import org.onap.aai.domain.yang.L3Network;
+import org.onap.so.bpmn.servicedecomposition.tasks.BBInputSetupUtils;
+import org.onap.so.client.aai.AAIObjectType;
+import org.onap.so.client.aai.entities.AAIResultWrapper;
+import org.onap.so.client.aai.entities.uri.AAIResourceUri;
+import org.onap.so.db.catalog.beans.ConfigurationResourceCustomization;
+import org.onap.so.db.catalog.beans.ServiceProxyResourceCustomization;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+@Component
+public class VrfValidation {
+
+ @Autowired
+ protected BBInputSetupUtils bbInputSetupUtils;
+
+ public void setBbInputSetupUtils(BBInputSetupUtils bbInputSetupUtils) {
+ this.bbInputSetupUtils = bbInputSetupUtils;
+ }
+
+ protected void vrfServiceValidation(org.onap.so.db.catalog.beans.Service service)
+ throws VrfBondingServiceException {
+ if (!"BONDING".equalsIgnoreCase(service.getServiceType())
+ || !"INFRASTRUCTURE-VPN".equalsIgnoreCase(service.getServiceRole())) {
+ throw new VrfBondingServiceException("Service: " + service.getModelName()
+ + " does not have service type of BONDING and does not have service role of INFRASTRUCTURE-VPN");
+ }
+ }
+
+ protected void vrfCatalogDbChecks(org.onap.so.db.catalog.beans.Service service) throws VrfBondingServiceException {
+ ConfigurationResourceCustomization configuration = getVrfConfiguration(service);
+ if (configuration == null || configuration.getServiceProxyResourceCustomization() == null
+ || configuration.getServiceProxyResourceCustomization().getSourceService() == null
+ || !configuration.getServiceProxyResourceCustomization().getSourceService().getServiceType()
+ .equalsIgnoreCase("TRANSPORT")) {
+ throw new VrfBondingServiceException("Service: " + service.getModelName()
+ + " does not have a configuration of type VRF-ENTRY and role INFRASTRUCTURE-CLOUD-VPN"
+ + ", and serviceProxy that does not have source service that has a serviceType of TRANSPORT)");
+ }
+ }
+
+ protected ConfigurationResourceCustomization getVrfConfiguration(org.onap.so.db.catalog.beans.Service service) {
+ for (ConfigurationResourceCustomization configuration : service.getConfigurationCustomizations()) {
+ if (configuration.getType() != null && configuration.getType().equalsIgnoreCase("VRF-ENTRY")
+ && configuration.getRole() != null
+ && configuration.getRole().equalsIgnoreCase("INFRASTRUCTURE-CLOUD-VPN")) {
+ return configuration;
+ }
+ }
+ return null;
+ }
+
+ protected void aaiVpnBindingValidation(org.onap.aai.domain.yang.VpnBinding aaiVpnBinding)
+ throws VrfBondingServiceException {
+ if (aaiVpnBinding == null || !aaiVpnBinding.getVpnType().equalsIgnoreCase("SERVICE-INFRASTRUCTURE")) {
+ throw new VrfBondingServiceException("VpnBinding: " + aaiVpnBinding.getVpnId()
+ + " does not have service type of BONDING and doesn not have service role of INFRASTRUCTURE-VPN");
+ }
+ }
+
+ protected void aaiAggregateRouteValidation(org.onap.aai.domain.yang.L3Network aaiLocalNetwork)
+ throws VrfBondingServiceException {
+ if (aaiLocalNetwork.getAggregateRoutes() == null
+ || aaiLocalNetwork.getAggregateRoutes().getAggregateRoute() == null) {
+ return;
+ }
+ if (aaiLocalNetwork.getAggregateRoutes().getAggregateRoute().size() == 1 && !aaiLocalNetwork
+ .getAggregateRoutes().getAggregateRoute().get(0).getIpVersion().equalsIgnoreCase("4")) {
+ throw new VrfBondingServiceException("LocalNetwork: " + aaiLocalNetwork.getNetworkId()
+ + " has 1 aggregate route but the Ip version of aggregate route is : "
+ + aaiLocalNetwork.getAggregateRoutes().getAggregateRoute().get(0).getIpVersion() + " and is not 4");
+ } else if (aaiLocalNetwork.getAggregateRoutes().getAggregateRoute().size() == 2
+ && !ipVersionValidation(aaiLocalNetwork.getAggregateRoutes().getAggregateRoute().get(0).getIpVersion(),
+ aaiLocalNetwork.getAggregateRoutes().getAggregateRoute().get(1).getIpVersion())) {
+ throw new VrfBondingServiceException("LocalNetwork: " + aaiLocalNetwork.getNetworkId()
+ + " has 2 aggregate routes but the combination of the Ip versions for the aggregate routes did not match the ip version of one of them to be 4 and one to be 6");
+ } else if (aaiLocalNetwork.getAggregateRoutes().getAggregateRoute().size() > 2) {
+ throw new VrfBondingServiceException(
+ "LocalNetwork: " + aaiLocalNetwork.getNetworkId() + " either has more than 2 aggregate routes");
+ }
+ }
+
+ protected void aaiSubnetValidation(org.onap.aai.domain.yang.L3Network aaiLocalNetwork)
+ throws VrfBondingServiceException {
+ if (aaiLocalNetwork.getSubnets() == null || aaiLocalNetwork.getSubnets().getSubnet() == null) {
+ throw new VrfBondingServiceException("LocalNetwork: " + aaiLocalNetwork.getNetworkId() + " has no subnets");
+ } else if (aaiLocalNetwork.getSubnets().getSubnet().size() == 1
+ && !aaiLocalNetwork.getSubnets().getSubnet().get(0).getIpVersion().equalsIgnoreCase("4")) {
+ throw new VrfBondingServiceException("LocalNetwork: " + aaiLocalNetwork.getNetworkId()
+ + " has 1 subnet but the Ip version of subnet is : "
+ + aaiLocalNetwork.getSubnets().getSubnet().get(0).getIpVersion() + " and is not 4");
+ } else if (aaiLocalNetwork.getSubnets().getSubnet().size() == 2
+ && !ipVersionValidation(aaiLocalNetwork.getSubnets().getSubnet().get(0).getIpVersion(),
+ aaiLocalNetwork.getSubnets().getSubnet().get(1).getIpVersion())) {
+ throw new VrfBondingServiceException("LocalNetwork: " + aaiLocalNetwork.getNetworkId()
+ + " has 2 subnets but the combination of the Ip versions for the subnets did not match the ip version of one of them to be 4 and one to be 6");
+ } else if (aaiLocalNetwork.getSubnets().getSubnet().isEmpty()
+ || aaiLocalNetwork.getSubnets().getSubnet().size() > 2) {
+ throw new VrfBondingServiceException("LocalNetwork: " + aaiLocalNetwork.getNetworkId()
+ + " either has no subnets or more than 2 subnets");
+ }
+ }
+
+ protected boolean ipVersionValidation(String ipVersion1, String ipVersion2) {
+ return (ipVersion1.equalsIgnoreCase("4") && ipVersion2.equalsIgnoreCase("6"))
+ || (ipVersion1.equalsIgnoreCase("6") && ipVersion2.equalsIgnoreCase("4"));
+ }
+
+ protected void aaiRouteTargetValidation(L3Network aaiLocalNetwork) throws VrfBondingServiceException {
+ AAIResultWrapper networkWrapper = new AAIResultWrapper(aaiLocalNetwork);
+ if (networkWrapper.getRelationships().isPresent()) {
+ List<AAIResourceUri> vpnBindingUris =
+ networkWrapper.getRelationships().get().getRelatedUris(AAIObjectType.VPN_BINDING);
+ if (!vpnBindingUris.isEmpty()) {
+ Optional<org.onap.aai.domain.yang.VpnBinding> vpnBindingOp =
+ bbInputSetupUtils.getAAIResourceDepthOne(vpnBindingUris.get(0))
+ .asBean(org.onap.aai.domain.yang.VpnBinding.class);
+ if (vpnBindingOp.isPresent()) {
+ org.onap.aai.domain.yang.VpnBinding vpnBinding = vpnBindingOp.get();
+ if (vpnBinding.getRouteTargets() != null
+ && !vpnBinding.getRouteTargets().getRouteTarget().isEmpty()) {
+ return;
+ }
+ }
+ }
+ }
+ throw new VrfBondingServiceException("The Local Network: " + aaiLocalNetwork.getNetworkId()
+ + " does not have vpn binding and/or RT information");
+ }
+}
import java.util.stream.Collectors;
import org.camunda.bpm.engine.delegate.DelegateExecution;
import org.javatuples.Pair;
-import org.slf4j.LoggerFactory;
import org.onap.aai.domain.yang.GenericVnf;
import org.onap.aai.domain.yang.L3Network;
import org.onap.aai.domain.yang.Relationship;
import org.onap.aai.domain.yang.ServiceInstance;
import org.onap.aai.domain.yang.Vnfc;
import org.onap.aai.domain.yang.VolumeGroup;
+import org.onap.aai.domain.yang.VpnBinding;
import org.onap.so.bpmn.servicedecomposition.bbobjects.Configuration;
import org.onap.so.bpmn.servicedecomposition.bbobjects.VfModule;
import org.onap.so.bpmn.servicedecomposition.entities.BuildingBlock;
import org.onap.so.db.catalog.beans.CollectionNetworkResourceCustomization;
import org.onap.so.db.catalog.beans.CollectionResourceCustomization;
import org.onap.so.db.catalog.beans.CollectionResourceInstanceGroupCustomization;
+import org.onap.so.db.catalog.beans.ConfigurationResourceCustomization;
+import org.onap.so.db.catalog.beans.CvnfcConfigurationCustomization;
import org.onap.so.db.catalog.beans.CvnfcCustomization;
+import org.onap.so.db.catalog.beans.ServiceProxyResourceCustomization;
import org.onap.so.db.catalog.beans.VfModuleCustomization;
-import org.onap.so.db.catalog.beans.CvnfcConfigurationCustomization;
import org.onap.so.db.catalog.beans.macro.NorthBoundRequest;
import org.onap.so.db.catalog.beans.macro.OrchestrationFlow;
import org.onap.so.db.catalog.client.CatalogDbClient;
import org.onap.so.serviceinstancebeans.VfModules;
import org.onap.so.serviceinstancebeans.Vnfs;
import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.env.Environment;
import org.springframework.stereotype.Component;
+import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
@Component
private static final String FABRIC_CONFIGURATION = "FabricConfiguration";
private static final String G_SERVICE_TYPE = "serviceType";
private static final String SERVICE_TYPE_TRANSPORT = "TRANSPORT";
+ private static final String SERVICE_TYPE_BONDING = "BONDING";
private static final Logger logger = LoggerFactory.getLogger(WorkflowAction.class);
@Autowired
private AAIConfigurationResources aaiConfigurationResources;
@Autowired
private WorkflowActionExtractResourcesAAI workflowActionUtils;
+ @Autowired
+ private VrfValidation vrfValidation;
@Autowired
private Environment environment;
foundRelated = traverseUserParamsService(execution, resourceCounter, sIRequest, requestAction);
}
if (!foundRelated) {
- traverseCatalogDbService(execution, sIRequest, resourceCounter);
+ traverseCatalogDbService(execution, sIRequest, resourceCounter, aaiResourceIds);
}
} else if (resourceType == WorkflowType.SERVICE && (requestAction.equalsIgnoreCase("activateInstance")
|| requestAction.equalsIgnoreCase("unassignInstance")
}
protected void traverseCatalogDbService(DelegateExecution execution, ServiceInstancesRequest sIRequest,
- List<Resource> resourceCounter) {
+ List<Resource> resourceCounter, List<Pair<WorkflowType, String>> aaiResourceIds) {
String modelUUID = sIRequest.getRequestDetails().getModelInfo().getModelVersionId();
org.onap.so.db.catalog.beans.Service service = catalogDbClient.getServiceByID(modelUUID);
if (service == null) {
buildAndThrowException(execution, "Could not find the service model in catalog db.");
} else {
resourceCounter.add(new Resource(WorkflowType.SERVICE, service.getModelUUID(), false));
- if (service.getVnfCustomizations() == null || service.getVnfCustomizations().isEmpty()) {
- List<CollectionResourceCustomization> customizations = service.getCollectionResourceCustomizations();
- if (customizations.isEmpty()) {
- logger.debug("No Collections found. CollectionResourceCustomization list is empty.");
- } else {
- CollectionResourceCustomization collectionResourceCustomization =
- findCatalogNetworkCollection(execution, service);
- if (collectionResourceCustomization != null) {
- resourceCounter.add(new Resource(WorkflowType.NETWORKCOLLECTION,
- collectionResourceCustomization.getModelCustomizationUUID(), false));
- logger.debug("Found a network collection");
- if (collectionResourceCustomization.getCollectionResource() != null) {
- if (collectionResourceCustomization.getCollectionResource().getInstanceGroup() != null) {
- String toscaNodeType = collectionResourceCustomization.getCollectionResource()
- .getInstanceGroup().getToscaNodeType();
- if (toscaNodeType != null && toscaNodeType.contains("NetworkCollection")) {
- int minNetworks = 0;
- org.onap.so.db.catalog.beans.InstanceGroup instanceGroup =
- collectionResourceCustomization.getCollectionResource().getInstanceGroup();
- CollectionResourceInstanceGroupCustomization collectionInstCust = null;
- if (!instanceGroup.getCollectionInstanceGroupCustomizations().isEmpty()) {
- for (CollectionResourceInstanceGroupCustomization collectionInstanceGroupTemp : instanceGroup
- .getCollectionInstanceGroupCustomizations()) {
- if (collectionInstanceGroupTemp.getModelCustomizationUUID()
- .equalsIgnoreCase(collectionResourceCustomization
- .getModelCustomizationUUID())) {
- collectionInstCust = collectionInstanceGroupTemp;
- break;
- }
- }
- if (collectionInstCust != null
- && collectionInstCust.getSubInterfaceNetworkQuantity() != null) {
- minNetworks = collectionInstCust.getSubInterfaceNetworkQuantity();
- }
- }
- logger.debug("minNetworks: {}", minNetworks);
- CollectionNetworkResourceCustomization collectionNetworkResourceCust = null;
- for (CollectionNetworkResourceCustomization collectionNetworkTemp : instanceGroup
- .getCollectionNetworkResourceCustomizations()) {
- if (collectionNetworkTemp.getNetworkResourceCustomization()
- .getModelCustomizationUUID().equalsIgnoreCase(
- collectionResourceCustomization.getModelCustomizationUUID())) {
- collectionNetworkResourceCust = collectionNetworkTemp;
+ RelatedInstance relatedVpnBinding =
+ bbInputSetupUtils.getRelatedInstanceByType(sIRequest.getRequestDetails(), ModelType.vpnBinding);
+ RelatedInstance relatedLocalNetwork =
+ bbInputSetupUtils.getRelatedInstanceByType(sIRequest.getRequestDetails(), ModelType.network);
+ if (relatedVpnBinding != null && relatedLocalNetwork != null) {
+ traverseVrfConfiguration(execution, aaiResourceIds, resourceCounter, service, relatedVpnBinding,
+ relatedLocalNetwork);
+ } else {
+ traverseNetworkCollection(execution, resourceCounter, service);
+ }
+ }
+ }
+
+ protected void traverseVrfConfiguration(DelegateExecution execution,
+ List<Pair<WorkflowType, String>> aaiResourceIds, List<Resource> resourceCounter,
+ org.onap.so.db.catalog.beans.Service service, RelatedInstance relatedVpnBinding,
+ RelatedInstance relatedLocalNetwork) {
+ try {
+ org.onap.aai.domain.yang.L3Network aaiLocalNetwork =
+ bbInputSetupUtils.getAAIL3Network(relatedLocalNetwork.getInstanceId());
+ vrfValidation.vrfServiceValidation(service);
+ vrfValidation.vrfCatalogDbChecks(service);
+ vrfValidation
+ .aaiVpnBindingValidation(bbInputSetupUtils.getAAIVpnBinding(relatedVpnBinding.getInstanceId()));
+ vrfValidation.aaiSubnetValidation(aaiLocalNetwork);
+ vrfValidation.aaiAggregateRouteValidation(aaiLocalNetwork);
+ vrfValidation.aaiRouteTargetValidation(aaiLocalNetwork);
+ String existingAAIVrfConfiguration = getExistingAAIVrfConfiguration(relatedVpnBinding, aaiLocalNetwork);
+ if (existingAAIVrfConfiguration != null) {
+ aaiResourceIds
+ .add(new Pair<WorkflowType, String>(WorkflowType.CONFIGURATION, existingAAIVrfConfiguration));
+ }
+ resourceCounter.add(new Resource(WorkflowType.CONFIGURATION,
+ service.getConfigurationCustomizations().get(0).getModelCustomizationUUID(), false));
+ } catch (VrfBondingServiceException | JsonProcessingException e) {
+ buildAndThrowException(execution, e.getMessage());
+ }
+ }
+
+ protected String getExistingAAIVrfConfiguration(RelatedInstance relatedVpnBinding,
+ org.onap.aai.domain.yang.L3Network aaiLocalNetwork)
+ throws JsonProcessingException, VrfBondingServiceException {
+ Optional<Relationships> relationshipsOp = new AAIResultWrapper(
+ new AAICommonObjectMapperProvider().getMapper().writeValueAsString(aaiLocalNetwork)).getRelationships();
+ if (relationshipsOp.isPresent()) {
+ List<AAIResultWrapper> configurationsRelatedToLocalNetwork =
+ relationshipsOp.get().getByType(AAIObjectType.CONFIGURATION);
+ if (configurationsRelatedToLocalNetwork.size() > 1) {
+ throw new VrfBondingServiceException(
+ "Network: " + aaiLocalNetwork.getNetworkId() + " has more than 1 configuration related to it");
+ }
+ if (configurationsRelatedToLocalNetwork.size() == 1) {
+ AAIResultWrapper configWrapper = configurationsRelatedToLocalNetwork.get(0);
+ Optional<Configuration> relatedConfiguration = configWrapper.asBean(Configuration.class);
+ if (relatedConfiguration.isPresent() && vrfConfigurationAlreadyExists(relatedVpnBinding,
+ relatedConfiguration.get(), configWrapper)) {
+ return relatedConfiguration.get().getConfigurationId();
+ }
+ }
+ }
+ return null;
+ }
+
+ protected boolean vrfConfigurationAlreadyExists(RelatedInstance relatedVpnBinding, Configuration vrfConfiguration,
+ AAIResultWrapper configWrapper) throws VrfBondingServiceException {
+ if (vrfConfiguration.getConfigurationType().equalsIgnoreCase("VRF-ENTRY")) {
+ Optional<Relationships> relationshipsConfigOp = configWrapper.getRelationships();
+ if (relationshipsConfigOp.isPresent()) {
+ Optional<VpnBinding> relatedInfraVpnBindingOp =
+ workflowActionUtils.extractRelationshipsVpnBinding(relationshipsConfigOp.get());
+ if (relatedInfraVpnBindingOp.isPresent()) {
+ VpnBinding relatedInfraVpnBinding = relatedInfraVpnBindingOp.get();
+ if (!relatedInfraVpnBinding.getVpnId().equalsIgnoreCase(relatedVpnBinding.getInstanceId())) {
+ throw new VrfBondingServiceException("Configuration: " + vrfConfiguration.getConfigurationId()
+ + " is not connected to the same vpn binding id provided in request: "
+ + relatedVpnBinding.getInstanceId());
+ } else {
+ return true;
+ }
+ }
+ }
+ }
+ return false;
+ }
+
+ protected void traverseNetworkCollection(DelegateExecution execution, List<Resource> resourceCounter,
+ org.onap.so.db.catalog.beans.Service service) {
+ if (service.getVnfCustomizations() == null || service.getVnfCustomizations().isEmpty()) {
+ List<CollectionResourceCustomization> customizations = service.getCollectionResourceCustomizations();
+ if (customizations.isEmpty()) {
+ logger.debug("No Collections found. CollectionResourceCustomization list is empty.");
+ } else {
+ CollectionResourceCustomization collectionResourceCustomization =
+ findCatalogNetworkCollection(execution, service);
+ if (collectionResourceCustomization != null) {
+ resourceCounter.add(new Resource(WorkflowType.NETWORKCOLLECTION,
+ collectionResourceCustomization.getModelCustomizationUUID(), false));
+ logger.debug("Found a network collection");
+ if (collectionResourceCustomization.getCollectionResource() != null) {
+ if (collectionResourceCustomization.getCollectionResource().getInstanceGroup() != null) {
+ String toscaNodeType = collectionResourceCustomization.getCollectionResource()
+ .getInstanceGroup().getToscaNodeType();
+ if (toscaNodeType != null && toscaNodeType.contains("NetworkCollection")) {
+ int minNetworks = 0;
+ org.onap.so.db.catalog.beans.InstanceGroup instanceGroup =
+ collectionResourceCustomization.getCollectionResource().getInstanceGroup();
+ CollectionResourceInstanceGroupCustomization collectionInstCust = null;
+ if (!instanceGroup.getCollectionInstanceGroupCustomizations().isEmpty()) {
+ for (CollectionResourceInstanceGroupCustomization collectionInstanceGroupTemp : instanceGroup
+ .getCollectionInstanceGroupCustomizations()) {
+ if (collectionInstanceGroupTemp.getModelCustomizationUUID().equalsIgnoreCase(
+ collectionResourceCustomization.getModelCustomizationUUID())) {
+ collectionInstCust = collectionInstanceGroupTemp;
break;
}
}
- for (int i = 0; i < minNetworks; i++) {
- if (collectionNetworkResourceCust != null && collectionInstCust != null) {
- Resource resource = new Resource(WorkflowType.VIRTUAL_LINK,
- collectionNetworkResourceCust.getModelCustomizationUUID(), false);
- resource.setVirtualLinkKey(Integer.toString(i));
- resourceCounter.add(resource);
- }
+ if (collectionInstCust != null
+ && collectionInstCust.getSubInterfaceNetworkQuantity() != null) {
+ minNetworks = collectionInstCust.getSubInterfaceNetworkQuantity();
+ }
+ }
+ logger.debug("minNetworks: {}", minNetworks);
+ CollectionNetworkResourceCustomization collectionNetworkResourceCust = null;
+ for (CollectionNetworkResourceCustomization collectionNetworkTemp : instanceGroup
+ .getCollectionNetworkResourceCustomizations()) {
+ if (collectionNetworkTemp.getNetworkResourceCustomization()
+ .getModelCustomizationUUID().equalsIgnoreCase(
+ collectionResourceCustomization.getModelCustomizationUUID())) {
+ collectionNetworkResourceCust = collectionNetworkTemp;
+ break;
+ }
+ }
+ for (int i = 0; i < minNetworks; i++) {
+ if (collectionNetworkResourceCust != null && collectionInstCust != null) {
+ Resource resource = new Resource(WorkflowType.VIRTUAL_LINK,
+ collectionNetworkResourceCust.getModelCustomizationUUID(), false);
+ resource.setVirtualLinkKey(Integer.toString(i));
+ resourceCounter.add(resource);
}
- } else {
- logger.debug(
- "Instance Group tosca node type does not contain NetworkCollection: {}",
- toscaNodeType);
}
} else {
- logger.debug("No Instance Group found for network collection.");
+ logger.debug("Instance Group tosca node type does not contain NetworkCollection: {}",
+ toscaNodeType);
}
} else {
- logger.debug("No Network Collection found. collectionResource is null");
+ logger.debug("No Instance Group found for network collection.");
}
} else {
- logger.debug("No Network Collection Customization found");
+ logger.debug("No Network Collection found. collectionResource is null");
}
+ } else {
+ logger.debug("No Network Collection Customization found");
}
- if (resourceCounter.stream().filter(x -> WorkflowType.NETWORKCOLLECTION == x.getResourceType())
- .collect(Collectors.toList()).isEmpty()) {
- if (service.getNetworkCustomizations() == null) {
- logger.debug("No networks were found on this service model");
- } else {
- for (int i = 0; i < service.getNetworkCustomizations().size(); i++) {
- resourceCounter.add(new Resource(WorkflowType.NETWORK,
- service.getNetworkCustomizations().get(i).getModelCustomizationUUID(), false));
- }
+ }
+ if (resourceCounter.stream().filter(x -> WorkflowType.NETWORKCOLLECTION == x.getResourceType())
+ .collect(Collectors.toList()).isEmpty()) {
+ if (service.getNetworkCustomizations() == null) {
+ logger.debug("No networks were found on this service model");
+ } else {
+ for (int i = 0; i < service.getNetworkCustomizations().size(); i++) {
+ resourceCounter.add(new Resource(WorkflowType.NETWORK,
+ service.getNetworkCustomizations().get(i).getModelCustomizationUUID(), false));
}
}
- } else {
- buildAndThrowException(execution,
- "Cannot orchestrate Service-Macro-Create without user params with a vnf. Please update ASDC model for new macro orchestration support or add service_recipe records to route to old macro flows");
}
+ } else {
+ buildAndThrowException(execution,
+ "Cannot orchestrate Service-Macro-Create without user params with a vnf. Please update ASDC model for new macro orchestration support or add service_recipe records to route to old macro flows");
}
}
aaiConfigurationResources.getConfiguration(config.getConfigurationId());
if (aaiConfig.isPresent() && aaiConfig.get().getRelationshipList() != null) {
for (Relationship relationship : aaiConfig.get().getRelationshipList().getRelationship()) {
- if (relationship.getRelatedTo().contains("vnfc")) {
+ if (relationship.getRelatedTo().contains("vnfc")
+ || relationship.getRelatedTo().contains("vpn-binding")) {
aaiResourceIds.add(new Pair<WorkflowType, String>(WorkflowType.CONFIGURATION,
config.getConfigurationId()));
resourceCounter.add(
WorkflowType resourceName, boolean aLaCarte, String cloudOwner, String serviceType) {
List<OrchestrationFlow> listToExecute = new ArrayList<>();
NorthBoundRequest northBoundRequest = null;
- if (serviceType.equalsIgnoreCase(SERVICE_TYPE_TRANSPORT)) {
+ if (serviceType.equalsIgnoreCase(SERVICE_TYPE_TRANSPORT)
+ || serviceType.equalsIgnoreCase(SERVICE_TYPE_BONDING)) {
northBoundRequest =
catalogDbClient.getNorthBoundRequestByActionAndIsALaCarteAndRequestScopeAndCloudOwnerAndServiceType(
requestAction, resourceName.toString(), aLaCarte, cloudOwner, serviceType);
import java.util.List;
import java.util.Optional;
+import org.onap.aai.domain.yang.VpnBinding;
import org.onap.so.bpmn.servicedecomposition.bbobjects.Configuration;
+import org.onap.so.bpmn.servicedecomposition.tasks.BBInputSetupUtils;
import org.onap.so.client.aai.AAIObjectType;
import org.onap.so.client.aai.entities.AAIResultWrapper;
import org.onap.so.client.aai.entities.Relationships;
+import org.onap.so.client.aai.entities.uri.AAIResourceUri;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
@Component
public class WorkflowActionExtractResourcesAAI {
private static final Logger logger = LoggerFactory.getLogger(WorkflowActionExtractResourcesAAI.class);
+ @Autowired
+ protected BBInputSetupUtils bbInputSetupUtils;
+
public Optional<Configuration> extractRelationshipsConfiguration(Relationships relationships) {
List<AAIResultWrapper> configurations = relationships.getByType(AAIObjectType.CONFIGURATION);
for (AAIResultWrapper configWrapper : configurations) {
return Optional.empty();
}
+ public Optional<VpnBinding> extractRelationshipsVpnBinding(Relationships relationships) {
+ List<AAIResourceUri> configurations = relationships.getRelatedUris(AAIObjectType.VPN_BINDING);
+ for (AAIResourceUri vpnBindingUri : configurations) {
+ AAIResultWrapper vpnBindingWrapper = bbInputSetupUtils.getAAIResourceDepthOne(vpnBindingUri);
+ Optional<VpnBinding> vpnBinding = vpnBindingWrapper.asBean(VpnBinding.class);
+ if (vpnBinding.isPresent()) {
+ return vpnBinding;
+ }
+ }
+ return Optional.empty();
+ }
+
public Optional<Relationships> extractRelationshipsVnfc(Relationships relationships) {
List<AAIResultWrapper> vnfcs = relationships.getByType(AAIObjectType.VNFC);
for (AAIResultWrapper vnfcWrapper : vnfcs) {
public class NamingClientResponseValidator {
private static final Logger logger = LoggerFactory.getLogger(NamingClientResponseValidator.class);
private static final String INSTANCE_GROUP_NAME = "instance-group-name";
+ private static final String SERVICE_INSTANCE_NAME = "Service-Instance-Name";
private static final String NO_RESPONSE_FROM_NAMING_SERVICE =
"Error did not receive a response from Naming Service.";
private static final String NULL_RESPONSE_FROM_NAMING_SERVICE =
if (INSTANCE_GROUP_NAME.equals(resourceName)) {
generatedName = respElement.getResourceValue();
break;
+ } else if (SERVICE_INSTANCE_NAME.equals(resourceName)) {
+ generatedName = respElement.getResourceValue();
+ break;
}
}
}
--- /dev/null
+package org.onap.so.client.namingservice;
+
+import java.util.HashMap;
+
+public class NamingRequestObject {
+
+ private HashMap<String, String> namingRequestMap = new HashMap<String, String>();
+
+ public HashMap<String, String> getNamingRequestObjectMap() {
+ return this.namingRequestMap;
+ }
+
+ public String getExternalKeyValue() {
+ return namingRequestMap.get(NamingServiceConstants.NS_EXTERNAL_KEY);
+ }
+
+ public void setExternalKeyValue(String externalKey) {
+ this.namingRequestMap.put(NamingServiceConstants.NS_EXTERNAL_KEY, externalKey);
+ }
+
+ public String getPolicyInstanceNameValue() {
+ return this.namingRequestMap.get(NamingServiceConstants.NS_POLICY_INSTANCE_NAME);
+ }
+
+ public void setPolicyInstanceNameValue(String policyInstanceName) {
+ this.namingRequestMap.put(NamingServiceConstants.NS_POLICY_INSTANCE_NAME, policyInstanceName);
+ }
+
+ public String getNamingTypeValue() {
+ return namingRequestMap.get(NamingServiceConstants.NS_NAMING_TYPE);
+ }
+
+ public void setNamingTypeValue(String namingType) {
+ this.namingRequestMap.put(NamingServiceConstants.NS_NAMING_TYPE, namingType);
+ }
+
+ public String getResourceNameValue() {
+ return this.namingRequestMap.get(NamingServiceConstants.NS_RESOURCE_NAME);
+ }
+
+ public void setResourceNameValue(String resourceName) {
+ namingRequestMap.put(NamingServiceConstants.NS_RESOURCE_NAME, resourceName);
+ }
+
+ public String getNfNamingCodeValue() {
+ return this.namingRequestMap.get(NamingServiceConstants.NS_NF_NAMING_CODE);
+ }
+
+ public void setNfNamingCodeValue(String nfNamingCode) {
+ this.namingRequestMap.put(NamingServiceConstants.NS_NF_NAMING_CODE, nfNamingCode);
+ }
+
+ public String getServiceModelNameValue() {
+ return this.namingRequestMap.get(NamingServiceConstants.NS_SERVICE_MODEL_NAME);
+ }
+
+ public void setServiceModelNameValue(String serviceModelName) {
+ this.namingRequestMap.put(NamingServiceConstants.NS_SERVICE_MODEL_NAME, serviceModelName);
+ }
+
+ public String getModelVersionValue() {
+ return this.namingRequestMap.get(NamingServiceConstants.NS_MODEL_VERSION);
+ }
+
+ public void setModelVersionValue(String modelVersion) {
+ this.namingRequestMap.put(NamingServiceConstants.NS_MODEL_VERSION, modelVersion);
+ }
+
+ public String getNetworkNameValue() {
+ return this.namingRequestMap.get(NamingServiceConstants.NS_NETWORK_NAME);
+ }
+
+ public void setNetworkNameValue(String networkName) {
+ this.namingRequestMap.put(NamingServiceConstants.NS_NETWORK_NAME, networkName);
+ }
+
+ public String getVpnNameValue() {
+ return this.namingRequestMap.get(NamingServiceConstants.NS_VPN_NAME);
+ }
+
+ public void setVpnNameValue(String vpnName) {
+ this.namingRequestMap.put(NamingServiceConstants.NS_VPN_NAME, vpnName);
+ }
+
+ public String getZoneIdValue() {
+ return this.namingRequestMap.get(NamingServiceConstants.NS_ZONE_ID);
+ }
+
+ public void setZoneIdValue(String zoneId) {
+ this.namingRequestMap.put(NamingServiceConstants.NS_ZONE_ID, zoneId);
+ }
+
+}
--- /dev/null
+package org.onap.so.client.namingservice;
+
+public class NamingServiceConstants {
+ public static final String NS_EXTERNAL_KEY = "external-key";
+ public static final String NS_POLICY_INSTANCE_NAME = "policy-instance-name";
+ public static final String NS_NAMING_TYPE = "naming-type";
+ public static final String NS_RESOURCE_NAME = "resource-name";
+ public static final String NS_NF_NAMING_CODE = "nf-naming-code";
+ public static final String NS_SERVICE_MODEL_NAME = "service-model-name";
+ public static final String NS_MODEL_VERSION = "model-version";
+ public static final String NS_NETWORK_NAME = "network-name";
+ public static final String NS_VPN_NAME = "vpn-name";
+ public static final String NS_ZONE_ID = "zone-id";
+ public static final String NS_RESOURCE_VALUE = "resource-value";
+
+ public static final String NAMING_TYPE_SERVICE = "SERVICE";
+ public static final String RESOURCE_NAME_SERVICE_INSTANCE_NAME = "Service-Instance-Name";
+ public static final String RESOURCE_NAME_SERVICEINSTANCE = "ServiceInstance";
+
+ private NamingServiceConstants() {}
+}
--- /dev/null
+package org.onap.so.client.namingservice;
+
+import org.onap.so.bpmn.common.BuildingBlockExecution;
+import org.onap.so.bpmn.servicedecomposition.bbobjects.ServiceInstance;
+import org.onap.so.bpmn.servicedecomposition.entities.ResourceKey;
+import org.onap.so.bpmn.servicedecomposition.tasks.ExtractPojosForBB;
+import org.onap.so.client.exception.ExceptionBuilder;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+@Component
+public class NamingServiceUtils {
+
+ private static String errorMessages = "Policy name is not present, or Onap name was not generated! ";
+
+ @Autowired
+ private ExceptionBuilder exceptionUtil;
+ @Autowired
+ private ExtractPojosForBB extractPojosForBB;
+
+ public void checkVpnBondingService(BuildingBlockExecution execution) {
+ execution.setVariable("isVpnBondingService", false);
+ boolean isNamingPolicyAndOnapGeneratedNaming = false;
+ checkBondingAndInfrastureVpn(execution);
+ boolean isBondingAndInsfrastructureVpn = execution.getVariable("isBondingAndInsfrastructureVpn");
+ if (isBondingAndInsfrastructureVpn) {
+ checkNamingPolicyAndOnapGeneratedNaming(execution);
+ isNamingPolicyAndOnapGeneratedNaming = execution.getVariable("isNamingPolicyAndOnapGeneratedNaming");
+ }
+ if (isBondingAndInsfrastructureVpn && isNamingPolicyAndOnapGeneratedNaming) {
+ execution.setVariable("isVpnBondingService", true);
+ }
+ }
+
+ public void checkBondingAndInfrastureVpn(BuildingBlockExecution execution) {
+ execution.setVariable("isBondingAndInsfrastructureVpn", false);
+ try {
+ ServiceInstance serviceInstance =
+ extractPojosForBB.extractByKey(execution, ResourceKey.SERVICE_INSTANCE_ID);
+ if ("bonding".equalsIgnoreCase(serviceInstance.getModelInfoServiceInstance().getServiceType())
+ && "infrastructure-vpn"
+ .equalsIgnoreCase(serviceInstance.getModelInfoServiceInstance().getServiceRole())) {
+ execution.setVariable("isBondingAndInsfrastructureVpn", true);
+ }
+ } catch (Exception ex) {
+ exceptionUtil.buildAndThrowWorkflowException(execution, 7000, ex);
+ }
+ }
+
+ public void checkNamingPolicyAndOnapGeneratedNaming(BuildingBlockExecution execution) {
+ execution.setVariable("isNamingPolicyAndOnapGeneratedNaming", false);
+ try {
+ ServiceInstance serviceInstance =
+ extractPojosForBB.extractByKey(execution, ResourceKey.SERVICE_INSTANCE_ID);
+ if (serviceInstance.getModelInfoServiceInstance().getNamingPolicy() != null
+ && !serviceInstance.getModelInfoServiceInstance().getNamingPolicy().isEmpty()
+ && serviceInstance.getModelInfoServiceInstance().getOnapGeneratedNaming() != null
+ && serviceInstance.getModelInfoServiceInstance().getOnapGeneratedNaming() == true) {
+ execution.setVariable("isNamingPolicyAndOnapGeneratedNaming", true);
+ } else {
+ exceptionUtil.buildAndThrowWorkflowException(execution, 7000, errorMessages);
+ }
+ } catch (Exception ex) {
+ exceptionUtil.buildAndThrowWorkflowException(execution, 7000, ex);
+ }
+ }
+}
/**
* A&AI call to disconnect configuration relation with service instance
- *
+ *
* @param configurationId
* @param serviceInstanceId
*/
/**
* Get Configuration from AAI using related Link
- *
+ *
* @param relatedLink related link - URI
* @return AAI Configuration object
*/
org.onap.aai.domain.yang.Configuration aaiConfiguration = aaiObjectMapper.mapConfiguration(configuration);
injectionHelper.getAaiClient().update(aaiResourceUri, aaiConfiguration);
}
+
+ public void updateConfigurationOrchestrationStatus(Configuration configuration,
+ OrchestrationStatus orchestrationStatus) {
+ AAIResourceUri aaiResourceUri =
+ AAIUriFactory.createResourceUri(AAIObjectType.CONFIGURATION, configuration.getConfigurationId());
+ org.onap.aai.domain.yang.Configuration aaiConfiguration = new org.onap.aai.domain.yang.Configuration();
+ aaiConfiguration.setOrchestrationStatus(orchestrationStatus.name());
+ injectionHelper.getAaiClient().update(aaiResourceUri, aaiConfiguration);
+ }
}
* ============LICENSE_START=======================================================
* ONAP - SO
* ================================================================================
- * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
+ * Copyright (C) 2019 AT&T Intellectual Property. All rights reserved.
* ================================================================================
* Modifications Copyright (c) 2019 Samsung
* ================================================================================
import java.io.IOException;
import java.util.ArrayList;
+import java.util.HashMap;
import java.util.List;
import org.onap.namingservice.model.Element;
import org.onap.namingservice.model.Deleteelement;
import org.onap.so.bpmn.servicedecomposition.bbobjects.InstanceGroup;
import org.onap.so.client.exception.BadResponseException;
import org.onap.so.client.namingservice.NamingClient;
+import org.onap.so.client.namingservice.NamingRequestObject;
import org.onap.so.client.namingservice.NamingRequestObjectBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
return (namingClient
.deleteNameGenRequest(namingRequestObjectBuilder.nameGenDeleteRequestMapper(deleteElements)));
}
+
+ public String generateServiceInstanceName(NamingRequestObject namingRequestObject)
+ throws BadResponseException, IOException {
+ HashMap<String, String> nsRequestObject = namingRequestObject.getNamingRequestObjectMap();
+ Element element = new Element();
+ nsRequestObject.forEach((k, v) -> element.put(k, v));
+ List<Element> elements = new ArrayList<Element>();
+ elements.add(element);
+ return (namingClient.postNameGenRequest(namingRequestObjectBuilder.nameGenRequestMapper(elements)));
+ }
+
+ public String deleteServiceInstanceName(NamingRequestObject namingRequestObject)
+ throws BadResponseException, IOException {
+ HashMap<String, String> nsRequestObject = namingRequestObject.getNamingRequestObjectMap();
+ Deleteelement delElement = new Deleteelement();
+ nsRequestObject.forEach((k, v) -> delElement.setExternalKey(v));
+ List<Deleteelement> delElements = new ArrayList<Deleteelement>();
+ delElements.add(delElement);
+ return (namingClient.deleteNameGenRequest(namingRequestObjectBuilder.nameGenDeleteRequestMapper(delElements)));
+ }
+
}
* 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.
@JsonProperty("cloudOwner")
private String cloudOwner;
+ public Candidate() {}
+
+ public Candidate(CandidateType identifierType, List<String> identifiers, String cloudOwner) {
+ this.identifierType = identifierType;
+ this.identifiers = identifiers;
+ this.cloudOwner = cloudOwner;
+ }
public CandidateType getIdentifierType() {
return identifierType;
private List<Candidate> excludedCandidates;
@JsonProperty("existingCandidates")
private List<Candidate> existingCandidates;
+ @JsonProperty("filteringAttributes")
+ private List<Candidate> filteringAttributes;
public List<Candidate> getRequiredCandidates() {
this.existingCandidates = existingCandidates;
}
+ public List<Candidate> getFilteringAttributes() {
+ return filteringAttributes;
+ }
+
+ public void setFilteringAttributes(List<Candidate> filteringAttributes) {
+ this.filteringAttributes = filteringAttributes;
+ }
+
}
import org.onap.so.client.adapter.network.mapper.NetworkAdapterObjectMapper;
import org.onap.so.client.appc.ApplicationControllerAction;
import org.onap.so.client.exception.ExceptionBuilder;
+import org.onap.so.client.namingservice.NamingRequestObject;
import org.onap.so.client.orchestration.AAICollectionResources;
import org.onap.so.client.orchestration.AAIConfigurationResources;
import org.onap.so.client.orchestration.AAIInstanceGroupResources;
@Mock
protected Environment env;
+
+ @Mock
+ protected NamingRequestObject namingRequestObject;
+
}
public void beforeServiceProxy() {
ServiceProxy sp = setServiceProxy("1", "infrastructure");
- Candidate requiredCandidate = new Candidate();
- requiredCandidate.setIdentifierType(CandidateType.CLOUD_REGION_ID);
+ Candidate filteringAttributes = new Candidate();
+ filteringAttributes.setIdentifierType(CandidateType.CLOUD_REGION_ID);
List<String> c = new ArrayList<String>();
c.add("testCloudRegionId");
- requiredCandidate.setCloudOwner("att");
- requiredCandidate.setIdentifiers(c);
- sp.addRequiredCandidates(requiredCandidate);
+ filteringAttributes.setCloudOwner("att");
+ filteringAttributes.setIdentifiers(c);
+ sp.getFilteringAttributes().add(filteringAttributes);
serviceInstance.getServiceProxies().add(sp);
}
import static org.junit.Assert.assertEquals;
import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.isA;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.doThrow;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
+import java.util.Optional;
import org.junit.Before;
import org.junit.Test;
import org.mockito.ArgumentMatchers;
import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.onap.aai.domain.yang.Zone;
import org.onap.so.bpmn.BaseTaskTest;
+import org.onap.so.bpmn.servicedecomposition.bbobjects.CloudRegion;
import org.onap.so.bpmn.servicedecomposition.bbobjects.InstanceGroup;
+import org.onap.so.bpmn.servicedecomposition.bbobjects.ServiceInstance;
+import org.onap.so.bpmn.servicedecomposition.entities.GeneralBuildingBlock;
import org.onap.so.bpmn.servicedecomposition.entities.ResourceKey;
+import org.onap.so.bpmn.servicedecomposition.tasks.BBInputSetupUtils;
+import org.onap.so.client.aai.AAICommonObjectMapperProvider;
+import org.onap.so.client.aai.entities.AAIResultWrapper;
+import org.onap.so.client.aai.entities.Relationships;
import org.onap.so.client.exception.BBObjectNotFoundException;
public class NamingServiceCreateTasksTest extends BaseTaskTest {
@InjectMocks
- private NamingServiceCreateTasks namingServiceCreateTasks = new NamingServiceCreateTasks();
+ private NamingServiceCreateTasks namingServiceCreateTasks;
+
+ @Mock
+ private BBInputSetupUtils MOCK_bbInputSetupUtils;
private InstanceGroup instanceGroup;
+ private ServiceInstance serviceInstance;
@Before
public void before() throws BBObjectNotFoundException {
instanceGroup = setInstanceGroup();
when(extractPojosForBB.extractByKey(any(), ArgumentMatchers.eq(ResourceKey.INSTANCE_GROUP_ID)))
.thenReturn(instanceGroup);
+ serviceInstance = setServiceInstance();
+ when(extractPojosForBB.extractByKey(any(), ArgumentMatchers.eq(ResourceKey.SERVICE_INSTANCE_ID)))
+ .thenReturn(serviceInstance);
}
@Test
namingServiceCreateTasks.createInstanceGroupName(execution);
verify(namingServiceResources, times(1)).generateInstanceGroupName(instanceGroup, policyInstanceName,
nfNamingCode);
+ }
+ @Test
+ public void createWanTransportServiceNameTest() throws Exception {
+ String generatedName = "generatedWanTransportServiceName";
+ doReturn(generatedName).when(namingServiceResources).generateServiceInstanceName(any());
+ NamingServiceCreateTasks spy = Mockito.spy(namingServiceCreateTasks);
+ doReturn("testZoneId").when(spy).getRelatedZoneId(any());
+ spy.createWanTransportServiceName(execution);
+ verify(namingServiceResources, times(1)).generateServiceInstanceName(any());
+ assertEquals(generatedName, serviceInstance.getServiceInstanceName());
}
+ @Test
+ public void createVpnBondingServiceNameTest() throws Exception {
+ when(extractPojosForBB.extractByKey(any(), ArgumentMatchers.eq(ResourceKey.NETWORK_ID)))
+ .thenReturn(buildL3Network());
+ when(extractPojosForBB.extractByKey(any(), ArgumentMatchers.eq(ResourceKey.VPN_ID)))
+ .thenReturn(buildVpnBinding());
+ String generatedName = "generatedWanTransportServiceName";
+ doReturn(generatedName).when(namingServiceResources).generateServiceInstanceName(any());
+ namingServiceCreateTasks.createVpnBondingServiceName(execution);
+ verify(namingServiceResources, times(1)).generateServiceInstanceName(any());
+ assertEquals(generatedName, serviceInstance.getServiceInstanceName());
+ }
+
+ @Test
+ public void getRelatedZoneIdTest() throws Exception {
+
+ String zoneId = "zoneId";
+ Zone zone = new Zone();
+ zone.setZoneId(zoneId);
+
+ CloudRegion cloudRegion = new CloudRegion();
+ cloudRegion.setCloudOwner("testCloudOwner");
+ cloudRegion.setLcpCloudRegionId("testLcpCloudRegionId");
+ GeneralBuildingBlock gBBInput = execution.getGeneralBuildingBlock();
+ gBBInput.setCloudRegion(cloudRegion);
+
+ AAIResultWrapper cloudRegionWrapper =
+ new AAIResultWrapper(new AAICommonObjectMapperProvider().getMapper().writeValueAsString(cloudRegion));
+
+ Relationships relationships = Mockito.mock(Relationships.class);
+ relationships.getAll().add(cloudRegionWrapper);
+ Optional<Relationships> relationshipsOp = Optional.of(relationships);
+
+ doReturn(cloudRegionWrapper).when(MOCK_bbInputSetupUtils).getAAIResourceDepthOne(any());
+
+ NamingServiceCreateTasks spy = Mockito.spy(namingServiceCreateTasks);
+
+ doReturn(relationshipsOp).when(spy).getRelationshipsFromWrapper(isA(AAIResultWrapper.class));
+ doReturn(zone).when(spy).getRelatedZone(any());
+ spy.setBbInputSetupUtils(MOCK_bbInputSetupUtils);
+
+ String returnedZoneId = spy.getRelatedZoneId(execution);
+
+ assertEquals(zoneId, returnedZoneId);
+ }
}
package org.onap.so.bpmn.infrastructure.namingservice.tasks;
import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.doThrow;
import static org.mockito.Mockito.times;
import org.mockito.InjectMocks;
import org.onap.so.bpmn.BaseTaskTest;
import org.onap.so.bpmn.servicedecomposition.bbobjects.InstanceGroup;
+import org.onap.so.bpmn.servicedecomposition.bbobjects.ServiceInstance;
import org.onap.so.bpmn.servicedecomposition.entities.ResourceKey;
import org.onap.so.client.exception.BBObjectNotFoundException;
+import org.onap.so.client.namingservice.NamingRequestObject;
public class NamingServiceDeleteTasksTest extends BaseTaskTest {
@InjectMocks
private NamingServiceDeleteTasks namingServiceDeleteTasks = new NamingServiceDeleteTasks();
private InstanceGroup instanceGroup;
+ private ServiceInstance serviceInstance;
@Before
public void before() throws BBObjectNotFoundException {
verify(namingServiceResources, times(1)).deleteInstanceGroupName(instanceGroup);
}
+ @Test
+ public void deleteServiceInstanceNameTest() throws Exception {
+ serviceInstance = setServiceInstance();
+ when(extractPojosForBB.extractByKey(any(), ArgumentMatchers.eq(ResourceKey.SERVICE_INSTANCE_ID)))
+ .thenReturn(serviceInstance);
+ doNothing().when(namingRequestObject).setExternalKeyValue(serviceInstance.getServiceInstanceId());
+ doReturn("").when(namingServiceResources).deleteServiceInstanceName(namingRequestObject);
+ namingServiceDeleteTasks.deleteServiceInstanceName(execution);
+ verify(namingServiceResources, times(1)).deleteServiceInstanceName(any(NamingRequestObject.class));
+ }
+
}
--- /dev/null
+package org.onap.so.bpmn.infrastructure.workflow.tasks;
+
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.doReturn;
+import java.io.File;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+import org.mockito.InjectMocks;
+import org.mockito.Mockito;
+import org.onap.aai.domain.yang.AggregateRoute;
+import org.onap.aai.domain.yang.AggregateRoutes;
+import org.onap.aai.domain.yang.L3Network;
+import org.onap.aai.domain.yang.RouteTarget;
+import org.onap.aai.domain.yang.RouteTargets;
+import org.onap.aai.domain.yang.Subnet;
+import org.onap.aai.domain.yang.Subnets;
+import org.onap.aai.domain.yang.VpnBinding;
+import org.onap.so.bpmn.BaseTaskTest;
+import org.onap.so.client.aai.AAIObjectType;
+import org.onap.so.client.aai.entities.AAIResultWrapper;
+import org.onap.so.client.aai.entities.uri.AAIResourceUri;
+import org.onap.so.db.catalog.beans.ConfigurationResourceCustomization;
+import org.onap.so.db.catalog.beans.Service;
+import org.onap.so.db.catalog.beans.ServiceProxyResourceCustomization;
+import com.fasterxml.jackson.core.JsonParseException;
+import com.fasterxml.jackson.databind.JsonMappingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+
+public class VrfValidationTest extends BaseTaskTest {
+
+ protected ObjectMapper mapper = new ObjectMapper();
+
+ @InjectMocks
+ protected VrfValidation vrfValidation;
+
+ @Rule
+ public ExpectedException exceptionRule = ExpectedException.none();
+
+ @Before
+ public void before() throws Exception {
+ vrfValidation.setBbInputSetupUtils(bbSetupUtils);
+ }
+
+ @Test
+ public void testVrfServiceValidation() throws VrfBondingServiceException {
+ Service service = new Service();
+ service.setModelName("modelName");
+ service.setServiceType("BONDING");
+ service.setServiceRole("VPN");
+ exceptionRule.expect(VrfBondingServiceException.class);
+ exceptionRule.expectMessage(
+ "Service: modelName does not have service type of BONDING and does not have service role of INFRASTRUCTURE-VPN");
+ vrfValidation.vrfServiceValidation(service);
+
+ service.setServiceType("BOND");
+ service.setServiceRole("INFRASTRUCTURE-VPN");
+ exceptionRule.expect(VrfBondingServiceException.class);
+ exceptionRule.expectMessage(
+ "Service: modelName does not have service type of BONDING and does not have service role of INFRASTRUCTURE-VPN");
+ vrfValidation.vrfServiceValidation(service);
+
+ service.setServiceType("BONDING");
+ service.setServiceRole("INFRASTRUCTURE-VPN");
+ ExpectedException.none();
+ vrfValidation.vrfServiceValidation(service);
+ }
+
+ @Test
+ public void testVrfCatalogDbChecks() throws VrfBondingServiceException {
+ Service service = new Service();
+ service.setModelName("modelName");
+ ConfigurationResourceCustomization configuration = new ConfigurationResourceCustomization();
+ service.setConfigurationCustomizations(new ArrayList<>());
+ service.getConfigurationCustomizations().add(configuration);
+ ServiceProxyResourceCustomization serviceProxy = new ServiceProxyResourceCustomization();
+ configuration.setServiceProxyResourceCustomization(serviceProxy);
+ service.setServiceProxyCustomizations(new ArrayList<>());
+ service.getServiceProxyCustomizations().add(serviceProxy);
+ Service sourceService = new Service();
+ sourceService.setServiceType("TRANSPORT");
+ serviceProxy.setSourceService(sourceService);
+ configuration.setType("VRF-ENTRY");
+ configuration.setRole("INFRASTRUCTURE-CLOUD-VPN");
+ ExpectedException.none();
+ vrfValidation.vrfCatalogDbChecks(service);
+ }
+
+ @Test
+ public void testAaiVpnBindingValidation() throws VrfBondingServiceException {
+ org.onap.aai.domain.yang.VpnBinding aaiVpnBinding = new org.onap.aai.domain.yang.VpnBinding();
+ aaiVpnBinding.setVpnType("SERVICE-INFRASTRUCTURE");
+ ExpectedException.none();
+ vrfValidation.aaiVpnBindingValidation(aaiVpnBinding);
+ }
+
+ @Test
+ public void testAaiAggregateRouteValidation() throws VrfBondingServiceException {
+ org.onap.aai.domain.yang.L3Network aaiLocalNetwork = new org.onap.aai.domain.yang.L3Network();
+ aaiLocalNetwork.setAggregateRoutes(new AggregateRoutes());
+ aaiLocalNetwork.getAggregateRoutes().getAggregateRoute().add(new AggregateRoute());
+ aaiLocalNetwork.getAggregateRoutes().getAggregateRoute().get(0).setIpVersion("4");
+ ExpectedException.none();
+ vrfValidation.aaiAggregateRouteValidation(aaiLocalNetwork);
+
+ aaiLocalNetwork.getAggregateRoutes().getAggregateRoute().add(new AggregateRoute());
+ aaiLocalNetwork.getAggregateRoutes().getAggregateRoute().get(1).setIpVersion("6");
+ ExpectedException.none();
+ vrfValidation.aaiAggregateRouteValidation(aaiLocalNetwork);
+
+ aaiLocalNetwork.setAggregateRoutes(null);
+ ExpectedException.none();
+ vrfValidation.aaiAggregateRouteValidation(aaiLocalNetwork);
+ }
+
+ @Test
+ public void testAaiSubnetValidation() throws VrfBondingServiceException {
+ org.onap.aai.domain.yang.L3Network aaiLocalNetwork = new org.onap.aai.domain.yang.L3Network();
+ aaiLocalNetwork.setNetworkId("myNetworkID");
+ aaiLocalNetwork.setSubnets(new Subnets());
+ aaiLocalNetwork.getSubnets().getSubnet().add(new Subnet());
+ aaiLocalNetwork.getSubnets().getSubnet().get(0).setIpVersion("4");
+ ExpectedException.none();
+ vrfValidation.aaiSubnetValidation(aaiLocalNetwork);
+
+ aaiLocalNetwork.getSubnets().getSubnet().add(new Subnet());
+ aaiLocalNetwork.getSubnets().getSubnet().get(1).setIpVersion("6");
+ ExpectedException.none();
+ vrfValidation.aaiSubnetValidation(aaiLocalNetwork);
+
+ aaiLocalNetwork.setSubnets(null);
+ exceptionRule.expect(VrfBondingServiceException.class);
+ exceptionRule.expectMessage("LocalNetwork: myNetworkID has no subnets");
+ vrfValidation.aaiSubnetValidation(aaiLocalNetwork);
+ }
+
+ @Test
+ public void testIpVersionValidation() {
+ String ipVersion1 = "4";
+ String ipVersion2 = "6";
+ boolean validation = vrfValidation.ipVersionValidation(ipVersion1, ipVersion2);
+ assertEquals("Validation is correct", true, validation);
+
+
+ validation = vrfValidation.ipVersionValidation(ipVersion2, ipVersion1);
+ assertEquals("Validation is correct", true, validation);
+
+ ipVersion1 = "6";
+ validation = vrfValidation.ipVersionValidation(ipVersion1, ipVersion2);
+ assertEquals("Validation is correct", false, validation);
+ }
+
+ @Test
+ public void testAaiRouteTargetValidation()
+ throws VrfBondingServiceException, JsonParseException, JsonMappingException, IOException {
+ L3Network l3Network = mapper.readValue(
+ new File("src/test/resources/__files/BuildingBlocks/aaiNetworkWrapper.json"), L3Network.class);
+ AAIResultWrapper networkWrapper = new AAIResultWrapper(l3Network);
+ if (networkWrapper.getRelationships().isPresent()) {
+ List<AAIResourceUri> vpnBindingUris =
+ networkWrapper.getRelationships().get().getRelatedUris(AAIObjectType.VPN_BINDING);
+ VpnBinding vpnBinding = new VpnBinding();
+ vpnBinding.setRouteTargets(new RouteTargets());
+ vpnBinding.getRouteTargets().getRouteTarget().add(new RouteTarget());
+ AAIResultWrapper wrapper = Mockito.mock(AAIResultWrapper.class);
+ doReturn(wrapper).when(bbSetupUtils).getAAIResourceDepthOne(vpnBindingUris.get(0));
+ doReturn(Optional.of(vpnBinding)).when(wrapper).asBean(VpnBinding.class);
+ ExpectedException.none();
+ vrfValidation.aaiRouteTargetValidation(l3Network);
+ }
+ }
+}
package org.onap.so.bpmn.infrastructure.workflow.tasks;
+import static com.shazam.shazamcrest.matcher.Matchers.sameBeanAs;
import static org.hamcrest.CoreMatchers.containsString;
import static org.hamcrest.CoreMatchers.equalTo;
import static org.junit.Assert.*;
import org.camunda.bpm.engine.delegate.BpmnError;
import org.camunda.bpm.engine.delegate.DelegateExecution;
import org.camunda.bpm.extension.mockito.delegate.DelegateExecutionFake;
+import org.javatuples.Pair;
import org.junit.Before;
import org.junit.Ignore;
import org.junit.Rule;
ServiceInstancesRequest sIRequest = mapper.readValue(bpmnRequest, ServiceInstancesRequest.class);
List<Resource> resourceCounter = new ArrayList<>();
thrown.expect(BpmnError.class);
- workflowAction.traverseCatalogDbService(execution, sIRequest, resourceCounter);
+ List<Pair<WorkflowType, String>> aaiResourceIds = new ArrayList<>();
+ workflowAction.traverseCatalogDbService(execution, sIRequest, resourceCounter, aaiResourceIds);
}
@Test
assertNotNull(result);
}
+ @Test
+ public void traverseAAIServiceTest() {
+ List<Resource> resourceCounter = new ArrayList<>();
+ String resourceId = "si0";
+ List<Pair<WorkflowType, String>> aaiResourceIds = new ArrayList<>();
+
+ ServiceInstance serviceInstanceAAI = new ServiceInstance();
+ serviceInstanceAAI.setServiceInstanceId(resourceId);
+
+ org.onap.so.bpmn.servicedecomposition.bbobjects.ServiceInstance serviceInstance = setServiceInstance();
+ setGenericVnf();
+ setVfModule(true);
+ setVolumeGroup();
+ setL3Network();
+ setCollection();
+ setConfiguration();
+
+ Configuration config = new Configuration();
+ config.setConfigurationId("testConfigurationId2");
+ serviceInstance.getConfigurations().add(config);
+
+ Relationship relationship1 = new Relationship();
+ relationship1.setRelatedTo("vnfc");
+ RelationshipList relationshipList1 = new RelationshipList();
+ relationshipList1.getRelationship().add(relationship1);
+
+ Relationship relationship2 = new Relationship();
+ relationship2.setRelatedTo("vpn-binding");
+ RelationshipList relationshipList2 = new RelationshipList();
+ relationshipList2.getRelationship().add(relationship2);
+
+ org.onap.aai.domain.yang.Configuration aaiConfiguration1 = new org.onap.aai.domain.yang.Configuration();
+ aaiConfiguration1.setConfigurationId("testConfigurationId");
+ aaiConfiguration1.setRelationshipList(relationshipList1);
+
+ org.onap.aai.domain.yang.Configuration aaiConfiguration2 = new org.onap.aai.domain.yang.Configuration();
+ aaiConfiguration2.setConfigurationId("testConfigurationId2");
+ aaiConfiguration2.setRelationshipList(relationshipList1);
+
+ try {
+ doReturn(serviceInstanceAAI).when(bbSetupUtils).getAAIServiceInstanceById(resourceId);
+ doReturn(serviceInstance).when(bbInputSetup).getExistingServiceInstance(serviceInstanceAAI);
+ doReturn(Optional.of(aaiConfiguration1)).when(aaiConfigurationResources)
+ .getConfiguration("testConfigurationId");
+ doReturn(Optional.of(aaiConfiguration2)).when(aaiConfigurationResources)
+ .getConfiguration("testConfigurationId2");
+ workflowAction.traverseAAIService(execution, resourceCounter, resourceId, aaiResourceIds);
+ assertEquals(8, resourceCounter.size());
+ assertThat(aaiResourceIds, sameBeanAs(getExpectedResourceIds()));
+ } catch (Exception e) {
+ fail("Unexpected exception was thrown.");
+ }
+ }
+
+ private List<Pair<WorkflowType, String>> getExpectedResourceIds() {
+ List<Pair<WorkflowType, String>> resourceIds = new ArrayList<>();
+ resourceIds.add(new Pair<WorkflowType, String>(WorkflowType.VNF, "testVnfId1"));
+ resourceIds.add(new Pair<WorkflowType, String>(WorkflowType.VFMODULE, "testVfModuleId1"));
+ resourceIds.add(new Pair<WorkflowType, String>(WorkflowType.VOLUMEGROUP, "testVolumeGroupId1"));
+ resourceIds.add(new Pair<WorkflowType, String>(WorkflowType.NETWORK, "testNetworkId1"));
+ resourceIds.add(new Pair<WorkflowType, String>(WorkflowType.NETWORKCOLLECTION, "testId"));
+ resourceIds.add(new Pair<WorkflowType, String>(WorkflowType.CONFIGURATION, "testConfigurationId"));
+ resourceIds.add(new Pair<WorkflowType, String>(WorkflowType.CONFIGURATION, "testConfigurationId2"));
+ return resourceIds;
+ }
+
private List<OrchestrationFlow> createFlowList(String... flowNames) {
List<OrchestrationFlow> result = new ArrayList<>();
for (String flowName : flowNames) {
private NamingClientResponseValidator responseValidator = new NamingClientResponseValidator();
private String instanceGroupName = "generatedInstanceGroupName";
+ private String serviceInstanceName = "generatedServiceInstanceName";
@Test
public void validateNameGenResponseSuccessTest() throws BadResponseException {
assertEquals(actual, "generatedInstanceGroupName");
}
+ @Test
+ public void validateServiceInstanceNameGenResponseSuccessTest() throws BadResponseException {
+ NameGenResponse name = new NameGenResponse();
+ Respelement respElement = new Respelement();
+ respElement.setResourceName("Service-Instance-Name");
+ respElement.setResourceValue(serviceInstanceName);
+ List<Respelement> respList = new ArrayList<Respelement>();
+ respList.add(respElement);
+ name.setElements(respList);
+ ResponseEntity<NameGenResponse> resp = new ResponseEntity<>(name, null, HttpStatus.OK);
+
+ String actual = responseValidator.validateNameGenResponse(resp);
+
+ assertEquals(actual, "generatedServiceInstanceName");
+ }
+
@Test
public void validateNameGenResponseNoNameGeneratedTest() throws BadResponseException {
NameGenResponse name = new NameGenResponse();
--- /dev/null
+/*-
+ * ============LICENSE_START=======================================================
+ * ONAP - SO
+ * ================================================================================
+ * Copyright (C) 2017 - 2019 AT&T Intellectual Property. All rights reserved.
+ * ================================================================================
+ * 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.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.so.client.namingservice;
+
+import static com.shazam.shazamcrest.matcher.Matchers.sameBeanAs;
+import static org.junit.Assert.assertThat;
+import java.util.HashMap;
+import org.junit.Test;
+import org.onap.namingservice.model.Element;
+
+public class NamingRequestObjectTest {
+
+ private String externalKey = "95cbbe59-1017-4c13-b4e8-d824e54def3e";
+ private String policyInstanceName = "MSO_Policy.Config_MS_VNFInstanceGroup";
+ private String namingType = "Service";
+ private String nfNamingCode = "NamingCode";
+ private String resourceName = "resourceName";
+ private String serviceModelName = "serviceModelName";
+ private String modelVersion = "modelVersion";
+ private String zoneId = "zoneId";
+
+ @Test
+ public void namingRequestObjectTest() {
+
+ Element expected = new Element();
+ expected.put(NamingServiceConstants.NS_EXTERNAL_KEY, externalKey);
+ expected.put(NamingServiceConstants.NS_POLICY_INSTANCE_NAME, policyInstanceName);
+ expected.put(NamingServiceConstants.NS_NAMING_TYPE, namingType);
+ expected.put(NamingServiceConstants.NS_RESOURCE_NAME, resourceName);
+ expected.put(NamingServiceConstants.NS_NF_NAMING_CODE, nfNamingCode);
+
+ NamingRequestObject namingRequestObject = new NamingRequestObject();
+ namingRequestObject.setExternalKeyValue(externalKey);
+ namingRequestObject.setPolicyInstanceNameValue(policyInstanceName);
+ namingRequestObject.setNamingTypeValue(namingType);
+ namingRequestObject.setNfNamingCodeValue(nfNamingCode);
+ namingRequestObject.setResourceNameValue(resourceName);
+
+ HashMap<String, String> actual = namingRequestObject.getNamingRequestObjectMap();
+ assertThat(actual, sameBeanAs(expected));
+ }
+
+ @Test
+ public void namingWanTransportRequestObjectTest() {
+
+ Element expected = new Element();
+ expected.put(NamingServiceConstants.NS_EXTERNAL_KEY, externalKey);
+ expected.put(NamingServiceConstants.NS_POLICY_INSTANCE_NAME, policyInstanceName);
+ expected.put(NamingServiceConstants.NS_NAMING_TYPE, namingType);
+ expected.put(NamingServiceConstants.NS_RESOURCE_NAME, resourceName);
+ expected.put(NamingServiceConstants.NS_SERVICE_MODEL_NAME, serviceModelName);
+ expected.put(NamingServiceConstants.NS_MODEL_VERSION, modelVersion);
+ expected.put(NamingServiceConstants.NS_ZONE_ID, zoneId);
+
+ NamingRequestObject namingRequestObject = new NamingRequestObject();
+ namingRequestObject.setExternalKeyValue(externalKey);
+ namingRequestObject.setPolicyInstanceNameValue(policyInstanceName);
+ namingRequestObject.setNamingTypeValue(namingType);
+ namingRequestObject.setResourceNameValue(resourceName);
+ namingRequestObject.setModelVersionValue(modelVersion);
+ namingRequestObject.setServiceModelNameValue(serviceModelName);
+ namingRequestObject.setZoneIdValue(zoneId);
+
+ HashMap<String, String> actual = namingRequestObject.getNamingRequestObjectMap();
+ assertThat(actual, sameBeanAs(expected));
+ }
+}
--- /dev/null
+/*-
+ * ============LICENSE_START=======================================================
+ * ONAP - SO
+ * ================================================================================
+ * Copyright (C) 2017 - 2019 AT&T Intellectual Property. All rights reserved.
+ * ================================================================================
+ * 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.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.so.client.namingservice;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.when;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.ArgumentMatchers;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.onap.so.bpmn.BaseTaskTest;
+import org.onap.so.bpmn.servicedecomposition.bbobjects.ServiceInstance;
+import org.onap.so.bpmn.servicedecomposition.entities.ResourceKey;
+import org.onap.so.bpmn.servicedecomposition.modelinfo.ModelInfoServiceInstance;
+import org.onap.so.client.exception.BBObjectNotFoundException;
+
+public class NamingRequestUtilsTest extends BaseTaskTest {
+
+ @Mock
+ private ServiceInstance serviceInstanceMock;
+
+ @Mock
+ ModelInfoServiceInstance modelInfoServiceInstanceMock;
+
+ @InjectMocks
+ private NamingServiceUtils namingServiceUtils = new NamingServiceUtils();
+
+ @Before
+ public void before() throws BBObjectNotFoundException {
+ when(extractPojosForBB.extractByKey(any(), ArgumentMatchers.eq(ResourceKey.SERVICE_INSTANCE_ID)))
+ .thenReturn(serviceInstanceMock);
+ doReturn(modelInfoServiceInstanceMock).when(serviceInstanceMock).getModelInfoServiceInstance();
+ }
+
+ @Test
+ public void checkVpnBondingServiceTest() {
+ doReturn("bonding").when(modelInfoServiceInstanceMock).getServiceType();
+ doReturn("infrastructure-vpn").when(modelInfoServiceInstanceMock).getServiceRole();
+ doReturn("testNaminPolicy").when(modelInfoServiceInstanceMock).getNamingPolicy();
+ doReturn(true).when(modelInfoServiceInstanceMock).getOnapGeneratedNaming();
+ namingServiceUtils.checkVpnBondingService(execution);
+ assertTrue(execution.getVariable("isVpnBondingService"));
+
+ doReturn("bonding-false").when(modelInfoServiceInstanceMock).getServiceType();
+ doReturn("infrastructure-vpn").when(modelInfoServiceInstanceMock).getServiceRole();
+ namingServiceUtils.checkVpnBondingService(execution);
+ assertFalse(execution.getVariable("isVpnBondingService"));
+ }
+
+ @Test
+ public void checkBondingAndInfrastureVpnTrueTest() {
+ doReturn("bonding").when(modelInfoServiceInstanceMock).getServiceType();
+ doReturn("infrastructure-vpn").when(modelInfoServiceInstanceMock).getServiceRole();
+ namingServiceUtils.checkBondingAndInfrastureVpn(execution);
+ assertTrue(execution.getVariable("isBondingAndInsfrastructureVpn"));
+ }
+
+ @Test
+ public void checkBondingAndInfrastureVpnFalse1Test() {
+ doReturn("falseBonding").when(modelInfoServiceInstanceMock).getServiceType();
+ doReturn("infrastructure-vpn").when(modelInfoServiceInstanceMock).getServiceRole();
+ namingServiceUtils.checkBondingAndInfrastureVpn(execution);
+ assertFalse(execution.getVariable("isBondingAndInsfrastructureVpn"));
+ }
+
+ @Test
+ public void checkBondingAndInfrastureVpnFalse2Test() {
+ doReturn("bonding").when(modelInfoServiceInstanceMock).getServiceType();
+ doReturn("false-infrastructure-vpn").when(modelInfoServiceInstanceMock).getServiceRole();
+ namingServiceUtils.checkBondingAndInfrastureVpn(execution);
+ assertFalse(execution.getVariable("isBondingAndInsfrastructureVpn"));
+ }
+
+ @Test
+ public void checkNamingPolicyAndAndEcompGeneratedNaming_TrueTest() {
+ doReturn("testNaminPolicy").when(modelInfoServiceInstanceMock).getNamingPolicy();
+ doReturn(true).when(modelInfoServiceInstanceMock).getOnapGeneratedNaming();
+ namingServiceUtils.checkNamingPolicyAndOnapGeneratedNaming(execution);
+ assertTrue(execution.getVariable("isNamingPolicyAndOnapGeneratedNaming"));
+ }
+
+ @Test
+ public void checkNamingPolicyAndAndEcompGeneratedNamingFalse1Test() throws BBObjectNotFoundException {
+ doReturn(null).when(modelInfoServiceInstanceMock).getNamingPolicy();
+ doReturn(true).when(modelInfoServiceInstanceMock).getOnapGeneratedNaming();
+ namingServiceUtils.checkNamingPolicyAndOnapGeneratedNaming(execution);
+ assertFalse(execution.getVariable("isNamingPolicyAndOnapGeneratedNaming"));
+ }
+
+ @Test
+ public void checkNamingPolicyAndAndEcompGeneratedNamingFalse2Test() throws BBObjectNotFoundException {
+ doReturn("testNaminPolicy").when(modelInfoServiceInstanceMock).getNamingPolicy();
+ doReturn(false).when(modelInfoServiceInstanceMock).getOnapGeneratedNaming();
+ namingServiceUtils.checkNamingPolicyAndOnapGeneratedNaming(execution);
+ assertFalse(execution.getVariable("isNamingPolicyAndOnapGeneratedNaming"));
+ }
+
+ @Test
+ public void checkNamingPolicyAndAndEcompGeneratedNamingFalse3Test() throws BBObjectNotFoundException {
+ doReturn("").when(modelInfoServiceInstanceMock).getNamingPolicy();
+ doReturn(false).when(modelInfoServiceInstanceMock).getOnapGeneratedNaming();
+ namingServiceUtils.checkNamingPolicyAndOnapGeneratedNaming(execution);
+ assertFalse(execution.getVariable("isNamingPolicyAndOnapGeneratedNaming"));
+ }
+
+ @Test
+ public void checkNamingPolicyAndAndEcompGeneratedNamingFalse4Test() throws BBObjectNotFoundException {
+ doReturn("bonding").when(modelInfoServiceInstanceMock).getNamingPolicy();
+ doReturn(null).when(modelInfoServiceInstanceMock).getOnapGeneratedNaming();
+ namingServiceUtils.checkNamingPolicyAndOnapGeneratedNaming(execution);
+ assertFalse(execution.getVariable("isNamingPolicyAndOnapGeneratedNaming"));
+ }
+
+}
* 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.
verify(MOCK_aaiResourcesClient, times(1)).update(any(AAIResourceUri.class), ArgumentMatchers.isNull());
assertEquals(OrchestrationStatus.ACTIVE, configuration.getOrchestrationStatus());
}
+
+ @Test
+ public void updateConfigurationOrchestrationStatusTest() throws Exception {
+ doNothing().when(MOCK_aaiResourcesClient).update(isA(AAIResourceUri.class),
+ isA(org.onap.aai.domain.yang.Configuration.class));
+ aaiConfigurationResources.updateConfigurationOrchestrationStatus(configuration, OrchestrationStatus.ACTIVE);
+ verify(MOCK_aaiResourcesClient, times(1)).update(any(AAIResourceUri.class),
+ any(org.onap.aai.domain.yang.Configuration.class));
+ }
}
import org.onap.namingservice.model.NameGenResponse;
import org.onap.so.bpmn.servicedecomposition.bbobjects.InstanceGroup;
import org.onap.so.client.namingservice.NamingClient;
+import org.onap.so.client.namingservice.NamingRequestObject;
import org.onap.so.client.namingservice.NamingRequestObjectBuilder;
+import org.onap.so.client.namingservice.NamingServiceConstants;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
}
+ @Test
+ public void generateServiceInstanceNameTest() throws Exception {
+
+ NameGenRequest req = new NameGenRequest();
+ doReturn("generatedServiceInstanceName").when(MOCK_namingClient).postNameGenRequest(isA(NameGenRequest.class));
+ doReturn(req).when(MOCK_namingRequestObjectBuilder).nameGenRequestMapper(isA(List.class));
+ NamingRequestObject nrObject = new NamingRequestObject();
+ nrObject.setExternalKeyValue("testExternalKey");
+ nrObject.setNamingTypeValue(NamingServiceConstants.NAMING_TYPE_SERVICE);
+ nrObject.setResourceNameValue(NamingServiceConstants.RESOURCE_NAME_SERVICE_INSTANCE_NAME);
+ nrObject.setPolicyInstanceNameValue(execution.getVariable("policyInstanceName"));
+ nrObject.setServiceModelNameValue("testServiceInstanceModelName");
+ nrObject.setModelVersionValue("testServiceInstanceModelVersion");
+ nrObject.setZoneIdValue(execution.getVariable("zoneId"));
+
+ String generatedName = namingServiceResources.generateServiceInstanceName(nrObject);
+
+ verify(MOCK_namingClient, times(1)).postNameGenRequest(any(NameGenRequest.class));
+ assertEquals("generatedServiceInstanceName", generatedName);
+ }
}
"modelVersion" : "testProxyModelVersion1",
"modelInvariantId" : "testProxyModelInvariantUuid1"
},
- "requiredCandidates" : [ {
+ "filteringAttributes" : [ {
"identifierType" : "cloudRegionId",
"identifiers" : [ "testCloudRegionId" ],
"cloudOwner" : "att"
--- /dev/null
+{
+ "networkId": "0384d743-f69b-4cc8-9aa8-c3ae66662c44",
+ "networkName": "Dev_Bindings_1802_020118",
+ "networkType": "CONTRAIL30_BASIC",
+ "networkRole": "GN_EVPN_direct",
+ "networkTechnology": "contrail",
+ "neutronNetworkId": "1112b912-0e00-4d6d-9392-014e106399ee",
+ "isBoundToVpn": true,
+ "serviceId": "a9a77d5a-123e-4ca2-9eb9-0b015d2ee0fb",
+ "networkRoleInstance": 0,
+ "resourceVersion": "1517496965485",
+ "orchestrationStatus": "Active",
+ "heatStackId": "Dev_Bindings_1802_020118/06c2445f-1ca1-4ad8-be08-454c4de443bb",
+ "contrailNetworkFqdn": "default-domain:ECOMP_MSO_DND:Dev_Bindings_1802_020118",
+ "physicalNetworkName": "tbd",
+ "isProviderNetwork": false,
+ "isSharedNetwork": true,
+ "isExternalNetwork": false,
+ "relationshipList": {
+ "relationship": [
+ {
+ "relatedTo": "vpn-binding",
+ "relatedLink": "/aai/v11/network/vpn-bindings/vpn-binding/9a7b327d9-287aa00-82c4b0-100001",
+ "relationshipData": [
+ {
+ "relationshipKey": "vpn-binding.vpn-id",
+ "relationshipValue": "9a7b327d9-287aa00-82c4b0-100001"
+ }
+ ],
+ "relatedToProperty": [
+ {
+ "propertyKey": "vpn-binding.vpn-name",
+ "propertyValue": "MSO_VPN_TEST"
+ },
+ {
+ "propertyKey": "vpn-binding.vpn-type"
+ }
+ ]
+ }
+ ]
+ }
+}
\ No newline at end of file
"modelType": "service",
"modelInvariantId": "5d48acb5-097d-4982-aeb2-f4a3bd87d31b",
"modelVersionId": "3c40d244-808e-42ca-b09a-256d83d19d0a",
- "modelName": "MOW AVPN vMX BV vPE 1 Service",
+ "modelName": "Sample Service Model",
"modelVersion": "10"
},
"cloudConfiguration": {
{
"service": {
"modelInfo": {
- "modelName": "MOW AVPN vMX BV vPE 1 Service",
+ "modelName": "Sample Service Model",
"modelVersionId": "3c40d244-808e-42ca-b09a-256d83d19d0a"
},
"instanceParams": [],
"modelType": "service",
"modelInvariantId": "5d48acb5-097d-4982-aeb2-f4a3bd87d31b",
"modelVersionId": "3c40d244-808e-42ca-b09a-256d83d19d0a",
- "modelName": "MOW AVPN vMX BV vPE 1 Service",
+ "modelName": "Sample Service Model",
"modelVersion": "10.0"
},
"cloudConfiguration": {
"modelType": "service",
"modelInvariantId": "5d48acb5-097d-4982-aeb2-f4a3bd87d31b",
"modelVersionId": "3c40d244-808e-42ca-b09a-256d83d19d0a",
- "modelName": "MOW AVPN vMX BV vPE 1 Service",
+ "modelName": "Sample Service Model",
"modelVersion": "10.0"
},
"cloudConfiguration": {
"service": {
"modelInfo": {
"modelType": "service",
- "modelName": "MOW AVPN vMX BV vPE 1 Service",
+ "modelName": "Sample Service Model",
"modelVersionId": "3c40d244-808e-42ca-b09a-256d83d19d0a"
},
"instanceParams": [],
"modelType": "service",
"modelInvariantId": "5d48acb5-097d-4982-aeb2-f4a3bd87d31b",
"modelVersionId": "3c40d244-808e-42ca-b09a-256d83d19d0a",
- "modelName": "MOW AVPN vMX BV vPE 1 Service",
+ "modelName": "Sample Service Model",
"modelVersion": "10.0"
},
"owningEntity": {
"service": {
"modelInfo": {
"modelType": "service",
- "modelName": "MOW AVPN vMX BV vPE 1 Service",
+ "modelName": "Sample Service Model",
"modelVersionId": "3c40d244-808e-42ca-b09a-256d83d19d0a"
},
"instanceParams": [],
import org.onap.aai.domain.yang.VolumeGroup;
import org.onap.aai.domain.yang.VpnBinding;
import org.onap.aai.domain.yang.Vserver;
+import org.onap.aai.domain.yang.Zone;
import org.onap.so.client.graphinventory.GraphInventoryObjectType;
import org.onap.so.constants.Defaults;
import org.reflections.Reflections;
"/esr-vnfm/{vnfm-id}/esr-system-info-list", "vnfm-esr-system-info-list");
public static final AAIObjectType CLOUD_ESR_SYSTEM_INFO_LIST = new AAIObjectType(
AAIObjectType.CLOUD_REGION.uriTemplate(), "/esr-system-info-list", "cloud-esr-system-info-list");
-
+ public static final AAIObjectType ZONE = new AAIObjectType(AAINamespaceConstants.NETWORK, Zone.class);
private final String uriTemplate;
private final String parentUri;
connectionPoint("connectionPoint"),
pnf("pnf"),
networkInstanceGroup("networkInstanceGroup"),
- instanceGroup("instanceGroup");
+ instanceGroup("instanceGroup"),
+ vpnBinding("vpnBinding");
final String name;
isRelatedServiceInstancePresent = true;
}
+ if (requestScope.equalsIgnoreCase(ModelType.service.name())) {
+ if (empty(relatedInstance.getInstanceName())
+ && ModelType.vpnBinding.equals(relatedInstanceModelInfo.getModelType())) {
+ throw new ValidationException("instanceName in relatedInstance for vpnBinding modelType", true);
+ }
+ if (empty(relatedInstance.getInstanceName())
+ && ModelType.network.equals(relatedInstanceModelInfo.getModelType())) {
+ throw new ValidationException("instanceName in relatedInstance for network modelType", true);
+ }
+ }
+
if (action != Action.deleteInstance
&& !requestScope.equalsIgnoreCase(ModelType.instanceGroup.toString())) {
if (!(relatedInstanceModelInfo.getModelType().equals(ModelType.volumeGroup)
|| relatedInstanceModelInfo.getModelType().equals(ModelType.connectionPoint)
|| relatedInstanceModelInfo.getModelType().equals(ModelType.pnf)
- || relatedInstanceModelInfo.getModelType().equals(ModelType.networkInstanceGroup))) {
+ || relatedInstanceModelInfo.getModelType().equals(ModelType.networkInstanceGroup)
+ || relatedInstanceModelInfo.getModelType().equals(ModelType.network)
+ || relatedInstanceModelInfo.getModelType().equals(ModelType.vpnBinding))) {
if (empty(relatedInstanceModelInfo.getModelInvariantId())) {
throw new ValidationException("modelInvariantId in relatedInstance");
return input;
}
+ public String inputStreamVpnBonding(String JsonInput) throws IOException {
+ JsonInput = "src/test/resources/Validation" + JsonInput;
+ String input = new String(Files.readAllBytes(Paths.get(JsonInput)));
+ return input;
+ }
+
// Tests for successful validation of incoming JSON requests through the parse method
@Test
@Parameters(method = "successParameters")
instanceIdMapTest, Action.addRelationships, "5"},
{mapper.readValue(inputStream("/SuccessfulValidation/ServiceAssign.json"),
ServiceInstancesRequest.class), instanceIdMapTest, Action.assignInstance, "7"},
+ {mapper.readValue(inputStream("/RelatedInstances/ServiceInstanceVpnBondingService.json"),
+ ServiceInstancesRequest.class), instanceIdMapTest, Action.createInstance, "7"},
{mapper.readValue(inputStream("/SuccessfulValidation/ServiceUnassign.json"),
ServiceInstancesRequest.class), instanceIdMapTest, Action.unassignInstance, "7"}});
}
mapper.readValue(inputStream("/RelatedInstances/v6AddRelationshipsInstanceName.json"),
ServiceInstancesRequest.class),
instanceIdMapTest, Action.addRelationships, 6},
+ {"No valid modelType in relatedInstance is specified",
+ mapper.readValue(inputStreamVpnBonding("/VpnBondingValidation/NoModelType.json"),
+ ServiceInstancesRequest.class),
+ instanceIdMapTest, Action.createInstance, 7},
+ {"No valid instanceId in relatedInstance is specified",
+ mapper.readValue(inputStreamVpnBonding("/VpnBondingValidation/NoInstanceId.json"),
+ ServiceInstancesRequest.class),
+ instanceIdMapTest, Action.createInstance, 7},
+ {"No valid instanceName in relatedInstance for vpnBinding modelType is specified",
+ mapper.readValue(inputStreamVpnBonding("/VpnBondingValidation/NoInstanceNameVpnBinding.json"),
+ ServiceInstancesRequest.class),
+ instanceIdMapTest, Action.createInstance, 7},
+ {"No valid instanceName in relatedInstance for network modelType is specified",
+ mapper.readValue(inputStreamVpnBonding("/VpnBondingValidation/NoInstanceNameNetwork.json"),
+ ServiceInstancesRequest.class),
+ instanceIdMapTest, Action.createInstance, 7},
{"No valid modelCustomizationName or modelCustomizationId in relatedInstance of vnf is specified",
mapper.readValue(inputStream("/RelatedInstances/RelatedInstancesModelCustomizationId.json"),
ServiceInstancesRequest.class),
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.HashMap;
+import org.junit.Rule;
import org.junit.Test;
+import org.junit.rules.ExpectedException;
import org.onap.so.apihandlerinfra.Action;
import org.onap.so.apihandlerinfra.BaseTest;
import org.onap.so.exceptions.ValidationException;
+import org.onap.so.serviceinstancebeans.RelatedInstanceList;
import org.onap.so.serviceinstancebeans.ServiceInstancesRequest;
import com.fasterxml.jackson.databind.ObjectMapper;
public class RelatedInstancesValidationTest extends BaseTest {
+ RelatedInstancesValidation validation = new RelatedInstancesValidation();
+
+ @Rule
+ public ExpectedException thrown = ExpectedException.none();
+
+ public ValidationInformation setupValidationInformation(String path) throws IOException {
+ String jsonInput = new String(Files.readAllBytes(Paths.get(path)));
+ ObjectMapper mapper = new ObjectMapper();
+ ServiceInstancesRequest sir = mapper.readValue(jsonInput, ServiceInstancesRequest.class);
+ ValidationInformation info = new ValidationInformation(sir, null, Action.createInstance, 7, false,
+ sir.getRequestDetails().getRequestParameters());
+
+ info.setRequestScope("service");
+ sir.setServiceInstanceId("0fd90c0c-0e3a-46e2-abb5-4c4820d5985b");
+ sir.getRequestDetails().getModelInfo().setModelCustomizationName("name");
+
+ info.setRequestInfo(sir.getRequestDetails().getRequestInfo());
+ return info;
+ }
+
@Test
public void testCreateVnfNetworkInstanceGroup() throws IOException, ValidationException {
String requestJson = new String(Files.readAllBytes(
assertEquals(info.getVnfType(), "Test/name");
}
+
+ @Test
+ public void testCreateSIVpnBonding() throws IOException, ValidationException {
+ String requestJson = new String(Files.readAllBytes(
+ Paths.get("src/test/resources/MsoRequestTest/RelatedInstances/ServiceInstanceVpnBondingService.json")));
+ ObjectMapper mapper = new ObjectMapper();
+ ServiceInstancesRequest sir = mapper.readValue(requestJson, ServiceInstancesRequest.class);
+ ValidationInformation info = new ValidationInformation(sir, new HashMap<String, String>(),
+ Action.createInstance, 7, false, sir.getRequestDetails().getRequestParameters());
+ info.setRequestScope("service");
+ sir.setServiceInstanceId("0fd90c0c-0e3a-46e2-abb5-4c4820d5985b");
+ sir.getRequestDetails().getModelInfo().setModelCustomizationName("name");
+ RelatedInstancesValidation validation = new RelatedInstancesValidation();
+ validation.validate(info);
+ RelatedInstanceList[] instanceList = sir.getRequestDetails().getRelatedInstanceList();
+
+ assertEquals(info.getRequestScope(), "service");
+ assertEquals(instanceList[0].getRelatedInstance().getModelInfo().getModelType().toString(), "vpnBinding");
+ assertEquals(instanceList[1].getRelatedInstance().getModelInfo().getModelType().toString(), "network");
+ }
+
+ @Test
+ public void validateModelTypeExceptionTest() throws IOException, ValidationException {
+ thrown.expect(ValidationException.class);
+ thrown.expectMessage("No valid modelType in relatedInstance is specified");
+ validation.validate(
+ setupValidationInformation("src/test/resources/Validation/VpnBondingValidation/NoModelType.json"));
+ }
+
+ @Test
+ public void validateInstanceNameVpnBindingExceptionTest() throws IOException, ValidationException {
+ thrown.expect(ValidationException.class);
+ thrown.expectMessage("No valid instanceName in relatedInstance for vpnBinding modelType is specified");
+ validation.validate(setupValidationInformation(
+ "src/test/resources/Validation/VpnBondingValidation/NoInstanceNameVpnBinding.json"));
+ }
+
+ @Test
+ public void validateInstanceNameNetworkExceptionTest() throws IOException, ValidationException {
+ thrown.expect(ValidationException.class);
+ thrown.expectMessage("No valid instanceName in relatedInstance for network modelType is specified");
+ validation.validate(setupValidationInformation(
+ "src/test/resources/Validation/VpnBondingValidation/NoInstanceNameNetwork.json"));
+ }
+
+ @Test
+ public void validateInstanceIdExceptionTest() throws IOException, ValidationException {
+ thrown.expect(ValidationException.class);
+ thrown.expectMessage("No valid instanceId in relatedInstance is specified");
+ validation.validate(
+ setupValidationInformation("src/test/resources/Validation/VpnBondingValidation/NoInstanceId.json"));
+ }
+
+ @Test
+ public void validatemodelInvariantIdExceptionTest() throws IOException, ValidationException {
+ thrown.expect(ValidationException.class);
+ thrown.expectMessage("No valid modelInvariantId in relatedInstance is specified");
+ validation.validate(setupValidationInformation(
+ "src/test/resources/Validation/VpnBondingValidation/NoModelInvariantId.json"));
+ }
}
--- /dev/null
+{
+ "requestDetails": {
+ "modelInfo": {
+ "modelType": "service",
+ "modelInvariantId": "1710f6e8-1c29-4990-9aea-e943a2ec3d21",
+ "modelVersionId": "1710966e-097c-4d63-afda-e0d3bb7015fb",
+ "modelName": "Test",
+ "modelVersion": "1.0"
+ },
+ "cloudConfiguration": {
+ "cloudOwner": "test-mgr",
+ "lcpCloudRegionId": "abc1",
+ "tenantId": "19123c2924c648eb8e42a3c1f14b7682"
+ },
+ "owningEntity": {
+ "owningEntityId": "038d99af-0427-42c2-9d15-971b99b9b489",
+ "owningEntityName": "PACKET CORE"
+ },
+ "project": {
+ "projectName": "projectName"
+ },
+ "subscriberInfo": {
+ "globalSubscriberId": "TEST_123",
+ "subscriberName": "TEST_123"
+ },
+ "requestInfo": {
+ "productFamilyId": "a9a77d5a-123e-4ca2-9eb9-0b015d2ee0fb",
+ "requestorId": "xxxxxx",
+ "source": "VID",
+ "suppressRollback": false
+ },
+ "relatedInstanceList": [
+ {
+ "relatedInstance": {
+ "instanceId": "ff305d54-75b4-431b-adb2-eb6b9e5ff000",
+ "instanceName": "vpn-name",
+ "modelInfo": {
+ "modelType": "vpnBinding"
+ }
+ }
+ },
+ {
+ "relatedInstance": {
+ "instanceId": "ff305d54-75b4-431b-adb2-eb6b9e5ff000",
+ "instanceName": "network-name",
+ "modelInfo": {
+ "modelType": "network"
+ }
+ }
+ }
+ ],
+ "requestParameters": {
+ "subscriptionServiceType": "dev-service-type",
+ "aLaCarte": false
+ }
+ }
+}
\ No newline at end of file
--- /dev/null
+{
+ "requestDetails": {
+ "modelInfo": {
+ "modelType": "service",
+ "modelInvariantId": "1710f6e8-1c29-4990-9aea-e943a2ec3d21",
+ "modelVersionId": "1710966e-097c-4d63-afda-e0d3bb7015fb",
+ "modelName": "Test",
+ "modelVersion": "1.0"
+ },
+ "cloudConfiguration": {
+ "cloudOwner": "test-mgr",
+ "lcpCloudRegionId": "abc1",
+ "tenantId": "19123c2924c648eb8e42a3c1f14b7682"
+ },
+ "owningEntity": {
+ "owningEntityId": "038d99af-0427-42c2-9d15-971b99b9b489",
+ "owningEntityName": "PACKET CORE"
+ },
+ "project": {
+ "projectName": "projectName"
+ },
+ "subscriberInfo": {
+ "globalSubscriberId": "TEST_123",
+ "subscriberName": "TEST_123"
+ },
+ "requestInfo": {
+ "productFamilyId": "a9a77d5a-123e-4ca2-9eb9-0b015d2ee0fb",
+ "requestorId": "xxxxxx",
+ "source": "VID",
+ "suppressRollback": false
+ },
+ "relatedInstanceList": [
+ {
+ "relatedInstance": {
+ "instanceId": "ff305d54-75b4-431b-adb2-eb6b9e5ff000",
+ "instanceName": "vpn-name",
+ "modelInfo": {
+ "modelType": "vpnBinding"
+ }
+ }
+ },
+ {
+ "relatedInstance": {
+ "instanceId": "ff305d54-75b4-431b-adb2-eb6b9e5ff000",
+ "instanceName": "network-name",
+ "modelInfo": {
+ "modelType": "network"
+ }
+ }
+ }
+ ],
+ "requestParameters": {
+ "subscriptionServiceType": "dev-service-type",
+ "aLaCarte": false
+ }
+ }
+}
\ No newline at end of file
--- /dev/null
+{
+ "requestDetails": {
+ "modelInfo": {
+ "modelType": "service",
+ "modelInvariantId": "1710f6e8-1c29-4990-9aea-e943a2ec3d21",
+ "modelVersionId": "1710966e-097c-4d63-afda-e0d3bb7015fb",
+ "modelName": "Test",
+ "modelVersion": "1.0"
+ },
+ "cloudConfiguration": {
+ "cloudOwner": "test-mgr",
+ "lcpCloudRegionId": "abc1",
+ "tenantId": "19123c2924c648eb8e42a3c1f14b7682"
+ },
+ "owningEntity": {
+ "owningEntityId": "038d99af-0427-42c2-9d15-971b99b9b489",
+ "owningEntityName": "PACKET CORE"
+ },
+ "project": {
+ "projectName": "projectName"
+ },
+ "subscriberInfo": {
+ "globalSubscriberId": "TEST_123",
+ "subscriberName": "TEST_123"
+ },
+ "requestInfo": {
+ "productFamilyId": "a9a77d5a-123e-4ca2-9eb9-0b015d2ee0fb",
+ "requestorId": "xxxxxx",
+ "source": "VID",
+ "suppressRollback": false
+ },
+ "relatedInstanceList": [
+ {
+ "relatedInstance": {
+ "instanceName": "vpn-name",
+ "modelInfo": {
+ "modelType": "vpnBinding"
+ }
+ }
+ },
+ {
+ "relatedInstance": {
+ "instanceId": "ff305d54-75b4-431b-adb2-eb6b9e5ff000",
+ "instanceName": "network-name",
+ "modelInfo": {
+ "modelType": "network"
+ }
+ }
+ }
+ ],
+ "requestParameters": {
+ "subscriptionServiceType": "dev-service-type",
+ "aLaCarte": false
+ }
+ }
+}
\ No newline at end of file
--- /dev/null
+{
+ "requestDetails": {
+ "modelInfo": {
+ "modelType": "service",
+ "modelInvariantId": "1710f6e8-1c29-4990-9aea-e943a2ec3d21",
+ "modelVersionId": "1710966e-097c-4d63-afda-e0d3bb7015fb",
+ "modelName": "Test",
+ "modelVersion": "1.0"
+ },
+ "cloudConfiguration": {
+ "cloudOwner": "test-mgr",
+ "lcpCloudRegionId": "abc1",
+ "tenantId": "19123c2924c648eb8e42a3c1f14b7682"
+ },
+ "owningEntity": {
+ "owningEntityId": "038d99af-0427-42c2-9d15-971b99b9b489",
+ "owningEntityName": "PACKET CORE"
+ },
+ "project": {
+ "projectName": "projectName"
+ },
+ "subscriberInfo": {
+ "globalSubscriberId": "TEST_123",
+ "subscriberName": "TEST_123"
+ },
+ "requestInfo": {
+ "productFamilyId": "a9a77d5a-123e-4ca2-9eb9-0b015d2ee0fb",
+ "requestorId": "xxxxxx",
+ "source": "VID",
+ "suppressRollback": false
+ },
+ "relatedInstanceList": [
+ {
+ "relatedInstance": {
+ "instanceId": "ff305d54-75b4-431b-adb2-eb6b9e5ff000",
+ "instanceName": "vpn-name",
+ "modelInfo": {
+ "modelType": "vpnBinding"
+ }
+ }
+ },
+ {
+ "relatedInstance": {
+ "instanceId": "ff305d54-75b4-431b-adb2-eb6b9e5ff000",
+ "modelInfo": {
+ "modelType": "network"
+ }
+ }
+ }
+ ],
+ "requestParameters": {
+ "subscriptionServiceType": "dev-service-type",
+ "aLaCarte": false
+ }
+ }
+}
\ No newline at end of file
--- /dev/null
+{
+ "requestDetails": {
+ "modelInfo": {
+ "modelType": "service",
+ "modelInvariantId": "1710f6e8-1c29-4990-9aea-e943a2ec3d21",
+ "modelVersionId": "1710966e-097c-4d63-afda-e0d3bb7015fb",
+ "modelName": "Test",
+ "modelVersion": "1.0"
+ },
+ "cloudConfiguration": {
+ "cloudOwner": "test-mgr",
+ "lcpCloudRegionId": "abc1",
+ "tenantId": "19123c2924c648eb8e42a3c1f14b7682"
+ },
+ "owningEntity": {
+ "owningEntityId": "038d99af-0427-42c2-9d15-971b99b9b489",
+ "owningEntityName": "PACKET CORE"
+ },
+ "project": {
+ "projectName": "projectName"
+ },
+ "subscriberInfo": {
+ "globalSubscriberId": "TEST_123",
+ "subscriberName": "TEST_123"
+ },
+ "requestInfo": {
+ "productFamilyId": "a9a77d5a-123e-4ca2-9eb9-0b015d2ee0fb",
+ "requestorId": "xxxxxx",
+ "source": "VID",
+ "suppressRollback": false
+ },
+ "relatedInstanceList": [
+ {
+ "relatedInstance": {
+ "instanceId": "ff305d54-75b4-431b-adb2-eb6b9e5ff000",
+ "modelInfo": {
+ "modelType": "vpnBinding"
+ }
+ }
+ },
+ {
+ "relatedInstance": {
+ "instanceId": "ff305d54-75b4-431b-adb2-eb6b9e5ff000",
+ "instanceName": "network-name",
+ "modelInfo": {
+ "modelType": "network"
+ }
+ }
+ }
+ ],
+ "requestParameters": {
+ "subscriptionServiceType": "dev-service-type",
+ "aLaCarte": false
+ }
+ }
+}
\ No newline at end of file
--- /dev/null
+{
+ "requestDetails": {
+ "modelInfo": {
+ "modelType": "service",
+ "modelInvariantId": "1710f6e8-1c29-4990-9aea-e943a2ec3d21",
+ "modelVersionId": "1710966e-097c-4d63-afda-e0d3bb7015fb",
+ "modelName": "Test",
+ "modelVersion": "1.0"
+ },
+ "cloudConfiguration": {
+ "cloudOwner": "test-mgr",
+ "lcpCloudRegionId": "abc1",
+ "tenantId": "19123c2924c648eb8e42a3c1f14b7682"
+ },
+ "owningEntity": {
+ "owningEntityId": "038d99af-0427-42c2-9d15-971b99b9b489",
+ "owningEntityName": "PACKET CORE"
+ },
+ "project": {
+ "projectName": "projectName"
+ },
+ "subscriberInfo": {
+ "globalSubscriberId": "TEST_123",
+ "subscriberName": "TEST_123"
+ },
+ "requestInfo": {
+ "productFamilyId": "a9a77d5a-123e-4ca2-9eb9-0b015d2ee0fb",
+ "requestorId": "xxxxxx",
+ "source": "VID",
+ "suppressRollback": false
+ },
+ "relatedInstanceList": [
+ {
+ "relatedInstance": {
+ "instanceId": "ff305d54-75b4-431b-adb2-eb6b9e5ff000",
+ "instanceName": "vpn-name",
+ "modelInfo": {
+ "modelType": "vnf"
+ }
+ }
+ },
+ {
+ "relatedInstance": {
+ "instanceId": "ff305d54-75b4-431b-adb2-eb6b9e5ff000",
+ "instanceName": "network-name",
+ "modelInfo": {
+ "modelType": "service"
+ }
+ }
+ }
+ ],
+ "requestParameters": {
+ "subscriptionServiceType": "dev-service-type",
+ "aLaCarte": false
+ }
+ }
+}
\ No newline at end of file
--- /dev/null
+{
+ "requestDetails": {
+ "modelInfo": {
+ "modelType": "service",
+ "modelInvariantId": "1710f6e8-1c29-4990-9aea-e943a2ec3d21",
+ "modelVersionId": "1710966e-097c-4d63-afda-e0d3bb7015fb",
+ "modelName": "Test",
+ "modelVersion": "1.0"
+ },
+ "cloudConfiguration": {
+ "cloudOwner": "test-mgr",
+ "lcpCloudRegionId": "abc1",
+ "tenantId": "19123c2924c648eb8e42a3c1f14b7682"
+ },
+ "owningEntity": {
+ "owningEntityId": "038d99af-0427-42c2-9d15-971b99b9b489",
+ "owningEntityName": "PACKET CORE"
+ },
+ "project": {
+ "projectName": "projectName"
+ },
+ "subscriberInfo": {
+ "globalSubscriberId": "TEST_123",
+ "subscriberName": "TEST_123"
+ },
+ "requestInfo": {
+ "productFamilyId": "a9a77d5a-123e-4ca2-9eb9-0b015d2ee0fb",
+ "requestorId": "xxxxxx",
+ "source": "VID",
+ "suppressRollback": false
+ },
+ "relatedInstanceList": [
+ {
+ "relatedInstance": {
+ "instanceId": "ff305d54-75b4-431b-adb2-eb6b9e5ff000",
+ "instanceName": "vpn-name",
+ "modelInfo": {
+ }
+ }
+ },
+ {
+ "relatedInstance": {
+ "instanceId": "ff305d54-75b4-431b-adb2-eb6b9e5ff000",
+ "instanceName": "network-name",
+ "modelInfo": {
+ "modelType": "network"
+ }
+ }
+ }
+ ],
+ "requestParameters": {
+ "subscriptionServiceType": "dev-service-type",
+ "aLaCarte": false
+ }
+ }
+}
\ No newline at end of file
`WORKLOAD_CONTEXT` varchar(200) DEFAULT NULL,
`SERVICE_CATEGORY` varchar(200) DEFAULT NULL,
`RESOURCE_ORDER` varchar(200) default NULL,
+ `OVERALL_DISTRIBUTION_STATUS` varchar(45),
+ `ONAP_GENERATED_NAMING` TINYINT(1) DEFAULT NULL,
+ `NAMING_POLICY` varchar(200) DEFAULT NULL,
PRIMARY KEY (`MODEL_UUID`),
KEY `fk_service__tosca_csar1_idx` (`TOSCA_CSAR_ARTIFACT_UUID`),
CONSTRAINT `fk_service__tosca_csar1` FOREIGN KEY (`TOSCA_CSAR_ARTIFACT_UUID`) REFERENCES `tosca_csar` (`ARTIFACT_UUID`) ON DELETE CASCADE ON UPDATE CASCADE
@Temporal(TemporalType.TIMESTAMP)
private Date created;
- @Column(name = "SERVICE_PROXY_CUSTOMIZATION_MODEL_CUSTOMIZATION_UUID")
- private String serviceProxyResourceCustomizationUUID;
+ @OneToOne(cascade = CascadeType.ALL, fetch = FetchType.LAZY)
+ @JoinColumn(name = "SERVICE_PROXY_CUSTOMIZATION_MODEL_CUSTOMIZATION_UUID")
+ private ServiceProxyResourceCustomization serviceProxyResourceCustomization;
@OneToOne(cascade = CascadeType.ALL, fetch = FetchType.LAZY)
@JoinColumn(name = "CONFIGURATION_CUSTOMIZATION_MODEL_CUSTOMIZATION_ID")
return created;
}
- public String getServiceProxyResourceCustomizationUUID() {
- return serviceProxyResourceCustomizationUUID;
+ @LinkedResource
+ public ServiceProxyResourceCustomization getServiceProxyResourceCustomization() {
+ return serviceProxyResourceCustomization;
}
- public void setServiceProxyResourceCustomizationUUID(String serviceProxyResourceCustomizationUUID) {
- this.serviceProxyResourceCustomizationUUID = serviceProxyResourceCustomizationUUID;
+ public void setServiceProxyResourceCustomization(
+ ServiceProxyResourceCustomization serviceProxyResourceCustomization) {
+ this.serviceProxyResourceCustomization = serviceProxyResourceCustomization;
}
* 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.
/**
* case insensitive regular expression match to enum value
- *
+ *
* @param status
* @return
*/
@JoinColumn(name = "TOSCA_CSAR_ARTIFACT_UUID")
private ToscaCsar csar;
+ @Column(name = "NAMING_POLICY")
+ private String namingPolicy;
+
+ @Column(name = "ONAP_GENERATED_NAMING")
+ private Boolean onapGeneratedNaming;
@Override
public String toString() {
.append("serviceProxyCustomizations", serviceProxyCustomizations)
.append("configurationCustomizations", configurationCustomizations)
.append("pnfCustomizations", pnfCustomizations).append("recipes", recipes).append("csar", csar)
- .toString();
+ .append("namingPolicy", namingPolicy).append("onapGeneratedNaming", onapGeneratedNaming).toString();
}
@PrePersist
this.resourceOrder = resourceOrder;
}
-
public String getDistrobutionStatus() {
return distrobutionStatus;
}
this.distrobutionStatus = distrobutionStatus;
}
+ public String getNamingPolicy() {
+ return namingPolicy;
+ }
+
+ public void setNamingPolicy(String namingPolicy) {
+ this.namingPolicy = namingPolicy;
+ }
+
+ public Boolean getOnapGeneratedNaming() {
+ return onapGeneratedNaming;
+ }
+
+ public void setOnapGeneratedNaming(Boolean onapGeneratedNaming) {
+ this.onapGeneratedNaming = onapGeneratedNaming;
+ }
+
}
`WORKLOAD_CONTEXT` varchar(200) DEFAULT NULL,
`SERVICE_CATEGORY` varchar(200) DEFAULT NULL,
`RESOURCE_ORDER` varchar(200) default NULL,
- OVERALL_DISTRIBUTION_STATUS varchar(45),
+ `OVERALL_DISTRIBUTION_STATUS` varchar(45),
+ `ONAP_GENERATED_NAMING` TINYINT(1) DEFAULT NULL,
+ `NAMING_POLICY` varchar(200) DEFAULT NULL,
PRIMARY KEY (`MODEL_UUID`),
KEY `fk_service__tosca_csar1_idx` (`TOSCA_CSAR_ARTIFACT_UUID`),
CONSTRAINT `fk_service__tosca_csar1` FOREIGN KEY (`TOSCA_CSAR_ARTIFACT_UUID`) REFERENCES `tosca_csar` (`ARTIFACT_UUID`) ON DELETE CASCADE ON UPDATE CASCADE
Code Review / so.git / commitdiff