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