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