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