X-Git-Url: https://gerrit.onap.org/r/gitweb?a=blobdiff_plain;f=plans%2Fso%2Fintegration-etsi-testing%2Fso-simulators%2Faai-simulator%2Fsrc%2Fmain%2Fjava%2Forg%2Fonap%2Fso%2Faaisimulator%2Fservice%2Fproviders%2FGenericVnfCacheServiceProviderImpl.java;h=42b2d8720d1772904ff59b584632c7f70ad0a06f;hb=03a107d9254ca0e1fbbf63f2ab5b7f14f1af63f3;hp=0d97ea9938d86b5d050b90d5fdaaf1c055493050;hpb=e5ae05042a015c29e454e8c45f902eb414b32afa;p=integration%2Fcsit.git

diff --git a/plans/so/integration-etsi-testing/so-simulators/aai-simulator/src/main/java/org/onap/so/aaisimulator/service/providers/GenericVnfCacheServiceProviderImpl.java b/plans/so/integration-etsi-testing/so-simulators/aai-simulator/src/main/java/org/onap/so/aaisimulator/service/providers/GenericVnfCacheServiceProviderImpl.java
index 0d97ea99..42b2d872 100644
--- a/plans/so/integration-etsi-testing/so-simulators/aai-simulator/src/main/java/org/onap/so/aaisimulator/service/providers/GenericVnfCacheServiceProviderImpl.java
+++ b/plans/so/integration-etsi-testing/so-simulators/aai-simulator/src/main/java/org/onap/so/aaisimulator/service/providers/GenericVnfCacheServiceProviderImpl.java
@@ -27,6 +27,9 @@ import static org.onap.so.aaisimulator.utils.Constants.GENERIC_VNF_VNF_NAME;
 import static org.onap.so.aaisimulator.utils.HttpServiceUtils.getBiDirectionalRelationShipListRelatedLink;
 import static org.onap.so.aaisimulator.utils.HttpServiceUtils.getRelationShipListRelatedLink;
 import static org.onap.so.aaisimulator.utils.HttpServiceUtils.getTargetUrl;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
 import java.util.Optional;
 import java.util.concurrent.ConcurrentHashMap;
 import org.onap.aai.domain.yang.GenericVnf;
@@ -34,6 +37,9 @@ import org.onap.aai.domain.yang.RelatedToProperty;
 import org.onap.aai.domain.yang.Relationship;
 import org.onap.aai.domain.yang.RelationshipData;
 import org.onap.aai.domain.yang.RelationshipList;
+import org.onap.aai.domain.yang.VfModule;
+import org.onap.aai.domain.yang.VfModules;
+import org.onap.so.aaisimulator.utils.ShallowBeanCopy;
 import org.onap.so.simulator.cache.provider.AbstractCacheServiceProvider;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -54,6 +60,7 @@ public class GenericVnfCacheServiceProviderImpl extends AbstractCacheServiceProv
     private static final Logger LOGGER = LoggerFactory.getLogger(GenericVnfCacheServiceProviderImpl.class);
 
     private final HttpRestServiceProvider httpRestServiceProvider;
+    //final VfModules vfModules = new VfModules();
 
     @Autowired
     public GenericVnfCacheServiceProviderImpl(final CacheManager cacheManager,
@@ -91,17 +98,20 @@ public class GenericVnfCacheServiceProviderImpl extends AbstractCacheServiceProv
                 final ConcurrentHashMap<Object, Object> concurrentHashMap =
                         (ConcurrentHashMap<Object, Object>) nativeCache;
                 for (final Object key : concurrentHashMap.keySet()) {
-                    final GenericVnf value = cache.get(key, GenericVnf.class);
-                    final String genericVnfName = value.getVnfName();
-                    if (value != null && genericVnfName.equals(vnfName)) {
-                        final String genericVnfId = value.getVnfId();
-                        LOGGER.info("Found matching vnf for name: {}, vnf-id: {}", genericVnfName, genericVnfId);
-                        return Optional.of(genericVnfId);
+                    final Optional<GenericVnf> optional = getGenericVnf(key.toString());
+                    if (optional.isPresent()) {
+                        final GenericVnf value = optional.get();
+                        final String genericVnfName = value.getVnfName();
+                        if (genericVnfName != null && genericVnfName.equals(vnfName)) {
+                            final String genericVnfId = value.getVnfId();
+                            LOGGER.info("Found matching vnf for name: {}, vnf-id: {}", genericVnfName, genericVnfId);
+                            return Optional.of(genericVnfId);
+                        }
                     }
                 }
             }
         }
