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.services.composition.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   private static final String VSP_ID_COMPONENT_ID = "VSP id, component id";
  65
  66   public NicManagerImpl(NicDao nicDao,
  67                         CompositionEntityDataManager compositionEntityDataManager,
  68                         NetworkManager networkManager,
  69                         VendorSoftwareProductInfoDao vspInfoDao) {
  70     this.nicDao = nicDao;
  71     this.compositionEntityDataManager = compositionEntityDataManager;
  72     this.networkManager = networkManager;
  73     this.vspInfoDao = vspInfoDao;
  74   }
  75
  76   @Override
  77   public Collection<NicEntity> listNics(String vspId, Version version, String componentId) {
  78     Collection<NicEntity> nics = nicDao.list(new NicEntity(vspId, version, componentId, null));
  79
  80     if (!nics.isEmpty()) {
  81       Map<String, String> networksNameById = listNetworksNameById(vspId, version);
  82       nics.forEach(nicEntity -> {
  83         Nic nic = nicEntity.getNicCompositionData();
  84         nic.setNetworkName(networksNameById.get(nic.getNetworkId()));
  85         nicEntity.setNicCompositionData(nic);
  86       });
  87     }
  88     return nics;
  89   }
  90
  91   private Map<String, String> listNetworksNameById(String vspId, Version version) {
  92     Collection<NetworkEntity> networks = networkManager.listNetworks(vspId, version);
  93     return networks.stream().collect(Collectors.toMap(NetworkEntity::getId,
  94         networkEntity -> networkEntity.getNetworkCompositionData().getName()));
  95   }
  96
  97   @Override
  98   public NicEntity createNic(NicEntity nic) {
  99     NicEntity createdNic;
 100     if (!vspInfoDao.isManual(nic.getVspId(), nic.getVersion())) {
 101       ErrorCode onboardingMethodUpdateErrorCode = NotSupportedHeatOnboardMethodErrorBuilder
 102           .getAddNicNotSupportedHeatOnboardMethodErrorBuilder();
 103       MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
 104           LoggerTragetServiceName.CREATE_NIC, ErrorLevel.ERROR.name(),
 105           LoggerErrorCode.PERMISSION_ERROR.getErrorCode(),
 106           onboardingMethodUpdateErrorCode.message());
 107       throw new CoreException(onboardingMethodUpdateErrorCode);
 108     } else {
 109       validateNic(nic);
 110       createdNic = compositionEntityDataManager.createNic(nic);
 111     }
 112     return createdNic;
 113   }
 114
 115
 116   private void validateNic(NicEntity nic) {
 117     Collection<NicEntity> listNics = listNics(nic.getVspId(), nic.getVersion(), nic
 118         .getComponentId());
 119     String networkId = nic.getNicCompositionData().getNetworkId();
 120     NetworkType networkType = nic.getNicCompositionData().getNetworkType();
 121     String networkDescription = nic.getNicCompositionData().getNetworkDescription();
 122
 123     if (!nic.getNicCompositionData().getName()
 124             .matches(VendorSoftwareProductConstants.NAME_PATTERN)) {
 125       ErrorCode errorCode = NicErrorBuilder
 126               .getNicNameFormatErrorBuilder(VendorSoftwareProductConstants.NAME_PATTERN);
 127
 128       MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
 129               LoggerTragetServiceName.CREATE_NIC, ErrorLevel.ERROR.name(),
 130               errorCode.id(),errorCode.message());
 131
 132       throw new CoreException(errorCode);
 133     }
 134
 135     validateNics(nic, listNics);
 136
 137     if (networkType.equals(NetworkType.Internal)) {
 138       validateInternalNetworkType(nic, networkId, networkDescription);
 139
 140     } else if (networkType.equals(NetworkType.External)
 141             && !(networkId == null || networkId.isEmpty())) {
 142         final ErrorCode nicNetworkIdNotAllowedExternalNetworkErrorBuilder =
 143             new NicNetworkIdNotAllowedExternalNetworkErrorBuilder().build();
 144         MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
 145             LoggerTragetServiceName.CREATE_NIC, ErrorLevel.ERROR.name(),
 146             LoggerErrorCode.DATA_ERROR.getErrorCode(),
 147             nicNetworkIdNotAllowedExternalNetworkErrorBuilder.message());
 148         throw new CoreException(nicNetworkIdNotAllowedExternalNetworkErrorBuilder);
 149     }
 150   }
 151
 152   private void validateInternalNetworkType(NicEntity nic, String networkId,
 153                                            String networkDescription) {
 154     if (!(networkId == null || networkId.isEmpty())) {
 155           networkManager.getNetwork(nic.getVspId(), nic.getVersion(), networkId);
 156     }
 157
 158     if (!(networkDescription == null || networkDescription.isEmpty())) {
 159       final ErrorCode nicNetworkDescriptionErrorBuilder =
 160           NicInternalNetworkErrorBuilder.getNetworkDescriptionInternalNetworkErrorBuilder();
 161       MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
 162           LoggerTragetServiceName.CREATE_NIC, ErrorLevel.ERROR.name(),
 163           LoggerErrorCode.DATA_ERROR.getErrorCode(), nicNetworkDescriptionErrorBuilder.message());
 164       throw new CoreException(nicNetworkDescriptionErrorBuilder);
 165     }
 166   }
 167
 168   private void validateNics(NicEntity nic, Collection<NicEntity> listNics) {
 169     listNics.forEach(nicEntity -> {
 170       Nic nicdata = nicEntity.getNicCompositionData();
 171       if (nic.getNicCompositionData().getName().equalsIgnoreCase(nicdata.getName())) {
 172         final ErrorCode duplicateNicInComponentErrorBuilder =
 173             new DuplicateNicInComponentErrorBuilder(nic.getNicCompositionData().getName(),
 174                 nic.getComponentId()).build();
 175         MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
 176             LoggerTragetServiceName.CREATE_NIC, ErrorLevel.ERROR.name(),
 177             LoggerErrorCode.DATA_ERROR.getErrorCode(),
 178             duplicateNicInComponentErrorBuilder.message());
 179         throw new CoreException(duplicateNicInComponentErrorBuilder);
 180       }
 181
 182     });
 183   }
 184
 185   @Override
 186   public CompositionEntityResponse<Nic> getNic(String vspId, Version version, String componentId,
 187                                                String nicId) {
 188     NicEntity nicEntity = getValidatedNic(vspId, version, componentId, nicId);
 189     Nic nic = nicEntity.getNicCompositionData();
 190
 191     NicCompositionSchemaInput schemaInput = new NicCompositionSchemaInput();
 192     schemaInput.setManual(vspInfoDao.isManual(vspId, version));
 193     schemaInput.setNic(nic);
 194     Map<String, String> networksNameById = listNetworksNameById(vspId, version);
 195     nic.setNetworkName(networksNameById.get(nic.getNetworkId()));
 196     schemaInput.setNetworkIds(networksNameById.keySet());
 197
 198     CompositionEntityResponse<Nic> response = new CompositionEntityResponse<>();
 199     response.setId(nicId);
 200     response.setData(nic);
 201     response.setSchema(getNicCompositionSchema(schemaInput));
 202     return response;
 203   }
 204
 205
 206   private NicEntity getValidatedNic(String vspId, Version version, String componentId,
 207                                     String nicId) {
 208     NicEntity retrieved = nicDao.get(new NicEntity(vspId, version, componentId, nicId));
 209     VersioningUtil
 210         .validateEntityExistence(retrieved, new NicEntity(vspId, version, componentId, nicId),
 211             VspDetails.ENTITY_TYPE);
 212     return retrieved;
 213   }
 214
 215   @Override
 216   public void deleteNic(String vspId, Version version, String componentId, String nicId) {
 217     if (!vspInfoDao.isManual(vspId, version)) {
 218       final ErrorCode deleteNicErrorBuilder =
 219           DeleteNicErrorBuilder.getDeleteNicForHeatOnboardedVspErrorBuilder();
 220       MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
 221           LoggerTragetServiceName.DELETE_NIC, ErrorLevel.ERROR.name(),
 222           LoggerErrorCode.PERMISSION_ERROR.getErrorCode(),
 223           deleteNicErrorBuilder.message());
 224       throw new CoreException(deleteNicErrorBuilder);
 225     }
 226
 227     NicEntity nicEntity = getValidatedNic(vspId, version, componentId, nicId);
 228     nicDao.delete(nicEntity);
 229   }
 230
 231   @Override
 232   public CompositionEntityValidationData updateNic(NicEntity nic) {
 233     NicEntity retrieved =
 234         getValidatedNic(nic.getVspId(), nic.getVersion(), nic.getComponentId(), nic.getId());
 235
 236     NicCompositionSchemaInput schemaInput = new NicCompositionSchemaInput();
 237     schemaInput.setManual(vspInfoDao.isManual(nic.getVspId(), nic.getVersion()));
 238     schemaInput.setNic(retrieved.getNicCompositionData());
 239
 240     if (schemaInput.isManual() && !nic.getNicCompositionData().getName()
 241             .matches(VendorSoftwareProductConstants.NAME_PATTERN)) {
 242       ErrorCode errorCode = NicErrorBuilder
 243               .getNicNameFormatErrorBuilder(VendorSoftwareProductConstants.NAME_PATTERN);
 244
 245       MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
 246               LoggerTragetServiceName.UPDATE_NIC, ErrorLevel.ERROR.name(),
 247               errorCode.id(),errorCode.message());
 248
 249       throw new CoreException(errorCode);
 250     }
 251
 252     CompositionEntityValidationData validationData = compositionEntityDataManager
 253         .validateEntity(nic, SchemaTemplateContext.composition, schemaInput);
 254     if (CollectionUtils.isEmpty(validationData.getErrors())) {
 255       nicDao.update(nic);
 256     }
 257     return validationData;
 258   }
 259
 260   @Override
 261   public QuestionnaireResponse getNicQuestionnaire(String vspId, Version version,
 262                                                    String componentId, String nicId) {
 263     QuestionnaireResponse questionnaireResponse = new QuestionnaireResponse();
 264     NicEntity nicQuestionnaire = nicDao.getQuestionnaireData(vspId, version, componentId, nicId);
 265     VersioningUtil.validateEntityExistence(nicQuestionnaire,
 266         new NicEntity(vspId, version, componentId, nicId), VspDetails.ENTITY_TYPE);
 267
 268     questionnaireResponse.setData(nicQuestionnaire.getQuestionnaireData());
 269     questionnaireResponse.setSchema(getNicQuestionnaireSchema(null));
 270     return questionnaireResponse;
 271   }
 272
 273   @Override
 274   public void updateNicQuestionnaire(String vspId, Version version, String componentId,
 275                                      String nicId, String questionnaireData) {
 276     getNic(vspId, version, componentId, nicId);
 277
 278     nicDao.updateQuestionnaireData(vspId, version, componentId, nicId, questionnaireData);
 279   }
 280
 281   protected String getNicQuestionnaireSchema(SchemaTemplateInput schemaInput) {
 282     return SchemaGenerator
 283         .generate(SchemaTemplateContext.questionnaire, CompositionEntityType.nic, schemaInput);
 284   }
 285
 286   protected String getNicCompositionSchema(NicCompositionSchemaInput schemaInput) {
 287     return SchemaGenerator
 288         .generate(SchemaTemplateContext.composition, CompositionEntityType.nic, schemaInput);
 289   }
 290 }