adapters/mso-openstack-adapters/src/main/java/org/onap/so/adapters/tasks/orchestration/StackService.java

   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.vnf.MsoVnfAdapterImpl;
  47 import org.onap.so.adapters.vnf.MsoVnfPluginAdapterImpl;
  48 import org.onap.so.adapters.vnf.VnfAdapterUtils;
  49 import org.onap.so.adapters.vnf.exceptions.VnfException;
  50 import org.onap.so.adapters.vnfrest.CreateVfModuleRequest;
  51 import org.onap.so.adapters.vnfrest.CreateVolumeGroupRequest;
  52 import org.onap.so.adapters.vnfrest.DeleteVfModuleRequest;
  53 import org.onap.so.adapters.vnfrest.DeleteVolumeGroupRequest;
  54 import org.onap.so.logging.tasks.AuditMDCSetup;
  55 import org.onap.so.openstack.beans.NetworkRollback;
  56 import org.onap.so.openstack.beans.RouteTarget;
  57 import org.onap.so.utils.ExternalTaskUtils;
  58 import org.slf4j.Logger;
  59 import org.slf4j.LoggerFactory;
  60 import org.springframework.beans.factory.annotation.Autowired;
  61 import org.springframework.stereotype.Component;
  62
  63 @Component
  64 public class StackService extends ExternalTaskUtils {
  65
  66     private static final Logger logger = LoggerFactory.getLogger(StackService.class);
  67
  68     @Autowired
  69     private MsoVnfAdapterImpl vnfAdapterImpl;
  70
  71     @Autowired
  72     private MsoNetworkAdapterImpl networkAdapterImpl;
  73
  74     @Autowired
  75     private MsoVnfPluginAdapterImpl vnfPluginImpl;
  76
  77     @Autowired
  78     private VnfAdapterUtils vnfAdapterUtils;
  79
  80     @Autowired
  81     private AuditMDCSetup mdcSetup;
  82
  83     private static final String SHARED = "shared";
  84     private static final String EXTERNAL = "external";
  85
  86     public void executeExternalTask(ExternalTask externalTask, ExternalTaskService externalTaskService) {
  87         Map<String, Object> variables = new HashMap<>();
  88         mdcSetup.setupMDC(externalTask);
  89         String xmlRequest = externalTask.getVariable("openstackAdapterTaskRequest");
  90         logger.debug("Starting External Task Stack Service. {}", xmlRequest);
  91         MutableBoolean success = new MutableBoolean();
  92         MutableBoolean backout = new MutableBoolean();
  93         MutableBoolean os3Nw = new MutableBoolean();
  94         Holder<String> canonicalStackId = new Holder<>();
  95         String errorMessage = "";
  96         try {
  97             if (xmlRequest != null) {
  98                 Optional<String> requestType = findRequestType(xmlRequest);
  99                 if ("createVolumeGroupRequest".equals(requestType.get())) {
 100                     logger.debug("Executing External Task Stack Service For Create Volume Group");
 101                     createVolumeGroup(xmlRequest, canonicalStackId, backout, success);
 102                 } else if ("createVfModuleRequest".equals(requestType.get())) {
 103                     logger.debug("Executing External Task Stack Service For Create Vf Module");
 104                     createVfModule(xmlRequest, canonicalStackId, backout, success);
 105                 } else if ("deleteVfModuleRequest".equals(requestType.get())) {
 106                     logger.debug("Executing External Task Stack Service For Delete Vf Module");
 107                     deleteVfModule(xmlRequest, canonicalStackId, backout, success);
 108                 } else if ("deleteVolumeGroupRequest".equals(requestType.get())) {
 109                     logger.debug("Executing External Task Stack Service For Delete Volume Group");
 110                     deleteVolumeGroup(xmlRequest, canonicalStackId, backout, success);
 111                 } else if ("createNetworkRequest".equals(requestType.get())) {
 112                     createNetwork(xmlRequest, canonicalStackId, backout, success, os3Nw);
 113                 } else if ("deleteNetworkRequest".equals(requestType.get())) {
 114                     deleteNetwork(xmlRequest, canonicalStackId, backout, success);
 115                 } else if ("updateNetworkRequest".equals(requestType.get())) {
 116                     updateNetwork(xmlRequest, canonicalStackId, backout, success);
 117                 } else if ("rollbackNetworkRequest".equals(requestType.get())) {
 118                     rollbackNetwork(xmlRequest, canonicalStackId, backout, success);
 119                 }
 120             }
 121         } catch (Exception e) {
 122             logger.error("Error during External Task Stack Service", e);
 123             errorMessage = e.getMessage();
 124         }
 125         variables.put("backout", backout.booleanValue());
 126         variables.put("OpenstackInvokeSuccess", success.booleanValue());
 127         variables.put("stackId", canonicalStackId.value);
 128         variables.put("openstackAdapterErrorMessage", errorMessage);
 129         variables.put("PollRollbackStatus", false);
 130         variables.put("rollbackPerformed", false);
 131         variables.put("OpenstackRollbackSuccess", false);
 132         variables.put("OpenstackPollSuccess", false);
 133         variables.put("os3Nw", os3Nw.booleanValue());
 134
 135         if (success.isTrue()) {
 136             externalTaskService.complete(externalTask, variables);
 137             logger.debug("The External Task Id: {}  Successful", externalTask.getId());
 138         } else {
 139             logger.debug("The External Task Id: {}  Failed. Not Retrying", externalTask.getId());
 140             externalTaskService.complete(externalTask, variables);
 141         }
 142     }
 143
 144     private void createVolumeGroup(String xmlRequest, Holder<String> canonicalStackId, MutableBoolean backout,
 145             MutableBoolean success) throws VnfException {
 146         CreateVolumeGroupRequest req = JAXB.unmarshal(new StringReader(xmlRequest), CreateVolumeGroupRequest.class);
 147         String completeVnfVfModuleType = req.getVnfType() + "::" + req.getVfModuleType();
 148         boolean isMulticloud = vnfAdapterUtils.isMulticloudMode(null, req.getCloudSiteId());
 149         if (isMulticloud) {
 150             vnfPluginImpl.createVfModule(req.getCloudSiteId(), req.getCloudOwner(), req.getTenantId(),
 151                     completeVnfVfModuleType, req.getVnfVersion(), "", req.getVolumeGroupName(), "", "VOLUME", null,
 152                     null, req.getModelCustomizationUuid(), req.getVolumeGroupParams(), false, true,
 153                     req.getEnableBridge(), req.getMsoRequest(), canonicalStackId);
 154         } else {
 155             vnfAdapterImpl.createVfModule(req.getCloudSiteId(), req.getCloudOwner(), req.getTenantId(),
 156                     completeVnfVfModuleType, req.getVnfVersion(), "", req.getVolumeGroupName(), "", "VOLUME", null,
 157                     null, req.getModelCustomizationUuid(), req.getVolumeGroupParams(), false, true,
 158                     req.getEnableBridge(), req.getMsoRequest(), canonicalStackId);
 159         }
 160         success.setTrue();
 161         backout.setValue(!req.getSuppressBackout());
 162     }
 163
 164     private void createVfModule(String xmlRequest, Holder<String> canonicalStackId, MutableBoolean backout,
 165             MutableBoolean success) throws VnfException {
 166         CreateVfModuleRequest req = JAXB.unmarshal(new StringReader(xmlRequest), CreateVfModuleRequest.class);
 167         String completeVnfVfModuleType = req.getVnfType() + "::" + req.getVfModuleType();
 168         boolean isMulticloud = vnfAdapterUtils.isMulticloudMode(null, req.getCloudSiteId());
 169         if (isMulticloud) {
 170             vnfPluginImpl.createVfModule(req.getCloudSiteId(), req.getCloudOwner(), req.getTenantId(),
 171                     completeVnfVfModuleType, req.getVnfVersion(), req.getVnfId(), req.getVfModuleName(),
 172                     req.getVfModuleId(), req.getRequestType(), req.getVolumeGroupStackId(),
 173                     req.getBaseVfModuleStackId(), req.getModelCustomizationUuid(), req.getVfModuleParams(), false,
 174                     false, req.getEnableBridge(), req.getMsoRequest(), canonicalStackId);
 175         } else {
 176             vnfAdapterImpl.createVfModule(req.getCloudSiteId(), req.getCloudOwner(), req.getTenantId(),
 177                     completeVnfVfModuleType, req.getVnfVersion(), req.getVnfId(), req.getVfModuleName(),
 178                     req.getVfModuleId(), req.getRequestType(), req.getVolumeGroupStackId(),
 179                     req.getBaseVfModuleStackId(), req.getModelCustomizationUuid(), req.getVfModuleParams(), false,
 180                     false, req.getEnableBridge(), req.getMsoRequest(), canonicalStackId);
 181         }
 182         success.setTrue();
 183         backout.setValue(req.getBackout());
 184     }
 185
 186     private void deleteVfModule(String xmlRequest, Holder<String> canonicalStackId, MutableBoolean backout,
 187             MutableBoolean success) throws VnfException {
 188         backout.setFalse();
 189         Holder<Map<String, String>> outputs = new Holder<>();
 190         DeleteVfModuleRequest req = JAXB.unmarshal(new StringReader(xmlRequest), DeleteVfModuleRequest.class);
 191         boolean isMulticloud = vnfAdapterUtils.isMulticloudMode(null, req.getCloudSiteId());
 192         if (isMulticloud) {
 193             vnfPluginImpl.deleteVfModule(req.getCloudSiteId(), req.getCloudOwner(), req.getTenantId(),
 194                     req.getVfModuleStackId(), req.getMsoRequest(), outputs);
 195         } else {
 196             vnfAdapterImpl.deleteVfModule(req.getCloudSiteId(), req.getCloudOwner(), req.getTenantId(),
 197                     req.getVfModuleStackId(), req.getModelCustomizationUuid(), req.getMsoRequest(), outputs);
 198         }
 199         success.setTrue();
 200         if (outputs != null && outputs.value != null) {
 201             canonicalStackId.value = outputs.value.get("canonicalStackId");
 202         } else {
 203             canonicalStackId.value = req.getVfModuleStackId();
 204         }
 205     }
 206
 207     private void deleteVolumeGroup(String xmlRequest, Holder<String> canonicalStackId, MutableBoolean backout,
 208             MutableBoolean success) throws VnfException {
 209         backout.setFalse();
 210         DeleteVolumeGroupRequest req = JAXB.unmarshal(new StringReader(xmlRequest), DeleteVolumeGroupRequest.class);
 211         vnfAdapterImpl.deleteVfModule(req.getCloudSiteId(), req.getCloudOwner(), req.getTenantId(),
 212                 req.getVolumeGroupStackId(), null, req.getMsoRequest(), new Holder<>());
 213         success.setTrue();
 214         canonicalStackId.value = req.getVolumeGroupStackId();
 215     }
 216
 217     private void createNetwork(String xmlRequest, Holder<String> canonicalStackId, MutableBoolean backout,
 218             MutableBoolean success, MutableBoolean os3) throws NetworkException {
 219
 220         CreateNetworkRequest req = JAXB.unmarshal(new StringReader(xmlRequest), CreateNetworkRequest.class);
 221         HashMap<String, String> params = (HashMap<String, String>) req.getNetworkParams();
 222         if (params == null) {
 223             params = new HashMap<>();
 224         }
 225         String shared = null;
 226         String external = null;
 227         String physicalNetworkName = null;
 228         List<Integer> vlans = null;
 229         List<RouteTarget> routeTargets = null;
 230         List<String> fqdns = null;
 231         List<String> routeTable = null;
 232         if (params.containsKey(SHARED))
 233             shared = params.get(SHARED);
 234         if (params.containsKey(EXTERNAL))
 235             external = params.get(EXTERNAL);
 236         if (req.isContrailRequest()) {
 237             ContrailNetwork ctn = req.getContrailNetwork();
 238             if (ctn == null) {
 239                 ctn = new ContrailNetwork();
 240                 req.setContrailNetwork(ctn);
 241             }
 242             if (shared == null && ctn.getShared() != null) {
 243                 shared = ctn.getShared();
 244             }
 245             if (shared == null && ctn.getExternal() != null) {
 246                 external = ctn.getExternal();
 247             }
 248             routeTargets = req.getContrailNetwork().getRouteTargets();
 249             fqdns = req.getContrailNetwork().getPolicyFqdns();
 250             routeTable = req.getContrailNetwork().getRouteTableFqdns();
 251         } else {
 252             ProviderVlanNetwork pvn = req.getProviderVlanNetwork();
 253             if (pvn == null) {
 254                 pvn = new ProviderVlanNetwork();
 255                 req.setProviderVlanNetwork(pvn);
 256             }
 257             physicalNetworkName = req.getProviderVlanNetwork().getPhysicalNetworkName();
 258             vlans = req.getProviderVlanNetwork().getVlans();
 259         }
 260         networkAdapterImpl.createNetwork(req.getCloudSiteId(), req.getTenantId(), req.getNetworkType(),
 261                 req.getModelCustomizationUuid(), req.getNetworkName(), physicalNetworkName, vlans, routeTargets, shared,
 262                 external, req.getFailIfExists(), false, req.getSubnets(), fqdns, routeTable, req.getMsoRequest(),
 263                 canonicalStackId, os3);
 264         success.setTrue();
 265         backout.setValue(req.getBackout());
 266     }
 267
 268     private void deleteNetwork(String xmlRequest, Holder<String> canonicalStackId, MutableBoolean backout,
 269             MutableBoolean success) throws NetworkException {
 270         backout.setFalse();
 271         DeleteNetworkRequest req = JAXB.unmarshal(new StringReader(xmlRequest), DeleteNetworkRequest.class);
 272
 273         networkAdapterImpl.deleteNetwork(req.getCloudSiteId(), req.getTenantId(), req.getNetworkType(),
 274                 req.getModelCustomizationUuid(), req.getNetworkStackId(), req.getMsoRequest());
 275
 276         canonicalStackId.value = req.getNetworkStackId();
 277         success.setTrue();
 278     }
 279
 280     private void rollbackNetwork(String xmlRequest, Holder<String> canonicalStackId, MutableBoolean backout,
 281             MutableBoolean success) throws NetworkException {
 282         backout.setFalse();
 283         RollbackNetworkRequest req = JAXB.unmarshal(new StringReader(xmlRequest), RollbackNetworkRequest.class);
 284
 285         NetworkRollback rollback = req.getNetworkRollback();
 286         networkAdapterImpl.rollbackNetwork(rollback);
 287
 288         canonicalStackId.value = rollback.getNetworkStackId();
 289         success.setTrue();
 290     }
 291
 292     private void updateNetwork(String xmlRequest, Holder<String> canonicalStackId, MutableBoolean backout,
 293             MutableBoolean success) throws NetworkException {
 294         backout.setFalse();
 295         UpdateNetworkRequest req = JAXB.unmarshal(new StringReader(xmlRequest), UpdateNetworkRequest.class);
 296         HashMap<String, String> params = (HashMap<String, String>) req.getNetworkParams();
 297         if (params == null) {
 298             params = new HashMap<>();
 299         }
 300         String shared = null;
 301         String external = null;
 302         String physicalNetworkName = null;
 303         List<Integer> vlans = null;
 304         List<RouteTarget> routeTargets = null;
 305         List<String> fqdns = null;
 306         List<String> routeTable = null;
 307         if (params.containsKey(SHARED))
 308             shared = params.get(SHARED);
 309         if (params.containsKey(EXTERNAL))
 310             external = params.get(EXTERNAL);
 311         if (req.isContrailRequest()) {
 312             ContrailNetwork ctn = req.getContrailNetwork();
 313             if (ctn == null) {
 314                 ctn = new ContrailNetwork();
 315                 req.setContrailNetwork(ctn);
 316             }
 317             if (shared == null && ctn.getShared() != null) {
 318                 shared = ctn.getShared();
 319             }
 320             if (shared == null && ctn.getExternal() != null) {
 321                 external = ctn.getExternal();
 322             }
 323             routeTargets = req.getContrailNetwork().getRouteTargets();
 324             fqdns = req.getContrailNetwork().getPolicyFqdns();
 325             routeTable = req.getContrailNetwork().getRouteTableFqdns();
 326         } else {
 327             ProviderVlanNetwork pvn = req.getProviderVlanNetwork();
 328             if (pvn == null) {
 329                 pvn = new ProviderVlanNetwork();
 330                 req.setProviderVlanNetwork(pvn);
 331             }
 332             physicalNetworkName = req.getProviderVlanNetwork().getPhysicalNetworkName();
 333             vlans = req.getProviderVlanNetwork().getVlans();
 334         }
 335
 336         networkAdapterImpl.updateNetwork(req.getCloudSiteId(), req.getTenantId(), req.getNetworkType(),
 337                 req.getModelCustomizationUuid(), req.getNetworkStackId(), req.getNetworkName(), physicalNetworkName,
 338                 vlans, routeTargets, shared, external, req.getSubnets(), fqdns, routeTable, req.getMsoRequest(),
 339                 canonicalStackId);
 340
 341         success.setTrue();
 342
 343     }
 344
 345     protected Optional<String> findRequestType(String xmlString) {
 346         try {
 347             DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
 348             DocumentBuilder builder = factory.newDocumentBuilder();
 349             org.w3c.dom.Document doc;
 350             doc = builder.parse(new ByteArrayInputStream(xmlString.getBytes("UTF-8")));
 351             return Optional.of(doc.getDocumentElement().getNodeName());
 352         } catch (Exception e) {
 353             logger.error("Error Finding Request Type", e);
 354             return Optional.empty();
 355         }
 356     }
 357 }