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