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