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
9 * http://www.apache.org/licenses/LICENSE-2.0
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.
17 * SPDX-License-Identifier: Apache-2.0
18 * ============LICENSE_END=========================================================
20 package org.onap.so.aaisimulator.service.providers;
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;
63 * @author Waqas Ikram (waqas.ikram@est.tech)
67 public class CloudRegionCacheServiceProviderImpl extends AbstractCacheServiceProvider
68 implements CloudRegionCacheServiceProvider {
72 private static final Logger LOGGER = LoggerFactory.getLogger(CloudRegionCacheServiceProviderImpl.class);
74 private final HttpRestServiceProvider httpRestServiceProvider;
77 public CloudRegionCacheServiceProviderImpl(final CacheManager cacheManager,
78 final HttpRestServiceProvider httpRestServiceProvider) {
80 this.httpRestServiceProvider = httpRestServiceProvider;
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);
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);
97 return Optional.of(value);
99 LOGGER.error("Unable to find CloudRegion in cache using key:{} ", cloudRegionKey);
100 return Optional.empty();
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);
114 relationshipList.getRelationship().add(relationship);
116 LOGGER.info("Successfully added relation to CloudRegion with key: {}", key);
119 final Relationship resultantRelationship = new Relationship();
120 resultantRelationship.setRelatedTo(CLOUD_REGION);
121 resultantRelationship.setRelationshipLabel(LOCATED_IN);
122 resultantRelationship.setRelatedLink(getBiDirectionalRelationShipListRelatedLink(requestUri));
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()));
128 final List<RelatedToProperty> relatedToPropertyList = resultantRelationship.getRelatedToProperty();
130 final RelatedToProperty relatedToProperty = new RelatedToProperty();
131 relatedToProperty.setPropertyKey(CLOUD_REGION_OWNER_DEFINED_TYPE);
132 relatedToProperty.setPropertyValue(cloudRegion.getOwnerDefinedType());
133 relatedToPropertyList.add(relatedToProperty);
135 return Optional.of(resultantRelationship);
138 LOGGER.error("Unable to find CloudRegion using key: {} ...", key);
139 return Optional.empty();
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);
153 final Optional<Tenant> existingTenantOptional = tenants.getTenant().stream()
154 .filter(existing -> existing.getTenantId() != null && existing.getTenantId().equals(tenantId))
157 if (!existingTenantOptional.isPresent()) {
158 return tenants.getTenant().add(tenant);
161 LOGGER.warn("Tenant already exists ...");
164 LOGGER.error("Unable to add Tenant using key: {} ...", key);
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))
180 LOGGER.error("Unable to find Tenant using key: {} and tenantId: {} ...", key, tenantId);
181 return Optional.empty();
185 public boolean addRelationShip(final HttpHeaders incomingHeader, final String targetBaseUrl,
186 final String requestUriString, final CloudRegionKey key, final String tenantId,
187 final Relationship relationship) {
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());
194 final Relationship outGoingRelationShip = getRelationship(requestUriString, key, tenant);
195 final Optional<Relationship> optionalRelationship = httpRestServiceProvider.put(incomingHeader,
196 outGoingRelationShip, targetUrl, Relationship.class);
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);
206 if (relationshipList.getRelationship().add(resultantRelationship)) {
207 LOGGER.info("added relationship {} in cache successfully", resultantRelationship);
214 } catch (final Exception exception) {
215 LOGGER.error("Unable to add two-way relationship for CloudRegion: {} and tenant: {}", key, tenantId,
218 LOGGER.error("Unable to add relationship in cache for CloudRegion: {} and tenant: {}", key, tenantId);
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);
232 LOGGER.error("Unable to find EsrSystemInfoList in cache for CloudRegion: {} ", key);
234 return Optional.empty();
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);
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());
253 return esrSystemInfoList.add(esrSystemInfo);
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);
270 final List<Vserver> vServerList = vServers.getVserver();
272 final Optional<Vserver> existingVserver = vServerList.stream()
273 .filter(existing -> existing.getVserverId() != null && existing.getVserverId().equals(vServerId))
276 if (existingVserver.isPresent()) {
277 LOGGER.error("Vserver already exists {}", existingVserver.get());
280 return vServerList.add(vServer);
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))
298 LOGGER.error("Unable to find vServer in cache ... ");
299 return Optional.empty();
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());
328 "Unable to find Vserver for using key: {}, tenant-id: {}, vserver-id: {} and resource-version: {} ...",
329 key, tenantId, vServerId, resourceVersion);
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);
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);
350 final Relationship resultantRelationship = getVserverRelationship(key, tenantId, vServer, relatedLink);
352 return Optional.of(resultantRelationship);
355 LOGGER.error("Unable to find Vserver using key: {}, tenantId: {} and vServerId: {}...", key, tenantId,
357 return Optional.empty();
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);
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()));
373 final List<RelatedToProperty> relatedToPropertyList = resultantRelationship.getRelatedToProperty();
375 final RelatedToProperty relatedToProperty = new RelatedToProperty();
376 relatedToProperty.setPropertyKey(VSERVER_VSERVER_NAME);
377 relatedToProperty.setPropertyValue(vServer.getVserverName());
378 relatedToPropertyList.add(relatedToProperty);
379 return resultantRelationship;
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) {
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();
398 RelationshipList relationshipList = vServer.getRelationshipList();
399 if (relationshipList == null) {
400 relationshipList = new RelationshipList();
401 vServer.setRelationshipList(relationshipList);
404 final Optional<Relationship> relationShipExists = relationshipList.getRelationship().stream()
405 .filter(relation -> relation.getRelatedTo().equals(resultantRelationship.getRelatedTo())
406 && relation.getRelatedLink().equals(resultantRelationship.getRelatedLink()))
409 if (relationShipExists.isPresent()) {
410 LOGGER.info("relationship {} already exists in cache ", resultantRelationship);
414 LOGGER.info("added relationship {} in cache successfully", resultantRelationship);
415 return relationshipList.getRelationship().add(resultantRelationship);
419 } catch (final Exception exception) {
420 LOGGER.error("Unable to add two-way relationship for key: {}, tenantId: {} and vServerId: {}", key,
421 tenantId, vServerId, exception);
423 LOGGER.error("Unable to add Vserver relationship for key: {}, tenantId: {} and vServerId: {}...", key, tenantId,
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);
434 return esrSystemInfoList.getEsrSystemInfo();
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));
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()));
451 final RelatedToProperty relatedToProperty = new RelatedToProperty();
452 relatedToProperty.setPropertyKey(TENANT_TENANT_NAME);
453 relatedToProperty.setPropertyValue(tenant.getTenantName());
454 relationShip.getRelatedToProperty().add(relatedToProperty);
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;
466 public void clearAll() {
467 clearCache(CLOUD_REGION_CACHE.getName());