openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/ImageManagerImpl.java

   1 package org.openecomp.sdc.vendorsoftwareproduct.impl;
   2
   3
   4 import org.apache.commons.collections4.CollectionUtils;
   5 import org.openecomp.core.utilities.json.JsonUtil;
   6 import org.openecomp.sdc.common.errors.CoreException;
   7 import org.openecomp.sdc.common.errors.ErrorCode;
   8 import org.openecomp.sdc.datatypes.error.ErrorLevel;
   9 import org.openecomp.sdc.logging.context.impl.MdcDataDebugMessage;
  10 import org.openecomp.sdc.logging.context.impl.MdcDataErrorMessage;
  11 import org.openecomp.sdc.logging.types.LoggerConstants;
  12 import org.openecomp.sdc.logging.types.LoggerErrorCode;
  13 import org.openecomp.sdc.logging.types.LoggerTragetServiceName;
  14 import org.openecomp.sdc.vendorsoftwareproduct.ImageManager;
  15 import org.openecomp.sdc.vendorsoftwareproduct.dao.ComponentDao;
  16 import org.openecomp.sdc.vendorsoftwareproduct.dao.ComputeDao;
  17 import org.openecomp.sdc.vendorsoftwareproduct.dao.DeploymentFlavorDao;
  18 import org.openecomp.sdc.vendorsoftwareproduct.dao.ImageDao;
  19 import org.openecomp.sdc.vendorsoftwareproduct.dao.VendorSoftwareProductInfoDao;
  20 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.ComponentEntity;
  21 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.ImageEntity;
  22 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.VspDetails;
  23 import org.openecomp.sdc.vendorsoftwareproduct.errors.ImageErrorBuilder;
  24 import org.openecomp.sdc.vendorsoftwareproduct.errors.NotSupportedHeatOnboardMethodErrorBuilder;
  25 import org.openecomp.sdc.vendorsoftwareproduct.services.composition.CompositionEntityDataManager;
  26 import org.openecomp.sdc.vendorsoftwareproduct.services.schemagenerator.SchemaGenerator;
  27 import org.openecomp.sdc.vendorsoftwareproduct.types.CompositionEntityResponse;
  28 import org.openecomp.sdc.vendorsoftwareproduct.types.QuestionnaireResponse;
  29 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.CompositionEntityType;
  30 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.CompositionEntityValidationData;
  31 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.Image;
  32 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.ImageFormat;
  33 import org.openecomp.sdc.vendorsoftwareproduct.types.questionnaire.component.image.ImageDetails;
  34 import org.openecomp.sdc.vendorsoftwareproduct.types.schemagenerator.ImageCompositionSchemaInput;
  35 import org.openecomp.sdc.vendorsoftwareproduct.types.schemagenerator.SchemaTemplateContext;
  36 import org.openecomp.sdc.vendorsoftwareproduct.types.schemagenerator.SchemaTemplateInput;
  37 import org.openecomp.sdc.vendorsoftwareproduct.utils.VendorSoftwareProductUtils;
  38 import org.openecomp.sdc.versioning.VersioningUtil;
  39 import org.openecomp.sdc.versioning.dao.types.Version;
  40 import org.openecomp.sdc.versioning.types.VersionableEntityAction;
  41
  42 import java.util.Collection;
  43
  44 public class ImageManagerImpl implements ImageManager {
  45   private static MdcDataDebugMessage mdcDataDebugMessage = new MdcDataDebugMessage();
  46   private VendorSoftwareProductInfoDao vspInfoDao;
  47   private ImageDao imageDao;
  48   private CompositionEntityDataManager compositionEntityDataManager;
  49
  50   public ImageManagerImpl(
  51       VendorSoftwareProductInfoDao vspInfoDao,
  52       ImageDao imageDao,
  53       CompositionEntityDataManager compositionEntityDataManager
  54
  55   ) {
  56
  57     this.vspInfoDao = vspInfoDao;
  58     this.imageDao = imageDao;
  59     this.compositionEntityDataManager = compositionEntityDataManager;
  60
  61   }
  62
  63   @Override
  64   public ImageEntity createImage(ImageEntity imageEntity, String user) {
  65     /*Version activeVersion = getVersionInfo(imageEntity.getVspId(),
  66         VersionableEntityAction.Write, user).getActiveVersion();
  67
  68     imageEntity.setVersion(activeVersion);*/
  69     if (!vspInfoDao.isManual(imageEntity.getVspId(), imageEntity.getVersion())) {
  70
  71       ErrorCode errorCode = NotSupportedHeatOnboardMethodErrorBuilder
  72           .getAddImageNotSupportedHeatOnboardMethodErrorBuilder();
  73
  74       MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
  75           LoggerTragetServiceName.CREATE_IMAGE, ErrorLevel.ERROR.name(),
  76           errorCode.id(), errorCode.message());
  77
  78       throw new CoreException(errorCode);
  79     }
  80
  81     Collection<ImageEntity> vfcImageList = listImages(imageEntity.getVspId() ,
  82         imageEntity.getVersion(), imageEntity.getComponentId());
  83     validateVfcImage(imageEntity, vfcImageList);
  84     compositionEntityDataManager.createImage(imageEntity);
  85     return imageEntity;
  86   }
  87
  88   @Override
  89   public Collection<ImageEntity> listImages(String vspId, Version version, String componentId,
  90                                             String user) {
  91     mdcDataDebugMessage.debugEntryMessage("VSP id", vspId);
  92     Collection<ImageEntity> imageEntities = listImages(vspId, version, componentId);
  93
  94     mdcDataDebugMessage.debugExitMessage("VSP id", vspId);
  95
  96     return imageEntities;
  97   }
  98
  99   private Collection<ImageEntity> listImages(String vspId, Version version, String componentId) {
 100     return imageDao.list(new ImageEntity(vspId, version, componentId, null));
 101   }
 102
 103   @Override
 104   public CompositionEntityResponse getImageSchema(String vspId, String user) {
 105     mdcDataDebugMessage.debugEntryMessage("VSP id, image id", vspId);
 106
 107     CompositionEntityResponse<Image> response = new CompositionEntityResponse<>();
 108     ImageCompositionSchemaInput inputSchema = new ImageCompositionSchemaInput();
 109     Image image = new Image();
 110     //image.setFormat(ImageFormat.qcow2.name());
 111     inputSchema.setImage(image);
 112     response.setSchema(getImageCompositionSchema(inputSchema));
 113
 114     mdcDataDebugMessage.debugExitMessage("VSP id, image id", vspId);
 115     return response;
 116   }
 117
 118   @Override
 119   public CompositionEntityResponse<Image> getImage(String vspId, Version version, String
 120       componentId, String imageId, String user) {
 121
 122     mdcDataDebugMessage.debugEntryMessage("VSP id, componentId, image id", vspId, componentId,
 123         imageId);
 124
 125     /*version = VersioningUtil
 126         .resolveVersion(version, getVersionInfo(vspId, VersionableEntityAction.Read, user));*/
 127
 128     ImageEntity imageEntity = getImageEntity(vspId, version, componentId, imageId);
 129
 130     Image image = imageEntity.getImageCompositionData();
 131     //Set format to default value in order to handle FTL validation when image format is null
 132     /*if(image.getFormat() == null)
 133       image.setFormat(ImageFormat.qcow2.name());*/
 134
 135     ImageCompositionSchemaInput schemaInput = new ImageCompositionSchemaInput();
 136     schemaInput.setImage(image);
 137
 138     CompositionEntityResponse<Image> response = new CompositionEntityResponse<>();
 139     response.setId(imageId);
 140     response.setData(image);
 141     response.setSchema(getImageCompositionSchema(schemaInput));
 142
 143     mdcDataDebugMessage.debugExitMessage("VSP id, componentId, image id", vspId, componentId,
 144         imageId);
 145
 146     return response;
 147   }
 148
 149   @Override
 150   public QuestionnaireResponse getImageQuestionnaire(String vspId, Version version, String
 151       componentId, String imageId, String user) {
 152     mdcDataDebugMessage.debugEntryMessage("VSP id", vspId);
 153
 154     /*version = VersioningUtil
 155         .resolveVersion(version, getVersionInfo(vspId, VersionableEntityAction.Read, user));
 156     validateComponentId(vspId,version,componentId);*/
 157     QuestionnaireResponse questionnaireResponse = new QuestionnaireResponse();
 158     //validateComponentId(vspId,version,componentId);
 159
 160     ImageEntity retrieved = imageDao.getQuestionnaireData(vspId, version, componentId, imageId);
 161     VersioningUtil.validateEntityExistence(retrieved, new ImageEntity(vspId, version, componentId,
 162             imageId), ComponentEntity.ENTITY_TYPE);
 163     questionnaireResponse.setData(retrieved.getQuestionnaireData());
 164     questionnaireResponse.setSchema(getImageQuestionnaireSchema(null));
 165
 166     mdcDataDebugMessage.debugExitMessage("VSP id", vspId);
 167
 168     return questionnaireResponse;
 169   }
 170
 171   @Override
 172   public void deleteImage(String vspId, Version version, String componentId, String imageId, String
 173       user) {
 174     mdcDataDebugMessage
 175         .debugEntryMessage("VSP id, component id", vspId, componentId, imageId);
 176
 177     /*Version activeVersion =
 178         getVersionInfo(vspId, VersionableEntityAction.Write, user).getActiveVersion();
 179     ComponentEntity component = getComponent(vspId, activeVersion, componentId);*/
 180     ImageEntity imageEntity = getImageEntity(vspId, version, componentId, imageId);
 181     if (!vspInfoDao.isManual(vspId, version)) {
 182       final ErrorCode deleteImageErrorBuilder =
 183           NotSupportedHeatOnboardMethodErrorBuilder
 184               .getDelImageNotSupportedHeatOnboardMethodErrorBuilder();
 185       MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
 186           LoggerTragetServiceName.DELETE_IMAGE, ErrorLevel.ERROR.name(),
 187           LoggerErrorCode.PERMISSION_ERROR.getErrorCode(),
 188           deleteImageErrorBuilder.message());
 189       throw new CoreException(deleteImageErrorBuilder);
 190     }
 191     if (imageEntity != null) {
 192       imageDao.delete(new ImageEntity(vspId, version, componentId, imageId));
 193     }
 194     mdcDataDebugMessage
 195         .debugExitMessage("VSP id, component id", vspId, componentId, imageId);
 196   }
 197
 198   private void validateHeatVspImageUpdate(String name, String value, String retrivedValue) {
 199
 200     if(value != null && !value.equals(retrivedValue)) {
 201
 202       final ErrorCode updateHeatImageErrorBuilder =
 203           ImageErrorBuilder.getImageHeatReadOnlyErrorBuilder(name);
 204
 205       MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
 206           LoggerTragetServiceName.UPDATE_IMAGE, ErrorLevel.ERROR.name(),
 207           LoggerErrorCode.PERMISSION_ERROR.getErrorCode(),
 208           updateHeatImageErrorBuilder.message());
 209       throw new CoreException(updateHeatImageErrorBuilder);
 210     }
 211   }
 212
 213   @Override
 214   public CompositionEntityValidationData updateImage(ImageEntity image, String user) {
 215     mdcDataDebugMessage
 216         .debugEntryMessage("VSP id, component id", image.getVspId(), image.getComponentId(),
 217             image.getId());
 218
 219     /*Version activeVersion =
 220         getVersionInfo(image.getVspId(), VersionableEntityAction.Write, user).getActiveVersion();
 221     image.setVersion(activeVersion);*/
 222
 223     ImageEntity retrieved = getImageEntity(image.getVspId(), image.getVersion(), image.getComponentId(),
 224         image.getId());
 225
 226     if(!vspInfoDao.isManual(image.getVspId(), image.getVersion())) {
 227       final Image imageCompositionData = image.getImageCompositionData();
 228       final String fileName = imageCompositionData.getFileName();
 229       //final String format = imageCompositionData.getFormat();
 230       validateHeatVspImageUpdate("fileName", fileName, retrieved.getImageCompositionData()
 231           .getFileName());
 232       /*validateHeatVspImageUpdate("format", format, retrieved.getImageCompositionData()
 233           .getFormat());*/
 234     }
 235
 236     Collection<ImageEntity> vfcImageList = listImages(image.getVspId() ,
 237         image.getVersion(), image.getComponentId());
 238
 239     //Set to null so that retrieved object is equal to one in list and gets removed.
 240     retrieved.setQuestionnaireData(null);
 241     vfcImageList.remove(retrieved);
 242     validateVfcImage(image, vfcImageList);
 243
 244     //Set format to default value in order to handle FTL validation when image format is null
 245     /*if(image.getImageCompositionData().getFormat() == null)
 246       image.getImageCompositionData().setFormat(ImageFormat.qcow2.name());*/
 247
 248     ImageCompositionSchemaInput schemaInput = new ImageCompositionSchemaInput();
 249     schemaInput.setImage(image.getImageCompositionData());
 250
 251     CompositionEntityValidationData validationData = compositionEntityDataManager
 252         .validateEntity(image, SchemaTemplateContext.composition, schemaInput);
 253     if (CollectionUtils.isEmpty(validationData.getErrors())) {
 254       imageDao.update(image);
 255     }
 256
 257     mdcDataDebugMessage
 258         .debugExitMessage("VSP id, component id", image.getVspId(), image.getComponentId(),
 259             image.getId());
 260
 261     return validationData;
 262   }
 263
 264   @Override
 265   public void updateImageQuestionnaire(String vspId, Version version, String componentId, String
 266       imageId, String questionnaireData, String user) {
 267     mdcDataDebugMessage.debugEntryMessage("VSP id, component id, imageId", vspId, componentId,
 268         imageId);
 269
 270     getImageEntity(vspId, version, componentId, imageId);
 271
 272     /*Version activeVersion =
 273         getVersionInfo(vspId, VersionableEntityAction.Write, user).getActiveVersion();
 274
 275     getComponent(vspId, activeVersion, componentId);*/
 276
 277     final ImageDetails image = JsonUtil.json2Object(questionnaireData, ImageDetails.class);
 278     final String format = image.getFormat();
 279     try {
 280       if (format != null) {
 281         final ImageFormat imageFormat = ImageFormat.valueOf(format);
 282       }
 283     } catch (IllegalArgumentException exception) {
 284       ErrorCode errorCode = ImageErrorBuilder.getInvalidImageFormatErrorBuilder();
 285       MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
 286           LoggerTragetServiceName.UPDATE_IMAGE, ErrorLevel.ERROR.name(),
 287           errorCode.id(), errorCode.message() );
 288       throw new CoreException(errorCode);
 289     }
 290
 291     //Validate Format is read only for HEAT Onboarding
 292     if (!vspInfoDao.isManual(vspId, version)) {
 293       final QuestionnaireResponse imageQuestionnaire = getImageQuestionnaire(vspId, version,
 294           componentId, imageId, user);
 295       final String data = imageQuestionnaire.getData();
 296       if (data != null) {
 297         String retrivedFormat = JsonUtil.json2Object(data, ImageDetails.class).getFormat();
 298         validateHeatVspImageUpdate("format", format, retrivedFormat);
 299       }
 300     }
 301
 302     imageDao.updateQuestionnaireData(vspId, version, componentId, imageId, questionnaireData);
 303     mdcDataDebugMessage.debugExitMessage("VSP id, component id, imageId", vspId, componentId,
 304         imageId);
 305   }
 306
 307   private ImageEntity getImageEntity(String vspId, Version version, String componentId,
 308                                      String imageId) {
 309     //validateComponentId(vspId,version,componentId);
 310
 311     ImageEntity imageEntity = imageDao.get(new ImageEntity(vspId, version, componentId, imageId));
 312
 313     VersioningUtil.validateEntityExistence(imageEntity, new ImageEntity(vspId, version, componentId,
 314         imageId), VspDetails.ENTITY_TYPE);
 315     return imageEntity;
 316   }
 317
 318
 319   private boolean isImageNameDuplicate(Collection<ImageEntity> images, String fileName) {
 320     for (ImageEntity image : images) {
 321       if (image.getImageCompositionData().getFileName().equalsIgnoreCase(fileName)) {
 322         return true;
 323       }
 324     }
 325     return false;
 326   }
 327
 328   private void validateVfcImage(ImageEntity image, Collection<ImageEntity> vfcImageList) {
 329     if (isImageNameDuplicate(vfcImageList,image.getImageCompositionData().getFileName())) {
 330       ErrorCode errorCode = ImageErrorBuilder.getDuplicateImageNameErrorBuilder(image
 331           .getImageCompositionData().getFileName(), image.getComponentId());
 332
 333       MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
 334           LoggerTragetServiceName.CREATE_COMPONENT, ErrorLevel.ERROR.name(),
 335           errorCode.id(),errorCode.message());
 336
 337       throw new CoreException(errorCode);
 338     }
 339   }
 340
 341   protected String getImageCompositionSchema(SchemaTemplateInput schemaInput) {
 342     mdcDataDebugMessage.debugEntryMessage(null, null);
 343     mdcDataDebugMessage.debugExitMessage(null, null);
 344     return SchemaGenerator
 345         .generate(SchemaTemplateContext.composition, CompositionEntityType.image,
 346             schemaInput);
 347   }
 348
 349   protected String getImageQuestionnaireSchema(SchemaTemplateInput schemaInput) {
 350     mdcDataDebugMessage.debugEntryMessage(null, null);
 351
 352     mdcDataDebugMessage.debugExitMessage(null, null);
 353     return SchemaGenerator
 354         .generate(SchemaTemplateContext.questionnaire, CompositionEntityType.image,
 355             schemaInput);
 356   }
 357
 358
 359 }