natservice/impl/src/main/java/org/opendaylight/netvirt/natservice/internal/NatScalein.java

   1 /*
   2  * Copyright (c) 2019 Ericsson India Global Services Pvt Ltd. and others. All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.netvirt.natservice.internal;
   9
  10 import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
  11
  12 import com.google.common.base.Optional;
  13 import com.google.common.util.concurrent.ListenableFuture;
  14
  15 import java.util.ArrayList;
  16 import java.util.List;
  17
  18 import javax.inject.Inject;
  19 import javax.inject.Singleton;
  20
  21 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  22 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  23 import org.opendaylight.genius.cloudscaler.api.TombstonedNodeManager;
  24 import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
  25 import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
  26 import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
  27 import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
  28 import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
  29 import org.opendaylight.netvirt.elanmanager.api.IElanService;
  30 import org.opendaylight.netvirt.neutronvpn.interfaces.INeutronVpnManager;
  31 import org.opendaylight.serviceutils.upgrade.UpgradeState;
  32 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdManagerService;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.dpn.routers.DpnRoutersList;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.dpn.routers.dpn.routers.list.RoutersList;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ProviderTypes;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ext.routers.Routers;
  38 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  39 import org.opendaylight.yangtools.yang.common.Uint32;
  40 import org.opendaylight.yangtools.yang.common.Uint64;
  41 import org.slf4j.Logger;
  42 import org.slf4j.LoggerFactory;
  43
  44 @Singleton
  45 public class NatScalein {
  46
  47     private static final Logger LOG = LoggerFactory.getLogger(NatScalein.class);
  48     private final DataBroker dataBroker;
  49     private final IMdsalApiManager mdsalManager;
  50     private final IdManagerService idManager;
  51     private final JobCoordinator jobCoordinator;
  52     private NaptSwitchHA naptSwitchHA;
  53     private final IElanService elanManager;
  54     private final INeutronVpnManager nvpnManager;
  55     private final TombstonedNodeManager tombstonedNodeManager;
  56     private final ManagedNewTransactionRunner txRunner;
  57     private final UpgradeState upgradeState;
  58
  59     @Inject
  60     public NatScalein(final DataBroker dataBroker, final IMdsalApiManager mdsalManager,
  61         final IdManagerService idManager, final JobCoordinator jobCoordinator,
  62         final NaptSwitchHA naptSwitchHA,
  63         final IElanService elanManager,
  64         final INeutronVpnManager nvpnManager,
  65         final TombstonedNodeManager tombstonedNodeManager,
  66         final UpgradeState upgradeState) {
  67         this.dataBroker = dataBroker;
  68         this.txRunner = new ManagedNewTransactionRunnerImpl(dataBroker);
  69         this.mdsalManager = mdsalManager;
  70         this.idManager = idManager;
  71         this.naptSwitchHA = naptSwitchHA;
  72         this.jobCoordinator = jobCoordinator;
  73         this.tombstonedNodeManager = tombstonedNodeManager;
  74         this.elanManager = elanManager;
  75         this.nvpnManager = nvpnManager;
  76         this.upgradeState = upgradeState;
  77         tombstonedNodeManager.addOnRecoveryCallback((dpnId) -> {
  78             jobCoordinator.enqueueJob(dpnId.toString(), () -> {
  79                 remove(dpnId);
  80                 return null;
  81             });
  82             return null;
  83         });
  84     }
  85
  86     protected void remove(Uint64 srcDpnId) {
  87         LOG.debug("Called Remove on addOnRecoveryCallback");
  88         InstanceIdentifier<DpnRoutersList> dpnRoutersListIdentifier = NatUtil
  89             .getDpnRoutersId(srcDpnId);
  90         Optional<DpnRoutersList> optionalDpnRoutersList =
  91             SingleTransactionDataBroker
  92                 .syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker,
  93                     LogicalDatastoreType.OPERATIONAL, dpnRoutersListIdentifier);
  94         if (optionalDpnRoutersList.isPresent()) {
  95             List<RoutersList> routersListFromDs = optionalDpnRoutersList.get()
  96                 .getRoutersList();
  97             routersListFromDs.forEach(router -> {
  98                 String routerName = router.getRouter();
  99                 Routers extRouters = NatUtil.getRoutersFromConfigDS(dataBroker, routerName);
 100                 if (extRouters != null && extRouters.isEnableSnat()) {
 101                     jobCoordinator.enqueueJob((NatConstants.NAT_DJC_PREFIX + routerName), () -> {
 102                         List<ListenableFuture<Void>> futures = new ArrayList<>();
 103                         Uint64 naptId = NatUtil
 104                             .getPrimaryNaptfromRouterName(dataBroker, routerName);
 105                         if (naptId == null || naptId.equals(Uint64.ZERO)) {
 106                             Uint32 routerId = NatUtil.getVpnId(dataBroker, routerName);
 107                             Uint32 routerVpnId = getBgpVpnIdForRouter(routerId, routerName);
 108
 109                             if (routerVpnId != NatConstants.INVALID_ID) {
 110                                 ProviderTypes extNwProvType = NatEvpnUtil
 111                                     .getExtNwProvTypeFromRouterName(dataBroker,
 112                                         routerName, extRouters.getNetworkId());
 113                                 txRunner.callWithNewReadWriteTransactionAndSubmit(CONFIGURATION,
 114                                     confTx -> {
 115                                         NatUtil
 116                                             .handleSNATForDPN(dataBroker, mdsalManager, idManager,
 117                                                 naptSwitchHA,
 118                                                 srcDpnId, extRouters, routerId, routerVpnId, confTx,
 119                                                 extNwProvType, upgradeState);
 120                                     });
 121                             }
 122                         }
 123                         return futures;
 124                     }, NatConstants.NAT_DJC_MAX_RETRIES);
 125                 }
 126             });
 127         }
 128     }
 129
 130     private Uint32 getBgpVpnIdForRouter(Uint32 routerId, String routerName) {
 131
 132         if (routerId == NatConstants.INVALID_ID) {
 133             LOG.error(
 134                 "NAT Service : SNAT -> Invalid ROUTER-ID {} returned for routerName {}",
 135                 routerId, routerName);
 136             return NatConstants.INVALID_ID;
 137         }
 138         Uuid bgpVpnUuid = NatUtil.getVpnForRouter(dataBroker, routerName);
 139         Uint32 bgpVpnId;
 140         if (bgpVpnUuid == null) {
 141             LOG.debug(
 142                 "NAT Service : SNAT -> Internal VPN-ID {} associated to router {}",
 143                 routerId, routerName);
 144             bgpVpnId = routerId;
 145         } else {
 146             bgpVpnId = NatUtil.getVpnId(dataBroker, bgpVpnUuid.getValue());
 147             if (bgpVpnId == NatConstants.INVALID_ID) {
 148                 LOG.error(
 149                     "NAT Service : SNAT -> Invalid Private BGP VPN ID returned for routerName {}",
 150                     routerName);
 151                 return NatConstants.INVALID_ID;
 152             }
 153         }
 154         return bgpVpnId;
 155     }
 156 }