catalog-be/src/main/java/org/openecomp/sdc/be/ecomp/converters/AssetMetadataConverter.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.openecomp.sdc.be.ecomp.converters;
  22
  23 import fj.data.Either;
  24 import org.apache.commons.collections.MapUtils;
  25 import org.apache.commons.lang3.tuple.ImmutablePair;
  26 import org.openecomp.sdc.be.dao.api.ActionStatus;
  27 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  28 import org.openecomp.sdc.be.distribution.servlet.DistributionCatalogServlet;
  29 import org.openecomp.sdc.be.externalapi.servlet.representation.*;
  30 import org.openecomp.sdc.be.impl.ComponentsUtils;
  31 import org.openecomp.sdc.be.model.*;
  32 import org.openecomp.sdc.be.model.category.CategoryDefinition;
  33 import org.openecomp.sdc.be.model.jsontitan.operations.ToscaOperationFacade;
  34 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  35 import org.openecomp.sdc.exception.ResponseFormat;
  36 import org.slf4j.Logger;
  37 import org.slf4j.LoggerFactory;
  38 import org.springframework.beans.factory.annotation.Autowired;
  39
  40 import java.util.*;
  41
  42 @org.springframework.stereotype.Component("asset-metadata-utils")
  43 public class AssetMetadataConverter {
  44     private static final Logger log = LoggerFactory.getLogger(DistributionCatalogServlet.class);
  45
  46     @Autowired
  47     private ComponentsUtils componentsUtils;
  48
  49     @Autowired
  50     protected ToscaOperationFacade toscaOperationFacade;
  51
  52     /*
  53      * Relative asset’s URL. Should be used in REST GET API to download the asset’s CSAR. https://{serverBaseURL}/{csarPath} can be obtained from (HttpServletRequest)request.getServerName()
  54      */
  55     public Either<List<? extends AssetMetadata>, ResponseFormat> convertToAssetMetadata(List<? extends Component> componentList, String serverBaseURL, boolean detailed) {
  56         if (componentList == null || componentList.isEmpty()) {
  57             return Either.left(new LinkedList<>());
  58         }
  59         List<AssetMetadata> retResList = new LinkedList<>();
  60
  61         for (Component curr : componentList) {
  62             Either<? extends AssetMetadata, ResponseFormat> resMetaData = convertToSingleAssetMetadata(curr, serverBaseURL, detailed);
  63             if (resMetaData.isRight()) {
  64                 return Either.right(resMetaData.right().value());
  65             }
  66             retResList.add(resMetaData.left().value());
  67         }
  68
  69         return Either.left(retResList);
  70
  71     }
  72
  73     public <T extends Component> Either<? extends AssetMetadata, ResponseFormat> convertToSingleAssetMetadata(T component, String serverBaseURL, boolean detailed) {
  74         ComponentTypeEnum componentType = component.getComponentType();
  75         Either<? extends AssetMetadata, ResponseFormat> resMetaData = convertToMetadata(componentType, serverBaseURL, detailed, component);
  76
  77         if (resMetaData.isRight()) {
  78             return Either.right(resMetaData.right().value());
  79         }
  80         else{
  81             return Either.left(resMetaData.left().value());
  82         }
  83
  84     }
  85
  86     private Either<? extends AssetMetadata, ResponseFormat> convertToMetadata(ComponentTypeEnum componentType, String serverBaseURL, boolean detailed, Component curr) {
  87
  88         switch (componentType) {
  89
  90         case RESOURCE:
  91
  92             return generateResourceMeatdata(serverBaseURL, detailed, curr);
  93
  94         case SERVICE:
  95
  96             return generateServiceMetadata(serverBaseURL, detailed, curr);
  97
  98         // For future US's that include product
  99         /*
 100          * case PRODUCT: if (component instanceof Product) { List<ProductAssetMetadata> retResList = new LinkedList<>(); for (Component curr : componentList) { retResList.add(convertToProductAssetMetadata((Product) curr, serverBaseURL)); } return
 101          * Either.left(retResList);
 102          */
 103         default:
 104
 105             ResponseFormat responseFormat = componentsUtils.getResponseFormatAdditionalProperty(ActionStatus.COMPONENT_INVALID_CATEGORY);
 106             return Either.right(responseFormat);
 107         }
 108     }
 109
 110     private Either<? extends AssetMetadata, ResponseFormat> generateResourceMeatdata(String serverBaseURL, boolean detailed, Component curr) {
 111         AssetMetadata metaData;
 112         metaData = createMetadaObject(detailed, curr.getComponentType());
 113         metaData = convertToResourceMetadata((ResourceAssetMetadata) metaData, (Resource) curr, serverBaseURL, detailed);
 114
 115         if (detailed) {
 116             Either<ResourceAssetDetailedMetadata, StorageOperationStatus> converted = convertToResourceDetailedMetadata((ResourceAssetDetailedMetadata) metaData, (Resource) curr, serverBaseURL);
 117             if (converted.isRight()) {
 118                 ActionStatus storageResponse = componentsUtils.convertFromStorageResponse(converted.right().value(), ComponentTypeEnum.RESOURCE);
 119                 ResponseFormat responseFormat = componentsUtils.getResponseFormat(storageResponse);
 120                 return Either.right(responseFormat);
 121             }
 122         }
 123
 124         return Either.left(metaData);
 125     }
 126
 127     private AssetMetadata createMetadaObject(boolean detailed, ComponentTypeEnum type) {
 128         AssetMetadata metaData = null;
 129         switch (type) {
 130         case SERVICE:
 131             if (!detailed) {
 132                 metaData = new ServiceAssetMetadata();
 133             } else {
 134                 metaData = new ServiceAssetDetailedMetadata();
 135             }
 136             break;
 137         case RESOURCE:
 138             if (!detailed) {
 139                 metaData = new ResourceAssetMetadata();
 140             } else {
 141                 metaData = new ResourceAssetDetailedMetadata();
 142             }
 143             break;
 144         default:
 145             break;
 146         }
 147         return metaData;
 148     }
 149
 150     private Either<? extends AssetMetadata, ResponseFormat> generateServiceMetadata(String serverBaseURL, boolean detailed, Component curr) {
 151         AssetMetadata metaData = createMetadaObject(detailed, curr.getComponentType());
 152
 153         metaData = convertToServiceAssetMetadata((ServiceAssetMetadata) metaData, (Service) curr, serverBaseURL, detailed);
 154
 155         if (detailed) {
 156             Either<ServiceAssetDetailedMetadata, StorageOperationStatus> converted = convertToServiceDetailedMetadata((ServiceAssetDetailedMetadata) metaData, (Service) curr, serverBaseURL);
 157             if (converted.isRight()) {
 158                 ActionStatus storageResponse = componentsUtils.convertFromStorageResponse(converted.right().value(), ComponentTypeEnum.RESOURCE);
 159                 ResponseFormat responseFormat = componentsUtils.getResponseFormat(storageResponse);
 160                 return Either.right(responseFormat);
 161             }
 162         }
 163
 164         return Either.left(metaData);
 165     }
 166
 167     private <U extends AssetMetadata, T extends Component> U convertToAsset(U asset, T component, String serverBaseURL, boolean detailed) {
 168         asset.setUuid(component.getUUID());
 169         asset.setInvariantUUID(component.getInvariantUUID());
 170         asset.setName(component.getName());
 171         asset.setVersion(component.getVersion());
 172         if (!detailed) {
 173             asset.setToscaModelURL(serverBaseURL + "/" + component.getUUID() + "/toscaModel");
 174         } else {
 175             String toscaModelUrl = (new String(serverBaseURL)).replace("metadata", "toscaModel");
 176             asset.setToscaModelURL(toscaModelUrl);
 177         }
 178
 179         return asset;
 180     }
 181
 182     private <T extends ResourceAssetMetadata> T convertToResourceMetadata(T assetToPopulate, Resource resource, String serverBaseURL, boolean detailed) {
 183         assetToPopulate = convertToAsset(assetToPopulate, resource, serverBaseURL, detailed);
 184         if(resource.getCategories() != null && !resource.getCategories().isEmpty()){
 185             CategoryDefinition categoryDefinition = resource.getCategories().get(0);
 186             assetToPopulate.setCategory(categoryDefinition.getName());
 187             assetToPopulate.setSubCategory(categoryDefinition.getSubcategories().get(0).getName());
 188         }
 189         assetToPopulate.setResourceType(resource.getResourceType().name());
 190         assetToPopulate.setLifecycleState(resource.getLifecycleState().name());
 191         assetToPopulate.setLastUpdaterUserId(resource.getLastUpdaterUserId());
 192
 193         return (T) assetToPopulate;
 194     }
 195
 196     private <T extends ServiceAssetMetadata> T convertToServiceAssetMetadata(T assetToPopulate, Service service, String serverBaseURL, boolean detailed) {
 197         assetToPopulate = convertToAsset(assetToPopulate, service, serverBaseURL, detailed);
 198
 199         if(service.getCategories() != null && !service.getCategories().isEmpty()){
 200             CategoryDefinition categoryDefinition = service.getCategories().get(0);
 201             assetToPopulate.setCategory(categoryDefinition.getName());
 202         }
 203
 204         assetToPopulate.setLifecycleState(service.getLifecycleState().name());
 205         assetToPopulate.setLastUpdaterUserId(service.getLastUpdaterUserId());
 206         assetToPopulate.setDistributionStatus(service.getDistributionStatus().name());
 207
 208         return (T) assetToPopulate;
 209     }
 210
 211     private <T extends ResourceAssetDetailedMetadata> Either<T, StorageOperationStatus> convertToResourceDetailedMetadata(T assetToPopulate, Resource resource, String serverBaseURL) {
 212
 213         List<ComponentInstance> componentInstances = resource.getComponentInstances();
 214
 215         if (componentInstances != null) {
 216             Either<List<ResourceInstanceMetadata>, StorageOperationStatus> resourceInstanceMetadata = convertToResourceInstanceMetadata(componentInstances, ComponentTypeEnum.RESOURCE_PARAM_NAME, resource.getUUID());
 217             if (resourceInstanceMetadata.isRight()) {
 218                 return Either.right(resourceInstanceMetadata.right().value());
 219             }
 220
 221             assetToPopulate.setResources(resourceInstanceMetadata.left().value());
 222         }
 223
 224         Map<String, ArtifactDefinition> deploymentArtifacts = resource.getDeploymentArtifacts();
 225         assetToPopulate = populateResourceWithArtifacts(assetToPopulate, resource, serverBaseURL, deploymentArtifacts);
 226
 227         assetToPopulate.setLastUpdaterFullName(resource.getLastUpdaterFullName());
 228         assetToPopulate.setToscaResourceName(resource.getToscaResourceName());
 229         assetToPopulate.setDescription(resource.getDescription());
 230         return Either.left(assetToPopulate);
 231     }
 232
 233     private <T extends ServiceAssetDetailedMetadata> Either<T, StorageOperationStatus> convertToServiceDetailedMetadata(T assetToPopulate, Service service, String serverBaseURL) {
 234
 235         List<ComponentInstance> componentInstances = service.getComponentInstances();
 236
 237         if (componentInstances != null) {
 238             Either<List<ResourceInstanceMetadata>, StorageOperationStatus> resourceInstanceMetadata = convertToResourceInstanceMetadata(componentInstances, ComponentTypeEnum.SERVICE_PARAM_NAME, service.getUUID());
 239             if (resourceInstanceMetadata.isRight()) {
 240                 return Either.right(resourceInstanceMetadata.right().value());
 241             }
 242
 243             assetToPopulate.setResources(resourceInstanceMetadata.left().value());
 244         }
 245
 246         Map<String, ArtifactDefinition> deploymentArtifacts = service.getDeploymentArtifacts();
 247         assetToPopulate = populateServiceWithArtifacts(assetToPopulate, service, deploymentArtifacts);
 248
 249         assetToPopulate.setLastUpdaterFullName(service.getLastUpdaterFullName());
 250
 251         return Either.left(assetToPopulate);
 252     }
 253
 254     private <T extends ResourceAssetDetailedMetadata> T populateResourceWithArtifacts(T asset, Resource resource, String serverBaseURL, Map<String, ArtifactDefinition> artifacts) {
 255
 256         List<ArtifactMetadata> artifactMetaList = populateAssetWithArtifacts(resource, artifacts);
 257
 258         asset.setArtifacts(artifactMetaList);
 259
 260         return asset;
 261     }
 262
 263     private <T extends ServiceAssetDetailedMetadata> T populateServiceWithArtifacts(T asset, Service service, Map<String, ArtifactDefinition> artifacts) {
 264
 265         List<ArtifactMetadata> artifactMetaList = populateAssetWithArtifacts(service, artifacts);
 266
 267         asset.setArtifacts(artifactMetaList);
 268
 269         return asset;
 270     }
 271
 272     private List<ArtifactMetadata> populateAssetWithArtifacts(Component component, Map<String, ArtifactDefinition> artifacts) {
 273         List<ArtifactMetadata> artifactMetaList =  new LinkedList<>();
 274         if (artifacts != null) {
 275             Collection<ArtifactDefinition> artefactDefList = artifacts.values();
 276
 277             for (ArtifactDefinition artifactDefinition : artefactDefList) {
 278                 if (artifactDefinition.getEsId() != null && !artifactDefinition.getEsId().isEmpty()) {
 279                     ArtifactMetadata convertedArtifactMetadata = convertToArtifactMetadata(artifactDefinition, ComponentTypeEnum.findParamByType(component.getComponentType()), component.getUUID(), null);
 280                     artifactMetaList.add(convertedArtifactMetadata);
 281                 }
 282             }
 283         }
 284         return artifactMetaList.isEmpty() ? null : artifactMetaList;
 285     }
 286
 287     private ArtifactMetadata convertToArtifactMetadata(ArtifactDefinition artifact, String componentType, String componentUUID, String resourceInstanceName) {
 288         final String COMPONENT_ARTIFACT_URL = "/sdc/v1/catalog/%s/%s/artifacts/%s";
 289
 290         final String RESOURCE_INSTANCE_ARTIFACT_URL = "/sdc/v1/catalog/%s/%s/resourceInstances/%s/artifacts/%s";
 291
 292         ArtifactMetadata metadata = new ArtifactMetadata();
 293
 294         metadata.setArtifactName(artifact.getArtifactName());
 295         metadata.setArtifactType(artifact.getArtifactType());
 296
 297         if (resourceInstanceName == null || resourceInstanceName.isEmpty()) {
 298             metadata.setArtifactURL(String.format(COMPONENT_ARTIFACT_URL, componentType, componentUUID, artifact.getArtifactUUID()));
 299         } else {
 300             metadata.setArtifactURL(String.format(RESOURCE_INSTANCE_ARTIFACT_URL, componentType, componentUUID, resourceInstanceName, artifact.getArtifactUUID()));
 301         }
 302
 303         metadata.setArtifactDescription(artifact.getDescription());
 304         metadata.setArtifactTimeout(artifact.getTimeout() > 0 ? artifact.getTimeout() : null);
 305         metadata.setArtifactChecksum(artifact.getArtifactChecksum());
 306         metadata.setArtifactUUID(artifact.getArtifactUUID());
 307         metadata.setArtifactVersion(artifact.getArtifactVersion());
 308         metadata.setGeneratedFromUUID(artifact.getGeneratedFromId());
 309         metadata.setArtifactLabel(artifact.getArtifactLabel());
 310         metadata.setArtifactGroupType(artifact.getArtifactGroupType().getType());
 311         return metadata;
 312     }
 313
 314     private Either<List<ResourceInstanceMetadata>, StorageOperationStatus> convertToResourceInstanceMetadata(List<ComponentInstance> componentInstances, String componentType, String componentUUID) {
 315         List<ResourceInstanceMetadata> retList = new LinkedList<>();
 316         Map<String, ImmutablePair<String, String>> uuidDuplicatesMap = new HashMap<>();
 317
 318         for (ComponentInstance componentInstance : componentInstances) {
 319             ResourceInstanceMetadata metadata = new ResourceInstanceMetadata();
 320             String componentUid = componentInstance.getComponentUid();
 321             String invariantUUID, resourceUUID;
 322
 323             if (!uuidDuplicatesMap.containsKey(componentUid)) {
 324                 Either<Resource, StorageOperationStatus> eitherResource = toscaOperationFacade.getToscaElement(componentInstance.getComponentUid());
 325                 if (eitherResource.isRight()) {
 326                     log.debug("convertToResourceInstanceMetadata: Failed getting resource with Uid: {}", componentInstance.getComponentUid());
 327                     return Either.right(eitherResource.right().value());
 328                 } else {
 329                     final Resource resource = eitherResource.left().value();
 330                     invariantUUID = resource.getInvariantUUID();
 331                     resourceUUID = resource.getUUID();
 332                     ImmutablePair<String, String> uuidInvariantUUIDPair = new ImmutablePair<>(resourceUUID, invariantUUID);
 333                     uuidDuplicatesMap.put(componentUid, uuidInvariantUUIDPair);
 334                 }
 335             } else {
 336                 invariantUUID = uuidDuplicatesMap.get(componentUid).getRight();
 337                 resourceUUID =  uuidDuplicatesMap.get(componentUid).getLeft();
 338             }
 339
 340             metadata.setResourceInvariantUUID(invariantUUID);
 341             metadata.setResourceUUID(resourceUUID);
 342             metadata.setResourceInstanceName(componentInstance.getName());
 343             metadata.setResourceName(componentInstance.getComponentName());
 344             metadata.setResourceVersion(componentInstance.getComponentVersion());
 345             metadata.setResoucreType(componentInstance.getOriginType().getValue());
 346
 347             if(MapUtils.isNotEmpty(componentInstance.getDeploymentArtifacts())){
 348                 LinkedList<ArtifactMetadata> artifactMetaList = new LinkedList<>();
 349                 Collection<ArtifactDefinition> values = componentInstance.getDeploymentArtifacts().values();
 350                 for (ArtifactDefinition artifactDefinition : values) {
 351                     ArtifactMetadata converted = convertToArtifactMetadata(artifactDefinition, componentType, componentUUID, componentInstance.getNormalizedName());
 352                     artifactMetaList.add(converted);
 353                 }
 354                 metadata.setArtifacts(artifactMetaList);
 355             }
 356             retList.add(metadata);
 357         }
 358         return Either.left(retList);
 359     }
 360
 361     // For future US to support Product
 362     /*
 363      * private ProductAssetMetadata convertToProductAssetMetadata(Product product, String serverBaseURL) { ProductAssetMetadata retProdAsset = new ProductAssetMetadata();
 364      *
 365      * retProdAsset = convertToAsset(retProdAsset, product, serverBaseURL); retProdAsset.setLifecycleState(product.getLifecycleState().name()); retProdAsset.setLastUpdaterUserId(product.getLastUpdaterUserId());
 366      * retProdAsset.setActive(product.getIsActive()); retProdAsset.setContacts(product.getContacts());
 367      *
 368      * List<CategoryDefinition> categories = product.getCategories(); List<ProductCategoryGroupMetadata> categoryMetadataList = new LinkedList<>();
 369      *
 370      * if (categories == null || categories.isEmpty()) { return retProdAsset; } else { for (CategoryDefinition categoryDefinition : categories) { String categoryName = categoryDefinition.getName(); List<SubCategoryDefinition> subcategories =
 371      * categoryDefinition.getSubcategories(); for (SubCategoryDefinition subCategoryDefinition : subcategories) { String subCategoryName = subCategoryDefinition.getName(); List<GroupDefinition> groups = product.getGroups(); for (GroupDefinition
 372      * groupDefinition : groups) { String groupName = groupDefinition.getName(); categoryMetadataList.add(new ProductCategoryGroupMetadata(categoryName, subCategoryName, groupName)); } } } retProdAsset.setProductGroupings(categoryMetadataList);
 373      * return retProdAsset; } }
 374      */
 375 }