-        LOGGER.info("No match found for vnf name: {}", vnfName);
+        LOGGER.error("No match found for vnf name: {}", vnfName);
         return Optional.empty();
     }
 
@@ -114,7 +124,7 @@ public class GenericVnfCacheServiceProviderImpl extends AbstractCacheServiceProv
                 final GenericVnf genericVnf = optional.get();
                 final String targetUrl = getTargetUrl(targetBaseUrl, relationship.getRelatedLink());
                 final Relationship outGoingRelationShip =
-                        getRelationship(getRelationShipListRelatedLink(requestUriString), genericVnf);
+                        getRelationship(getRelationShipListRelatedLink(requestUriString), genericVnf, COMPOSED_OF);
                 final Optional<Relationship> optionalRelationship = httpRestServiceProvider.put(incomingHeader,
                         outGoingRelationShip, targetUrl, Relationship.class);
                 if (optionalRelationship.isPresent()) {
@@ -153,7 +163,8 @@ public class GenericVnfCacheServiceProviderImpl extends AbstractCacheServiceProv
             LOGGER.info("Successfully added relation to GenericVnf for vnfId: {}", vnfId);
 
             final String relatedLink = getBiDirectionalRelationShipListRelatedLink(requestURI);
-            final Relationship resultantRelationship = getRelationship(relatedLink, genericVnf);
+            final Relationship resultantRelationship =
+                    getRelationship(relatedLink, genericVnf, relationship.getRelationshipLabel());
             return Optional.of(resultantRelationship);
         }
         return Optional.empty();
@@ -164,19 +175,70 @@ public class GenericVnfCacheServiceProviderImpl extends AbstractCacheServiceProv
         final Optional<GenericVnf> optional = getGenericVnf(vnfId);
         if (optional.isPresent()) {
             final GenericVnf cachedGenericVnf = optional.get();
-            LOGGER.info("Changing OrchestrationStatus from {} to {} ", cachedGenericVnf.getOrchestrationStatus(),
-                    genericVnf.getOrchestrationStatus());
-            cachedGenericVnf.setOrchestrationStatus(genericVnf.getOrchestrationStatus());
-            return true;
+            try {
+                ShallowBeanCopy.copy(genericVnf, cachedGenericVnf);
+                return true;
+            } catch (final Exception exception) {
+                LOGGER.error("Unable to update GenericVnf for vnfId: {}", vnfId, exception);
+            }
         }
         LOGGER.error("Unable to find GenericVnf ...");
         return false;
     }
 
