nokiav2/driver/src/main/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/so/SoLifecycleManager.java

   1 /*
   2  * Copyright 2016-2017, Nokia Corporation
   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 package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.so;
  17
  18
  19 import com.nokia.cbam.lcm.v32.model.*;
  20 import com.nokia.cbam.lcm.v32.model.VimInfo;
  21 import java.util.ArrayList;
  22 import java.util.List;
  23 import javax.servlet.http.HttpServletResponse;
  24 import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.api.VimInfoProvider;
  25 import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.util.CbamUtils;
  26 import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.AdditionalParameters;
  27 import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.CbamRestApiProvider;
  28 import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.JobManager;
  29 import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.LifecycleManager;
  30 import org.onap.vnfmadapter.so.model.*;
  31 import org.onap.vnfmdriver.model.ExtVirtualLinkInfo;
  32 import org.onap.vnfmdriver.model.*;
  33 import org.onap.vnfmdriver.model.VnfInfo;
  34 import org.springframework.beans.factory.annotation.Autowired;
  35 import org.springframework.stereotype.Component;
  36
  37 import static java.util.Optional.of;
  38
  39 import static com.nokia.cbam.lcm.v32.model.VimInfo.VimInfoTypeEnum.*;
  40 import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.direct.notification.VnfcManager.buildCbamId;
  41 import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.CbamRestApiProvider.NOKIA_LCM_API_VERSION;
  42 import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.LifecycleManager.getVnfdIdFromModifyableAttributes;
  43 import static org.onap.vnfmadapter.so.model.SoJobStatus.*;
  44
  45 /**
  46  * Responsible for providing access to AAI APIs.
  47  * Handles authentication and mandatory parameters.
  48  */
  49
  50 @Component
  51 public class SoLifecycleManager {
  52     private final LifecycleManager lifecycleManager;
  53     private final VimInfoProvider vimInfoProvider;
  54     private final CbamRestApiProvider cbamRestApiProvider;
  55     private final JobManager jobManager;
  56
  57     @Autowired
  58     SoLifecycleManager(LifecycleManager lifecycleManager, VimInfoProvider vimInfoProvider, CbamRestApiProvider cbamRestApiProvider, JobManager jobManager) {
  59         this.lifecycleManager = lifecycleManager;
  60         this.vimInfoProvider = vimInfoProvider;
  61         this.cbamRestApiProvider = cbamRestApiProvider;
  62         this.jobManager = jobManager;
  63     }
  64
  65     /**
  66      * Creates the VNF in SO terminology
  67      *
  68      * @param vnfmId  the identifier of the VNFM
  69      * @param request the VNF creation request
  70      * @return the VNF creation response
  71      */
  72     public SoVnfCreationResponse create(String vnfmId, SoVnfCreationRequest request) {
  73         SoVnfCreationResponse response = new SoVnfCreationResponse();
  74         LifecycleManager.VnfCreationResult result = lifecycleManager.create(vnfmId, request.getCsarId(), request.getName(), request.getDescription());
  75         response.setVnfId(result.getVnfInfo().getId());
  76         return response;
  77     }
  78
  79     /**
  80      * Activate the VNF in SO terminology
  81      *
  82      * @param vnfmId       the identifier of the VNFM
  83      * @param vnfId        the identifier of the VNF
  84      * @param soRequest    the VNF activation request
  85      * @param httpResponse the HTTP response
  86      * @return the job handler of the VNF activation
  87      */
  88     public SoJobHandler activate(String vnfmId, String vnfId, SoVnfActivationRequest soRequest, HttpServletResponse httpResponse) {
  89         AdditionalParameters additionalParameters = new AdditionalParameters();
  90         additionalParameters.setAdditionalParams(buildAdditionalParameters(soRequest.getAdditionalParams()));
  91         String vimId = soRequest.getVimId();
  92         org.onap.vnfmdriver.model.VimInfo vimInfo = vimInfoProvider.getVimInfo(vimId);
  93         additionalParameters.setVimType(vimTypeHeuristic(vimInfo.getUrl()));
  94         processVdus(soRequest, additionalParameters, vimId);
  95         additionalParameters.setInstantiationLevel("default");
  96         processNetworks(soRequest, additionalParameters, vimId);
  97         processZones(soRequest, additionalParameters, vimId);
  98         com.nokia.cbam.lcm.v32.model.VnfInfo cbamVnfInfo = cbamRestApiProvider.getCbamLcmApi(vnfmId).vnfsVnfInstanceIdGet(vnfId, NOKIA_LCM_API_VERSION).blockingFirst();
  99         String onapVnfdId = getVnfdIdFromModifyableAttributes(cbamVnfInfo);
 100         VnfInfo vnfInfo = lifecycleManager.queryVnf(vnfmId, vnfId);
 101         List<ExtVirtualLinkInfo> externalVirtualLinks = new ArrayList<>();
 102         VnfInstantiateResponse instantiate = lifecycleManager.instantiate(vnfmId, externalVirtualLinks, httpResponse, soRequest.getAdditionalParams(), additionalParameters, vnfId, onapVnfdId, vnfInfo.getVnfdId());
 103         return buildJobHandler(instantiate.getJobId());
 104     }
 105
 106     /**
 107      * Scale the VNF
 108      *
 109      * @param vnfmId       the identifier of the VNFM
 110      * @param vnfId        the identifier of the VNF
 111      * @param soRequest    the VNF scale request
 112      * @param httpResponse the HTTP response
 113      * @return the job handler of the VNF activation
 114      */
 115     public SoJobHandler scale(String vnfmId, String vnfId, SoVnfScaleRequest soRequest, HttpServletResponse httpResponse) {
 116         org.onap.vnfmdriver.model.VnfScaleRequest driverRequest = new org.onap.vnfmdriver.model.VnfScaleRequest();
 117         driverRequest.setAdditionalParam(buildAdditionalParameters(soRequest.getAdditionalParams()));
 118         driverRequest.setAspectId(soRequest.getAspectId());
 119         driverRequest.setNumberOfSteps(soRequest.getSteps().toString());
 120         driverRequest.setType(soRequest.getDirection() == SoScaleDirection.IN ? org.onap.vnfmdriver.model.ScaleDirection.IN : org.onap.vnfmdriver.model.ScaleDirection.OUT);
 121         return buildJobHandler(lifecycleManager.scaleVnf(vnfmId, vnfId, driverRequest, httpResponse).getJobId());
 122     }
 123
 124     /**
 125      * Heal the VNF
 126      *
 127      * @param vnfmId       the identifier of the VNFM
 128      * @param vnfId        the identifier of the VNF
 129      * @param request      the VNF heal request
 130      * @param httpResponse the HTTP response
 131      * @return the job handler of the VNF activation
 132      */
 133     public SoJobHandler heal(String vnfmId, String vnfId, SoVnfHealRequest request, HttpServletResponse httpResponse) {
 134         org.onap.vnfmdriver.model.VnfHealRequest vnfHealRequest = new org.onap.vnfmdriver.model.VnfHealRequest();
 135         VnfHealRequestAffectedvm affectedVm = new VnfHealRequestAffectedvm();
 136         affectedVm.setVimid("notUsedByDriver");
 137         affectedVm.setVduid("notUsedByDriver");
 138         affectedVm.setVmname("unknown");
 139         vnfHealRequest.setAffectedvm(affectedVm);
 140         vnfHealRequest.setAction("heal");
 141         return buildJobHandler(lifecycleManager.healVnf(vnfmId, vnfId, vnfHealRequest, of(buildCbamId(request.getVnfcId())), httpResponse).getJobId());
 142     }
 143
 144     /**
 145      * Deactivate the VNF
 146      *
 147      * @param vnfmId       the identifier of the VNFM
 148      * @param vnfId        the identifier of the VNF
 149      * @param soRequest    the VNF deactivation request
 150      * @param httpResponse the HTTP response
 151      * @return the job handler of the VNF activation
 152      */
 153     public SoJobHandler deactivate(String vnfmId, String vnfId, SoVnfTerminationRequest soRequest, HttpServletResponse httpResponse) {
 154         VnfTerminateRequest driverRequest = new VnfTerminateRequest();
 155         if (soRequest.getMode() == SoTerminationMode.FORCEFUL) {
 156             driverRequest.setTerminationType(VnfTerminationType.FORCEFUL);
 157         } else {
 158             driverRequest.setTerminationType(VnfTerminationType.GRACEFUL);
 159             driverRequest.setGracefulTerminationTimeout(soRequest.getGracefulTerminationTimeoutInMs().toString());
 160
 161         }
 162         return buildJobHandler(lifecycleManager.terminateAndDelete(vnfmId, vnfId, driverRequest, httpResponse).getJobId());
 163     }
 164
 165     /**
 166      * Delete the VNF
 167      *
 168      * @param vnfmId the identifier of the VNFM
 169      * @param vnfId  the identifier of the VNF
 170      * @return the job handler of the VNF activation
 171      */
 172     public void delete(String vnfmId, String vnfId) {
 173         lifecycleManager.deleteVnf(vnfmId, vnfId);
 174     }
 175
 176     /**
 177      * Execute a custom operation on a VNF
 178      *
 179      * @param vnfmId       the identifier of the VNFM
 180      * @param vnfId        the identifier of the VNF
 181      * @param request      the VNF custom
 182      * @param httpResponse the HTTP response
 183      * @return the job handler of the VNF activation
 184      */
 185     public SoJobHandler customOperation(String vnfmId, String vnfId, SoVnfCustomOperation request, HttpServletResponse httpResponse) {
 186         String operationId = request.getOperationId();
 187         CustomOperationRequest cbamRequest = new CustomOperationRequest();
 188         cbamRequest.setAdditionalParams(buildAdditionalParameters(request.getAdditionalParams()));
 189         return buildJobHandler(lifecycleManager.customOperation(vnfmId, vnfId, operationId, request.getAdditionalParams(), httpResponse).getJobId());
 190     }
 191
 192     /**
 193      * @param jobId  the identifier of the job
 194      * @param vnfmId the identifier of the VNFM
 195      * @return the details of the job
 196      */
 197     public SoJobDetail getJobDetails(String vnfmId, String jobId) {
 198         SoJobDetail jobDetail = new SoJobDetail();
 199         jobDetail.setJobId(jobId);
 200         JobStatus currentStatus = jobManager.getJob(vnfmId, jobId).getResponseDescriptor().getStatus();
 201         if (JobStatus.STARTED.equals(currentStatus)) {
 202             jobDetail.setStatus(STARTED);
 203         } else if (JobStatus.PROCESSING.equals(currentStatus)) {
 204             jobDetail.setStatus(STARTED);
 205         } else if (JobStatus.FINISHED.equals(currentStatus)) {
 206             jobDetail.setStatus(FINISHED);
 207         } else if (JobStatus.TIMEOUT.equals(currentStatus)) {
 208             jobDetail.setStatus(FAILED);
 209         } else {//ERROR
 210             jobDetail.setStatus(FAILED);
 211         }
 212         return jobDetail;
 213     }
 214
 215     private VimInfo.VimInfoTypeEnum vimTypeHeuristic(String url) {
 216         if (url.contains("/v3")) {
 217             return OPENSTACK_V3_INFO;
 218         } else if (url.contains("/v2")) {
 219             return OPENSTACK_V2_INFO;
 220         } else {
 221             return VMWARE_VCLOUD_INFO;
 222         }
 223     }
 224
 225     private Object buildAdditionalParameters(Object additionalParams) {
 226         return additionalParams;
 227     }
 228
 229     private SoJobHandler buildJobHandler(String jobId) {
 230         SoJobHandler jobHandler = new SoJobHandler();
 231         jobHandler.setJobId(jobId);
 232         return jobHandler;
 233     }
 234
 235     private void processVdus(SoVnfActivationRequest request, AdditionalParameters additionalParameters, String vimId) {
 236         if (request.getVduMappings() != null) {
 237             for (SoVduMapping vduMapping : request.getVduMappings()) {
 238                 VimComputeResourceFlavour flavour = new VimComputeResourceFlavour();
 239                 flavour.setVimId(vimId);
 240                 flavour.setVnfdVirtualComputeDescId(vduMapping.getVduId());
 241                 flavour.setResourceId(vduMapping.getFlavourId());
 242                 additionalParameters.getComputeResourceFlavours().add(flavour);
 243                 VimSoftwareImage image = new VimSoftwareImage();
 244                 image.setVimId(vimId);
 245                 image.setResourceId(vduMapping.getImageId());
 246                 image.setVnfdSoftwareImageId(vduMapping.getVduId() + CbamUtils.SEPARATOR + "image");
 247                 additionalParameters.getSoftwareImages().add(image);
 248             }
 249         }
 250     }
 251
 252     private void processNetworks(SoVnfActivationRequest request, AdditionalParameters additionalParameters, String vimId) {
 253         if (request.getNetworkMappings() != null) {
 254             for (SoNetworkMapping networkMapping : request.getNetworkMappings()) {
 255                 ExtVirtualLinkData extVirtualLinkData = createExtVirtualLinkData(additionalParameters, networkMapping.getVldId());
 256                 extVirtualLinkData.setVimId(vimId);
 257                 extVirtualLinkData.setResourceId(networkMapping.getNetworkProviderId());
 258                 processAssingedAddress(networkMapping, extVirtualLinkData);
 259             }
 260         }
 261     }
 262
 263     private void processAssingedAddress(SoNetworkMapping networkMapping, ExtVirtualLinkData extVirtualLinkData) {
 264         if (networkMapping.getAssignedAddresses() != null) {
 265             for (SoAssignedAddresses assignedAddresses : networkMapping.getAssignedAddresses()) {
 266                 VnfExtCpData extCpData = createExtVirtualLinkData(extVirtualLinkData.getExtCps(), assignedAddresses.getCpdId());
 267                 addMissing(extCpData, assignedAddresses.getIpAddress());
 268             }
 269         }
 270     }
 271
 272     private void processZones(SoVnfActivationRequest request, AdditionalParameters additionalParameters, String vimId) {
 273         if (request.getServerMappings() != null) {
 274             for (SoServerMapping serverMapping : request.getServerMappings()) {
 275                 ZoneInfo zone = locateOrCreateZone(additionalParameters.getZones(), serverMapping.getVduId());
 276                 zone.setResourceId(serverMapping.getAvailabilityZoneId());
 277                 zone.setVimId(vimId);
 278             }
 279         }
 280     }
 281
 282     private ZoneInfo locateOrCreateZone(List<ZoneInfo> zones, String vduId) {
 283         for (ZoneInfo zone : zones) {
 284             if (zone.getId().equals(vduId)) {
 285                 return zone;
 286             }
 287         }
 288         ZoneInfo zoneInfo = new ZoneInfo();
 289         zoneInfo.setId(vduId);
 290         zones.add(zoneInfo);
 291         return zoneInfo;
 292     }
 293
 294     private void addMissing(VnfExtCpData extCpData, String ipAddress) {
 295         if (extCpData.getAddresses() == null) {
 296             extCpData.setAddresses(new ArrayList<>());
 297         }
 298         for (NetworkAddress networkAddress : extCpData.getAddresses()) {
 299             if (ipAddress.equals(networkAddress.getIp())) {
 300                 return;
 301             }
 302         }
 303         NetworkAddress address = new NetworkAddress();
 304         address.setIp(ipAddress);
 305         extCpData.getAddresses().add(address);
 306     }
 307
 308     private VnfExtCpData createExtVirtualLinkData(List<VnfExtCpData> extCps, String cpdId) {
 309         for (VnfExtCpData extCp : extCps) {
 310             if (extCp.getCpdId().equals(cpdId)) {
 311                 return extCp;
 312             }
 313         }
 314         VnfExtCpData extCp = new VnfExtCpData();
 315         extCp.setCpdId(cpdId);
 316         extCps.add(extCp);
 317         return extCp;
 318     }
 319
 320     private ExtVirtualLinkData createExtVirtualLinkData(AdditionalParameters additionalParameters, String virtualLinkId) {
 321         ExtVirtualLinkData nonExistingVl = new ExtVirtualLinkData();
 322         nonExistingVl.setExtVirtualLinkId(virtualLinkId);
 323         additionalParameters.getExtVirtualLinks().add(nonExistingVl);
 324         return nonExistingVl;
 325     }
 326 }