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