gerrit.onap Code Review - so.git/blob

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * ONAP - SO
   4  * ================================================================================
   5  * Copyright (C) 2017-2019 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Modifications Copyright (c) 2019 Samsung
   8  * ================================================================================
   9  * Licensed under the Apache License, Version 2.0 (the "License");
  10  * you may not use this file except in compliance with the License.
  11  * You may obtain a copy of the License at
  12  *
  13  *      http://www.apache.org/licenses/LICENSE-2.0
  14  *
  15  * Unless required by applicable law or agreed to in writing, software
  16  * distributed under the License is distributed on an "AS IS" BASIS,
  17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  18  * See the License for the specific language governing permissions and
  19  * limitations under the License.
  20  * ============LICENSE_END=========================================================
  21  */
  22
  23 package org.onap.so.adapters.tasks.orchestration;
  24
  25 import java.io.ByteArrayInputStream;
  26 import java.io.StringReader;
  27 import java.util.HashMap;
  28 import java.util.List;
  29 import java.util.Map;
  30 import java.util.Optional;
  31 import javax.xml.bind.JAXB;
  32 import javax.xml.parsers.DocumentBuilder;
  33 import javax.xml.parsers.DocumentBuilderFactory;
  34 import javax.xml.ws.Holder;
  35 import org.apache.commons.lang3.mutable.MutableBoolean;
  36 import org.camunda.bpm.client.task.ExternalTask;
  37 import org.camunda.bpm.client.task.ExternalTaskService;
  38 import org.onap.so.adapters.network.MsoNetworkAdapterImpl;
  39 import org.onap.so.adapters.network.exceptions.NetworkException;
  40 import org.onap.so.adapters.nwrest.ContrailNetwork;
  41 import org.onap.so.adapters.nwrest.CreateNetworkRequest;
  42 import org.onap.so.adapters.nwrest.DeleteNetworkRequest;
  43 import org.onap.so.adapters.nwrest.ProviderVlanNetwork;
  44 import org.onap.so.adapters.nwrest.RollbackNetworkRequest;
  45 import org.onap.so.adapters.nwrest.UpdateNetworkRequest;
  46 import org.onap.so.adapters.nwrest.UpdateNetworkResponse;
  47 import org.onap.so.adapters.vnf.MsoVnfAdapterImpl;
  48 import org.onap.so.adapters.vnf.MsoVnfPluginAdapterImpl;
  49 import org.onap.so.adapters.vnf.VnfAdapterUtils;
  50 import org.onap.so.adapters.vnf.exceptions.VnfException;
  51 import org.onap.so.adapters.vnfrest.CreateVfModuleRequest;
  52 import org.onap.so.adapters.vnfrest.CreateVolumeGroupRequest;
  53 import org.onap.so.adapters.vnfrest.DeleteVfModuleRequest;
  54 import org.onap.so.adapters.vnfrest.DeleteVolumeGroupRequest;
  55 import org.onap.so.logging.tasks.AuditMDCSetup;
  56 import org.onap.so.openstack.beans.NetworkRollback;
  57 import org.onap.so.openstack.beans.RouteTarget;
  58 import org.onap.so.openstack.beans.VnfRollback;
  59 import org.onap.so.utils.ExternalTaskUtils;
  60 import org.slf4j.Logger;
  61 import org.slf4j.LoggerFactory;
  62 import org.springframework.beans.factory.annotation.Autowired;
  63 import org.springframework.stereotype.Component;
  64
  65 @Component
  66 public class StackService extends ExternalTaskUtils {
  67
  68     private static final Logger logger = LoggerFactory.getLogger(StackService.class);
  69
  70     @Autowired
  71     private MsoVnfAdapterImpl vnfAdapterImpl;
  72
  73     @Autowired
  74     private MsoNetworkAdapterImpl networkAdapterImpl;
  75
  76     @Autowired
  77     private MsoVnfPluginAdapterImpl vnfPluginImpl;
  78
  79     @Autowired
  80     private VnfAdapterUtils vnfAdapterUtils;
  81
  82     @Autowired
  83     private AuditMDCSetup mdcSetup;
  84
  85     private static final String SHARED = "shared";
  86     private static final String EXTERNAL = "external";
  87
  88     public void executeExternalTask(ExternalTask externalTask, ExternalTaskService externalTaskService) {
  89         Map<String, Object> variables = new HashMap<>();
  90         mdcSetup.setupMDC(externalTask);
  91         String xmlRequest = externalTask.getVariable("openstackAdapterTaskRequest");
  92         logger.debug("Starting External Task Stack Service. {}", xmlRequest);
  93         MutableBoolean success = new MutableBoolean();
  94         MutableBoolean backout = new MutableBoolean();
  95         MutableBoolean os3Nw = new MutableBoolean();
  96         Holder<String> canonicalStackId = new Holder<>();
  97         String errorMessage = "";
  98         try {
  99             if (xmlRequest != null) {
 100                 Holder<Map<String, String>> outputs = new Holder<>();
 101                 Holder<VnfRollback> vnfRollback = new Holder<>();
 102                 Optional<String> requestType = findRequestType(xmlRequest);
 103                 Holder<String> networkId = new Holder<>();
 104                 Holder<String> neutronNetworkId = new Holder<>();
 105                 Holder<String> networkFqdn = new Holder<>();
 106                 Holder<Map<String, String>> subnetIdMap = new Holder<>();
 107                 Holder<NetworkRollback> networkRollback = new Holder<>();
 108                 if ("createVolumeGroupRequest".equals(requestType.get())) {
 109                     logger.debug("Executing External Task Stack Service For Create Volume Group");
 110                     createVolumeGroup(xmlRequest, outputs, vnfRollback, canonicalStackId, backout, success);
 111                 } else if ("createVfModuleRequest".equals(requestType.get())) {
 112                     logger.debug("Executing External Task Stack Service For Create Vf Module");
 113                     createVfModule(xmlRequest, outputs, vnfRollback, canonicalStackId, backout, success);
 114                 } else if ("deleteVfModuleRequest".equals(requestType.get())) {
 115                     logger.debug("Executing External Task Stack Service For Delete Vf Module");
 116                     deleteVfModule(xmlRequest, outputs, vnfRollback, canonicalStackId, backout, success);
 117                 } else if ("deleteVolumeGroupRequest".equals(requestType.get())) {
 118                     logger.debug("Executing External Task Stack Service For Delete Volume Group");
 119                     deleteVolumeGroup(xmlRequest, outputs, vnfRollback, canonicalStackId, backout, success);
 120                 } else if ("createNetworkRequest".equals(requestType.get())) {
 121                     createNetwork(xmlRequest, networkId, neutronNetworkId, networkFqdn, subnetIdMap, networkRollback,
 122                             canonicalStackId, backout, success, os3Nw);
 123                 } else if ("deleteNetworkRequest".equals(requestType.get())) {
 124                     deleteNetwork(xmlRequest, canonicalStackId, backout, success);
 125                 } else if ("updateNetworkRequest".equals(requestType.get())) {
 126
 127                     updateNetwork(xmlRequest, subnetIdMap, networkRollback, canonicalStackId, backout, success);
 128                 } else if ("rollbackNetworkRequest".equals(requestType.get())) {
 129                     rollbackNetwork(xmlRequest, canonicalStackId, backout, success);
 130                 }
 131             }
 132         } catch (Exception e) {
 133             logger.error("Error during External Task Stack Service", e);
 134             errorMessage = e.getMessage();
 135         }
 136         variables.put("backout", backout.booleanValue());
 137         variables.put("OpenstackInvokeSuccess", success.booleanValue());
 138         variables.put("stackId", canonicalStackId.value);
 139         variables.put("openstackAdapterErrorMessage", errorMessage);
 140         variables.put("PollRollbackStatus", false);
 141         variables.put("rollbackPerformed", false);
 142         variables.put("OpenstackRollbackSuccess", false);
 143         variables.put("OpenstackPollSuccess", false);
 144         variables.put("os3Nw", os3Nw.booleanValue());
 145
 146         if (success.isTrue()) {
 147             externalTaskService.complete(externalTask, variables);
 148             logger.debug("The External Task Id: {}  Successful", externalTask.getId());
 149         } else {
 150             logger.debug("The External Task Id: {}  Failed. Not Retrying", externalTask.getId());
 151             externalTaskService.complete(externalTask, variables);
 152         }
 153     }
 154
 155     private void createVolumeGroup(String xmlRequest, Holder<Map<String, String>> outputs,
 156             Holder<VnfRollback> vnfRollback, Holder<String> canonicalStackId, MutableBoolean backout,
 157             MutableBoolean success) throws VnfException {
 158         CreateVolumeGroupRequest req = JAXB.unmarshal(new StringReader(xmlRequest), CreateVolumeGroupRequest.class);
 159         String completeVnfVfModuleType = req.getVnfType() + "::" + req.getVfModuleType();
 160         boolean isMulticloud = vnfAdapterUtils.isMulticloudMode(null, req.getCloudSiteId());
 161         if (isMulticloud) {
 162             vnfPluginImpl.createVfModule(req.getCloudSiteId(), req.getCloudOwner(), req.getTenantId(),
 163                     completeVnfVfModuleType, req.getVnfVersion(), "", req.getVolumeGroupName(), "", "VOLUME", null,
 164                     null, req.getModelCustomizationUuid(), req.getVolumeGroupParams(), false, true,
 165                     req.getEnableBridge(), req.getMsoRequest(), canonicalStackId, outputs, vnfRollback);
 166         } else {
 167             vnfAdapterImpl.createVfModule(req.getCloudSiteId(), req.getCloudOwner(), req.getTenantId(),
 168                     completeVnfVfModuleType, req.getVnfVersion(), "", req.getVolumeGroupName(), "", "VOLUME", null,
 169                     null, req.getModelCustomizationUuid(), req.getVolumeGroupParams(), false, true,
 170                     req.getEnableBridge(), req.getMsoRequest(), canonicalStackId, outputs, vnfRollback);
 171         }
 172         success.setTrue();
 173         backout.setValue(!req.getSuppressBackout());
 174     }
 175
 176     private void createVfModule(String xmlRequest, Holder<Map<String, String>> outputs, Holder<VnfRollback> vnfRollback,
 177             Holder<String> canonicalStackId, MutableBoolean backout, MutableBoolean success) throws VnfException {
 178         CreateVfModuleRequest req = JAXB.unmarshal(new StringReader(xmlRequest), CreateVfModuleRequest.class);
 179         String completeVnfVfModuleType = req.getVnfType() + "::" + req.getVfModuleType();
 180         boolean isMulticloud = vnfAdapterUtils.isMulticloudMode(null, req.getCloudSiteId());
 181         if (isMulticloud) {
 182             vnfPluginImpl.createVfModule(req.getCloudSiteId(), req.getCloudOwner(), req.getTenantId(),
 183                     completeVnfVfModuleType, req.getVnfVersion(), req.getVnfId(), req.getVfModuleName(),
 184                     req.getVfModuleId(), req.getRequestType(), req.getVolumeGroupStackId(),
 185                     req.getBaseVfModuleStackId(), req.getModelCustomizationUuid(), req.getVfModuleParams(), false,
 186                     false, req.getEnableBridge(), req.getMsoRequest(), canonicalStackId, outputs, vnfRollback);
 187         } else {
 188             vnfAdapterImpl.createVfModule(req.getCloudSiteId(), req.getCloudOwner(), req.getTenantId(),
 189                     completeVnfVfModuleType, req.getVnfVersion(), req.getVnfId(), req.getVfModuleName(),
 190                     req.getVfModuleId(), req.getRequestType(), req.getVolumeGroupStackId(),
 191                     req.getBaseVfModuleStackId(), req.getModelCustomizationUuid(), req.getVfModuleParams(), false,
 192                     false, req.getEnableBridge(), req.getMsoRequest(), canonicalStackId, outputs, vnfRollback);
 193         }
 194         success.setTrue();
 195         backout.setValue(req.getBackout());
 196     }
 197
 198     private void deleteVfModule(String xmlRequest, Holder<Map<String, String>> outputs, Holder<VnfRollback> vnfRollback,
 199             Holder<String> canonicalStackId, MutableBoolean backout, MutableBoolean success) throws VnfException {
 200         backout.setFalse();
 201         DeleteVfModuleRequest req = JAXB.unmarshal(new StringReader(xmlRequest), DeleteVfModuleRequest.class);
 202         boolean isMulticloud = vnfAdapterUtils.isMulticloudMode(null, req.getCloudSiteId());
 203         if (isMulticloud) {
 204             vnfPluginImpl.deleteVfModule(req.getCloudSiteId(), req.getCloudOwner(), req.getTenantId(),
 205                     req.getVfModuleStackId(), req.getMsoRequest(), outputs);
 206         } else {
 207             vnfAdapterImpl.deleteVfModule(req.getCloudSiteId(), req.getCloudOwner(), req.getTenantId(),
 208                     req.getVfModuleStackId(), req.getVnfId(), req.getVfModuleId(), req.getModelCustomizationUuid(),
 209                     req.getMsoRequest(), outputs);
 210         }
 211         success.setTrue();
 212         if (outputs != null && outputs.value != null) {
 213             canonicalStackId.value = outputs.value.get("canonicalStackId");
 214         } else {
 215             canonicalStackId.value = req.getVfModuleStackId();
 216         }
 217     }
 218
 219     private void deleteVolumeGroup(String xmlRequest, Holder<Map<String, String>> outputs,
 220             Holder<VnfRollback> vnfRollback, Holder<String> canonicalStackId, MutableBoolean backout,
 221             MutableBoolean success) throws VnfException {
 222         backout.setFalse();
 223         DeleteVolumeGroupRequest req = JAXB.unmarshal(new StringReader(xmlRequest), DeleteVolumeGroupRequest.class);
 224         vnfAdapterImpl.deleteVnf(req.getCloudSiteId(), req.getCloudOwner(), req.getTenantId(),
 225                 req.getVolumeGroupStackId(), req.getMsoRequest(), false);
 226         success.setTrue();
 227         canonicalStackId.value = req.getVolumeGroupStackId();
 228     }
 229
 230     private void createNetwork(String xmlRequest, Holder<String> networkId, Holder<String> neutronNetworkId,
 231             Holder<String> networkFqdn, Holder<Map<String, String>> subnetIdMap,
 232             Holder<NetworkRollback> networkRollback, Holder<String> canonicalStackId, MutableBoolean backout,
 233             MutableBoolean success, MutableBoolean os3) throws NetworkException {
 234         CreateNetworkRequest req = JAXB.unmarshal(new StringReader(xmlRequest), CreateNetworkRequest.class);
 235         HashMap<String, String> params = (HashMap<String, String>) req.getNetworkParams();
 236         if (params == null) {
 237             params = new HashMap<>();
 238         }
 239         String shared = null;
 240         String external = null;
 241         String physicalNetworkName = null;
 242         List<Integer> vlans = null;
 243         List<RouteTarget> routeTargets = null;
 244         List<String> fqdns = null;
 245         List<String> routeTable = null;
 246         if (params.containsKey(SHARED))
 247             shared = params.get(SHARED);
 248         if (params.containsKey(EXTERNAL))
 249             external = params.get(EXTERNAL);
 250         if (req.isContrailRequest()) {
 251             ContrailNetwork ctn = req.getContrailNetwork();
 252             if (ctn == null) {
 253                 ctn = new ContrailNetwork();
 254                 req.setContrailNetwork(ctn);
 255             }
 256             if (shared == null && ctn.getShared() != null) {
 257                 shared = ctn.getShared();
 258             }
 259             if (shared == null && ctn.getExternal() != null) {
 260                 external = ctn.getExternal();
 261             }
 262             routeTargets = req.getContrailNetwork().getRouteTargets();
 263             fqdns = req.getContrailNetwork().getPolicyFqdns();
 264             routeTable = req.getContrailNetwork().getRouteTableFqdns();
 265         } else {
 266             ProviderVlanNetwork pvn = req.getProviderVlanNetwork();
 267             if (pvn == null) {
 268                 pvn = new ProviderVlanNetwork();
 269                 req.setProviderVlanNetwork(pvn);
 270             }
 271             physicalNetworkName = req.getProviderVlanNetwork().getPhysicalNetworkName();
 272             vlans = req.getProviderVlanNetwork().getVlans();
 273         }
 274         networkAdapterImpl.createNetwork(req.getCloudSiteId(), req.getTenantId(), req.getNetworkType(),
 275                 req.getModelCustomizationUuid(), req.getNetworkName(), physicalNetworkName, vlans, routeTargets, shared,
 276                 external, req.getFailIfExists(), false, req.getSubnets(), fqdns, routeTable, req.getMsoRequest(),
 277                 networkId, neutronNetworkId, networkFqdn, subnetIdMap, networkRollback, true, os3);
 278         success.setTrue();
 279         backout.setValue(req.getBackout());
 280         canonicalStackId.value = networkRollback.value.getNetworkStackId();
 281     }
 282
 283     private void deleteNetwork(String xmlRequest, Holder<String> canonicalStackId, MutableBoolean backout,
 284             MutableBoolean success) throws NetworkException {
 285         backout.setFalse();
 286         DeleteNetworkRequest req = JAXB.unmarshal(new StringReader(xmlRequest), DeleteNetworkRequest.class);
 287         Holder<Boolean> networkDeleted = new Holder<>();
 288
 289         networkAdapterImpl.deleteNetwork(req.getCloudSiteId(), req.getTenantId(), req.getNetworkType(),
 290                 req.getModelCustomizationUuid(), req.getNetworkStackId(), req.getMsoRequest(), networkDeleted, false);
 291
 292         canonicalStackId.value = req.getNetworkStackId();
 293         success.setTrue();
 294     }
 295
 296     private void rollbackNetwork(String xmlRequest, Holder<String> canonicalStackId, MutableBoolean backout,
 297             MutableBoolean success) throws NetworkException {
 298         backout.setFalse();
 299         RollbackNetworkRequest req = JAXB.unmarshal(new StringReader(xmlRequest), RollbackNetworkRequest.class);
 300
 301         NetworkRollback rollback = req.getNetworkRollback();
 302         networkAdapterImpl.rollbackNetwork(rollback, false);
 303
 304         canonicalStackId.value = rollback.getNetworkStackId();
 305         success.setTrue();
 306     }
 307
 308     private String updateNetwork(String xmlRequest, Holder<Map<String, String>> subnetIdMap,
 309             Holder<NetworkRollback> networkRollback, Holder<String> canonicalStackId, MutableBoolean backout,
 310             MutableBoolean success) throws NetworkException {
 311         backout.setFalse();
 312         UpdateNetworkRequest req = JAXB.unmarshal(new StringReader(xmlRequest), UpdateNetworkRequest.class);
 313         HashMap<String, String> params = (HashMap<String, String>) req.getNetworkParams();
 314         if (params == null) {
 315             params = new HashMap<>();
 316         }
 317         String shared = null;
 318         String external = null;
 319         String physicalNetworkName = null;
 320         List<Integer> vlans = null;
 321         List<RouteTarget> routeTargets = null;
 322         List<String> fqdns = null;
 323         List<String> routeTable = null;
 324         if (params.containsKey(SHARED))
 325             shared = params.get(SHARED);
 326         if (params.containsKey(EXTERNAL))
 327             external = params.get(EXTERNAL);
 328         if (req.isContrailRequest()) {
 329             ContrailNetwork ctn = req.getContrailNetwork();
 330             if (ctn == null) {
 331                 ctn = new ContrailNetwork();
 332                 req.setContrailNetwork(ctn);
 333             }
 334             if (shared == null && ctn.getShared() != null) {
 335                 shared = ctn.getShared();
 336             }
 337             if (shared == null && ctn.getExternal() != null) {
 338                 external = ctn.getExternal();
 339             }
 340             routeTargets = req.getContrailNetwork().getRouteTargets();
 341             fqdns = req.getContrailNetwork().getPolicyFqdns();
 342             routeTable = req.getContrailNetwork().getRouteTableFqdns();
 343         } else {
 344             ProviderVlanNetwork pvn = req.getProviderVlanNetwork();
 345             if (pvn == null) {
 346                 pvn = new ProviderVlanNetwork();
 347                 req.setProviderVlanNetwork(pvn);
 348             }
 349             physicalNetworkName = req.getProviderVlanNetwork().getPhysicalNetworkName();
 350             vlans = req.getProviderVlanNetwork().getVlans();
 351         }
 352
 353         networkAdapterImpl.updateNetwork(req.getCloudSiteId(), req.getTenantId(), req.getNetworkType(),
 354                 req.getModelCustomizationUuid(), req.getNetworkStackId(), req.getNetworkName(), physicalNetworkName,
 355                 vlans, routeTargets, shared, external, req.getSubnets(), fqdns, routeTable, req.getMsoRequest(),
 356                 subnetIdMap, networkRollback);
 357
 358         success.setTrue();
 359         canonicalStackId.value = req.getNetworkStackId();
 360
 361         UpdateNetworkResponse response =
 362                 new UpdateNetworkResponse(req.getNetworkId(), null, subnetIdMap.value, req.getMessageId());
 363         return response.toXmlString();
 364     }
 365
 366
 367
 368     protected Optional<String> findRequestType(String xmlString) {
 369         try {
 370             DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
 371             DocumentBuilder builder = factory.newDocumentBuilder();
 372             org.w3c.dom.Document doc;
 373             doc = builder.parse(new ByteArrayInputStream(xmlString.getBytes("UTF-8")));
 374             return Optional.of(doc.getDocumentElement().getNodeName());
 375         } catch (Exception e) {
 376             logger.error("Error Finding Request Type", e);
 377             return Optional.empty();
 378         }
 379     }
 380 }