openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/NicManagerImpl.java

   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.vendorsoftwareproduct.CompositionEntityDataManager;
  23 import org.openecomp.sdc.vendorsoftwareproduct.NetworkManager;
  24 import org.openecomp.sdc.vendorsoftwareproduct.NicManager;
  25 import org.openecomp.sdc.vendorsoftwareproduct.VendorSoftwareProductConstants;
  26 import org.openecomp.sdc.vendorsoftwareproduct.dao.NicDao;
  27 import org.openecomp.sdc.vendorsoftwareproduct.dao.VendorSoftwareProductInfoDao;
  28 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.NetworkEntity;
  29 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.NicEntity;
  30 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.VspDetails;
  31 import org.openecomp.sdc.vendorsoftwareproduct.errors.*;
  32 import org.openecomp.sdc.vendorsoftwareproduct.services.schemagenerator.SchemaGenerator;
  33 import org.openecomp.sdc.vendorsoftwareproduct.types.CompositionEntityResponse;
  34 import org.openecomp.sdc.vendorsoftwareproduct.types.QuestionnaireResponse;
  35 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.CompositionEntityType;
  36 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.CompositionEntityValidationData;
  37 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.NetworkType;
  38 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.Nic;
  39 import org.openecomp.sdc.vendorsoftwareproduct.types.schemagenerator.NicCompositionSchemaInput;
  40 import org.openecomp.sdc.vendorsoftwareproduct.types.schemagenerator.SchemaTemplateContext;
  41 import org.openecomp.sdc.vendorsoftwareproduct.types.schemagenerator.SchemaTemplateInput;
  42 import org.openecomp.sdc.versioning.VersioningUtil;
  43 import org.openecomp.sdc.versioning.dao.types.Version;
  44
  45 import java.util.Collection;
  46 import java.util.Map;
  47 import java.util.stream.Collectors;
  48
  49 public class NicManagerImpl implements NicManager {
  50   private final NicDao nicDao;
  51   private final CompositionEntityDataManager compositionEntityDataManager;
  52   private final NetworkManager networkManager;
  53   private final VendorSoftwareProductInfoDao vspInfoDao;
  54
  55   public NicManagerImpl(NicDao nicDao,
  56                         CompositionEntityDataManager compositionEntityDataManager,
  57                         NetworkManager networkManager,
  58                         VendorSoftwareProductInfoDao vspInfoDao) {
  59     this.nicDao = nicDao;
  60     this.compositionEntityDataManager = compositionEntityDataManager;
  61     this.networkManager = networkManager;
  62     this.vspInfoDao = vspInfoDao;
  63   }
  64
  65   @Override
  66   public Collection<NicEntity> listNics(String vspId, Version version, String componentId) {
  67     Collection<NicEntity> nics = nicDao.list(new NicEntity(vspId, version, componentId, null));
  68
  69     if (!nics.isEmpty()) {
  70       Map<String, String> networksNameById = listNetworksNameById(vspId, version);
  71       nics.forEach(nicEntity -> {
  72         Nic nic = nicEntity.getNicCompositionData();
  73         nic.setNetworkName(networksNameById.get(nic.getNetworkId()));
  74         nicEntity.setNicCompositionData(nic);
  75       });
  76     }
  77     return nics;
  78   }
  79
  80   private Map<String, String> listNetworksNameById(String vspId, Version version) {
  81     Collection<NetworkEntity> networks = networkManager.listNetworks(vspId, version);
  82     return networks.stream().collect(Collectors.toMap(NetworkEntity::getId,
  83         networkEntity -> networkEntity.getNetworkCompositionData().getName()));
  84   }
  85
  86   @Override
  87   public NicEntity createNic(NicEntity nic) {
  88     NicEntity createdNic;
  89     if (!vspInfoDao.isManual(nic.getVspId(), nic.getVersion())) {
  90       ErrorCode onboardingMethodUpdateErrorCode = NotSupportedHeatOnboardMethodErrorBuilder
  91           .getAddNicNotSupportedHeatOnboardMethodErrorBuilder();
  92       throw new CoreException(onboardingMethodUpdateErrorCode);
  93     } else {
  94       validateNic(nic);
  95       createdNic = compositionEntityDataManager.createNic(nic);
  96     }
  97     return createdNic;
  98   }
  99
 100
 101   private void validateNic(NicEntity nic) {
 102     Collection<NicEntity> listNics = listNics(nic.getVspId(), nic.getVersion(), nic
 103         .getComponentId());
 104     String networkId = nic.getNicCompositionData().getNetworkId();
 105     NetworkType networkType = nic.getNicCompositionData().getNetworkType();
 106     String networkDescription = nic.getNicCompositionData().getNetworkDescription();
 107
 108     if (!nic.getNicCompositionData().getName()
 109             .matches(VendorSoftwareProductConstants.NAME_PATTERN)) {
 110       ErrorCode errorCode = NicErrorBuilder
 111               .getNicNameFormatErrorBuilder(VendorSoftwareProductConstants.NAME_PATTERN);
 112       throw new CoreException(errorCode);
 113     }
 114
 115     validateNics(nic, listNics);
 116
 117     if (networkType.equals(NetworkType.Internal)) {
 118       validateInternalNetworkType(nic, networkId, networkDescription);
 119
 120     } else if (networkType.equals(NetworkType.External)
 121             && !(networkId == null || networkId.isEmpty())) {
 122         final ErrorCode nicNetworkIdNotAllowedExternalNetworkErrorBuilder =
 123             new NicNetworkIdNotAllowedExternalNetworkErrorBuilder().build();
 124         throw new CoreException(nicNetworkIdNotAllowedExternalNetworkErrorBuilder);
 125     }
 126   }
 127
 128   private void validateInternalNetworkType(NicEntity nic, String networkId,
 129                                            String networkDescription) {
 130     if (!(networkId == null || networkId.isEmpty())) {
 131           networkManager.getNetwork(nic.getVspId(), nic.getVersion(), networkId);
 132     }
 133
 134     if (!(networkDescription == null || networkDescription.isEmpty())) {
 135       final ErrorCode nicNetworkDescriptionErrorBuilder =
 136           NicInternalNetworkErrorBuilder.getNetworkDescriptionInternalNetworkErrorBuilder();
 137       throw new CoreException(nicNetworkDescriptionErrorBuilder);
 138     }
 139   }
 140
 141   private void validateNics(NicEntity nic, Collection<NicEntity> listNics) {
 142     listNics.forEach(nicEntity -> {
 143       Nic nicdata = nicEntity.getNicCompositionData();
 144       if (nic.getNicCompositionData().getName().equalsIgnoreCase(nicdata.getName())) {
 145         final ErrorCode duplicateNicInComponentErrorBuilder =
 146             new DuplicateNicInComponentErrorBuilder(nic.getNicCompositionData().getName(),
 147                 nic.getComponentId()).build();
 148         throw new CoreException(duplicateNicInComponentErrorBuilder);
 149       }
 150
 151     });
 152   }
 153
 154   @Override
 155   public CompositionEntityResponse<Nic> getNic(String vspId, Version version, String componentId,
 156                                                String nicId) {
 157     NicEntity nicEntity = getValidatedNic(vspId, version, componentId, nicId);
 158     Nic nic = nicEntity.getNicCompositionData();
 159
 160     NicCompositionSchemaInput schemaInput = new NicCompositionSchemaInput();
 161     schemaInput.setManual(vspInfoDao.isManual(vspId, version));
 162     schemaInput.setNic(nic);
 163     Map<String, String> networksNameById = listNetworksNameById(vspId, version);
 164     nic.setNetworkName(networksNameById.get(nic.getNetworkId()));
 165     schemaInput.setNetworkIds(networksNameById.keySet());
 166
 167     CompositionEntityResponse<Nic> response = new CompositionEntityResponse<>();
 168     response.setId(nicId);
 169     response.setData(nic);
 170     response.setSchema(getNicCompositionSchema(schemaInput));
 171     return response;
 172   }
 173
 174
 175   private NicEntity getValidatedNic(String vspId, Version version, String componentId,
 176                                     String nicId) {
 177     NicEntity retrieved = nicDao.get(new NicEntity(vspId, version, componentId, nicId));
 178     VersioningUtil
 179         .validateEntityExistence(retrieved, new NicEntity(vspId, version, componentId, nicId),
 180             VspDetails.ENTITY_TYPE);
 181     return retrieved;
 182   }
 183
 184   @Override
 185   public void deleteNic(String vspId, Version version, String componentId, String nicId) {
 186     if (!vspInfoDao.isManual(vspId, version)) {
 187       final ErrorCode deleteNicErrorBuilder =
 188           DeleteNicErrorBuilder.getDeleteNicForHeatOnboardedVspErrorBuilder();
 189       throw new CoreException(deleteNicErrorBuilder);
 190     }
 191
 192     NicEntity nicEntity = getValidatedNic(vspId, version, componentId, nicId);
 193     nicDao.delete(nicEntity);
 194   }
 195
 196   @Override
 197   public CompositionEntityValidationData updateNic(NicEntity nic) {
 198     NicEntity retrieved =
 199         getValidatedNic(nic.getVspId(), nic.getVersion(), nic.getComponentId(), nic.getId());
 200
 201     NicCompositionSchemaInput schemaInput = new NicCompositionSchemaInput();
 202     schemaInput.setManual(vspInfoDao.isManual(nic.getVspId(), nic.getVersion()));
 203     schemaInput.setNic(retrieved.getNicCompositionData());
 204
 205     CompositionEntityValidationData validationData = compositionEntityDataManager
 206         .validateEntity(nic, SchemaTemplateContext.composition, schemaInput);
 207     if (CollectionUtils.isEmpty(validationData.getErrors())) {
 208       nicDao.update(nic);
 209     }
 210     return validationData;
 211   }
 212
 213   @Override
 214   public QuestionnaireResponse getNicQuestionnaire(String vspId, Version version,
 215                                                    String componentId, String nicId) {
 216     QuestionnaireResponse questionnaireResponse = new QuestionnaireResponse();
 217     NicEntity nicQuestionnaire = nicDao.getQuestionnaireData(vspId, version, componentId, nicId);
 218     VersioningUtil.validateEntityExistence(nicQuestionnaire,
 219         new NicEntity(vspId, version, componentId, nicId), VspDetails.ENTITY_TYPE);
 220
 221     questionnaireResponse.setData(nicQuestionnaire.getQuestionnaireData());
 222     questionnaireResponse.setSchema(getNicQuestionnaireSchema(null));
 223     return questionnaireResponse;
 224   }
 225
 226   @Override
 227   public void updateNicQuestionnaire(String vspId, Version version, String componentId,
 228                                      String nicId, String questionnaireData) {
 229     getNic(vspId, version, componentId, nicId);
 230
 231     nicDao.updateQuestionnaireData(vspId, version, componentId, nicId, questionnaireData);
 232   }
 233
 234   protected String getNicQuestionnaireSchema(SchemaTemplateInput schemaInput) {
 235     return SchemaGenerator
 236         .generate(SchemaTemplateContext.questionnaire, CompositionEntityType.nic, schemaInput);
 237   }
 238
 239   protected String getNicCompositionSchema(NicCompositionSchemaInput schemaInput) {
 240     return SchemaGenerator
 241         .generate(SchemaTemplateContext.composition, CompositionEntityType.nic, schemaInput);
 242   }
 243 }