-    private Relationship getRelationship(final String relatedLink, final GenericVnf genericVnf) {
+    @Override
+    public List<GenericVnf> getGenericVnfs(final String selflink) {
+        final Cache cache = getCache(GENERIC_VNF_CACHE.getName());
+        if (cache != null) {
+            final Object nativeCache = cache.getNativeCache();
+            if (nativeCache instanceof ConcurrentHashMap) {
+                @SuppressWarnings("unchecked")
+                final ConcurrentHashMap<Object, Object> concurrentHashMap =
+                        (ConcurrentHashMap<Object, Object>) nativeCache;
+                final List<GenericVnf> result = new ArrayList<>();
+
+                concurrentHashMap.keySet().stream().forEach(key -> {
+                    final Optional<GenericVnf> optional = getGenericVnf(key.toString());
+                    if (optional.isPresent()) {
+                        final GenericVnf genericVnf = optional.get();
+                        final String genericVnfSelfLink = genericVnf.getSelflink();
+                        final String genericVnfId = genericVnf.getSelflink();
+
+                        if (genericVnfSelfLink != null && genericVnfSelfLink.equals(selflink)) {
+                            LOGGER.info("Found matching vnf for selflink: {}, vnf-id: {}", genericVnfSelfLink,
+                                    genericVnfId);
+                            result.add(genericVnf);
+                        }
+                    }
+                });
+                return result;
+            }
+        }
+        LOGGER.error("No match found for selflink: {}", selflink);
+        return Collections.emptyList();
+    }
+
+    @Override
+    public boolean deleteGenericVnf(final String vnfId, final String resourceVersion) {
+        final Optional<GenericVnf> optional = getGenericVnf(vnfId);
+        if (optional.isPresent()) {
+            final GenericVnf genericVnf = optional.get();
+            if (genericVnf.getResourceVersion() != null && genericVnf.getResourceVersion().equals(resourceVersion)) {
+                final Cache cache = getCache(GENERIC_VNF_CACHE.getName());
+                LOGGER.info("Will evict GenericVnf from cache with vnfId: {}", genericVnf.getVnfId());
+                cache.evict(vnfId);
+                return true;
+            }
+        }
+        LOGGER.error("Unable to find GenericVnf for vnfId: {} and resourceVersion: {} ...", vnfId, resourceVersion);
+        return false;
+    }
+
+    private Relationship getRelationship(final String relatedLink, final GenericVnf genericVnf,
+            final String relationshipLabel) {
         final Relationship relationShip = new Relationship();
         relationShip.setRelatedTo(GENERIC_VNF);
-        relationShip.setRelationshipLabel(COMPOSED_OF);
+        relationShip.setRelationshipLabel(relationshipLabel);
         relationShip.setRelatedLink(relatedLink);
 
         final RelationshipData relationshipData = new RelationshipData();
@@ -193,7 +255,67 @@ public class GenericVnfCacheServiceProviderImpl extends AbstractCacheServiceProv
 
     @Override
     public void clearAll() {
-        clearCahce(GENERIC_VNF_CACHE.getName());
+        clearCache(GENERIC_VNF_CACHE.getName());
+    }
+
+    @Override
+    public Optional<VfModule> getVfModule(final String vnfId, final String vfModuleId) {
+        LOGGER.info("Getting vfModule from cache for vnfId: {} and vfModuleId: {}",
+                vnfId, vfModuleId);
+        final Optional<GenericVnf> genericVnfOptional = getGenericVnf(vnfId);
+        final GenericVnf value = genericVnfOptional.get();
+        final VfModules vfmodules = value.getVfModules();
+        if (vfmodules != null) {
+            for (VfModule vfModule : vfmodules.getVfModule()) {
+                 if (vfModule.getVfModuleId().equalsIgnoreCase(vfModuleId)){
+                    return Optional.of(vfModule);
+                }
+            }
+        }
+        return Optional.empty();
+    }
+
+
+    @Override
+    public void putVfModule(final String vnfId, final String vfModuleId, final VfModule vfModule) {
+        LOGGER.info("Adding vfModule for vnfId: {} and vfModuleId: {}",
+                vnfId, vfModuleId);
+        final Optional<GenericVnf> genericVnfOptional = getGenericVnf(vnfId);
+        final Cache cache = getCache(GENERIC_VNF_CACHE.getName());
+        if (genericVnfOptional.isPresent()) {
+            final GenericVnf genericVnf = genericVnfOptional.get();
+            VfModules vfModules = null;
+            if(genericVnf.getVfModules()==null){
+                vfModules = new VfModules();
+                genericVnf.setVfModules(vfModules);
+            } else {
+                vfModules = genericVnf.getVfModules();
+            }
+
+            vfModules.getVfModule().add(vfModule);
+            cache.put(vfModuleId, vfModule);
+        }
     }
 
+    @Override
+    public boolean patchVfModule(final String vnfId, final String vfModuleId, final VfModule vfModule) {
+        final Optional<GenericVnf> genericVnfOptional = getGenericVnf(vnfId);
+        LOGGER.info("Create vfModule for vnfId: {} and vfModuleId: {}",
+                vnfId, vfModuleId);
+        if (genericVnfOptional.isPresent()) {
+            final GenericVnf cachedGenericVnf = genericVnfOptional.get();
+            final VfModules vfmodules = cachedGenericVnf.getVfModules();
+            LOGGER.info("vfModuleId is Matched");
+            try {
+                vfmodules.getVfModule().stream().filter(tempVfModule ->
+                        tempVfModule.getVfModuleId().equalsIgnoreCase(vfModuleId)).forEach(tempVfModule ->
+                        tempVfModule.setOrchestrationStatus(vfModule.getOrchestrationStatus()));
+                return true;
+            } catch (final Exception exception) {
+                LOGGER.error("Unable to update VfModule for vfModuleId: {}", vfModule, exception);
+            }
+        }
+        LOGGER.error("Unable to find VfModule ...");
+        return false;
+    }
 }