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