gerrit.onap Code Review - sdc.git/blob

   1 /*
   2  * Copyright © 2016-2017 European Support Limited
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package org.openecomp.sdc.vendorsoftwareproduct.impl;
  18
  19 import org.apache.commons.collections4.CollectionUtils;
  20 import org.openecomp.sdc.common.errors.CoreException;
  21 import org.openecomp.sdc.common.errors.ErrorCode;
  22 import org.openecomp.sdc.datatypes.error.ErrorLevel;
  23 import org.openecomp.sdc.logging.context.impl.MdcDataErrorMessage;
  24 import org.openecomp.sdc.logging.types.LoggerConstants;
  25 import org.openecomp.sdc.logging.types.LoggerErrorCode;
  26 import org.openecomp.sdc.logging.types.LoggerTragetServiceName;
  27 import org.openecomp.sdc.vendorsoftwareproduct.NetworkManager;
  28 import org.openecomp.sdc.vendorsoftwareproduct.NicManager;
  29 import org.openecomp.sdc.vendorsoftwareproduct.VendorSoftwareProductConstants;
  30 import org.openecomp.sdc.vendorsoftwareproduct.dao.NicDao;
  31 import org.openecomp.sdc.vendorsoftwareproduct.dao.VendorSoftwareProductInfoDao;
  32 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.NetworkEntity;
  33 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.NicEntity;
  34 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.VspDetails;
  35 import org.openecomp.sdc.vendorsoftwareproduct.errors.DeleteNicErrorBuilder;
  36 import org.openecomp.sdc.vendorsoftwareproduct.errors.DuplicateNicInComponentErrorBuilder;
  37 import org.openecomp.sdc.vendorsoftwareproduct.errors.NicErrorBuilder;
  38 import org.openecomp.sdc.vendorsoftwareproduct.errors.NicInternalNetworkErrorBuilder;
  39 import org.openecomp.sdc.vendorsoftwareproduct.errors.NicNetworkIdNotAllowedExternalNetworkErrorBuilder;
  40 import org.openecomp.sdc.vendorsoftwareproduct.errors.NotSupportedHeatOnboardMethodErrorBuilder;
  41 import org.openecomp.sdc.vendorsoftwareproduct.CompositionEntityDataManager;
  42 import org.openecomp.sdc.vendorsoftwareproduct.services.schemagenerator.SchemaGenerator;
  43 import org.openecomp.sdc.vendorsoftwareproduct.types.CompositionEntityResponse;
  44 import org.openecomp.sdc.vendorsoftwareproduct.types.QuestionnaireResponse;
  45 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.CompositionEntityType;
  46 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.CompositionEntityValidationData;
  47 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.NetworkType;
  48 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.Nic;
  49 import org.openecomp.sdc.vendorsoftwareproduct.types.schemagenerator.NicCompositionSchemaInput;
  50 import org.openecomp.sdc.vendorsoftwareproduct.types.schemagenerator.SchemaTemplateContext;
  51 import org.openecomp.sdc.vendorsoftwareproduct.types.schemagenerator.SchemaTemplateInput;
  52 import org.openecomp.sdc.versioning.VersioningUtil;
  53 import org.openecomp.sdc.versioning.dao.types.Version;
  54
  55 import java.util.Collection;
  56 import java.util.Map;
  57 import java.util.stream.Collectors;
  58
  59 public class NicManagerImpl implements NicManager {
  60   private final NicDao nicDao;
  61   private final CompositionEntityDataManager compositionEntityDataManager;
  62   private final NetworkManager networkManager;
  63   private final VendorSoftwareProductInfoDao vspInfoDao;
  64
  65   public NicManagerImpl(NicDao nicDao,
  66                         CompositionEntityDataManager compositionEntityDataManager,
  67                         NetworkManager networkManager,
  68                         VendorSoftwareProductInfoDao vspInfoDao) {
  69     this.nicDao = nicDao;
  70     this.compositionEntityDataManager = compositionEntityDataManager;
  71     this.networkManager = networkManager;
  72     this.vspInfoDao = vspInfoDao;
  73   }
  74
  75   @Override
  76   public Collection<NicEntity> listNics(String vspId, Version version, String componentId) {
  77     Collection<NicEntity> nics = nicDao.list(new NicEntity(vspId, version, componentId, null));
  78
  79     if (!nics.isEmpty()) {
  80       Map<String, String> networksNameById = listNetworksNameById(vspId, version);
  81       nics.forEach(nicEntity -> {
  82         Nic nic = nicEntity.getNicCompositionData();
  83         nic.setNetworkName(networksNameById.get(nic.getNetworkId()));
  84         nicEntity.setNicCompositionData(nic);
  85       });
  86     }
  87     return nics;
  88   }
  89
  90   private Map<String, String> listNetworksNameById(String vspId, Version version) {
  91     Collection<NetworkEntity> networks = networkManager.listNetworks(vspId, version);
  92     return networks.stream().collect(Collectors.toMap(NetworkEntity::getId,
  93         networkEntity -> networkEntity.getNetworkCompositionData().getName()));
  94   }
  95
  96   @Override
  97   public NicEntity createNic(NicEntity nic) {
  98     NicEntity createdNic;
  99     if (!vspInfoDao.isManual(nic.getVspId(), nic.getVersion())) {
 100       ErrorCode onboardingMethodUpdateErrorCode = NotSupportedHeatOnboardMethodErrorBuilder
 101           .getAddNicNotSupportedHeatOnboardMethodErrorBuilder();
 102       MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
 103           LoggerTragetServiceName.CREATE_NIC, ErrorLevel.ERROR.name(),
 104           LoggerErrorCode.PERMISSION_ERROR.getErrorCode(),
 105           onboardingMethodUpdateErrorCode.message());
 106       throw new CoreException(onboardingMethodUpdateErrorCode);
 107     } else {
 108       validateNic(nic);
 109       createdNic = compositionEntityDataManager.createNic(nic);
 110     }
 111     return createdNic;
 112   }
 113
 114
 115   private void validateNic(NicEntity nic) {
 116     Collection<NicEntity> listNics = listNics(nic.getVspId(), nic.getVersion(), nic
 117         .getComponentId());
 118     String networkId = nic.getNicCompositionData().getNetworkId();
 119     NetworkType networkType = nic.getNicCompositionData().getNetworkType();
 120     String networkDescription = nic.getNicCompositionData().getNetworkDescription();
 121
 122     if (!nic.getNicCompositionData().getName()
 123             .matches(VendorSoftwareProductConstants.NAME_PATTERN)) {
 124       ErrorCode errorCode = NicErrorBuilder
 125               .getNicNameFormatErrorBuilder(VendorSoftwareProductConstants.NAME_PATTERN);
 126
 127       MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
 128               LoggerTragetServiceName.CREATE_NIC, ErrorLevel.ERROR.name(),
 129               errorCode.id(),errorCode.message());
 130
 131       throw new CoreException(errorCode);
 132     }
 133
 134     validateNics(nic, listNics);
 135
 136     if (networkType.equals(NetworkType.Internal)) {
 137       validateInternalNetworkType(nic, networkId, networkDescription);
 138
 139     } else if (networkType.equals(NetworkType.External)
 140             && !(networkId == null || networkId.isEmpty())) {
 141         final ErrorCode nicNetworkIdNotAllowedExternalNetworkErrorBuilder =
 142             new NicNetworkIdNotAllowedExternalNetworkErrorBuilder().build();
 143         MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
 144             LoggerTragetServiceName.CREATE_NIC, ErrorLevel.ERROR.name(),
 145             LoggerErrorCode.DATA_ERROR.getErrorCode(),
 146             nicNetworkIdNotAllowedExternalNetworkErrorBuilder.message());
 147         throw new CoreException(nicNetworkIdNotAllowedExternalNetworkErrorBuilder);
 148     }
 149   }
 150
 151   private void validateInternalNetworkType(NicEntity nic, String networkId,
 152                                            String networkDescription) {
 153     if (!(networkId == null || networkId.isEmpty())) {
 154           networkManager.getNetwork(nic.getVspId(), nic.getVersion(), networkId);
 155     }
 156
 157     if (!(networkDescription == null || networkDescription.isEmpty())) {
 158       final ErrorCode nicNetworkDescriptionErrorBuilder =
 159           NicInternalNetworkErrorBuilder.getNetworkDescriptionInternalNetworkErrorBuilder();
 160       MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
 161           LoggerTragetServiceName.CREATE_NIC, ErrorLevel.ERROR.name(),
 162           LoggerErrorCode.DATA_ERROR.getErrorCode(), nicNetworkDescriptionErrorBuilder.message());
 163       throw new CoreException(nicNetworkDescriptionErrorBuilder);
 164     }
 165   }
 166
 167   private void validateNics(NicEntity nic, Collection<NicEntity> listNics) {
 168     listNics.forEach(nicEntity -> {
 169       Nic nicdata = nicEntity.getNicCompositionData();
 170       if (nic.getNicCompositionData().getName().equalsIgnoreCase(nicdata.getName())) {
 171         final ErrorCode duplicateNicInComponentErrorBuilder =
 172             new DuplicateNicInComponentErrorBuilder(nic.getNicCompositionData().getName(),
 173                 nic.getComponentId()).build();
 174         MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
 175             LoggerTragetServiceName.CREATE_NIC, ErrorLevel.ERROR.name(),
 176             LoggerErrorCode.DATA_ERROR.getErrorCode(),
 177             duplicateNicInComponentErrorBuilder.message());
 178         throw new CoreException(duplicateNicInComponentErrorBuilder);
 179       }
 180
 181     });
 182   }
 183
 184   @Override
 185   public CompositionEntityResponse<Nic> getNic(String vspId, Version version, String componentId,
 186                                                String nicId) {
 187     NicEntity nicEntity = getValidatedNic(vspId, version, componentId, nicId);
 188     Nic nic = nicEntity.getNicCompositionData();
 189
 190     NicCompositionSchemaInput schemaInput = new NicCompositionSchemaInput();
 191     schemaInput.setManual(vspInfoDao.isManual(vspId, version));
 192     schemaInput.setNic(nic);
 193     Map<String, String> networksNameById = listNetworksNameById(vspId, version);
 194     nic.setNetworkName(networksNameById.get(nic.getNetworkId()));
 195     schemaInput.setNetworkIds(networksNameById.keySet());
 196
 197     CompositionEntityResponse<Nic> response = new CompositionEntityResponse<>();
 198     response.setId(nicId);
 199     response.setData(nic);
 200     response.setSchema(getNicCompositionSchema(schemaInput));
 201     return response;
 202   }
 203
 204
 205   private NicEntity getValidatedNic(String vspId, Version version, String componentId,
 206                                     String nicId) {
 207     NicEntity retrieved = nicDao.get(new NicEntity(vspId, version, componentId, nicId));
 208     VersioningUtil
 209         .validateEntityExistence(retrieved, new NicEntity(vspId, version, componentId, nicId),
 210             VspDetails.ENTITY_TYPE);
 211     return retrieved;
 212   }
 213
 214   @Override
 215   public void deleteNic(String vspId, Version version, String componentId, String nicId) {
 216     if (!vspInfoDao.isManual(vspId, version)) {
 217       final ErrorCode deleteNicErrorBuilder =
 218           DeleteNicErrorBuilder.getDeleteNicForHeatOnboardedVspErrorBuilder();
 219       MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
 220           LoggerTragetServiceName.DELETE_NIC, ErrorLevel.ERROR.name(),
 221           LoggerErrorCode.PERMISSION_ERROR.getErrorCode(),
 222           deleteNicErrorBuilder.message());
 223       throw new CoreException(deleteNicErrorBuilder);
 224     }
 225
 226     NicEntity nicEntity = getValidatedNic(vspId, version, componentId, nicId);
 227     nicDao.delete(nicEntity);
 228   }
 229
 230   @Override
 231   public CompositionEntityValidationData updateNic(NicEntity nic) {
 232     NicEntity retrieved =
 233         getValidatedNic(nic.getVspId(), nic.getVersion(), nic.getComponentId(), nic.getId());
 234
 235     NicCompositionSchemaInput schemaInput = new NicCompositionSchemaInput();
 236     schemaInput.setManual(vspInfoDao.isManual(nic.getVspId(), nic.getVersion()));
 237     schemaInput.setNic(retrieved.getNicCompositionData());
 238
 239     if (schemaInput.isManual() && !nic.getNicCompositionData().getName()
 240             .matches(VendorSoftwareProductConstants.NAME_PATTERN)) {
 241       ErrorCode errorCode = NicErrorBuilder
 242               .getNicNameFormatErrorBuilder(VendorSoftwareProductConstants.NAME_PATTERN);
 243
 244       MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
 245               LoggerTragetServiceName.UPDATE_NIC, ErrorLevel.ERROR.name(),
 246               errorCode.id(),errorCode.message());
 247
 248       throw new CoreException(errorCode);
 249     }
 250
 251     CompositionEntityValidationData validationData = compositionEntityDataManager
 252         .validateEntity(nic, SchemaTemplateContext.composition, schemaInput);
 253     if (CollectionUtils.isEmpty(validationData.getErrors())) {
 254       nicDao.update(nic);
 255     }
 256     return validationData;
 257   }
 258
 259   @Override
 260   public QuestionnaireResponse getNicQuestionnaire(String vspId, Version version,
 261                                                    String componentId, String nicId) {
 262     QuestionnaireResponse questionnaireResponse = new QuestionnaireResponse();
 263     NicEntity nicQuestionnaire = nicDao.getQuestionnaireData(vspId, version, componentId, nicId);
 264     VersioningUtil.validateEntityExistence(nicQuestionnaire,
 265         new NicEntity(vspId, version, componentId, nicId), VspDetails.ENTITY_TYPE);
 266
 267     questionnaireResponse.setData(nicQuestionnaire.getQuestionnaireData());
 268     questionnaireResponse.setSchema(getNicQuestionnaireSchema(null));
 269     return questionnaireResponse;
 270   }
 271
 272   @Override
 273   public void updateNicQuestionnaire(String vspId, Version version, String componentId,
 274                                      String nicId, String questionnaireData) {
 275     getNic(vspId, version, componentId, nicId);
 276
 277     nicDao.updateQuestionnaireData(vspId, version, componentId, nicId, questionnaireData);
 278   }
 279
 280   protected String getNicQuestionnaireSchema(SchemaTemplateInput schemaInput) {
 281     return SchemaGenerator
 282         .generate(SchemaTemplateContext.questionnaire, CompositionEntityType.nic, schemaInput);
 283   }
 284
 285   protected String getNicCompositionSchema(NicCompositionSchemaInput schemaInput) {
 286     return SchemaGenerator
 287         .generate(SchemaTemplateContext.composition, CompositionEntityType.nic, schemaInput);
 288   }
 289 }