gerrit.onap Code Review - sdc.git/blob

   1 /*
   2  * Copyright © 2016-2017 European Support Limited
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package org.openecomp.sdc.vendorsoftwareproduct.impl;
  18
  19
  20 import org.apache.commons.collections4.CollectionUtils;
  21 import org.openecomp.core.utilities.json.JsonUtil;
  22 import org.openecomp.sdc.common.errors.CoreException;
  23 import org.openecomp.sdc.common.errors.ErrorCode;
  24 import org.openecomp.sdc.datatypes.error.ErrorLevel;
  25 import org.openecomp.sdc.logging.context.impl.MdcDataErrorMessage;
  26 import org.openecomp.sdc.logging.types.LoggerConstants;
  27 import org.openecomp.sdc.logging.types.LoggerErrorCode;
  28 import org.openecomp.sdc.logging.types.LoggerTragetServiceName;
  29 import org.openecomp.sdc.vendorsoftwareproduct.ImageManager;
  30 import org.openecomp.sdc.vendorsoftwareproduct.dao.ImageDao;
  31 import org.openecomp.sdc.vendorsoftwareproduct.dao.VendorSoftwareProductInfoDao;
  32 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.ComponentEntity;
  33 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.ImageEntity;
  34 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.VspDetails;
  35 import org.openecomp.sdc.vendorsoftwareproduct.errors.ImageErrorBuilder;
  36 import org.openecomp.sdc.vendorsoftwareproduct.errors.NotSupportedHeatOnboardMethodErrorBuilder;
  37 import org.openecomp.sdc.vendorsoftwareproduct.services.composition.CompositionEntityDataManager;
  38 import org.openecomp.sdc.vendorsoftwareproduct.services.schemagenerator.SchemaGenerator;
  39 import org.openecomp.sdc.vendorsoftwareproduct.types.CompositionEntityResponse;
  40 import org.openecomp.sdc.vendorsoftwareproduct.types.QuestionnaireResponse;
  41 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.CompositionEntityType;
  42 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.CompositionEntityValidationData;
  43 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.Image;
  44 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.ImageFormat;
  45 import org.openecomp.sdc.vendorsoftwareproduct.types.questionnaire.component.image.ImageDetails;
  46 import org.openecomp.sdc.vendorsoftwareproduct.types.schemagenerator.ImageCompositionSchemaInput;
  47 import org.openecomp.sdc.vendorsoftwareproduct.types.schemagenerator.SchemaTemplateContext;
  48 import org.openecomp.sdc.vendorsoftwareproduct.types.schemagenerator.SchemaTemplateInput;
  49 import org.openecomp.sdc.versioning.VersioningUtil;
  50 import org.openecomp.sdc.versioning.dao.types.Version;
  51
  52 import java.util.Collection;
  53 import java.util.stream.Collectors;
  54
  55 public class ImageManagerImpl implements ImageManager {
  56   private final VendorSoftwareProductInfoDao vspInfoDao;
  57   private final ImageDao imageDao;
  58   private final CompositionEntityDataManager compositionEntityDataManager;
  59   private  static final String VSP_ID = "VSP id";
  60   private static final String VSP_ID_COMPONENT_ID = "VSP id, component id";
  61
  62   public ImageManagerImpl(VendorSoftwareProductInfoDao vspInfoDao,
  63                           ImageDao imageDao,
  64                           CompositionEntityDataManager compositionEntityDataManager) {
  65     this.vspInfoDao = vspInfoDao;
  66     this.imageDao = imageDao;
  67     this.compositionEntityDataManager = compositionEntityDataManager;
  68   }
  69
  70   @Override
  71   public ImageEntity createImage(ImageEntity imageEntity) {
  72     boolean isManual = vspInfoDao.isManual(imageEntity.getVspId(), imageEntity.getVersion());
  73     if (!isManual) {
  74       ErrorCode errorCode = NotSupportedHeatOnboardMethodErrorBuilder
  75           .getAddImageNotSupportedHeatOnboardMethodErrorBuilder();
  76
  77       MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
  78           LoggerTragetServiceName.CREATE_IMAGE, ErrorLevel.ERROR.name(),
  79           errorCode.id(), errorCode.message());
  80
  81       throw new CoreException(errorCode);
  82     }
  83     compositionEntityDataManager.createImage(imageEntity);
  84     return imageEntity;
  85   }
  86
  87   @Override
  88   public Collection<ImageEntity> listImages(String vspId, Version version, String componentId) {
  89     Collection<ImageEntity> imageEntities =
  90         imageDao.list(new ImageEntity(vspId, version, componentId, null));
  91     return imageEntities;
  92   }
  93
  94   @Override
  95   public CompositionEntityResponse<Image> getImageSchema(String vspId) {
  96     CompositionEntityResponse<Image> response = new CompositionEntityResponse<>();
  97     ImageCompositionSchemaInput inputSchema = new ImageCompositionSchemaInput();
  98     Image image = new Image();
  99     inputSchema.setImage(image);
 100     response.setSchema(getImageCompositionSchema(inputSchema));
 101     return response;
 102   }
 103
 104   @Override
 105   public CompositionEntityResponse<Image> getImage(String vspId, Version version, String
 106       componentId, String imageId) {
 107     ImageEntity imageEntity = getImageEntity(vspId, version, componentId, imageId);
 108
 109     Image image = imageEntity.getImageCompositionData();
 110
 111     ImageCompositionSchemaInput schemaInput = new ImageCompositionSchemaInput();
 112     schemaInput.setImage(image);
 113
 114     CompositionEntityResponse<Image> response = new CompositionEntityResponse<>();
 115     response.setId(imageId);
 116     response.setData(image);
 117     response.setSchema(getImageCompositionSchema(schemaInput));
 118     return response;
 119   }
 120
 121   @Override
 122   public QuestionnaireResponse getImageQuestionnaire(String vspId, Version version, String
 123       componentId, String imageId) {
 124     QuestionnaireResponse questionnaireResponse = new QuestionnaireResponse();
 125
 126     ImageEntity retrieved = imageDao.getQuestionnaireData(vspId, version, componentId, imageId);
 127     VersioningUtil.validateEntityExistence(retrieved, new ImageEntity(vspId, version, componentId,
 128         imageId), ComponentEntity.ENTITY_TYPE);
 129     questionnaireResponse.setData(retrieved.getQuestionnaireData());
 130     questionnaireResponse.setSchema(getImageQuestionnaireSchema(null));
 131     return questionnaireResponse;
 132   }
 133
 134   @Override
 135   public void deleteImage(String vspId, Version version, String componentId, String imageId) {
 136     ImageEntity imageEntity = getImageEntity(vspId, version, componentId, imageId);
 137     if (!vspInfoDao.isManual(vspId, version)) {
 138       final ErrorCode deleteImageErrorBuilder =
 139           NotSupportedHeatOnboardMethodErrorBuilder
 140               .getDelImageNotSupportedHeatOnboardMethodErrorBuilder();
 141       MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
 142           LoggerTragetServiceName.DELETE_IMAGE, ErrorLevel.ERROR.name(),
 143           LoggerErrorCode.PERMISSION_ERROR.getErrorCode(),
 144           deleteImageErrorBuilder.message());
 145       throw new CoreException(deleteImageErrorBuilder);
 146     }
 147     if (imageEntity != null) {
 148       imageDao.delete(new ImageEntity(vspId, version, componentId, imageId));
 149     }
 150   }
 151
 152   private void validateHeatVspImageUpdate(String name, String value, String retrivedValue) {
 153     if (value != null && !value.equals(retrivedValue)) {
 154       final ErrorCode updateHeatImageErrorBuilder =
 155           ImageErrorBuilder.getImageHeatReadOnlyErrorBuilder(name);
 156
 157       MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
 158           LoggerTragetServiceName.UPDATE_IMAGE, ErrorLevel.ERROR.name(),
 159           LoggerErrorCode.PERMISSION_ERROR.getErrorCode(),
 160           updateHeatImageErrorBuilder.message());
 161       throw new CoreException(updateHeatImageErrorBuilder);
 162     }
 163   }
 164
 165   @Override
 166   public CompositionEntityValidationData updateImage(ImageEntity image) {
 167     boolean isManual = vspInfoDao.isManual(image.getVspId(), image.getVersion());
 168     ImageEntity retrieved =
 169         getImageEntity(image.getVspId(), image.getVersion(), image.getComponentId(),
 170             image.getId());
 171
 172     if (!isManual) {
 173       final Image imageCompositionData = image.getImageCompositionData();
 174       final String fileName = imageCompositionData.getFileName();
 175       validateHeatVspImageUpdate("fileName", fileName, retrieved.getImageCompositionData()
 176           .getFileName());
 177     }
 178
 179     Collection<ImageEntity> vfcImageList = listImages(image.getVspId(),
 180         image.getVersion(), image.getComponentId());
 181
 182     //Set to null so that retrieved object is equal to one in list and gets removed.
 183     retrieved.setQuestionnaireData(null);
 184     vfcImageList.remove(retrieved);
 185
 186
 187     ImageCompositionSchemaInput schemaInput = new ImageCompositionSchemaInput();
 188     schemaInput.setImage(image.getImageCompositionData());
 189
 190     CompositionEntityValidationData validationData = compositionEntityDataManager
 191         .validateEntity(image, SchemaTemplateContext.composition, schemaInput);
 192     if (CollectionUtils.isEmpty(validationData.getErrors())) {
 193       imageDao.update(image);
 194     }
 195     return validationData;
 196   }
 197
 198   @Override
 199   public void updateImageQuestionnaire(String vspId, Version version, String componentId, String
 200       imageId, String questionnaireData) {
 201     getImageEntity(vspId, version, componentId, imageId);
 202
 203
 204     final ImageDetails image = JsonUtil.json2Object(questionnaireData, ImageDetails.class);
 205     final String format = image.getFormat();
 206     try {
 207       if (format != null) {
 208         ImageFormat.valueOf(format);
 209       }
 210     } catch (IllegalArgumentException exception) {
 211       ErrorCode errorCode = ImageErrorBuilder.getInvalidImageFormatErrorBuilder();
 212       MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
 213           LoggerTragetServiceName.UPDATE_IMAGE, ErrorLevel.ERROR.name(),
 214           errorCode.id(), errorCode.message() + exception);
 215       throw new CoreException(errorCode, exception);
 216     }
 217
 218     //Validate Format is read only for HEAT Onboarding
 219     if (!vspInfoDao.isManual(vspId, version)) {
 220       final QuestionnaireResponse imageQuestionnaire = getImageQuestionnaire(vspId, version,
 221           componentId, imageId);
 222       final String data = imageQuestionnaire.getData();
 223       if (data != null) {
 224         String retrivedFormat = JsonUtil.json2Object(data, ImageDetails.class).getFormat();
 225         validateHeatVspImageUpdate("format", format, retrivedFormat);
 226       }
 227     }
 228
 229     if (!isImageVersionUnique(vspId, version, componentId, imageId, image)) {
 230       ErrorCode errorCode = ImageErrorBuilder.getDuplicateImageVersionErrorBuilder(image
 231           .getVersion(), componentId);
 232
 233       MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
 234           LoggerTragetServiceName.UPDATE_IMAGE, ErrorLevel.ERROR.name(),
 235           errorCode.id(), errorCode.message());
 236
 237       throw new CoreException(errorCode);
 238     }
 239
 240     imageDao.updateQuestionnaireData(vspId, version, componentId, imageId, questionnaireData);
 241   }
 242
 243   private boolean isImageVersionUnique(String vspId, Version version, String componentId,
 244                                        String imageId,
 245                                        ImageDetails image) {
 246     boolean isPresent = true;
 247     if (image != null && image.getVersion() != null) {
 248       Collection<ImageEntity> imageEntities =
 249           imageDao.list(new ImageEntity(vspId, version, componentId, null));
 250       if (CollectionUtils.isNotEmpty(imageEntities)) {
 251         imageEntities =
 252             imageEntities.stream().filter(imageEntity -> image.getVersion().trim().equalsIgnoreCase(
 253                 getImageVersion(vspId, version, componentId, imageEntity))
 254                 && !imageEntity.getId().equals(imageId)).collect(Collectors.toList());
 255
 256         isPresent = CollectionUtils.isEmpty(imageEntities);
 257       }
 258     }
 259
 260     return isPresent;
 261   }
 262
 263   private String getImageVersion(String vspId, Version version, String componentId,
 264                                  ImageEntity imageEntity) {
 265     QuestionnaireResponse imageQuestionnaire = getImageQuestionnaire(vspId, version,
 266         componentId, imageEntity.getId());
 267     ImageDetails imageDetails =
 268         JsonUtil.json2Object(imageQuestionnaire.getData(), ImageDetails.class);
 269
 270     return imageDetails == null ? null
 271         : imageDetails.getVersion() != null ? imageDetails.getVersion().trim() : null;
 272   }
 273
 274   private ImageEntity getImageEntity(String vspId, Version version, String componentId,
 275                                      String imageId) {
 276
 277     ImageEntity imageEntity = imageDao.get(new ImageEntity(vspId, version, componentId, imageId));
 278
 279     VersioningUtil.validateEntityExistence(imageEntity, new ImageEntity(vspId, version, componentId,
 280         imageId), VspDetails.ENTITY_TYPE);
 281     return imageEntity;
 282   }
 283
 284   protected String getImageCompositionSchema(SchemaTemplateInput schemaInput) {
 285     return SchemaGenerator
 286         .generate(SchemaTemplateContext.composition, CompositionEntityType.image,
 287             schemaInput);
 288   }
 289
 290   protected String getImageQuestionnaireSchema(SchemaTemplateInput schemaInput) {
 291     return SchemaGenerator
 292         .generate(SchemaTemplateContext.questionnaire, CompositionEntityType.image,
 293             schemaInput);
 294   }
 295 }