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.K8S_RESOURCE;
  30 import static org.onap.so.aaisimulator.utils.Constants.K8S_RESOURCE_ID;
  31 import static org.onap.so.aaisimulator.utils.Constants.K8S_RESOURCE_NAME;
  32 import static org.onap.so.aaisimulator.utils.Constants.LOCATED_IN;
  33 import static org.onap.so.aaisimulator.utils.Constants.TENANT;
  34 import static org.onap.so.aaisimulator.utils.Constants.TENANT_TENANT_ID;
  35 import static org.onap.so.aaisimulator.utils.Constants.TENANT_TENANT_NAME;
  36 import static org.onap.so.aaisimulator.utils.Constants.USES;
  37 import static org.onap.so.aaisimulator.utils.Constants.VSERVER;
  38 import static org.onap.so.aaisimulator.utils.Constants.VSERVER_VSERVER_ID;
  39 import static org.onap.so.aaisimulator.utils.Constants.VSERVER_VSERVER_NAME;
  40 import static org.onap.so.aaisimulator.utils.HttpServiceUtils.getBiDirectionalRelationShipListRelatedLink;
  41 import static org.onap.so.aaisimulator.utils.HttpServiceUtils.getRelationShipListRelatedLink;
  42 import static org.onap.so.aaisimulator.utils.HttpServiceUtils.getTargetUrl;
  43 import java.util.List;
  44 import java.util.Optional;
  45 import org.onap.aai.domain.yang.CloudRegion;
  46 import org.onap.aai.domain.yang.EsrSystemInfo;
  47 import org.onap.aai.domain.yang.EsrSystemInfoList;
  48 import org.onap.aai.domain.yang.K8SResource;
  49 import org.onap.aai.domain.yang.K8SResources;
  50 import org.onap.aai.domain.yang.RelatedToProperty;
  51 import org.onap.aai.domain.yang.Relationship;
  52 import org.onap.aai.domain.yang.RelationshipData;
  53 import org.onap.aai.domain.yang.RelationshipList;
  54 import org.onap.aai.domain.yang.Tenant;
  55 import org.onap.aai.domain.yang.Tenants;
  56 import org.onap.aai.domain.yang.Vserver;
  57 import org.onap.aai.domain.yang.Vservers;
  58 import org.onap.so.aaisimulator.models.CloudRegionKey;
  59 import org.onap.so.simulator.cache.provider.AbstractCacheServiceProvider;
  60 import org.slf4j.Logger;
  61 import org.slf4j.LoggerFactory;
  62 import org.springframework.beans.factory.annotation.Autowired;
  63 import org.springframework.cache.Cache;
  64 import org.springframework.cache.CacheManager;
  65 import org.springframework.http.HttpHeaders;
  66 import org.springframework.stereotype.Service;
  67
  68 /**
  69  * @author Waqas Ikram (waqas.ikram@est.tech)
  70  *
  71  */
  72 @Service
  73 public class CloudRegionCacheServiceProviderImpl extends AbstractCacheServiceProvider
  74         implements CloudRegionCacheServiceProvider {
  75
  76     private static final Logger LOGGER = LoggerFactory.getLogger(CloudRegionCacheServiceProviderImpl.class);
  77
  78     private final HttpRestServiceProvider httpRestServiceProvider;
  79
  80     @Autowired
  81     public CloudRegionCacheServiceProviderImpl(final CacheManager cacheManager,
  82             final HttpRestServiceProvider httpRestServiceProvider) {
  83         super(cacheManager);
  84         this.httpRestServiceProvider = httpRestServiceProvider;
  85     }
  86
  87     @Override
  88     public void putCloudRegion(final CloudRegionKey cloudRegionKey, final CloudRegion cloudRegion) {
  89         LOGGER.info("Adding CloudRegion to cache with key: {} ...", cloudRegionKey);
  90         final Cache cache = getCache(CLOUD_REGION_CACHE.getName());
  91         cache.put(cloudRegionKey, cloudRegion);
  92
  93     }
  94
  95     @Override
  96     public Optional<CloudRegion> getCloudRegion(final CloudRegionKey cloudRegionKey) {
  97         LOGGER.info("getting CloudRegion from cache using key: {}", cloudRegionKey);
  98         final Cache cache = getCache(CLOUD_REGION_CACHE.getName());
  99         final CloudRegion value = cache.get(cloudRegionKey, CloudRegion.class);
 100         if (value != null) {
 101             return Optional.of(value);
 102         }
 103         LOGGER.error("Unable to find CloudRegion in cache using key:{} ", cloudRegionKey);
 104         return Optional.empty();
 105     }
 106
 107     @Override
 108     public Optional<Relationship> addRelationShip(final CloudRegionKey key, final Relationship relationship,
 109             final String requestUri) {
 110         final Optional<CloudRegion> optional = getCloudRegion(key);
 111         if (optional.isPresent()) {
 112             final CloudRegion cloudRegion = optional.get();
 113             RelationshipList relationshipList = cloudRegion.getRelationshipList();
 114             if (relationshipList == null) {
 115                 relationshipList = new RelationshipList();
 116                 cloudRegion.setRelationshipList(relationshipList);
 117             }
 118             relationshipList.getRelationship().add(relationship);
 119
 120             LOGGER.info("Successfully added relation to CloudRegion with key: {}", key);
 121
 122
 123             final Relationship resultantRelationship = new Relationship();
 124             resultantRelationship.setRelatedTo(CLOUD_REGION);
 125             resultantRelationship.setRelationshipLabel(LOCATED_IN);
 126             resultantRelationship.setRelatedLink(getBiDirectionalRelationShipListRelatedLink(requestUri));
 127
 128             final List<RelationshipData> relationshipDataList = resultantRelationship.getRelationshipData();
 129             relationshipDataList.add(getRelationshipData(CLOUD_REGION_CLOUD_OWNER, cloudRegion.getCloudOwner()));
 130             relationshipDataList.add(getRelationshipData(CLOUD_REGION_CLOUD_REGION_ID, cloudRegion.getCloudRegionId()));
 131
 132             final List<RelatedToProperty> relatedToPropertyList = resultantRelationship.getRelatedToProperty();
 133
 134             final RelatedToProperty relatedToProperty = new RelatedToProperty();
 135             relatedToProperty.setPropertyKey(CLOUD_REGION_OWNER_DEFINED_TYPE);
 136             relatedToProperty.setPropertyValue(cloudRegion.getOwnerDefinedType());
 137             relatedToPropertyList.add(relatedToProperty);
 138
 139             return Optional.of(resultantRelationship);
 140
 141         }
 142         LOGGER.error("Unable to find CloudRegion using key: {} ...", key);
 143         return Optional.empty();
 144     }
 145
 146     @Override
 147     public boolean putTenant(final CloudRegionKey key, final String tenantId, final Tenant tenant) {
 148         final Optional<CloudRegion> optional = getCloudRegion(key);
 149         if (optional.isPresent()) {
 150             final CloudRegion cloudRegion = optional.get();
 151             Tenants tenants = cloudRegion.getTenants();
 152             if (tenants == null) {
 153                 tenants = new Tenants();
 154                 cloudRegion.setTenants(tenants);
 155             }
 156
 157             final Optional<Tenant> existingTenantOptional = tenants.getTenant().stream()
 158                     .filter(existing -> existing.getTenantId() != null && existing.getTenantId().equals(tenantId))
 159                     .findFirst();
 160
 161             if (!existingTenantOptional.isPresent()) {
 162                 return tenants.getTenant().add(tenant);
 163             }
 164
 165             LOGGER.warn("Tenant already exists ...");
 166             return false;
 167         }
 168         LOGGER.error("Unable to add Tenant using key: {} ...", key);
 169         return false;
 170     }
 171
 172     @Override
 173     public Optional<Tenant> getTenant(final CloudRegionKey key, final String tenantId) {
 174         final Optional<CloudRegion> optional = getCloudRegion(key);
 175         if (optional.isPresent()) {
 176             final CloudRegion cloudRegion = optional.get();
 177             final Tenants tenants = cloudRegion.getTenants();
 178             if (tenants != null) {
 179                 return tenants.getTenant().stream().filter(existing -> existing.getTenantId().equals(tenantId))
 180                         .findFirst();
 181             }
 182         }
 183
 184         LOGGER.error("Unable to find Tenant using key: {} and tenantId: {} ...", key, tenantId);
 185         return Optional.empty();
 186     }
 187
 188     @Override
 189     public boolean addRelationShip(final HttpHeaders incomingHeader, final String targetBaseUrl,
 190             final String requestUriString, final CloudRegionKey key, final String tenantId,
 191             final Relationship relationship) {
 192         try {
 193             final Optional<Tenant> optional = getTenant(key, tenantId);
 194             if (optional.isPresent()) {
 195                 final Tenant tenant = optional.get();
 196                 final String targetUrl = getTargetUrl(targetBaseUrl, relationship.getRelatedLink());
 197
 198                 final Relationship outGoingRelationShip = getRelationship(requestUriString, key, tenant);
 199                 final Optional<Relationship> optionalRelationship = httpRestServiceProvider.put(incomingHeader,
 200                         outGoingRelationShip, targetUrl, Relationship.class);
 201
 202                 if (optionalRelationship.isPresent()) {
 203                     final Relationship resultantRelationship = optionalRelationship.get();
 204                     RelationshipList relationshipList = tenant.getRelationshipList();
 205                     if (relationshipList == null) {
 206                         relationshipList = new RelationshipList();
 207                         tenant.setRelationshipList(relationshipList);
 208                     }
 209
 210                     if (relationshipList.getRelationship().add(resultantRelationship)) {
 211                         LOGGER.info("added relationship {} in cache successfully", resultantRelationship);
 212                         return true;
 213                     }
 214                 }
 215
 216
 217             }
 218         } catch (final Exception exception) {
 219             LOGGER.error("Unable to add two-way relationship for CloudRegion: {} and tenant: {}", key, tenantId,
 220                     exception);
 221         }
 222         LOGGER.error("Unable to add relationship in cache for CloudRegion: {} and tenant: {}", key, tenantId);
 223         return false;
 224     }
 225
 226     @Override
 227     public Optional<EsrSystemInfoList> getEsrSystemInfoList(final CloudRegionKey key) {
 228         final Optional<CloudRegion> optional = getCloudRegion(key);
 229         if (optional.isPresent()) {
 230             final CloudRegion cloudRegion = optional.get();
 231             final EsrSystemInfoList esrSystemInfoList = cloudRegion.getEsrSystemInfoList();
 232             if (esrSystemInfoList != null) {
 233                 return Optional.of(esrSystemInfoList);
 234             }
 235         }
 236         LOGGER.error("Unable to find EsrSystemInfoList in cache for CloudRegion: {} ", key);
 237
 238         return Optional.empty();
 239     }
 240
 241     @Override
 242     public boolean putEsrSystemInfo(final CloudRegionKey key, final String esrSystemInfoId,
 243             final EsrSystemInfo esrSystemInfo) {
 244         final Optional<CloudRegion> optional = getCloudRegion(key);
 245         if (optional.isPresent()) {
 246             final CloudRegion cloudRegion = optional.get();
 247             final List<EsrSystemInfo> esrSystemInfoList = getEsrSystemInfoList(cloudRegion);
 248
 249             final Optional<EsrSystemInfo> existingEsrSystemInfo =
 250                     esrSystemInfoList.stream().filter(existing -> existing.getEsrSystemInfoId() != null
 251                             && existing.getEsrSystemInfoId().equals(esrSystemInfoId)).findFirst();
 252             if (existingEsrSystemInfo.isPresent()) {
 253                 LOGGER.error("EsrSystemInfo already exists {}", existingEsrSystemInfo.get());
 254                 return false;
 255             }
 256
 257             return esrSystemInfoList.add(esrSystemInfo);
 258
 259         }
 260         return false;
 261     }
 262
 263     @Override
 264     public boolean putVserver(final CloudRegionKey key, final String tenantId, final String vServerId,
 265             final Vserver vServer) {
 266         final Optional<Tenant> optional = getTenant(key, tenantId);
 267         if (optional.isPresent()) {
 268             final Tenant tenant = optional.get();
 269             Vservers vServers = tenant.getVservers();
 270             if (vServers == null) {
 271                 vServers = new Vservers();
 272                 tenant.setVservers(vServers);
 273             }
 274             final List<Vserver> vServerList = vServers.getVserver();
 275
 276             final Optional<Vserver> existingVserver = vServerList.stream()
 277                     .filter(existing -> existing.getVserverId() != null && existing.getVserverId().equals(vServerId))
 278                     .findFirst();
 279
 280             if (existingVserver.isPresent()) {
 281                 LOGGER.error("Vserver already exists {}", existingVserver.get());
 282                 return false;
 283             }
 284             return vServerList.add(vServer);
 285
 286         }
 287         return false;
 288     }
 289
 290     @Override
 291     public Optional<Vserver> getVserver(final CloudRegionKey key, final String tenantId, final String vServerId) {
 292         final Optional<Tenant> optional = getTenant(key, tenantId);
 293         if (optional.isPresent()) {
 294             final Tenant tenant = optional.get();
 295             final Vservers vServers = tenant.getVservers();
 296             if (vServers != null) {
 297                 return vServers.getVserver().stream()
 298                         .filter(vServer -> vServer.getVserverId() != null && vServer.getVserverId().equals(vServerId))
 299                         .findFirst();
 300             }
 301         }
 302         LOGGER.error("Unable to find vServer in cache ... ");
 303         return Optional.empty();
 304     }
 305
 306     @Override
 307     public boolean deleteVserver(final CloudRegionKey key, final String tenantId, final String vServerId,
 308             final String resourceVersion) {
 309         final Optional<Vserver> optional = getVserver(key, tenantId, vServerId);
 310         if (optional.isPresent()) {
 311             final Optional<Tenant> tenantOptional = getTenant(key, tenantId);
 312             if (tenantOptional.isPresent()) {
 313                 final Tenant tenant = tenantOptional.get();
 314                 final Vservers vServers = tenant.getVservers();
 315                 if (vServers != null) {
 316                     return vServers.getVserver().removeIf(vServer -> {
 317                         if (vServer.getVserverId() != null && vServer.getVserverId().equals(vServerId)
 318                                 && vServer.getResourceVersion() != null
 319                                 && vServer.getResourceVersion().equals(resourceVersion)) {
 320                             LOGGER.info("Will remove Vserver from cache with vServerId: {} and resource-version: {} ",
 321                                     vServerId, vServer.getResourceVersion());
 322                             return true;
 323                         }
 324                         return false;
 325                     });
 326                 }
 327
 328             }
 329
 330         }
 331         LOGGER.error(
 332                 "Unable to find Vserver for using key: {}, tenant-id: {}, vserver-id: {} and resource-version: {} ...",
 333                 key, tenantId, vServerId, resourceVersion);
 334
 335         return false;
 336     }
 337
 338     @Override
 339     public boolean putK8sResource(final CloudRegionKey key, final String tenantId, final String id,
 340             final K8SResource k8sResource) {
 341         final Optional<Tenant> optional = getTenant(key, tenantId);
 342         if (optional.isPresent()) {
 343             final Tenant tenant = optional.get();
 344             K8SResources k8sResources = tenant.getK8SResources();
 345             if (k8sResources == null) {
 346                 k8sResources = new K8SResources();
 347                 tenant.setK8SResources(k8sResources);
 348             }
 349
 350
 351             final Optional<K8SResource> existingK8sResource = k8sResources.getK8SResource().stream()
 352                     .filter(entry -> entry.getId() != null && entry.getId().equalsIgnoreCase(id)).findFirst();
 353
 354             if (existingK8sResource.isEmpty()) {
 355                 LOGGER.info("Adding k8sResources to cache...");
 356                 return k8sResources.getK8SResource().add(k8sResource);
 357             }
 358
 359             LOGGER.warn("K8SResource already exists existingK8sResource: {}...", existingK8sResource.get());
 360             return false;
 361         }
 362
 363         LOGGER.error("Unable to add K8s Resource using key: {}, tenantId: {} and id: {}...", key, tenantId, id);
 364         return false;
 365     }
 366
 367     @Override
 368     public Optional<K8SResource> getK8sResource(final CloudRegionKey key, final String tenantId, final String id) {
 369         final Optional<Tenant> optional = getTenant(key, tenantId);
 370
 371         if (optional.isPresent()) {
 372
 373             final Tenant tenant = optional.get();
 374             final K8SResources k8sResources = tenant.getK8SResources();
 375             if (k8sResources != null) {
 376                 return k8sResources.getK8SResource().stream()
 377                         .filter(entry -> entry.getId() != null && entry.getId().equalsIgnoreCase(id)).findFirst();
 378             }
 379
 380         }
 381         LOGGER.error("Unable to find K8sResource using key: {}, tenantId: {} and id: {}...", key, tenantId, id);
 382         return Optional.empty();
 383     }
 384
 385     @Override
 386     public boolean addK8sResourceRelationShip(final HttpHeaders incomingHeader, final String targetBaseUrl,
 387             final String requestUriString, final CloudRegionKey key, final String tenantId, final String id,
 388             final Relationship relationship) {
 389         try {
 390             final Optional<K8SResource> optional = getK8sResource(key, tenantId, id);
 391             if (optional.isPresent()) {
 392                 final K8SResource k8sResource = optional.get();
 393                 final String targetUrl = getTargetUrl(targetBaseUrl, relationship.getRelatedLink());
 394                 final Relationship outGoingRelationShip =
 395                         getRelationship(key, tenantId, k8sResource, getRelationShipListRelatedLink(requestUriString));
 396                 final Optional<Relationship> optionalRelationship = httpRestServiceProvider.put(incomingHeader,
 397                         outGoingRelationShip, targetUrl, Relationship.class);
 398
 399                 if (optionalRelationship.isPresent()) {
 400                     final Relationship resultantRelationship = optionalRelationship.get();
 401
 402                     RelationshipList relationshipList = k8sResource.getRelationshipList();
 403                     if (relationshipList == null) {
 404                         relationshipList = new RelationshipList();
 405                         k8sResource.setRelationshipList(relationshipList);
 406                     }
 407                     if (relationshipList.getRelationship().add(resultantRelationship)) {
 408                         LOGGER.info("added relationship {} in cache successfully", resultantRelationship);
 409                         return true;
 410                     }
 411                 }
 412
 413             }
 414         } catch (final Exception exception) {
 415             LOGGER.error("Unable to add two-way relationship for key: {}, tenantId: {} and id: {}", key, tenantId, id,
 416                     exception);
 417         }
 418         LOGGER.error("Unable to add K8sResource relationship for key: {}, tenantId: {} and id: {}...", key, tenantId,
 419                 id);
 420         return false;
 421     }
 422
 423     private Relationship getRelationship(final CloudRegionKey key, final String tenantId, final K8SResource k8sResource,
 424             final String relatedLink) {
 425         final Relationship relationShip = new Relationship();
 426         relationShip.setRelatedTo(K8S_RESOURCE);
 427         relationShip.setRelationshipLabel(USES);
 428         relationShip.setRelatedLink(relatedLink);
 429
 430         final List<RelationshipData> relationshipDataList = relationShip.getRelationshipData();
 431         relationshipDataList.add(getRelationshipData(CLOUD_REGION_CLOUD_OWNER, key.getCloudOwner()));
 432         relationshipDataList.add(getRelationshipData(CLOUD_REGION_CLOUD_REGION_ID, key.getCloudRegionId()));
 433         relationshipDataList.add(getRelationshipData(TENANT_TENANT_ID, tenantId));
 434         relationshipDataList.add(getRelationshipData(K8S_RESOURCE_ID, k8sResource.getId()));
 435
 436         final RelatedToProperty relatedToProperty = new RelatedToProperty();
 437         relatedToProperty.setPropertyKey(K8S_RESOURCE_NAME);
 438         relatedToProperty.setPropertyValue(k8sResource.getName());
 439         relationShip.getRelatedToProperty().add(relatedToProperty);
 440
 441         return relationShip;
 442     }
 443
 444     @Override
 445     public Optional<Relationship> addvServerRelationShip(final CloudRegionKey key, final String tenantId,
 446             final String vServerId, final Relationship relationship, final String requestUri) {
 447         final Optional<Vserver> optional = getVserver(key, tenantId, vServerId);
 448         if (optional.isPresent()) {
 449             final Vserver vServer = optional.get();
 450             RelationshipList relationshipList = vServer.getRelationshipList();
 451             if (relationshipList == null) {
 452                 relationshipList = new RelationshipList();
 453                 vServer.setRelationshipList(relationshipList);
 454             }
 455             relationshipList.getRelationship().add(relationship);
 456             LOGGER.info("Successfully added relation to Vserver with key: {}, tenantId: {} and vServerId: {}", key,
 457                     tenantId, vServerId);
 458             final String relatedLink = getBiDirectionalRelationShipListRelatedLink(requestUri);
 459
 460             final Relationship resultantRelationship = getVserverRelationship(key, tenantId, vServer, relatedLink);
 461
 462             return Optional.of(resultantRelationship);
 463         }
 464
 465         LOGGER.error("Unable to find Vserver using key: {}, tenantId: {} and vServerId: {}...", key, tenantId,
 466                 vServerId);
 467         return Optional.empty();
 468     }
 469
 470     private Relationship getVserverRelationship(final CloudRegionKey key, final String tenantId, final Vserver vServer,
 471             final String relatedLink) {
 472         final Relationship resultantRelationship = new Relationship();
 473         resultantRelationship.setRelatedTo(VSERVER);
 474         resultantRelationship.setRelationshipLabel(HOSTED_ON);
 475         resultantRelationship.setRelatedLink(relatedLink);
 476
 477         final List<RelationshipData> relationshipDataList = resultantRelationship.getRelationshipData();
 478         relationshipDataList.add(getRelationshipData(CLOUD_REGION_CLOUD_OWNER, key.getCloudOwner()));
 479         relationshipDataList.add(getRelationshipData(CLOUD_REGION_CLOUD_REGION_ID, key.getCloudRegionId()));
 480         relationshipDataList.add(getRelationshipData(TENANT_TENANT_ID, tenantId));
 481         relationshipDataList.add(getRelationshipData(VSERVER_VSERVER_ID, vServer.getVserverId()));
 482
 483         final List<RelatedToProperty> relatedToPropertyList = resultantRelationship.getRelatedToProperty();
 484
 485         final RelatedToProperty relatedToProperty = new RelatedToProperty();
 486         relatedToProperty.setPropertyKey(VSERVER_VSERVER_NAME);
 487         relatedToProperty.setPropertyValue(vServer.getVserverName());
 488         relatedToPropertyList.add(relatedToProperty);
 489         return resultantRelationship;
 490     }
 491
 492     @Override
 493     public boolean addVServerRelationShip(final HttpHeaders incomingHeader, final String targetBaseUrl,
 494             final String requestUriString, final CloudRegionKey key, final String tenantId, final String vServerId,
 495             final Relationship relationship) {
 496         try {
 497             final Optional<Vserver> optional = getVserver(key, tenantId, vServerId);
 498             if (optional.isPresent()) {
 499                 final Vserver vServer = optional.get();
 500                 final String targetUrl = getTargetUrl(targetBaseUrl, relationship.getRelatedLink());
 501                 final Relationship outGoingRelationShip = getVserverRelationship(key, tenantId, vServer,
 502                         getRelationShipListRelatedLink(requestUriString));
 503                 final Optional<Relationship> optionalRelationship = httpRestServiceProvider.put(incomingHeader,
 504                         outGoingRelationShip, targetUrl, Relationship.class);
 505                 if (optionalRelationship.isPresent()) {
 506                     final Relationship resultantRelationship = optionalRelationship.get();
 507
 508                     RelationshipList relationshipList = vServer.getRelationshipList();
 509                     if (relationshipList == null) {
 510                         relationshipList = new RelationshipList();
 511                         vServer.setRelationshipList(relationshipList);
 512                     }
 513
 514                     final Optional<Relationship> relationShipExists = relationshipList.getRelationship().stream()
 515                             .filter(relation -> relation.getRelatedTo().equals(resultantRelationship.getRelatedTo())
 516                                     && relation.getRelatedLink().equals(resultantRelationship.getRelatedLink()))
 517                             .findAny();
 518
 519                     if (relationShipExists.isPresent()) {
 520                         LOGGER.info("relationship {} already exists in cache ", resultantRelationship);
 521                         return true;
 522                     }
 523
 524                     LOGGER.info("added relationship {} in cache successfully", resultantRelationship);
 525                     return relationshipList.getRelationship().add(resultantRelationship);
 526                 }
 527
 528             }
 529         } catch (final Exception exception) {
 530             LOGGER.error("Unable to add two-way relationship for key: {}, tenantId: {} and vServerId: {}", key,
 531                     tenantId, vServerId, exception);
 532         }
 533         LOGGER.error("Unable to add Vserver relationship for key: {}, tenantId: {} and vServerId: {}...", key, tenantId,
 534                 vServerId);
 535         return false;
 536     }
 537
 538     private List<EsrSystemInfo> getEsrSystemInfoList(final CloudRegion cloudRegion) {
 539         EsrSystemInfoList esrSystemInfoList = cloudRegion.getEsrSystemInfoList();
 540         if (esrSystemInfoList == null) {
 541             esrSystemInfoList = new EsrSystemInfoList();
 542             cloudRegion.setEsrSystemInfoList(esrSystemInfoList);
 543         }
 544         return esrSystemInfoList.getEsrSystemInfo();
 545     }
 546
 547     private Relationship getRelationship(final String requestUriString, final CloudRegionKey cloudRegionKey,
 548             final Tenant tenant) {
 549         final Relationship relationShip = new Relationship();
 550         relationShip.setRelatedTo(TENANT);
 551         relationShip.setRelationshipLabel(BELONGS_TO);
 552         relationShip.setRelatedLink(getRelationShipListRelatedLink(requestUriString));
 553
 554
 555         final List<RelationshipData> relationshipDataList = relationShip.getRelationshipData();
 556         relationshipDataList.add(getRelationshipData(CLOUD_REGION_CLOUD_OWNER, cloudRegionKey.getCloudOwner()));
 557         relationshipDataList.add(getRelationshipData(CLOUD_REGION_CLOUD_REGION_ID, cloudRegionKey.getCloudRegionId()));
 558         relationshipDataList.add(getRelationshipData(TENANT_TENANT_ID, tenant.getTenantId()));
 559
 560
 561         final RelatedToProperty relatedToProperty = new RelatedToProperty();
 562         relatedToProperty.setPropertyKey(TENANT_TENANT_NAME);
 563         relatedToProperty.setPropertyValue(tenant.getTenantName());
 564         relationShip.getRelatedToProperty().add(relatedToProperty);
 565         return relationShip;
 566     }
 567
 568     private RelationshipData getRelationshipData(final String key, final String value) {
 569         final RelationshipData relationshipData = new RelationshipData();
 570         relationshipData.setRelationshipKey(key);
 571         relationshipData.setRelationshipValue(value);
 572         return relationshipData;
 573     }
 574
 575     @Override
 576     public void clearAll() {
 577         clearCache(CLOUD_REGION_CACHE.getName());
 578
 579     }
 580
 581     @Override
 582     public boolean deleteK8sResource(final CloudRegionKey key, final String tenantId, final String id,
 583                                      final String resourceVersion) {
 584         final Optional<Tenant> optional = getTenant(key, tenantId);
 585         if (optional.isPresent()) {
 586             final Tenant tenant = optional.get();
 587             K8SResources k8sResources = tenant.getK8SResources();
 588             if (k8sResources != null) {
 589                 final Optional<K8SResource> existingK8sResource = k8sResources.getK8SResource().stream()
 590                     .filter(entry -> entry.getId() != null && entry.getId().equalsIgnoreCase(id)).findFirst();
 591
 592                 if (existingK8sResource.isPresent()
 593                     && existingK8sResource.get().getResourceVersion().equals(resourceVersion)) {
 594                     LOGGER.info("k8sResources found in cache and removing the same.");
 595                     return k8sResources.getK8SResource().remove(existingK8sResource.get());
 596                 }
 597             }
 598             else {
 599                 return true;
 600             }
 601         }
 602
 603         LOGGER.error("Unable to add K8s Resource using key: {}, tenantId: {} and id: {}...", key, tenantId, id);
 604         return false;
 605     }
 606 }