renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/policy/ForwardingManager.java

   1 /*
   2  * Copyright (c) 2016 Cisco Systems, Inc. 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
   9 package org.opendaylight.groupbasedpolicy.renderer.vpp.policy;
  10
  11 import java.util.ArrayList;
  12 import java.util.HashMap;
  13 import java.util.List;
  14 import java.util.Map;
  15 import java.util.Set;
  16 import java.util.concurrent.ExecutionException;
  17 import java.util.concurrent.TimeUnit;
  18 import java.util.concurrent.TimeoutException;
  19
  20 import javax.annotation.Nonnull;
  21 import javax.annotation.Nullable;
  22
  23 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  24 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
  25 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  26 import org.opendaylight.groupbasedpolicy.renderer.vpp.api.BridgeDomainManager;
  27 import org.opendaylight.groupbasedpolicy.renderer.vpp.commands.RoutingCommand;
  28 import org.opendaylight.groupbasedpolicy.renderer.vpp.iface.InterfaceManager;
  29 import org.opendaylight.groupbasedpolicy.renderer.vpp.nat.NatManager;
  30 import org.opendaylight.groupbasedpolicy.renderer.vpp.nat.NatUtil;
  31 import org.opendaylight.groupbasedpolicy.renderer.vpp.policy.acl.AclManager;
  32 import org.opendaylight.groupbasedpolicy.renderer.vpp.routing.RoutingManager;
  33 import org.opendaylight.groupbasedpolicy.renderer.vpp.util.General;
  34 import org.opendaylight.groupbasedpolicy.renderer.vpp.util.KeyFactory;
  35 import org.opendaylight.groupbasedpolicy.util.DataStoreHelper;
  36 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpPrefix;
  37 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.nat.rev150908.nat.config.nat.instances.nat.instance.mapping.table.MappingEntryBuilder;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.common.endpoint.fields.NetworkContainment;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.common.endpoint.fields.network.containment.Containment;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.common.endpoint.fields.network.containment.containment.ForwardingContextContainment;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.common.endpoint.fields.network.containment.containment.NetworkDomainContainment;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.absolute.location.absolute.location.LocationType;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.absolute.location.absolute.location.location.type.ExternalLocationCase;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.parent.child.endpoints.ParentEndpointChoice;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.parent.child.endpoints.parent.endpoint.choice.ParentEndpointCase;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.parent.child.endpoints.parent.endpoint.choice.parent.endpoint._case.ParentEndpoint;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ContextId;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.NetworkDomainId;
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.TenantId;
  50 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.IpPrefixType;
  51 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.L2FloodDomain;
  52 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.MacAddressType;
  53 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.SubnetAugmentRenderer;
  54 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.NetworkDomain;
  55 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.forwarding.fields.Parent;
  56 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.NatAddressRenderer;
  57 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.Configuration;
  58 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.Endpoints;
  59 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.endpoints.AddressEndpointWithLocation;
  60 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.renderer.endpoints.RendererEndpointKey;
  61 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.renderer.forwarding.RendererForwardingByTenant;
  62 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.renderer.forwarding.renderer.forwarding.by.tenant.RendererForwardingContext;
  63 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.renderer.forwarding.renderer.forwarding.by.tenant.RendererForwardingContextKey;
  64 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.renderer.forwarding.renderer.forwarding.by.tenant.RendererNetworkDomain;
  65 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.renderer.forwarding.renderer.forwarding.by.tenant.RendererNetworkDomainKey;
  66 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.Config;
  67 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.VlanNetwork;
  68 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425._interface.attributes.InterfaceTypeChoice;
  69 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425._interface.attributes._interface.type.choice.LoopbackCase;
  70 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.GbpBridgeDomain;
  71 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.GbpBridgeDomainKey;
  72 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.VppEndpoint;
  73 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.VppEndpointKey;
  74 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.renderers.renderer.renderer.nodes.renderer.node.PhysicalInterface;
  75 import org.opendaylight.yang.gen.v1.urn.opendaylight.l2.types.rev130827.VlanId;
  76 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev170315.VxlanVni;
  77 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
  78 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  79 import org.slf4j.Logger;
  80 import org.slf4j.LoggerFactory;
  81
  82 import com.google.common.annotations.VisibleForTesting;
  83 import com.google.common.base.Optional;
  84 import com.google.common.base.Preconditions;
  85 import com.google.common.base.Strings;
  86 import com.google.common.collect.SetMultimap;
  87 import com.google.common.collect.Table;
  88
  89 public final class ForwardingManager {
  90
  91     private static final Logger LOG = LoggerFactory.getLogger(ForwardingManager.class);
  92     @VisibleForTesting
  93     private byte WAIT_FOR_BD_PROCESSING = 60; // seconds
  94     private long lastVxlanVni = 1L;
  95     private final Map<String, VxlanVni> vxlanVniByBridgeDomain = new HashMap<>();
  96     private final InterfaceManager ifaceManager;
  97     private final AclManager aclManager;
  98     private final BridgeDomainManager bdManager;
  99     private final NatManager natManager;
 100     private final RoutingManager routingManager;
 101     private final DataBroker dataBroker;
 102
 103     public ForwardingManager(@Nonnull InterfaceManager ifaceManager, @Nonnull AclManager aclManager,
 104         @Nonnull NatManager natManager, @Nonnull RoutingManager routingManager, @Nonnull BridgeDomainManager bdManager,
 105         @Nonnull DataBroker dataBroker) {
 106         this.ifaceManager = Preconditions.checkNotNull(ifaceManager);
 107         this.bdManager = Preconditions.checkNotNull(bdManager);
 108         this.natManager = Preconditions.checkNotNull(natManager);
 109         this.routingManager = Preconditions.checkNotNull(routingManager);
 110         this.dataBroker = Preconditions.checkNotNull(dataBroker);
 111         this.aclManager = Preconditions.checkNotNull(aclManager);
 112     }
 113
 114     public Optional<GbpBridgeDomain> readGbpBridgeDomainConfig(String name) {
 115         InstanceIdentifier<GbpBridgeDomain> bdIid = InstanceIdentifier.builder(Config.class)
 116             .child(GbpBridgeDomain.class, new GbpBridgeDomainKey(name))
 117             .build();
 118         ReadOnlyTransaction rTx = dataBroker.newReadOnlyTransaction();
 119         Optional<GbpBridgeDomain> optBd = DataStoreHelper.readFromDs(LogicalDatastoreType.CONFIGURATION, bdIid, rTx);
 120         rTx.close();
 121         return optBd;
 122     }
 123
 124     public void createBridgeDomainOnNodes(SetMultimap<String, NodeId> vppNodesByBridgeDomain) {
 125         for (String bd : vppNodesByBridgeDomain.keySet()) {
 126             Optional<GbpBridgeDomain> bdConfig = readGbpBridgeDomainConfig(bd);
 127             Set<NodeId> vppNodes = vppNodesByBridgeDomain.get(bd);
 128             if (bdConfig.isPresent()) {
 129                 if (bdConfig.get().getType().equals(VlanNetwork.class)) {
 130                     createVlanBridgeDomains(bd, bdConfig.get().getVlan(), vppNodes);
 131                 }
 132             } else {
 133                 VxlanVni vxlanVni = vxlanVniByBridgeDomain.get(bd);
 134                 if (vxlanVni == null) {
 135                     vxlanVni = new VxlanVni(lastVxlanVni++);
 136                     vxlanVniByBridgeDomain.put(bd, vxlanVni);
 137                 }
 138                 createVxlanBridgeDomains(bd, vxlanVni, vppNodes);
 139             }
 140         }
 141     }
 142
 143     private void createVxlanBridgeDomains(final String bd, final VxlanVni vni, final Set<NodeId> vppNodes) {
 144         for (NodeId vppNode : vppNodes) {
 145             try {
 146                 LOG.debug("Creating VXLAN bridge-domain {} on node {} with VNI {}", bd, vppNode.getValue(),
 147                         vni);
 148                 bdManager.createVxlanBridgeDomainOnVppNode(bd, vni, vppNode).get(WAIT_FOR_BD_PROCESSING,
 149                         TimeUnit.SECONDS);
 150             } catch (InterruptedException | ExecutionException e) {
 151                 LOG.warn("VXLAN Bridge domain {} was not created on node {}", bd, vppNode.getValue(), e);
 152             } catch (TimeoutException e) {
 153                 LOG.warn("Probably, VXLAN Bridge domain {} was not created on node {} because BridgeDomainManager "
 154                         + "did not respond by {} seconds. Check VBD log for more details",
 155                         bd, vppNode.getValue(), WAIT_FOR_BD_PROCESSING, e);
 156             }
 157         }
 158     }
 159
 160     private void createVlanBridgeDomains(final String bd, final VlanId vlanId, final Set<NodeId> vppNodes) {
 161         for (NodeId vppNode : vppNodes) {
 162             try {
 163                 LOG.debug("Creating VLAN bridge-domain {} on node {} with VLAN ID {}", bd, vppNode.getValue(),
 164                         vlanId.getValue());
 165                 bdManager.createVlanBridgeDomainOnVppNode(bd, vlanId, vppNode).get(WAIT_FOR_BD_PROCESSING,
 166                         TimeUnit.SECONDS);
 167             } catch (InterruptedException | ExecutionException e) {
 168                 LOG.warn("VLAN Bridge domain {} was not created on node {}", bd, vppNode.getValue(), e);
 169             } catch (TimeoutException e) {
 170                 LOG.warn("Probably, VLAN Bridge domain {} was not created on node {} because BridgeDomainManager "
 171                         + "did not respond by {} seconds. Check VBD log for more details",
 172                         bd, vppNode.getValue(), WAIT_FOR_BD_PROCESSING, e);
 173             }
 174         }
 175     }
 176
 177     public void removeBridgeDomainOnNodes(final SetMultimap<String, NodeId> vppNodesByBridgeDomain) {
 178         for (String bd : vppNodesByBridgeDomain.keySet()) {
 179             Set<NodeId> vppNodes = vppNodesByBridgeDomain.get(bd);
 180             for (NodeId vppNode : vppNodes) {
 181                 try {
 182                     bdManager.removeBridgeDomainFromVppNode(bd, vppNode).get(WAIT_FOR_BD_PROCESSING,
 183                             TimeUnit.SECONDS);
 184                 } catch (InterruptedException | ExecutionException e) {
 185                     LOG.warn("Bridge domain {} was not removed from node {}", bd, vppNode.getValue(), e);
 186                 } catch (TimeoutException e) {
 187                     LOG.warn("Probably, bridge domain {} was not removed from node {} because BridgeDomainManager "
 188                             + "did not respond by {} seconds. Check VBD log for more details",
 189                             bd, vppNode.getValue(), WAIT_FOR_BD_PROCESSING, e);
 190                 }
 191             }
 192         }
 193     }
 194
 195     public void createForwardingForEndpoint(RendererEndpointKey rEpKey, PolicyContext policyCtx) {
 196         AddressEndpointWithLocation rEp = policyCtx.getAddrEpByKey().get(KeyFactory.addressEndpointKey(rEpKey));
 197         ExternalLocationCase rEpLoc = resolveAndValidateLocation(rEp);
 198         if (Strings.isNullOrEmpty(rEpLoc.getExternalNodeConnector())) {
 199             // TODO add it to the status for renderer manager
 200             LOG.info("Renderer endpoint does not have external-node-connector therefore it is ignored {}", rEp);
 201             return;
 202         }
 203
 204         if (Strings.isNullOrEmpty(rEpLoc.getExternalNode())) {
 205             java.util.Optional<String> optL2FloodDomain = resolveL2FloodDomain(rEp, policyCtx);
 206             if (!optL2FloodDomain.isPresent()) {
 207                 // TODO add it to the status for renderer manager
 208                 LOG.info("Renderer endpoint does not have l2FloodDomain as network containment {}", rEp);
 209                 return;
 210             }
 211             String l2FloodDomain = optL2FloodDomain.get();
 212             try {
 213                 ifaceManager.addBridgeDomainToInterface(l2FloodDomain, rEp, aclManager.resolveAclsOnInterface(
 214                         rEpKey, policyCtx), isBviForEndpoint(rEp)).get();
 215                 aclManager.updateAclsForPeers(policyCtx, rEpKey);
 216                 LOG.debug("Interface added to bridge-domain {} for endpoint {}", l2FloodDomain, rEp);
 217             } catch (InterruptedException | ExecutionException e) {
 218                 // TODO add it to the status for renderer manager
 219                 LOG.warn("Interface was not added to bridge-domain {} for endpoint {}", l2FloodDomain, rEp, e);
 220             }
 221         } else {
 222             LOG.debug("Forwarding is not created - Location of renderer endpoint contains "
 223                     + "external-node therefore VPP renderer assumes that interface for endpoint is "
 224                     + "already assigned in bridge-domain representing external-node. {}", rEp);
 225         }
 226     }
 227
 228     private boolean isBviForEndpoint(AddressEndpointWithLocation rEp) {
 229         VppEndpointKey vppEndpointKey =
 230             new VppEndpointKey(rEp.getAddress(), rEp.getAddressType(), rEp.getContextId(), rEp.getContextType());
 231         ReadOnlyTransaction rTx = dataBroker.newReadOnlyTransaction();
 232         Optional<VppEndpoint> vppEndpointOptional =
 233             DataStoreHelper.readFromDs(LogicalDatastoreType.CONFIGURATION,
 234                 InstanceIdentifier.builder(Config.class).child(VppEndpoint.class, vppEndpointKey).build(), rTx);
 235         if (vppEndpointOptional.isPresent()) {
 236             InterfaceTypeChoice interfaceTypeChoice = vppEndpointOptional.get().getInterfaceTypeChoice();
 237             if (interfaceTypeChoice instanceof LoopbackCase) {
 238                 LOG.trace("Vpp renderer endpoint {} IS a BVI interface.", rEp.getKey());
 239                 return ((LoopbackCase) interfaceTypeChoice).isBvi();
 240             }
 241         }
 242         rTx.close();
 243         LOG.trace("Vpp renderer endpoint {} IS NOT a BVI interface.", rEp.getKey());
 244         return false;
 245     }
 246
 247     public void removeForwardingForEndpoint(RendererEndpointKey rEpKey, PolicyContext policyCtx) {
 248         AddressEndpointWithLocation rEp = policyCtx.getAddrEpByKey().get(KeyFactory.addressEndpointKey(rEpKey));
 249         ExternalLocationCase rEpLoc = resolveAndValidateLocation(rEp);
 250         if (Strings.isNullOrEmpty(rEpLoc.getExternalNodeConnector())) {
 251             // nothing was created for endpoint therefore nothing is removed
 252             return;
 253         }
 254         if (!Strings.isNullOrEmpty(rEpLoc.getExternalNode())) {
 255             try {
 256                 ifaceManager.deleteBridgeDomainFromInterface(rEp).get();
 257                 LOG.debug("bridge-domain was deleted from interface for endpoint {}", rEp);
 258             } catch (InterruptedException | ExecutionException e) {
 259                 // TODO add it to the status for renderer manager
 260                 LOG.warn("bridge-domain was not deleted from interface for endpoint {}", rEp, e);
 261             }
 262         } else {
 263             LOG.debug("Forwarding is not removed - Location of renderer endpoint does not contain "
 264                     + "external-node therefore VPP renderer assumes that interface for endpoint is not "
 265                     + "assigned to bridge-domain representing external-node. {}", rEp);
 266         }
 267     }
 268
 269     public static ExternalLocationCase resolveAndValidateLocation(AddressEndpointWithLocation addrEpWithLoc) {
 270         LocationType locationType = addrEpWithLoc.getAbsoluteLocation().getLocationType();
 271         if (!(locationType instanceof ExternalLocationCase)) {
 272             throw new IllegalStateException("Endpoint does not have external location " + addrEpWithLoc);
 273         }
 274         ExternalLocationCase result = (ExternalLocationCase) locationType;
 275         if (result.getExternalNodeMountPoint() == null) {
 276             throw new IllegalStateException("Endpoint does not have external-node-mount-point " + addrEpWithLoc);
 277         }
 278         return result;
 279     }
 280
 281     public static java.util.Optional<String> resolveL2FloodDomain(@Nonnull AddressEndpointWithLocation ep,
 282             @Nonnull PolicyContext policyCtx) {
 283         NetworkContainment netCont = ep.getNetworkContainment();
 284         if (netCont == null) {
 285             return java.util.Optional.empty();
 286         }
 287         Containment containment = netCont.getContainment();
 288         if (containment instanceof ForwardingContextContainment) {
 289             ForwardingContextContainment fwCtxCont = (ForwardingContextContainment) containment;
 290             if (L2FloodDomain.class.equals(fwCtxCont.getContextType())) {
 291                 return fwCtxCont.getContextId() == null ? java.util.Optional.empty() : java.util.Optional
 292                     .of(fwCtxCont.getContextId().getValue());
 293             }
 294         }
 295         if (containment instanceof NetworkDomainContainment) {
 296             final NetworkDomainContainment netDomainCont = (NetworkDomainContainment) containment;
 297             final TenantId tenantId = ep.getTenant();
 298             final NetworkDomainId domainId = netDomainCont.getNetworkDomainId();
 299             final Class<? extends NetworkDomain> domainKey = netDomainCont.getNetworkDomainType();
 300             final RendererNetworkDomainKey rendererNetworkDomainKey = new RendererNetworkDomainKey(domainId, domainKey);
 301             final RendererNetworkDomain rendererNetworkDomain =
 302                     policyCtx.getNetworkDomainTable().get(tenantId, rendererNetworkDomainKey);
 303             if (rendererNetworkDomain == null) {
 304                 LOG.debug("Network domain not found. Containment: {}", containment);
 305                 return java.util.Optional.empty();
 306             }
 307             java.util.Optional<String> optL2Fd = getForwardingCtxForParent(ep.getTenant(),
 308                     rendererNetworkDomain.getParent(), policyCtx.getForwardingCtxTable())
 309                         .filter(fwdCtx -> L2FloodDomain.class.equals(fwdCtx.getContextType()))
 310                         .map(RendererForwardingContext::getContextId)
 311                         .map(ContextId::getValue);
 312             if (!optL2Fd.isPresent()) {
 313                 LOG.debug("network-domain-containment in endpoint does not have L2-flood-domain as parent. "
 314                         + "This case is not supported in VPP renderer. {}", ep);
 315             }
 316             return optL2Fd;
 317         }
 318         return java.util.Optional.empty();
 319     }
 320
 321     private static @Nonnull java.util.Optional<RendererForwardingContext> getForwardingCtxForParent(
 322             @Nullable TenantId tenant, @Nullable Parent parent,
 323             Table<TenantId, RendererForwardingContextKey, RendererForwardingContext> forwardingCtxTable) {
 324         if (tenant == null || parent == null) {
 325             return java.util.Optional.empty();
 326         }
 327         if (parent.getContextId() != null && parent.getContextType() != null) {
 328             return java.util.Optional.ofNullable(forwardingCtxTable.get(tenant,
 329                     new RendererForwardingContextKey(parent.getContextId(), parent.getContextType())));
 330         }
 331         return java.util.Optional.empty();
 332     }
 333
 334     void syncNatEntries(PolicyContext policyCtx) {
 335         Configuration cfg = policyCtx.getPolicy().getConfiguration();
 336         if(cfg != null) {
 337             final List<MappingEntryBuilder> sNatEntries = resolveStaticNatTableEntries(cfg.getEndpoints());
 338             LOG.trace("Syncing static NAT entries {}", sNatEntries);
 339             if (cfg.getRendererForwarding() != null) {
 340                 for (RendererForwardingByTenant fwd : cfg.getRendererForwarding().getRendererForwardingByTenant()) {
 341                     List<InstanceIdentifier<PhysicalInterface>> physIfacesIid =
 342                         resolvePhysicalInterfacesForNat(fwd.getRendererNetworkDomain());
 343                     natManager.submitNatChanges(physIfacesIid, sNatEntries, policyCtx, true);
 344                 }
 345             }
 346         }
 347     }
 348
 349     public void deleteNatEntries(PolicyContext policyCtx) {
 350         Configuration cfg = policyCtx.getPolicy().getConfiguration();
 351         if(cfg != null) {
 352             List<MappingEntryBuilder> natEntries = resolveStaticNatTableEntries(cfg.getEndpoints());
 353             if (natEntries.isEmpty()) {
 354                 LOG.trace("NAT entries are empty,nothing to delete, skipping processing.");
 355                 return;
 356             }
 357             LOG.trace("Deleting NAT entries {}", natEntries);
 358             if (cfg.getRendererForwarding() != null) {
 359                 for (RendererForwardingByTenant fwd : cfg.getRendererForwarding().getRendererForwardingByTenant()) {
 360                     List<InstanceIdentifier<PhysicalInterface>> physIfacesIid =
 361                         resolvePhysicalInterfacesForNat(fwd.getRendererNetworkDomain());
 362                     natManager.submitNatChanges(physIfacesIid, natEntries, policyCtx, false);
 363                 }
 364             }
 365         }
 366     }
 367
 368     public List<InstanceIdentifier<PhysicalInterface>> resolvePhysicalInterfacesForNat(
 369             List<RendererNetworkDomain> rendNetDomains) {
 370         List<InstanceIdentifier<PhysicalInterface>> physIfaces = new ArrayList<>();
 371         for (RendererNetworkDomain rendDomain : rendNetDomains) {
 372             Optional<IpPrefix> resolvedIpPrefix = resolveIpPrefix(rendDomain);
 373             if (resolvedIpPrefix.isPresent()) {
 374                 Optional<InstanceIdentifier<PhysicalInterface>> resPhIface =
 375                     NatUtil.resolvePhysicalInterface(resolvedIpPrefix.get(), dataBroker.newReadOnlyTransaction());
 376                 if (resPhIface.isPresent()) {
 377                     physIfaces.add(resPhIface.get());
 378                 }
 379             }
 380         }
 381         return physIfaces;
 382     }
 383
 384     private Optional<IpPrefix> resolveIpPrefix(RendererNetworkDomain rendDomain) {
 385         SubnetAugmentRenderer subnetAug = rendDomain.getAugmentation(SubnetAugmentRenderer.class);
 386         if (subnetAug.getSubnet() != null) {
 387             return Optional.of(subnetAug.getSubnet().getIpPrefix());
 388         }
 389         return Optional.absent();
 390     }
 391
 392     private List<MappingEntryBuilder> resolveStaticNatTableEntries(Endpoints endpoints) {
 393         List<MappingEntryBuilder> sNatEntries = new ArrayList<>();
 394         for (AddressEndpointWithLocation addrEp : endpoints.getAddressEndpointWithLocation()) {
 395             if (addrEp.getAugmentation(NatAddressRenderer.class) == null) {
 396                 continue;
 397             }
 398             String endpointIP = resolveEpIpAddressForSnat(addrEp);
 399
 400             if (endpointIP == null) {
 401                 LOG.warn("Endpoints {} IP cannot be null, skipping processing of SNAT", addrEp);
 402                 continue;
 403             }
 404
 405             NatAddressRenderer natAddr = addrEp.getAugmentation(NatAddressRenderer.class);
 406             if (natAddr.getNatAddress() == null && natAddr.getNatAddress().getIpv4Address() == null) {
 407                 LOG.warn("Only Ipv4 SNAT is currently supported. Cannot apply SNAT for [{},{}]", endpointIP,
 408                         natAddr.getNatAddress());
 409                 continue;
 410             }
 411             Optional<MappingEntryBuilder> entry = natManager.resolveSnatEntry(endpointIP, natAddr.getNatAddress()
 412                 .getIpv4Address());
 413             if (entry.isPresent()) {
 414                 sNatEntries.add(entry.get());
 415             }
 416         }
 417         return sNatEntries;
 418     }
 419
 420     private String resolveEpIpAddressForSnat(AddressEndpointWithLocation addrEp) {
 421         if (addrEp.getAddressType().equals(MacAddressType.class)) {
 422             ParentEndpointChoice parentEndpointChoice = addrEp.getParentEndpointChoice();
 423             if (parentEndpointChoice instanceof ParentEndpointCase
 424                 && !((ParentEndpointCase) parentEndpointChoice).getParentEndpoint().isEmpty()) {
 425                 ParentEndpoint parentEndpoint = ((ParentEndpointCase) parentEndpointChoice).getParentEndpoint().get(0);
 426                 if (parentEndpoint.getAddressType().equals(IpPrefixType.class)) {
 427                     String[] ipWithPrefix = parentEndpoint.getAddress().split("/");
 428                     return ipWithPrefix[0];
 429                 } else {
 430                     LOG.warn("Endpoint {} Does not have a Parent Ep with IP for SNAT. skipping processing of SNAT",
 431                         addrEp);
 432                     return null;
 433                 }
 434
 435             } else {
 436                 LOG.warn("Endpoint {} Does not contain IP address for SNAT. skipping processing of SNAT", addrEp);
 437                 return null;
 438             }
 439         } else if (addrEp.getAddressType().equals(IpPrefixType.class)) {
 440             return addrEp.getAddress();
 441         }
 442         return null;
 443     }
 444
 445     @VisibleForTesting
 446     void setTimer(byte time) {
 447         WAIT_FOR_BD_PROCESSING = time;
 448     }
 449
 450     public void syncRouting(PolicyContext policyCtx) {
 451         Configuration cfg = policyCtx.getPolicy().getConfiguration();
 452         if (cfg != null && cfg.getRendererForwarding() != null) {
 453             for (RendererForwardingByTenant fwd : cfg.getRendererForwarding().getRendererForwardingByTenant()) {
 454                 if (fwd == null) {
 455                     continue;
 456                 }
 457
 458                 List<InstanceIdentifier<PhysicalInterface>>
 459                     physIfacesIid = resolvePhysicalInterfacesForNat(fwd.getRendererNetworkDomain());
 460                 Map<InstanceIdentifier<?>, RoutingCommand> routingCommandMap =
 461                     routingManager.createRouting(fwd, physIfacesIid, General.Operations.PUT);
 462
 463                 routingCommandMap.forEach((node, command) -> {
 464                     if (command != null && routingManager.submitRouting(command, node)) {
 465                         LOG.debug("Routing was successfully applied: {}.", command);
 466                     }
 467                 });
 468             }
 469         }
 470     }
 471
 472     public void deleteRouting(PolicyContext policyCtx) {
 473         Configuration cfg = policyCtx.getPolicy().getConfiguration();
 474         if (cfg != null && cfg.getRendererForwarding() != null) {
 475             for (RendererForwardingByTenant fwd : cfg.getRendererForwarding().getRendererForwardingByTenant()) {
 476                 if (fwd == null) {
 477                     continue;
 478                 }
 479
 480                 List<InstanceIdentifier<PhysicalInterface>>
 481                     physIfacesIid = resolvePhysicalInterfacesForNat(fwd.getRendererNetworkDomain());
 482                 Map<InstanceIdentifier<?>, RoutingCommand> routingCommandMap =
 483                     routingManager.createRouting(fwd, physIfacesIid, General.Operations.DELETE);
 484                 routingCommandMap.forEach((node, command) -> {
 485                     if (command != null && routingManager.submitRouting(command, node)) {
 486                         LOG.debug("Routing was successfully removed: {}.", command);
 487                     }
 488                 });
 489             }
 490         }
 491     }
 492 }