gerrit.onap Code Review - integration/csit.git/blob

   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.LOCATED_IN;
  29 import static org.onap.so.aaisimulator.utils.Constants.TENANT;
  30 import static org.onap.so.aaisimulator.utils.Constants.TENANT_TENANT_ID;
  31 import static org.onap.so.aaisimulator.utils.Constants.TENANT_TENANT_NAME;
  32 import static org.onap.so.aaisimulator.utils.HttpServiceUtils.getBiDirectionalRelationShipListRelatedLink;
  33 import static org.onap.so.aaisimulator.utils.HttpServiceUtils.getRelationShipListRelatedLink;
  34 import static org.onap.so.aaisimulator.utils.HttpServiceUtils.getTargetUrl;
  35 import java.util.List;
  36 import java.util.Optional;
  37 import org.onap.aai.domain.yang.CloudRegion;
  38 import org.onap.aai.domain.yang.RelatedToProperty;
  39 import org.onap.aai.domain.yang.Relationship;
  40 import org.onap.aai.domain.yang.RelationshipData;
  41 import org.onap.aai.domain.yang.RelationshipList;
  42 import org.onap.aai.domain.yang.Tenant;
  43 import org.onap.aai.domain.yang.Tenants;
  44 import org.onap.so.aaisimulator.models.CloudRegionKey;
  45 import org.onap.so.simulator.cache.provider.AbstractCacheServiceProvider;
  46 import org.slf4j.Logger;
  47 import org.slf4j.LoggerFactory;
  48 import org.springframework.beans.factory.annotation.Autowired;
  49 import org.springframework.cache.Cache;
  50 import org.springframework.cache.CacheManager;
  51 import org.springframework.http.HttpHeaders;
  52 import org.springframework.stereotype.Service;
  53
  54 /**
  55  * @author Waqas Ikram (waqas.ikram@est.tech)
  56  *
  57  */
  58 @Service
  59 public class CloudRegionCacheServiceProviderImpl extends AbstractCacheServiceProvider
  60         implements CloudRegionCacheServiceProvider {
  61
  62     private static final Logger LOGGER = LoggerFactory.getLogger(CloudRegionCacheServiceProviderImpl.class);
  63
  64     private final HttpRestServiceProvider httpRestServiceProvider;
  65
  66     @Autowired
  67     public CloudRegionCacheServiceProviderImpl(final CacheManager cacheManager,
  68             final HttpRestServiceProvider httpRestServiceProvider) {
  69         super(cacheManager);
  70         this.httpRestServiceProvider = httpRestServiceProvider;
  71     }
  72
  73     @Override
  74     public void putCloudRegion(final CloudRegionKey cloudRegionKey, final CloudRegion cloudRegion) {
  75         LOGGER.info("Adding CloudRegion to cache with key: {} ...", cloudRegionKey);
  76         final Cache cache = getCache(CLOUD_REGION_CACHE.getName());
  77         cache.put(cloudRegionKey, cloudRegion);
  78
  79     }
  80
  81     @Override
  82     public Optional<CloudRegion> getCloudRegion(final CloudRegionKey cloudRegionKey) {
  83         LOGGER.info("getting CloudRegion from cache using key: {}", cloudRegionKey);
  84         final Cache cache = getCache(CLOUD_REGION_CACHE.getName());
  85         final CloudRegion value = cache.get(cloudRegionKey, CloudRegion.class);
  86         if (value != null) {
  87             return Optional.of(value);
  88         }
  89         LOGGER.error("Unable to find CloudRegion in cache using key:{} ", cloudRegionKey);
  90         return Optional.empty();
  91     }
  92
  93     @Override
  94     public Optional<Relationship> addRelationShip(final CloudRegionKey key, final Relationship relationship,
  95             final String requestUri) {
  96         final Optional<CloudRegion> optional = getCloudRegion(key);
  97         if (optional.isPresent()) {
  98             final CloudRegion cloudRegion = optional.get();
  99             RelationshipList relationshipList = cloudRegion.getRelationshipList();
 100             if (relationshipList == null) {
 101                 relationshipList = new RelationshipList();
 102                 cloudRegion.setRelationshipList(relationshipList);
 103             }
 104             relationshipList.getRelationship().add(relationship);
 105
 106             LOGGER.info("Successfully added relation to CloudRegion with key: {}", key);
 107
 108
 109             final Relationship resultantRelationship = new Relationship();
 110             resultantRelationship.setRelatedTo(CLOUD_REGION);
 111             resultantRelationship.setRelationshipLabel(LOCATED_IN);
 112             resultantRelationship.setRelatedLink(getBiDirectionalRelationShipListRelatedLink(requestUri));
 113
 114             final List<RelationshipData> relationshipDataList = resultantRelationship.getRelationshipData();
 115             relationshipDataList.add(getRelationshipData(CLOUD_REGION_CLOUD_OWNER, cloudRegion.getCloudOwner()));
 116             relationshipDataList.add(getRelationshipData(CLOUD_REGION_CLOUD_REGION_ID, cloudRegion.getCloudRegionId()));
 117
 118             final List<RelatedToProperty> relatedToPropertyList = resultantRelationship.getRelatedToProperty();
 119
 120             final RelatedToProperty relatedToProperty = new RelatedToProperty();
 121             relatedToProperty.setPropertyKey(CLOUD_REGION_OWNER_DEFINED_TYPE);
 122             relatedToProperty.setPropertyValue(cloudRegion.getOwnerDefinedType());
 123             relatedToPropertyList.add(relatedToProperty);
 124
 125             return Optional.of(resultantRelationship);
 126
 127         }
 128         LOGGER.error("Unable to find CloudRegion using key: {} ...", key);
 129         return Optional.empty();
 130     }
 131
 132     @Override
 133     public boolean putTenant(final CloudRegionKey key, final Tenant tenant) {
 134         final Optional<CloudRegion> optional = getCloudRegion(key);
 135         if (optional.isPresent()) {
 136             final CloudRegion cloudRegion = optional.get();
 137             Tenants tenants = cloudRegion.getTenants();
 138             if (tenants == null) {
 139                 tenants = new Tenants();
 140                 cloudRegion.setTenants(tenants);
 141             }
 142
 143             final Optional<Tenant> existingTenantOptional = tenants.getTenant().stream()
 144                     .filter(existing -> existing.getTenantId().equals(tenant.getTenantId())).findFirst();
 145
 146             if (!existingTenantOptional.isPresent()) {
 147                 return tenants.getTenant().add(tenant);
 148             }
 149             LOGGER.warn("Tenant already exists ...");
 150             return false;
 151         }
 152         LOGGER.error("Unable to add Tenant using key: {} ...", key);
 153         return false;
 154     }
 155
 156     @Override
 157     public Optional<Tenant> getTenant(final CloudRegionKey key, final String tenantId) {
 158         final Optional<CloudRegion> optional = getCloudRegion(key);
 159         if (optional.isPresent()) {
 160             final CloudRegion cloudRegion = optional.get();
 161             final Tenants tenants = cloudRegion.getTenants();
 162             if (tenants != null) {
 163                 return tenants.getTenant().stream().filter(existing -> existing.getTenantId().equals(tenantId))
 164                         .findFirst();
 165             }
 166         }
 167
 168         LOGGER.error("Unable to find Tenant using key: {} and tenantId: {} ...", key, tenantId);
 169         return Optional.empty();
 170     }
 171
 172     @Override
 173     public boolean addRelationShip(final HttpHeaders incomingHeader, final String targetBaseUrl,
 174             final String requestUriString, final CloudRegionKey key, final String tenantId,
 175             final Relationship relationship) {
 176         try {
 177             final Optional<Tenant> optional = getTenant(key, tenantId);
 178             if (optional.isPresent()) {
 179                 final Tenant tenant = optional.get();
 180                 final String targetUrl = getTargetUrl(targetBaseUrl, relationship.getRelatedLink());
 181
 182                 final Relationship outGoingRelationShip = getRelationship(requestUriString, key, tenant);
 183                 final Optional<Relationship> optionalRelationship = httpRestServiceProvider.put(incomingHeader,
 184                         outGoingRelationShip, targetUrl, Relationship.class);
 185
 186                 if (optionalRelationship.isPresent()) {
 187                     final Relationship resultantRelationship = optionalRelationship.get();
 188                     RelationshipList relationshipList = tenant.getRelationshipList();
 189                     if (relationshipList == null) {
 190                         relationshipList = new RelationshipList();
 191                         tenant.setRelationshipList(relationshipList);
 192                     }
 193
 194                     if (relationshipList.getRelationship().add(resultantRelationship)) {
 195                         LOGGER.info("added relationship {} in cache successfully", resultantRelationship);
 196                         return true;
 197                     }
 198                 }
 199
 200
 201             }
 202         } catch (final Exception exception) {
 203             LOGGER.error("Unable to add two-way relationship for CloudRegion: {} and tenant: {}", key, tenantId,
 204                     exception);
 205         }
 206         LOGGER.error("Unable to add relationship in cache for CloudRegion: {} and tenant: {}", key, tenantId);
 207         return false;
 208     }
 209
 210     private Relationship getRelationship(final String requestUriString, final CloudRegionKey cloudRegionKey,
 211             final Tenant tenant) {
 212         final Relationship relationShip = new Relationship();
 213         relationShip.setRelatedTo(TENANT);
 214         relationShip.setRelationshipLabel(BELONGS_TO);
 215         relationShip.setRelatedLink(getRelationShipListRelatedLink(requestUriString));
 216
 217
 218         final List<RelationshipData> relationshipDataList = relationShip.getRelationshipData();
 219         relationshipDataList.add(getRelationshipData(CLOUD_REGION_CLOUD_OWNER, cloudRegionKey.getCloudOwner()));
 220         relationshipDataList.add(getRelationshipData(CLOUD_REGION_CLOUD_REGION_ID, cloudRegionKey.getCloudRegionId()));
 221         relationshipDataList.add(getRelationshipData(TENANT_TENANT_ID, tenant.getTenantId()));
 222
 223
 224         final RelatedToProperty relatedToProperty = new RelatedToProperty();
 225         relatedToProperty.setPropertyKey(TENANT_TENANT_NAME);
 226         relatedToProperty.setPropertyValue(tenant.getTenantName());
 227         relationShip.getRelatedToProperty().add(relatedToProperty);
 228         return relationShip;
 229     }
 230
 231     private RelationshipData getRelationshipData(final String key, final String value) {
 232         final RelationshipData relationshipData = new RelationshipData();
 233         relationshipData.setRelationshipKey(key);
 234         relationshipData.setRelationshipValue(value);
 235         return relationshipData;
 236     }
 237
 238     @Override
 239     public void clearAll() {
 240         clearCahce(CLOUD_REGION_CACHE.getName());
 241
 242     }
 243
 244 }