* 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.
package org.onap.so.bpmn.servicedecomposition.tasks;
import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import org.onap.aai.domain.yang.CloudRegion;
import org.onap.aai.domain.yang.Configuration;
+import org.onap.aai.domain.yang.Configurations;
import org.onap.aai.domain.yang.GenericVnf;
import org.onap.aai.domain.yang.GenericVnfs;
import org.onap.aai.domain.yang.InstanceGroup;
import org.onap.aai.domain.yang.L3Network;
import org.onap.aai.domain.yang.L3Networks;
+import org.onap.aai.domain.yang.Pnf;
import org.onap.aai.domain.yang.ServiceInstance;
import org.onap.aai.domain.yang.ServiceInstances;
import org.onap.aai.domain.yang.ServiceSubscription;
import org.onap.aai.domain.yang.VolumeGroup;
import org.onap.aai.domain.yang.VolumeGroups;
import org.onap.aai.domain.yang.VpnBinding;
+import org.onap.aaiclient.client.aai.AAIResourcesClient;
+import org.onap.aaiclient.client.aai.entities.AAIResultWrapper;
+import org.onap.aaiclient.client.aai.entities.uri.AAIFluentSingleType;
+import org.onap.aaiclient.client.aai.entities.uri.AAIPluralResourceUri;
+import org.onap.aaiclient.client.aai.entities.uri.AAIResourceUri;
+import org.onap.aaiclient.client.aai.entities.uri.AAIUriFactory;
+import org.onap.aaiclient.client.generated.fluentbuilders.AAIFluentTypeBuilder;
+import org.onap.aaiclient.client.generated.fluentbuilders.AAIFluentTypeBuilder.Types;
+import org.onap.aaiclient.client.graphinventory.entities.uri.Depth;
import org.onap.so.bpmn.common.InjectionHelper;
import org.onap.so.bpmn.servicedecomposition.bbobjects.Customer;
+import org.onap.so.bpmn.servicedecomposition.entities.ExecuteBuildingBlock;
import org.onap.so.bpmn.servicedecomposition.tasks.exceptions.MultipleObjectsFoundException;
import org.onap.so.bpmn.servicedecomposition.tasks.exceptions.NoServiceInstanceFoundException;
-import org.onap.so.client.aai.AAIObjectPlurals;
-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.client.aai.entities.uri.AAIUriFactory;
-import org.onap.so.client.graphinventory.entities.uri.Depth;
import org.onap.so.db.catalog.beans.CollectionNetworkResourceCustomization;
import org.onap.so.db.catalog.beans.CollectionResourceInstanceGroupCustomization;
import org.onap.so.db.catalog.beans.CvnfcConfigurationCustomization;
import org.onap.so.db.catalog.beans.VnfcInstanceGroupCustomization;
import org.onap.so.db.catalog.client.CatalogDbClient;
import org.onap.so.db.request.beans.InfraActiveRequests;
+import org.onap.so.db.request.beans.RequestProcessingData;
import org.onap.so.db.request.client.RequestsDbClient;
import org.onap.so.serviceinstancebeans.CloudConfiguration;
import org.onap.so.serviceinstancebeans.ModelType;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
+import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
+import com.fasterxml.jackson.databind.type.TypeFactory;
@Component("BBInputSetupUtils")
public class BBInputSetupUtils {
private static final Logger logger = LoggerFactory.getLogger(BBInputSetupUtils.class);
- private ObjectMapper objectMapper = new ObjectMapper();
private static final String REQUEST_ERROR = "Could not find request.";
+ private static final String DATA_LOAD_ERROR = "Could not process loading data from database";
+ private static final String DATA_PARSE_ERROR = "Could not parse data";
+ private static final String PROCESSING_DATA_NAME_EXECUTION_FLOWS = "flowExecutionPath";
@Autowired
protected CatalogDbClient catalogDbClient;
}
}
+ public void persistFlowExecutionPath(String requestId, List<ExecuteBuildingBlock> flowsToExecute) {
+
+ if (requestId != null) {
+ List<String> flows = new ArrayList<>();
+ ObjectMapper om = new ObjectMapper();
+ try {
+ for (ExecuteBuildingBlock ebb : flowsToExecute) {
+ flows.add(om.writeValueAsString(ebb));
+ }
+ } catch (JsonProcessingException e) {
+ logger.error(DATA_PARSE_ERROR, e);
+ }
+
+ this.requestsDbClient.persistProcessingData(flows.toString(), requestId);
+ } else {
+ logger.debug(REQUEST_ERROR);
+ }
+ }
+
+ public InfraActiveRequests loadInfraActiveRequestById(String requestId) {
+
+ return this.requestsDbClient.getInfraActiveRequestbyRequestId(requestId);
+ }
+
+ public InfraActiveRequests loadOriginalInfraActiveRequestById(String requestId) {
+ return this.requestsDbClient.getInfraActiveRequestbyRequestId(
+ this.requestsDbClient.getInfraActiveRequestbyRequestId(requestId).getOriginalRequestId());
+ }
+
+ public List<ExecuteBuildingBlock> loadOriginalFlowExecutionPath(String requestId) {
+ if (requestId != null) {
+ InfraActiveRequests request = loadInfraActiveRequestById(requestId);
+ if (request.getOriginalRequestId() != null) {
+ RequestProcessingData requestProcessingData =
+ this.requestsDbClient.getRequestProcessingDataBySoRequestIdAndName(
+ request.getOriginalRequestId(), PROCESSING_DATA_NAME_EXECUTION_FLOWS);
+ try {
+ ObjectMapper om = new ObjectMapper();
+ TypeFactory typeFactory = om.getTypeFactory();
+ om.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
+ return om.readValue(requestProcessingData.getValue(),
+ typeFactory.constructCollectionType(List.class, ExecuteBuildingBlock.class));
+ } catch (Exception e) {
+ logger.error(DATA_LOAD_ERROR, e);
+ throw new RuntimeException("Error Loading Original Request Data", e);
+ }
+ } else {
+ throw new RuntimeException("Original Request Id is null for record: " + requestId);
+ }
+ } else {
+ throw new RuntimeException("Null Request Id Passed in");
+ }
+ }
+
public Service getCatalogServiceByModelUUID(String modelUUID) {
return catalogDbClient.getServiceByID(modelUUID);
}
}
public Map<String, String> getURIKeysFromServiceInstance(String serviceInstanceId) {
- AAIResourceUri uri = AAIUriFactory.createResourceUri(AAIObjectType.SERVICE_INSTANCE, serviceInstanceId);
+ AAIResourceUri uri = AAIUriFactory.createResourceUri(Types.SERVICE_INSTANCE.getFragment(serviceInstanceId));
return uri.getURIKeys();
}
if (requestId != null && !requestId.isEmpty()) {
InfraActiveRequests activeRequest = this.getInfraActiveRequest(requestId);
String requestBody = activeRequest.getRequestBody().replaceAll("\\\\", "");
+ ObjectMapper objectMapper = new ObjectMapper();
+ objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
objectMapper.configure(SerializationFeature.WRAP_ROOT_VALUE, true);
objectMapper.configure(DeserializationFeature.UNWRAP_ROOT_VALUE, true);
return objectMapper.readValue(requestBody, RequestDetails.class);
String cloudRegionId = cloudConfiguration.getLcpCloudRegionId();
String cloudOwner = cloudConfiguration.getCloudOwner();
if (cloudRegionId != null && cloudOwner != null && !cloudRegionId.isEmpty() && !cloudOwner.isEmpty()) {
- return injectionHelper.getAaiClient().get(CloudRegion.class, AAIUriFactory
- .createResourceUri(AAIObjectType.CLOUD_REGION, cloudOwner, cloudRegionId).depth(Depth.TWO))
+ return injectionHelper.getAaiClient().get(CloudRegion.class,
+ AAIUriFactory.createResourceUri(
+ AAIFluentTypeBuilder.cloudInfrastructure().cloudRegion(cloudOwner, cloudRegionId))
+ .depth(Depth.ONE).nodesOnly(true))
.orElse(null);
} else {
}
}
- protected InstanceGroup getAAIInstanceGroup(String instanceGroupId) {
- return injectionHelper.getAaiClient().get(InstanceGroup.class,
- AAIUriFactory.createResourceUri(AAIObjectType.INSTANCE_GROUP, instanceGroupId)).orElse(null);
+ public InstanceGroup getAAIInstanceGroup(String instanceGroupId) {
+ return injectionHelper.getAaiClient()
+ .get(InstanceGroup.class,
+ AAIUriFactory.createResourceUri(AAIFluentTypeBuilder.network().instanceGroup(instanceGroupId)))
+ .orElse(null);
}
public org.onap.aai.domain.yang.Customer getAAICustomer(String globalSubscriberId) {
- return injectionHelper.getAaiClient().get(org.onap.aai.domain.yang.Customer.class,
- AAIUriFactory.createResourceUri(AAIObjectType.CUSTOMER, globalSubscriberId)).orElse(null);
+ return injectionHelper.getAaiClient()
+ .get(org.onap.aai.domain.yang.Customer.class,
+ AAIUriFactory.createResourceUri(AAIFluentTypeBuilder.business().customer(globalSubscriberId)))
+ .orElse(null);
}
public ServiceSubscription getAAIServiceSubscription(String globalSubscriberId, String subscriptionServiceType) {
|| subscriptionServiceType.equals("")) {
return null;
} else {
- return injectionHelper.getAaiClient().get(ServiceSubscription.class, AAIUriFactory
- .createResourceUri(AAIObjectType.SERVICE_SUBSCRIPTION, globalSubscriberId, subscriptionServiceType))
+ return injectionHelper
+ .getAaiClient().get(ServiceSubscription.class, AAIUriFactory.createResourceUri(AAIFluentTypeBuilder
+ .business().customer(globalSubscriberId).serviceSubscription(subscriptionServiceType)))
.orElse(null);
}
public ServiceInstance getAAIServiceInstanceById(String serviceInstanceId) {
return injectionHelper.getAaiClient()
.get(ServiceInstance.class, AAIUriFactory
- .createResourceUri(AAIObjectType.SERVICE_INSTANCE, serviceInstanceId).depth(Depth.TWO))
+ .createResourceUri(Types.SERVICE_INSTANCE.getFragment(serviceInstanceId)).depth(Depth.TWO))
.orElse(null);
}
protected ServiceInstance getAAIServiceInstanceByIdAndCustomer(String globalCustomerId, String serviceType,
String serviceInstanceId) {
- return injectionHelper.getAaiClient().get(ServiceInstance.class, AAIUriFactory
- .createResourceUri(AAIObjectType.SERVICE_INSTANCE, globalCustomerId, serviceType, serviceInstanceId)
- .depth(Depth.TWO)).orElse(null);
- }
-
- protected org.onap.aai.domain.yang.ServiceInstances getAAIServiceInstancesByName(String serviceInstanceName,
- Customer customer) {
-
- return injectionHelper.getAaiClient()
- .get(org.onap.aai.domain.yang.ServiceInstances.class,
- AAIUriFactory
- .createResourceUri(AAIObjectPlurals.SERVICE_INSTANCE, customer.getGlobalCustomerId(),
- customer.getServiceSubscription().getServiceType())
- .queryParam("service-instance-name", serviceInstanceName).depth(Depth.TWO))
- .orElseGet(() -> {
- logger.debug("No Service Instance matched by name");
- return null;
- });
+ return injectionHelper.getAaiClient().get(ServiceInstance.class,
+ AAIUriFactory.createResourceUri(AAIFluentTypeBuilder.business().customer(globalCustomerId)
+ .serviceSubscription(serviceType).serviceInstance(serviceInstanceId)).depth(Depth.TWO))
+ .orElse(null);
}
public org.onap.aai.domain.yang.ServiceInstance getAAIServiceInstanceByName(String serviceInstanceName,
Customer customer) throws Exception {
- org.onap.aai.domain.yang.ServiceInstance aaiServiceInstance = null;
- org.onap.aai.domain.yang.ServiceInstances aaiServiceInstances = null;
- aaiServiceInstances = getAAIServiceInstancesByName(serviceInstanceName, customer);
+ Optional<org.onap.aai.domain.yang.ServiceInstance> aaiServiceInstance = injectionHelper.getAaiClient().getOne(
+ ServiceInstances.class, org.onap.aai.domain.yang.ServiceInstance.class,
+ AAIUriFactory.createResourceUri(AAIFluentTypeBuilder.business().customer(customer.getGlobalCustomerId())
+ .serviceSubscription(customer.getServiceSubscription().getServiceType()).serviceInstances())
+ .queryParam("service-instance-name", serviceInstanceName).depth(Depth.TWO));
- if (aaiServiceInstances == null) {
- return null;
- } else if (aaiServiceInstances.getServiceInstance().size() > 1) {
- throw new Exception("Multiple Service Instances Returned");
- } else {
- aaiServiceInstance = aaiServiceInstances.getServiceInstance().get(0);
- }
- return aaiServiceInstance;
- }
-
- protected ServiceInstances getAAIServiceInstancesByName(String globalCustomerId, String serviceType,
- String serviceInstanceName) {
-
- return injectionHelper.getAaiClient()
- .get(ServiceInstances.class,
- AAIUriFactory
- .createResourceUri(AAIObjectPlurals.SERVICE_INSTANCE, globalCustomerId, serviceType)
- .queryParam("service-instance-name", serviceInstanceName).depth(Depth.TWO))
- .orElseGet(() -> {
- logger.debug("No Service Instance matched by name");
- return null;
- });
+ return aaiServiceInstance.orElse(null);
}
public Optional<ServiceInstance> getAAIServiceInstanceByName(String globalCustomerId, String serviceType,
- String serviceInstanceName) throws Exception {
- ServiceInstance aaiServiceInstance = null;
- ServiceInstances aaiServiceInstances = null;
- aaiServiceInstances = getAAIServiceInstancesByName(globalCustomerId, serviceType, serviceInstanceName);
+ String serviceInstanceName) {
- if (aaiServiceInstances == null) {
- return Optional.empty();
- } else if (aaiServiceInstances.getServiceInstance().size() > 1) {
- throw new Exception("Multiple Service Instances Returned");
- } else {
- aaiServiceInstance = aaiServiceInstances.getServiceInstance().get(0);
- }
- return Optional.of(aaiServiceInstance);
+ return injectionHelper.getAaiClient().getOne(ServiceInstances.class, ServiceInstance.class,
+ AAIUriFactory
+ .createResourceUri(AAIFluentTypeBuilder.business().customer(globalCustomerId)
+ .serviceSubscription(serviceType).serviceInstances())
+ .queryParam("service-instance-name", serviceInstanceName).depth(Depth.TWO));
}
public org.onap.so.db.catalog.beans.InstanceGroup getCatalogInstanceGroup(String modelUUID) {
}
public Configuration getAAIConfiguration(String configurationId) {
- return this.injectionHelper.getAaiClient()
- .get(Configuration.class,
- AAIUriFactory.createResourceUri(AAIObjectType.CONFIGURATION, configurationId).depth(Depth.ONE))
- .orElseGet(() -> {
- logger.debug("No Configuration matched by id");
- return null;
- });
+ return this.getConcreteAAIResource(Configuration.class,
+ AAIFluentTypeBuilder.network().configuration(configurationId));
}
public GenericVnf getAAIGenericVnf(String vnfId) {
+ return getConcreteAAIResource(GenericVnf.class, AAIFluentTypeBuilder.network().genericVnf(vnfId));
+ }
- return this.injectionHelper.getAaiClient()
- .get(GenericVnf.class,
- AAIUriFactory.createResourceUri(AAIObjectType.GENERIC_VNF, vnfId).depth(Depth.ONE))
- .orElseGet(() -> {
- logger.debug("No Generic Vnf matched by id");
- return null;
- });
+
+ public Pnf getAAIPnf(String pnfId) {
+ return getConcreteAAIResource(Pnf.class, AAIFluentTypeBuilder.network().pnf(pnfId));
}
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;
- });
+ return getConcreteAAIResource(VpnBinding.class, AAIFluentTypeBuilder.network().vpnBinding(vpnBindingId));
}
public VolumeGroup getAAIVolumeGroup(String cloudOwnerId, String cloudRegionId, String volumeGroupId) {
- return this.injectionHelper.getAaiClient()
- .get(VolumeGroup.class, AAIUriFactory
- .createResourceUri(AAIObjectType.VOLUME_GROUP, cloudOwnerId, cloudRegionId, volumeGroupId)
- .depth(Depth.ONE))
- .orElseGet(() -> {
- logger.debug("No Generic Vnf matched by id");
- return null;
- });
+ return getConcreteAAIResource(VolumeGroup.class, AAIFluentTypeBuilder.cloudInfrastructure()
+ .cloudRegion(cloudOwnerId, cloudRegionId).volumeGroup(volumeGroupId));
}
public VfModule getAAIVfModule(String vnfId, String vfModuleId) {
- return this.injectionHelper.getAaiClient()
- .get(VfModule.class,
- AAIUriFactory.createResourceUri(AAIObjectType.VF_MODULE, vnfId, vfModuleId).depth(Depth.ONE))
- .orElseGet(() -> {
- logger.debug("No Generic Vnf matched by id");
- return null;
- });
+ return getConcreteAAIResource(VfModule.class,
+ AAIFluentTypeBuilder.network().genericVnf(vnfId).vfModule(vfModuleId));
}
public L3Network getAAIL3Network(String networkId) {
+ return getConcreteAAIResource(L3Network.class, AAIFluentTypeBuilder.network().l3Network(networkId));
+ }
- return this.injectionHelper.getAaiClient()
- .get(L3Network.class,
- AAIUriFactory.createResourceUri(AAIObjectType.L3_NETWORK, networkId).depth(Depth.ONE))
+ private <T> T getConcreteAAIResource(Class<T> clazz, AAIFluentSingleType type) {
+ return injectionHelper.getAaiClient().get(clazz, AAIUriFactory.createResourceUri(type).depth(Depth.ONE))
.orElseGet(() -> {
- logger.debug("No Generic Vnf matched by id");
+ logger.debug("No resource of type: {} matched by ids: {}", type.build().typeName(),
+ Arrays.toString(type.values()));
return null;
});
-
}
public Optional<ServiceInstance> getRelatedServiceInstanceFromInstanceGroup(String instanceGroupId)
throws Exception {
- AAIResourceUri uri = AAIUriFactory.createResourceUri(AAIObjectType.INSTANCE_GROUP, instanceGroupId);
- uri.relatedTo(AAIObjectPlurals.SERVICE_INSTANCE);
+ AAIPluralResourceUri uri =
+ AAIUriFactory.createResourceUri(AAIFluentTypeBuilder.network().instanceGroup(instanceGroupId))
+ .relatedTo(Types.SERVICE_INSTANCES.getFragment());
Optional<ServiceInstances> serviceInstances = injectionHelper.getAaiClient().get(ServiceInstances.class, uri);
ServiceInstance serviceInstance = null;
if (!serviceInstances.isPresent()) {
if (serviceInstances.get().getServiceInstance().isEmpty()) {
throw new NoServiceInstanceFoundException("No ServiceInstances Returned");
} else if (serviceInstances.get().getServiceInstance().size() > 1) {
- throw new MultipleObjectsFoundException("Multiple ServiceInstances Returned");
+ String message = String.format("Mulitple service instances were found for instance-group-id: %s.",
+ instanceGroupId);
+ throw new MultipleObjectsFoundException(message);
} else {
serviceInstance = serviceInstances.get().getServiceInstance().get(0);
}
}
public Optional<L3Network> getRelatedNetworkByNameFromServiceInstance(String serviceInstanceId, String networkName)
- throws Exception {
- AAIResourceUri uri = AAIUriFactory.createResourceUri(AAIObjectType.SERVICE_INSTANCE, serviceInstanceId);
- uri.relatedTo(AAIObjectPlurals.L3_NETWORK).queryParam("network-name", networkName);
+ throws MultipleObjectsFoundException {
+ AAIPluralResourceUri uri =
+ AAIUriFactory.createResourceUri(Types.SERVICE_INSTANCE.getFragment(serviceInstanceId))
+ .relatedTo(Types.L3_NETWORKS.getFragment()).queryParam("network-name", networkName);
Optional<L3Networks> networks = injectionHelper.getAaiClient().get(L3Networks.class, uri);
L3Network network = null;
if (!networks.isPresent()) {
return Optional.empty();
} else {
if (networks.get().getL3Network().size() > 1) {
- throw new Exception("Multiple Networks Returned");
+ String message =
+ String.format("Multiple networks found for service-instance-id: %s and network-name: %s.",
+ serviceInstanceId, networkName);
+ throw new MultipleObjectsFoundException(message);
} else {
network = networks.get().getL3Network().get(0);
}
}
}
- public Optional<GenericVnf> getRelatedVnfByNameFromServiceInstance(String serviceInstanceId, String vnfName)
- throws Exception {
- AAIResourceUri uri = AAIUriFactory.createResourceUri(AAIObjectType.SERVICE_INSTANCE, serviceInstanceId);
- uri.relatedTo(AAIObjectPlurals.GENERIC_VNF).queryParam("vnf-name", vnfName);
- Optional<GenericVnfs> vnfs = injectionHelper.getAaiClient().get(GenericVnfs.class, uri);
- GenericVnf vnf = null;
- if (!vnfs.isPresent()) {
- logger.debug("No Vnfs matched by name");
- return Optional.empty();
- } else {
- if (vnfs.get().getGenericVnf().size() > 1) {
- throw new Exception("Multiple Vnfs Returned");
- } else {
- vnf = vnfs.get().getGenericVnf().get(0);
- }
- return Optional.of(vnf);
- }
+ public Optional<GenericVnf> getRelatedVnfByNameFromServiceInstance(String serviceInstanceId, String vnfName) {
+ AAIPluralResourceUri uri =
+ AAIUriFactory.createResourceUri(Types.SERVICE_INSTANCE.getFragment(serviceInstanceId))
+ .relatedTo(Types.GENERIC_VNFS.getFragment()).queryParam("vnf-name", vnfName);
+ return injectionHelper.getAaiClient().getOne(GenericVnfs.class, GenericVnf.class, uri);
+
}
- public Optional<VolumeGroup> getRelatedVolumeGroupByNameFromVnf(String vnfId, String volumeGroupName)
- throws Exception {
- AAIResourceUri uri = AAIUriFactory.createResourceUri(AAIObjectType.GENERIC_VNF, vnfId);
- uri.relatedTo(AAIObjectPlurals.VOLUME_GROUP).queryParam("volume-group-name", volumeGroupName);
- Optional<VolumeGroups> volumeGroups = injectionHelper.getAaiClient().get(VolumeGroups.class, uri);
- VolumeGroup volumeGroup = null;
- if (!volumeGroups.isPresent()) {
- logger.debug("No VolumeGroups matched by name");
- return Optional.empty();
- } else {
- if (volumeGroups.get().getVolumeGroup().size() > 1) {
- throw new Exception("Multiple VolumeGroups Returned");
- } else {
- volumeGroup = volumeGroups.get().getVolumeGroup().get(0);
- }
- return Optional.of(volumeGroup);
- }
+ public Optional<VolumeGroup> getRelatedVolumeGroupByNameFromVnf(String vnfId, String volumeGroupName) {
+ AAIPluralResourceUri uri = AAIUriFactory.createResourceUri(AAIFluentTypeBuilder.network().genericVnf(vnfId))
+ .relatedTo(Types.VOLUME_GROUPS.getFragment()).queryParam("volume-group-name", volumeGroupName);
+ return injectionHelper.getAaiClient().getOne(VolumeGroups.class, VolumeGroup.class, uri);
+ }
+
+ public Optional<VolumeGroup> getRelatedVolumeGroupByIdFromVnf(String vnfId, String volumeGroupId) {
+ AAIPluralResourceUri uri = AAIUriFactory.createResourceUri(AAIFluentTypeBuilder.network().genericVnf(vnfId))
+ .relatedTo(Types.VOLUME_GROUPS.getFragment()).queryParam("volume-group-id", volumeGroupId);
+ return injectionHelper.getAaiClient().getOne(VolumeGroups.class, VolumeGroup.class, uri);
}
public Optional<VolumeGroup> getRelatedVolumeGroupByNameFromVfModule(String vnfId, String vfModuleId,
String volumeGroupName) throws Exception {
- AAIResourceUri uri = AAIUriFactory.createResourceUri(AAIObjectType.VF_MODULE, vnfId, vfModuleId);
- uri.relatedTo(AAIObjectPlurals.VOLUME_GROUP).queryParam("volume-group-name", volumeGroupName);
- Optional<VolumeGroups> volumeGroups = injectionHelper.getAaiClient().get(VolumeGroups.class, uri);
- VolumeGroup volumeGroup = null;
- if (!volumeGroups.isPresent()) {
- logger.debug("No VolumeGroups matched by name");
- return Optional.empty();
- } else {
- if (volumeGroups.get().getVolumeGroup().size() > 1) {
- throw new Exception("Multiple VolumeGroups Returned");
- } else {
- volumeGroup = volumeGroups.get().getVolumeGroup().get(0);
- }
- return Optional.of(volumeGroup);
- }
+ AAIPluralResourceUri uri =
+ AAIUriFactory.createResourceUri(AAIFluentTypeBuilder.network().genericVnf(vnfId).vfModule(vfModuleId))
+ .relatedTo(Types.VOLUME_GROUPS.getFragment()).queryParam("volume-group-name", volumeGroupName);
+ return injectionHelper.getAaiClient().getOne(VolumeGroups.class, VolumeGroup.class, uri);
+ }
+
+ public Optional<VolumeGroup> getRelatedVolumeGroupFromVfModule(String vnfId, String vfModuleId) throws Exception {
+ AAIPluralResourceUri uri =
+ AAIUriFactory.createResourceUri(AAIFluentTypeBuilder.network().genericVnf(vnfId).vfModule(vfModuleId))
+ .relatedTo(Types.VOLUME_GROUPS.getFragment());
+ return injectionHelper.getAaiClient().getOne(VolumeGroups.class, VolumeGroup.class, uri);
}
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()) {
+ && !networkWrapper.getRelationships().get().getRelatedUris(Types.VPN_BINDING).isEmpty()) {
return getAAIResourceDepthOne(
- networkWrapper.getRelationships().get().getRelatedUris(AAIObjectType.VPN_BINDING).get(0))
+ networkWrapper.getRelationships().get().getRelatedUris(Types.VPN_BINDING).get(0))
.asBean(org.onap.aai.domain.yang.VpnBinding.class);
}
return Optional.empty();
}
+
+ public ServiceInstances getAAIServiceInstancesGloballyByName(String serviceInstanceName) {
+
+ return injectionHelper.getAaiClient()
+ .get(ServiceInstances.class, AAIUriFactory.createNodesUri(Types.SERVICE_INSTANCES.getFragment())
+ .queryParam("service-instance-name", serviceInstanceName))
+ .orElseGet(() -> {
+ logger.debug("No Service Instance matched by name");
+ return null;
+ });
+ }
+
+ public boolean existsAAINetworksGloballyByName(String networkName) {
+
+ AAIPluralResourceUri l3networkUri = AAIUriFactory.createResourceUri(AAIFluentTypeBuilder.network().l3Networks())
+ .queryParam("network-name", networkName);
+ AAIResourcesClient aaiRC = injectionHelper.getAaiClient();
+ return aaiRC.exists(l3networkUri);
+ }
+
+ public boolean existsAAIVfModuleGloballyByName(String vfModuleName) {
+ AAIPluralResourceUri vfModuleUri =
+ AAIUriFactory.createNodesUri(Types.VF_MODULES.getFragment()).queryParam("vf-module-name", vfModuleName);
+ return injectionHelper.getAaiClient().exists(vfModuleUri);
+ }
+
+ public boolean existsAAIConfigurationGloballyByName(String configurationName) {
+ AAIPluralResourceUri configUri =
+ AAIUriFactory.createResourceUri(AAIFluentTypeBuilder.network().configurations())
+ .queryParam("configuration-name", configurationName);
+ return injectionHelper.getAaiClient().exists(configUri);
+ }
+
+ public boolean existsAAIVolumeGroupGloballyByName(String volumeGroupName) {
+ AAIPluralResourceUri volumeGroupUri = AAIUriFactory.createNodesUri(Types.VOLUME_GROUPS.getFragment())
+ .queryParam("volume-group-name", volumeGroupName);
+ return injectionHelper.getAaiClient().exists(volumeGroupUri);
+ }
+
+ public GenericVnfs getAAIVnfsGloballyByName(String vnfName) {
+
+ return injectionHelper.getAaiClient()
+ .get(GenericVnfs.class,
+ AAIUriFactory.createNodesUri(Types.GENERIC_VNFS.getFragment()).queryParam("vnf-name", vnfName))
+ .orElseGet(() -> {
+ logger.debug("No GenericVnfs matched by name");
+ return null;
+ });
+ }
+
+ public Optional<Configuration> getRelatedConfigurationByNameFromServiceInstance(String serviceInstanceId,
+ String configurationName) {
+ AAIPluralResourceUri uri = AAIUriFactory
+ .createResourceUri(Types.SERVICE_INSTANCE.getFragment(serviceInstanceId))
+ .relatedTo(Types.CONFIGURATIONS.getFragment()).queryParam("configuration-name", configurationName);
+ return injectionHelper.getAaiClient().getOne(Configurations.class, Configuration.class, uri);
+ }
}