gerrit.onap Code Review - sdc.git/blob

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