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