plans/so/integration-etsi-testing/so-simulators/aai-simulator/src/main/java/org/onap/so/aaisimulator/service/providers/CloudRegionCacheServiceProviderImpl.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  *  Copyright (C) 2019 Nordix Foundation.
   4  * ================================================================================
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *      http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  *
  17  * SPDX-License-Identifier: Apache-2.0
  18  * ============LICENSE_END=========================================================
  19  */
  20 package org.onap.so.aaisimulator.service.providers;
  21
  22 import static org.onap.so.aaisimulator.utils.CacheName.CLOUD_REGION_CACHE;
  23 import static org.onap.so.aaisimulator.utils.Constants.BELONGS_TO;
  24 import static org.onap.so.aaisimulator.utils.Constants.CLOUD_REGION;
  25 import static org.onap.so.aaisimulator.utils.Constants.CLOUD_REGION_CLOUD_OWNER;
  26 import static org.onap.so.aaisimulator.utils.Constants.CLOUD_REGION_CLOUD_REGION_ID;
  27 import static org.onap.so.aaisimulator.utils.Constants.CLOUD_REGION_OWNER_DEFINED_TYPE;
  28 import static org.onap.so.aaisimulator.utils.Constants.HOSTED_ON;
  29 import static org.onap.so.aaisimulator.utils.Constants.LOCATED_IN;
  30 import static org.onap.so.aaisimulator.utils.Constants.TENANT;
  31 import static org.onap.so.aaisimulator.utils.Constants.TENANT_TENANT_ID;
  32 import static org.onap.so.aaisimulator.utils.Constants.TENANT_TENANT_NAME;
  33 import static org.onap.so.aaisimulator.utils.Constants.VSERVER;
  34 import static org.onap.so.aaisimulator.utils.Constants.VSERVER_VSERVER_ID;
  35 import static org.onap.so.aaisimulator.utils.Constants.VSERVER_VSERVER_NAME;
  36 import static org.onap.so.aaisimulator.utils.HttpServiceUtils.getBiDirectionalRelationShipListRelatedLink;
  37 import static org.onap.so.aaisimulator.utils.HttpServiceUtils.getRelationShipListRelatedLink;
  38 import static org.onap.so.aaisimulator.utils.HttpServiceUtils.getTargetUrl;
  39 import java.util.List;
  40 import java.util.Optional;
  41 import org.onap.aai.domain.yang.CloudRegion;
  42 import org.onap.aai.domain.yang.EsrSystemInfo;
  43 import org.onap.aai.domain.yang.EsrSystemInfoList;
  44 import org.onap.aai.domain.yang.RelatedToProperty;
  45 import org.onap.aai.domain.yang.Relationship;
  46 import org.onap.aai.domain.yang.RelationshipData;
  47 import org.onap.aai.domain.yang.RelationshipList;
  48 import org.onap.aai.domain.yang.Tenant;
  49 import org.onap.aai.domain.yang.Tenants;
  50 import org.onap.aai.domain.yang.Vserver;
  51 import org.onap.aai.domain.yang.Vservers;
  52 import org.onap.so.aaisimulator.models.CloudRegionKey;
  53 import org.onap.so.simulator.cache.provider.AbstractCacheServiceProvider;
  54 import org.slf4j.Logger;
  55 import org.slf4j.LoggerFactory;
  56 import org.springframework.beans.factory.annotation.Autowired;
  57 import org.springframework.cache.Cache;
  58 import org.springframework.cache.CacheManager;
  59 import org.springframework.http.HttpHeaders;
  60 import org.springframework.stereotype.Service;
  61
  62 /**
  63  * @author Waqas Ikram (waqas.ikram@est.tech)
  64  *
  65  */
  66 @Service
  67 public class CloudRegionCacheServiceProviderImpl extends AbstractCacheServiceProvider
  68         implements CloudRegionCacheServiceProvider {
  69
  70
  71
  72     private static final Logger LOGGER = LoggerFactory.getLogger(CloudRegionCacheServiceProviderImpl.class);
  73
  74     private final HttpRestServiceProvider httpRestServiceProvider;
  75
  76     @Autowired
  77     public CloudRegionCacheServiceProviderImpl(final CacheManager cacheManager,
  78             final HttpRestServiceProvider httpRestServiceProvider) {
  79         super(cacheManager);
  80         this.httpRestServiceProvider = httpRestServiceProvider;
  81     }
  82
  83     @Override
  84     public void putCloudRegion(final CloudRegionKey cloudRegionKey, final CloudRegion cloudRegion) {
  85         LOGGER.info("Adding CloudRegion to cache with key: {} ...", cloudRegionKey);
  86         final Cache cache = getCache(CLOUD_REGION_CACHE.getName());
  87         cache.put(cloudRegionKey, cloudRegion);
  88
  89     }
  90
  91     @Override
  92     public Optional<CloudRegion> getCloudRegion(final CloudRegionKey cloudRegionKey) {
  93         LOGGER.info("getting CloudRegion from cache using key: {}", cloudRegionKey);
  94         final Cache cache = getCache(CLOUD_REGION_CACHE.getName());
  95         final CloudRegion value = cache.get(cloudRegionKey, CloudRegion.class);
  96         if (value != null) {
  97             return Optional.of(value);
  98         }
  99         LOGGER.error("Unable to find CloudRegion in cache using key:{} ", cloudRegionKey);
 100         return Optional.empty();
 101     }
 102
 103     @Override
 104     public Optional<Relationship> addRelationShip(final CloudRegionKey key, final Relationship relationship,
 105             final String requestUri) {
 106         final Optional<CloudRegion> optional = getCloudRegion(key);
 107         if (optional.isPresent()) {
 108             final CloudRegion cloudRegion = optional.get();
 109             RelationshipList relationshipList = cloudRegion.getRelationshipList();
 110             if (relationshipList == null) {
 111                 relationshipList = new RelationshipList();
 112                 cloudRegion.setRelationshipList(relationshipList);
 113             }
 114             relationshipList.getRelationship().add(relationship);
 115
 116             LOGGER.info("Successfully added relation to CloudRegion with key: {}", key);
 117
 118
 119             final Relationship resultantRelationship = new Relationship();
 120             resultantRelationship.setRelatedTo(CLOUD_REGION);
 121             resultantRelationship.setRelationshipLabel(LOCATED_IN);
 122             resultantRelationship.setRelatedLink(getBiDirectionalRelationShipListRelatedLink(requestUri));
 123
 124             final List<RelationshipData> relationshipDataList = resultantRelationship.getRelationshipData();
 125             relationshipDataList.add(getRelationshipData(CLOUD_REGION_CLOUD_OWNER, cloudRegion.getCloudOwner()));
 126             relationshipDataList.add(getRelationshipData(CLOUD_REGION_CLOUD_REGION_ID, cloudRegion.getCloudRegionId()));
 127
 128             final List<RelatedToProperty> relatedToPropertyList = resultantRelationship.getRelatedToProperty();
 129
 130             final RelatedToProperty relatedToProperty = new RelatedToProperty();
 131             relatedToProperty.setPropertyKey(CLOUD_REGION_OWNER_DEFINED_TYPE);
 132             relatedToProperty.setPropertyValue(cloudRegion.getOwnerDefinedType());
 133             relatedToPropertyList.add(relatedToProperty);
 134
 135             return Optional.of(resultantRelationship);
 136
 137         }
 138         LOGGER.error("Unable to find CloudRegion using key: {} ...", key);
 139         return Optional.empty();
 140     }
 141
 142     @Override
 143     public boolean putTenant(final CloudRegionKey key, final String tenantId, final Tenant tenant) {
 144         final Optional<CloudRegion> optional = getCloudRegion(key);
 145         if (optional.isPresent()) {
 146             final CloudRegion cloudRegion = optional.get();
 147             Tenants tenants = cloudRegion.getTenants();
 148             if (tenants == null) {
 149                 tenants = new Tenants();
 150                 cloudRegion.setTenants(tenants);
 151             }
 152
 153             final Optional<Tenant> existingTenantOptional = tenants.getTenant().stream()
 154                     .filter(existing -> existing.getTenantId() != null && existing.getTenantId().equals(tenantId))
 155                     .findFirst();
 156
 157             if (!existingTenantOptional.isPresent()) {
 158                 return tenants.getTenant().add(tenant);
 159             }
 160
 161             LOGGER.warn("Tenant already exists ...");
 162             return false;
 163         }
 164         LOGGER.error("Unable to add Tenant using key: {} ...", key);
 165         return false;
 166     }
 167
 168     @Override
 169     public Optional<Tenant> getTenant(final CloudRegionKey key, final String tenantId) {
 170         final Optional<CloudRegion> optional = getCloudRegion(key);
 171         if (optional.isPresent()) {
 172             final CloudRegion cloudRegion = optional.get();
 173             final Tenants tenants = cloudRegion.getTenants();
 174             if (tenants != null) {
 175                 return tenants.getTenant().stream().filter(existing -> existing.getTenantId().equals(tenantId))
 176                         .findFirst();
 177             }
 178         }
 179
 180         LOGGER.error("Unable to find Tenant using key: {} and tenantId: {} ...", key, tenantId);
 181         return Optional.empty();
 182     }
 183
 184     @Override
 185     public boolean addRelationShip(final HttpHeaders incomingHeader, final String targetBaseUrl,
 186             final String requestUriString, final CloudRegionKey key, final String tenantId,
 187             final Relationship relationship) {
 188         try {
 189             final Optional<Tenant> optional = getTenant(key, tenantId);
 190             if (optional.isPresent()) {
 191                 final Tenant tenant = optional.get();
 192                 final String targetUrl = getTargetUrl(targetBaseUrl, relationship.getRelatedLink());
 193
 194                 final Relationship outGoingRelationShip = getRelationship(requestUriString, key, tenant);
 195                 final Optional<Relationship> optionalRelationship = httpRestServiceProvider.put(incomingHeader,
 196                         outGoingRelationShip, targetUrl, Relationship.class);
 197
 198                 if (optionalRelationship.isPresent()) {
 199                     final Relationship resultantRelationship = optionalRelationship.get();
 200                     RelationshipList relationshipList = tenant.getRelationshipList();
 201                     if (relationshipList == null) {
 202                         relationshipList = new RelationshipList();
 203                         tenant.setRelationshipList(relationshipList);
 204                     }
 205
 206                     if (relationshipList.getRelationship().add(resultantRelationship)) {
 207                         LOGGER.info("added relationship {} in cache successfully", resultantRelationship);
 208                         return true;
 209                     }
 210                 }
 211
 212
 213             }
 214         } catch (final Exception exception) {
 215             LOGGER.error("Unable to add two-way relationship for CloudRegion: {} and tenant: {}", key, tenantId,
 216                     exception);
 217         }
 218         LOGGER.error("Unable to add relationship in cache for CloudRegion: {} and tenant: {}", key, tenantId);
 219         return false;
 220     }
 221
 222     @Override
 223     public Optional<EsrSystemInfoList> getEsrSystemInfoList(final CloudRegionKey key) {
 224         final Optional<CloudRegion> optional = getCloudRegion(key);
 225         if (optional.isPresent()) {
 226             final CloudRegion cloudRegion = optional.get();
 227             final EsrSystemInfoList esrSystemInfoList = cloudRegion.getEsrSystemInfoList();
 228             if (esrSystemInfoList != null) {
 229                 return Optional.of(esrSystemInfoList);
 230             }
 231         }
 232         LOGGER.error("Unable to find EsrSystemInfoList in cache for CloudRegion: {} ", key);
 233
 234         return Optional.empty();
 235     }
 236
 237     @Override
 238     public boolean putEsrSystemInfo(final CloudRegionKey key, final String esrSystemInfoId,
 239             final EsrSystemInfo esrSystemInfo) {
 240         final Optional<CloudRegion> optional = getCloudRegion(key);
 241         if (optional.isPresent()) {
 242             final CloudRegion cloudRegion = optional.get();
 243             final List<EsrSystemInfo> esrSystemInfoList = getEsrSystemInfoList(cloudRegion);
 244
 245             final Optional<EsrSystemInfo> existingEsrSystemInfo =
 246                     esrSystemInfoList.stream().filter(existing -> existing.getEsrSystemInfoId() != null
 247                             && existing.getEsrSystemInfoId().equals(esrSystemInfoId)).findFirst();
 248             if (existingEsrSystemInfo.isPresent()) {
 249                 LOGGER.error("EsrSystemInfo already exists {}", existingEsrSystemInfo.get());
 250                 return false;
 251             }
 252
 253             return esrSystemInfoList.add(esrSystemInfo);
 254
 255         }
 256         return false;
 257     }
 258
 259     @Override
 260     public boolean putVserver(final CloudRegionKey key, final String tenantId, final String vServerId,
 261             final Vserver vServer) {
 262         final Optional<Tenant> optional = getTenant(key, tenantId);
 263         if (optional.isPresent()) {
 264             final Tenant tenant = optional.get();
 265             Vservers vServers = tenant.getVservers();
 266             if (vServers == null) {
 267                 vServers = new Vservers();
 268                 tenant.setVservers(vServers);
 269             }
 270             final List<Vserver> vServerList = vServers.getVserver();
 271
 272             final Optional<Vserver> existingVserver = vServerList.stream()
 273                     .filter(existing -> existing.getVserverId() != null && existing.getVserverId().equals(vServerId))
 274                     .findFirst();
 275
 276             if (existingVserver.isPresent()) {
 277                 LOGGER.error("Vserver already exists {}", existingVserver.get());
 278                 return false;
 279             }
 280             return vServerList.add(vServer);
 281
 282         }
 283         return false;
 284     }
 285
 286     @Override
 287     public Optional<Vserver> getVserver(final CloudRegionKey key, final String tenantId, final String vServerId) {
 288         final Optional<Tenant> optional = getTenant(key, tenantId);
 289         if (optional.isPresent()) {
 290             final Tenant tenant = optional.get();
 291             final Vservers vServers = tenant.getVservers();
 292             if (vServers != null) {
 293                 return vServers.getVserver().stream()
 294                         .filter(vServer -> vServer.getVserverId() != null && vServer.getVserverId().equals(vServerId))
 295                         .findFirst();
 296             }
 297         }
 298         LOGGER.error("Unable to find vServer in cache ... ");
 299         return Optional.empty();
 300     }
 301
 302     @Override
 303     public boolean deleteVserver(final CloudRegionKey key, final String tenantId, final String vServerId,
 304             final String resourceVersion) {
 305         final Optional<Vserver> optional = getVserver(key, tenantId, vServerId);
 306         if (optional.isPresent()) {
 307             final Optional<Tenant> tenantOptional = getTenant(key, tenantId);
 308             if (tenantOptional.isPresent()) {
 309                 final Tenant tenant = tenantOptional.get();
 310                 final Vservers vServers = tenant.getVservers();
 311                 if (vServers != null) {
 312                     return vServers.getVserver().removeIf(vServer -> {
 313                         if (vServer.getVserverId() != null && vServer.getVserverId().equals(vServerId)
 314                                 && vServer.getResourceVersion() != null
 315                                 && vServer.getResourceVersion().equals(resourceVersion)) {
 316                             LOGGER.info("Will remove Vserver from cache with vServerId: {} and resource-version: {} ",
 317                                     vServerId, vServer.getResourceVersion());
 318                             return true;
 319                         }
 320                         return false;
 321                     });
 322                 }
 323
 324             }
 325
 326         }
 327         LOGGER.error(
 328                 "Unable to find Vserver for using key: {}, tenant-id: {}, vserver-id: {} and resource-version: {} ...",
 329                 key, tenantId, vServerId, resourceVersion);
 330
 331         return false;
 332     }
 333
 334     @Override
 335     public Optional<Relationship> addvServerRelationShip(final CloudRegionKey key, final String tenantId,
 336             final String vServerId, final Relationship relationship, final String requestUri) {
 337         final Optional<Vserver> optional = getVserver(key, tenantId, vServerId);
 338         if (optional.isPresent()) {
 339             final Vserver vServer = optional.get();
 340             RelationshipList relationshipList = vServer.getRelationshipList();
 341             if (relationshipList == null) {
 342                 relationshipList = new RelationshipList();
 343                 vServer.setRelationshipList(relationshipList);
 344             }
 345             relationshipList.getRelationship().add(relationship);
 346             LOGGER.info("Successfully added relation to Vserver with key: {}, tenantId: {} and vServerId: {}", key,
 347                     tenantId, vServerId);
 348             final String relatedLink = getBiDirectionalRelationShipListRelatedLink(requestUri);
 349
 350             final Relationship resultantRelationship = getVserverRelationship(key, tenantId, vServer, relatedLink);
 351
 352             return Optional.of(resultantRelationship);
 353         }
 354
 355         LOGGER.error("Unable to find Vserver using key: {}, tenantId: {} and vServerId: {}...", key, tenantId,
 356                 vServerId);
 357         return Optional.empty();
 358     }
 359
 360     private Relationship getVserverRelationship(final CloudRegionKey key, final String tenantId, final Vserver vServer,
 361             final String relatedLink) {
 362         final Relationship resultantRelationship = new Relationship();
 363         resultantRelationship.setRelatedTo(VSERVER);
 364         resultantRelationship.setRelationshipLabel(HOSTED_ON);
 365         resultantRelationship.setRelatedLink(relatedLink);
 366
 367         final List<RelationshipData> relationshipDataList = resultantRelationship.getRelationshipData();
 368         relationshipDataList.add(getRelationshipData(CLOUD_REGION_CLOUD_OWNER, key.getCloudOwner()));
 369         relationshipDataList.add(getRelationshipData(CLOUD_REGION_CLOUD_REGION_ID, key.getCloudRegionId()));
 370         relationshipDataList.add(getRelationshipData(TENANT_TENANT_ID, tenantId));
 371         relationshipDataList.add(getRelationshipData(VSERVER_VSERVER_ID, vServer.getVserverId()));
 372
 373         final List<RelatedToProperty> relatedToPropertyList = resultantRelationship.getRelatedToProperty();
 374
 375         final RelatedToProperty relatedToProperty = new RelatedToProperty();
 376         relatedToProperty.setPropertyKey(VSERVER_VSERVER_NAME);
 377         relatedToProperty.setPropertyValue(vServer.getVserverName());
 378         relatedToPropertyList.add(relatedToProperty);
 379         return resultantRelationship;
 380     }
 381
 382     @Override
 383     public boolean addVServerRelationShip(final HttpHeaders incomingHeader, final String targetBaseUrl,
 384             final String requestUriString, final CloudRegionKey key, final String tenantId, final String vServerId,
 385             final Relationship relationship) {
 386         try {
 387             final Optional<Vserver> optional = getVserver(key, tenantId, vServerId);
 388             if (optional.isPresent()) {
 389                 final Vserver vServer = optional.get();
 390                 final String targetUrl = getTargetUrl(targetBaseUrl, relationship.getRelatedLink());
 391                 final Relationship outGoingRelationShip = getVserverRelationship(key, tenantId, vServer,
 392                         getRelationShipListRelatedLink(requestUriString));
 393                 final Optional<Relationship> optionalRelationship = httpRestServiceProvider.put(incomingHeader,
 394                         outGoingRelationShip, targetUrl, Relationship.class);
 395                 if (optionalRelationship.isPresent()) {
 396                     final Relationship resultantRelationship = optionalRelationship.get();
 397
 398                     RelationshipList relationshipList = vServer.getRelationshipList();
 399                     if (relationshipList == null) {
 400                         relationshipList = new RelationshipList();
 401                         vServer.setRelationshipList(relationshipList);
 402                     }
 403
 404                     final Optional<Relationship> relationShipExists = relationshipList.getRelationship().stream()
 405                             .filter(relation -> relation.getRelatedTo().equals(resultantRelationship.getRelatedTo())
 406                                     && relation.getRelatedLink().equals(resultantRelationship.getRelatedLink()))
 407                             .findAny();
 408
 409                     if (relationShipExists.isPresent()) {
 410                         LOGGER.info("relationship {} already exists in cache ", resultantRelationship);
 411                         return true;
 412                     }
 413
 414                     LOGGER.info("added relationship {} in cache successfully", resultantRelationship);
 415                     return relationshipList.getRelationship().add(resultantRelationship);
 416                 }
 417
 418             }
 419         } catch (final Exception exception) {
 420             LOGGER.error("Unable to add two-way relationship for key: {}, tenantId: {} and vServerId: {}", key,
 421                     tenantId, vServerId, exception);
 422         }
 423         LOGGER.error("Unable to add Vserver relationship for key: {}, tenantId: {} and vServerId: {}...", key, tenantId,
 424                 vServerId);
 425         return false;
 426     }
 427
 428     private List<EsrSystemInfo> getEsrSystemInfoList(final CloudRegion cloudRegion) {
 429         EsrSystemInfoList esrSystemInfoList = cloudRegion.getEsrSystemInfoList();
 430         if (esrSystemInfoList == null) {
 431             esrSystemInfoList = new EsrSystemInfoList();
 432             cloudRegion.setEsrSystemInfoList(esrSystemInfoList);
 433         }
 434         return esrSystemInfoList.getEsrSystemInfo();
 435     }
 436
 437     private Relationship getRelationship(final String requestUriString, final CloudRegionKey cloudRegionKey,
 438             final Tenant tenant) {
 439         final Relationship relationShip = new Relationship();
 440         relationShip.setRelatedTo(TENANT);
 441         relationShip.setRelationshipLabel(BELONGS_TO);
 442         relationShip.setRelatedLink(getRelationShipListRelatedLink(requestUriString));
 443
 444
 445         final List<RelationshipData> relationshipDataList = relationShip.getRelationshipData();
 446         relationshipDataList.add(getRelationshipData(CLOUD_REGION_CLOUD_OWNER, cloudRegionKey.getCloudOwner()));
 447         relationshipDataList.add(getRelationshipData(CLOUD_REGION_CLOUD_REGION_ID, cloudRegionKey.getCloudRegionId()));
 448         relationshipDataList.add(getRelationshipData(TENANT_TENANT_ID, tenant.getTenantId()));
 449
 450
 451         final RelatedToProperty relatedToProperty = new RelatedToProperty();
 452         relatedToProperty.setPropertyKey(TENANT_TENANT_NAME);
 453         relatedToProperty.setPropertyValue(tenant.getTenantName());
 454         relationShip.getRelatedToProperty().add(relatedToProperty);
 455         return relationShip;
 456     }
 457
 458     private RelationshipData getRelationshipData(final String key, final String value) {
 459         final RelationshipData relationshipData = new RelationshipData();
 460         relationshipData.setRelationshipKey(key);
 461         relationshipData.setRelationshipValue(value);
 462         return relationshipData;
 463     }
 464
 465     @Override
 466     public void clearAll() {
 467         clearCache(CLOUD_REGION_CACHE.getName());
 468
 469     }
 470
 471 }