gerrit.onap Code Review - sdc.git/blob

   1 package org.openecomp.sdc.healing.healers;
   2
   3 import org.apache.commons.collections4.MapUtils;
   4 import org.openecomp.core.converter.ToscaConverter;
   5 import org.openecomp.core.converter.factory.ToscaConverterFactory;
   6 import org.openecomp.core.model.dao.ServiceModelDao;
   7 import org.openecomp.core.model.dao.ServiceModelDaoFactory;
   8 import org.openecomp.core.model.types.ServiceElement;
   9 import org.openecomp.core.translator.datatypes.TranslatorOutput;
  10 import org.openecomp.core.utilities.file.FileContentHandler;
  11 import org.openecomp.core.utilities.orchestration.OnboardingTypesEnum;
  12 import org.openecomp.core.validation.util.MessageContainerUtil;
  13 import org.openecomp.sdc.common.utils.CommonUtil;
  14 import org.openecomp.sdc.datatypes.error.ErrorLevel;
  15 import org.openecomp.sdc.healing.interfaces.Healer;
  16 import org.openecomp.sdc.tosca.datatypes.ToscaServiceModel;
  17 import org.openecomp.sdc.translator.services.heattotosca.HeatToToscaUtil;
  18 import org.openecomp.sdc.vendorsoftwareproduct.dao.OrchestrationTemplateDao;
  19 import org.openecomp.sdc.vendorsoftwareproduct.dao.OrchestrationTemplateDaoFactory;
  20 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.OrchestrationTemplateEntity;
  21 import org.openecomp.sdc.versioning.dao.types.Version;
  22
  23 import java.io.IOException;
  24 import java.util.Objects;
  25 import java.util.Optional;
  26
  27 public class ToscaServiceModelHealer implements Healer {
  28   private ServiceModelDao<ToscaServiceModel, ServiceElement> serviceModelDao;
  29   private OrchestrationTemplateDao orchestrationTemplateDao;
  30   private static final String VALIDATION_FAILURE_MESSAGE = "Product was updated. Please " +
  31       "update the uploaded Heat file according to these validation errors: \n";
  32
  33   public ToscaServiceModelHealer() {
  34     this.serviceModelDao = ServiceModelDaoFactory.getInstance().createInterface();
  35     this.orchestrationTemplateDao = OrchestrationTemplateDaoFactory.getInstance().createInterface();
  36   }
  37
  38   public ToscaServiceModelHealer(
  39       ServiceModelDao<ToscaServiceModel, ServiceElement> serviceModelDao,
  40       OrchestrationTemplateDao orchestrationTemplateDao) {
  41     this.serviceModelDao = serviceModelDao;
  42     this.orchestrationTemplateDao = orchestrationTemplateDao;
  43   }
  44
  45   @Override
  46   public boolean isHealingNeeded(String itemId, Version version) {
  47     OrchestrationTemplateEntity orchestrationTemplate =
  48         orchestrationTemplateDao.get(itemId, version);
  49     OnboardingTypesEnum onboardingTypes =
  50         OnboardingTypesEnum.getOnboardingTypesEnum(orchestrationTemplate.getFileSuffix());
  51
  52     return Objects.nonNull(onboardingTypes) &&
  53         Objects.nonNull(orchestrationTemplate.getContentData());
  54   }
  55
  56   @Override
  57   public void heal(String itemId, Version version) throws Exception {
  58     OrchestrationTemplateEntity orchestrationTemplateEntity =
  59         orchestrationTemplateDao.get(itemId, version);
  60     OnboardingTypesEnum type =
  61         OnboardingTypesEnum.getOnboardingTypesEnum(orchestrationTemplateEntity.getFileSuffix());
  62
  63     Optional<ToscaServiceModel> healedServiceModel =
  64         healServiceModel(orchestrationTemplateEntity, type);
  65
  66     healedServiceModel.ifPresent(serviceModel -> serviceModelDao
  67         .overrideServiceModel(itemId, version, serviceModel));
  68   }
  69
  70   private Optional<ToscaServiceModel> healServiceModel(
  71       OrchestrationTemplateEntity orchestrationTemplateEntity,
  72       OnboardingTypesEnum type) throws IOException {
  73     switch (type) {
  74       case ZIP:
  75         return Optional.of(healServiceModelFromZip(
  76             getFileContentHandlerForHealing(orchestrationTemplateEntity, type)));
  77
  78       case CSAR:
  79         return Optional.of(healServiceModelFromCsar(
  80             getFileContentHandlerForHealing(orchestrationTemplateEntity, type)));
  81
  82       default:
  83         return Optional.empty();
  84     }
  85   }
  86
  87   private FileContentHandler getFileContentHandlerForHealing(
  88       OrchestrationTemplateEntity orchestrationTemplateEntity, OnboardingTypesEnum type)
  89       throws IOException {
  90     byte[] uploadedFileContent = orchestrationTemplateEntity.getContentData().array();
  91     return CommonUtil.validateAndUploadFileContent(type, uploadedFileContent);
  92   }
  93
  94   private ToscaServiceModel healServiceModelFromZip(FileContentHandler contentMap) {
  95     TranslatorOutput translatorOutput =
  96         HeatToToscaUtil.loadAndTranslateTemplateData(contentMap);
  97
  98     if (areThereValidationErrors(translatorOutput)) {
  99       String validationErrorsAsString = MessageContainerUtil.getErrorMessagesListAsString
 100           (MessageContainerUtil
 101               .getMessageByLevel(ErrorLevel.ERROR, translatorOutput.getErrorMessages()));
 102       throw new RuntimeException(VALIDATION_FAILURE_MESSAGE + validationErrorsAsString);
 103     }
 104
 105     return translatorOutput.getToscaServiceModel();
 106   }
 107
 108   private boolean areThereValidationErrors(TranslatorOutput translatorOutput) {
 109     return MapUtils.isNotEmpty(MessageContainerUtil.getMessageByLevel(ErrorLevel.ERROR,
 110         translatorOutput.getErrorMessages()));
 111   }
 112
 113   private ToscaServiceModel healServiceModelFromCsar(FileContentHandler contentMap)
 114       throws IOException {
 115     ToscaConverter toscaConverter = ToscaConverterFactory.getInstance().createInterface();
 116     return toscaConverter.convert(contentMap);
 117   }
 118 }