Policy exclusions & parallel netconf transactions

[groupbasedpolicy.git] / renderers / vpp / src / main / java / org / opendaylight / controller / config / yang / config / vpp_provider / impl / VppRenderer.java

diff --git a/renderers/vpp/src/main/java/org/opendaylight/controller/config/yang/config/vpp_provider/impl/VppRenderer.java b/renderers/vpp/src/main/java/org/opendaylight/controller/config/yang/config/vpp_provider/impl/VppRenderer.java
index 4a7711512c1bffea3829ff1617df1f81a79b7127..c6fbf448108b922da34321de1f9ce8fde3e5caba 100644 (file)
--- a/renderers/vpp/src/main/java/org/opendaylight/controller/config/yang/config/vpp_provider/impl/VppRenderer.java
+++ b/renderers/vpp/src/main/java/org/opendaylight/controller/config/yang/config/vpp_provider/impl/VppRenderer.java
@@ -11,6 +11,9 @@ package org.opendaylight.controller.config.yang.config.vpp_provider.impl;
 import java.util.ArrayList;
 import java.util.List;
 
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+
 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
 import org.opendaylight.controller.md.sal.binding.api.MountPointService;
 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
@@ -19,16 +22,23 @@ import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFaile
 import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
 import org.opendaylight.controller.sal.binding.api.BindingAwareProvider;
 import org.opendaylight.groupbasedpolicy.renderer.vpp.api.BridgeDomainManager;
-import org.opendaylight.groupbasedpolicy.renderer.vpp.adapter.VppRpcServiceImpl;
-import org.opendaylight.groupbasedpolicy.renderer.vpp.iface.AclManager;
+import org.opendaylight.groupbasedpolicy.renderer.vpp.dhcp.DhcpRelayHandler;
 import org.opendaylight.groupbasedpolicy.renderer.vpp.iface.InterfaceManager;
+import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.LispStateManager;
+import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.event.manager.GbpSubnetEventManager;
+import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.flat.overlay.FlatOverlayManager;
+import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.loopback.LoopbackManager;
+import org.opendaylight.groupbasedpolicy.renderer.vpp.listener.GbpSubnetListener;
 import org.opendaylight.groupbasedpolicy.renderer.vpp.listener.RendererPolicyListener;
 import org.opendaylight.groupbasedpolicy.renderer.vpp.listener.VppEndpointListener;
 import org.opendaylight.groupbasedpolicy.renderer.vpp.listener.VppNodeListener;
 import org.opendaylight.groupbasedpolicy.renderer.vpp.manager.VppNodeManager;
+import org.opendaylight.groupbasedpolicy.renderer.vpp.nat.NatManager;
 import org.opendaylight.groupbasedpolicy.renderer.vpp.policy.BridgeDomainManagerImpl;
 import org.opendaylight.groupbasedpolicy.renderer.vpp.policy.ForwardingManager;
 import org.opendaylight.groupbasedpolicy.renderer.vpp.policy.VppRendererPolicyManager;
+import org.opendaylight.groupbasedpolicy.renderer.vpp.policy.acl.AclManager;
+import org.opendaylight.groupbasedpolicy.renderer.vpp.routing.RoutingManager;
 import org.opendaylight.groupbasedpolicy.renderer.vpp.sf.AllowAction;
 import org.opendaylight.groupbasedpolicy.renderer.vpp.sf.Classifier;
 import org.opendaylight.groupbasedpolicy.renderer.vpp.sf.EtherTypeClassifier;
@@ -58,30 +68,29 @@ import com.google.common.util.concurrent.Futures;
 
 public class VppRenderer implements AutoCloseable, BindingAwareProvider {
 
-    private static final Logger LOG = LoggerFactory.getLogger(VppRenderer.class);
-
     public static final RendererName NAME = new RendererName("vpp-renderer");
-
+    private static final Logger LOG = LoggerFactory.getLogger(VppRenderer.class);
     private final List<SupportedActionDefinition> actionDefinitions =
             ImmutableList.of(new SupportedActionDefinitionBuilder().setActionDefinitionId(new AllowAction().getId())
-                .setSupportedParameterValues(new AllowAction().getSupportedParameterValues())
-                .build());
+                    .setSupportedParameterValues(new AllowAction().getSupportedParameterValues())
+                    .build());
     private final List<SupportedClassifierDefinition> classifierDefinitions;
 
     private final DataBroker dataBroker;
-
-    private VppNodeManager vppNodeManager;
+    private final String publicInterfaces;
     private InterfaceManager interfaceManager;
-    private AclManager aclManager;
-    private VppRendererPolicyManager vppRendererPolicyManager;
-
+    private MountedDataBrokerProvider mountDataProvider;
+    private BridgeDomainManager bdManager;
     private VppNodeListener vppNodeListener;
     private VppEndpointListener vppEndpointListener;
     private RendererPolicyListener rendererPolicyListener;
-    private VppRpcServiceImpl vppRpcServiceImpl;
+    private GbpSubnetListener vppGbpSubnetListener;
+    private GbpSubnetEventManager subnetEventManager;
 
-    public VppRenderer(DataBroker dataBroker, BindingAwareBroker bindingAwareBroker) {
+    VppRenderer(@Nonnull DataBroker dataBroker, @Nonnull BindingAwareBroker bindingAwareBroker,
+                       @Nullable String publicInterfaces) {
         this.dataBroker = Preconditions.checkNotNull(dataBroker);
+        this.publicInterfaces = publicInterfaces;
         bindingAwareBroker.registerProvider(this);
         EtherTypeClassifier etherTypeClassifier = new EtherTypeClassifier(null);
         IpProtoClassifier ipProtoClassifier = new IpProtoClassifier(etherTypeClassifier);
@@ -89,7 +98,7 @@ public class VppRenderer implements AutoCloseable, BindingAwareProvider {
                 buildClassifierDefinitions(etherTypeClassifier, ipProtoClassifier, new L4Classifier(ipProtoClassifier));
     }
 
-    private List<SupportedClassifierDefinition> buildClassifierDefinitions(Classifier ... classifs) {
+    private List<SupportedClassifierDefinition> buildClassifierDefinitions(Classifier... classifs) {
         List<SupportedClassifierDefinition> clDefs = new ArrayList<>();
         SupportedClassifierDefinitionBuilder clDefBuilder = new SupportedClassifierDefinitionBuilder();
         for (Classifier classif : classifs) {
@@ -97,8 +106,8 @@ public class VppRenderer implements AutoCloseable, BindingAwareProvider {
                 clDefBuilder.setParentClassifierDefinitionId(classif.getParent().getId());
             }
             clDefs.add(clDefBuilder.setClassifierDefinitionId(classif.getId())
-                .setSupportedParameterValues(classif.getSupportedParameterValues())
-                .build());
+                    .setSupportedParameterValues(classif.getSupportedParameterValues())
+                    .build());
         }
         return clDefs;
     }
@@ -118,6 +127,10 @@ public class VppRenderer implements AutoCloseable, BindingAwareProvider {
         if (interfaceManager != null) {
             interfaceManager.close();
         }
+
+        if (vppGbpSubnetListener != null) {
+            vppGbpSubnetListener.close();
+        }
         unregisterFromRendererManager();
     }
 
@@ -127,23 +140,34 @@ public class VppRenderer implements AutoCloseable, BindingAwareProvider {
 
         MountPointService mountService =
                 Preconditions.checkNotNull(providerContext.getSALService(MountPointService.class));
-        MountedDataBrokerProvider mountDataProvider = new MountedDataBrokerProvider(mountService, dataBroker);
-        vppNodeManager = new VppNodeManager(dataBroker, providerContext);
+        mountDataProvider = new MountedDataBrokerProvider(mountService, dataBroker);
+        VppNodeManager vppNodeManager = new VppNodeManager(dataBroker, providerContext, publicInterfaces);
 
         EventBus dtoEventBus = new EventBus((exception, context) -> LOG.error("Could not dispatch event: {} to {}",
                 context.getSubscriber(), context.getSubscriberMethod(), exception));
-        interfaceManager = new InterfaceManager(mountDataProvider, dataBroker);
-        aclManager = new AclManager(mountDataProvider);
+        LispStateManager lispStateManager = new LispStateManager(mountDataProvider);
+        FlatOverlayManager flatOverlayManager = new FlatOverlayManager(dataBroker, mountDataProvider);
+        LoopbackManager loopbackManager = new LoopbackManager(mountDataProvider);
+
+        interfaceManager = new InterfaceManager(mountDataProvider, dataBroker, flatOverlayManager);
+        AclManager aclManager = new AclManager(mountDataProvider, interfaceManager);
+        NatManager natManager = new NatManager(dataBroker, mountDataProvider);
+        subnetEventManager = new GbpSubnetEventManager(loopbackManager);
         dtoEventBus.register(interfaceManager);
-        BridgeDomainManager bdManager = new BridgeDomainManagerImpl(dataBroker);
-        ForwardingManager fwManager = new ForwardingManager(interfaceManager, aclManager, bdManager, dataBroker);
-        vppRendererPolicyManager = new VppRendererPolicyManager(fwManager, aclManager, dataBroker);
+        dtoEventBus.register(subnetEventManager);
+        RoutingManager routingManager = new RoutingManager(dataBroker, mountDataProvider);
+        DhcpRelayHandler dhcpRelayHandler = new DhcpRelayHandler(dataBroker, mountDataProvider);
+        bdManager = new BridgeDomainManagerImpl(dataBroker);
+        ForwardingManager fwManager =
+                new ForwardingManager(interfaceManager, aclManager, natManager, routingManager, bdManager,
+                        lispStateManager, loopbackManager, flatOverlayManager, dhcpRelayHandler, dataBroker);
+        VppRendererPolicyManager vppRendererPolicyManager = new VppRendererPolicyManager(fwManager, aclManager, dataBroker);
         dtoEventBus.register(vppRendererPolicyManager);
 
         vppNodeListener = new VppNodeListener(dataBroker, vppNodeManager, dtoEventBus);
         vppEndpointListener = new VppEndpointListener(dataBroker, dtoEventBus);
         rendererPolicyListener = new RendererPolicyListener(dataBroker, dtoEventBus);
-        vppRpcServiceImpl = new VppRpcServiceImpl(dataBroker, mountDataProvider, bdManager, interfaceManager);
+        vppGbpSubnetListener = new GbpSubnetListener(dataBroker, dtoEventBus);
         registerToRendererManager();
     }
 
@@ -151,11 +175,11 @@ public class VppRenderer implements AutoCloseable, BindingAwareProvider {
         WriteTransaction writeTransaction = dataBroker.newWriteOnlyTransaction();
 
         Renderer renderer = new RendererBuilder().setName(VppRenderer.NAME)
-            .setRendererNodes(new RendererNodesBuilder().build())
-            .setCapabilities(new CapabilitiesBuilder().setSupportedActionDefinition(actionDefinitions)
-                .setSupportedClassifierDefinition(classifierDefinitions)
-                .build())
-            .build();
+                .setRendererNodes(new RendererNodesBuilder().build())
+                .setCapabilities(new CapabilitiesBuilder().setSupportedActionDefinition(actionDefinitions)
+                        .setSupportedClassifierDefinition(classifierDefinitions)
+                        .build())
+                .build();
 
         writeTransaction.put(LogicalDatastoreType.OPERATIONAL, VppIidFactory.getRendererIID(renderer.getKey()),
                 renderer, true);
@@ -163,7 +187,7 @@ public class VppRenderer implements AutoCloseable, BindingAwareProvider {
         Futures.addCallback(future, new FutureCallback<Void>() {
 
             @Override
-            public void onFailure(Throwable throwable) {
+            public void onFailure(@Nonnull Throwable throwable) {
                 LOG.error("Could not register renderer {}: {}", renderer, throwable);
             }
 
@@ -183,7 +207,7 @@ public class VppRenderer implements AutoCloseable, BindingAwareProvider {
         Futures.addCallback(future, new FutureCallback<Void>() {
 
             @Override
-            public void onFailure(Throwable throwable) {
+            public void onFailure(@Nonnull Throwable throwable) {
                 LOG.error("Could not unregister renderer {}: {}", VppRenderer.NAME, throwable);
             }
 
@@ -194,7 +218,15 @@ public class VppRenderer implements AutoCloseable, BindingAwareProvider {
         });
     }
 
-    VppRpcServiceImpl getVppRpcServiceImpl() {
-        return vppRpcServiceImpl;
+    public MountedDataBrokerProvider getMountedDataBroker() {
+        return mountDataProvider;
+    }
+
+    public InterfaceManager getInterfaceManager() {
+        return interfaceManager;
+    }
+
+    public BridgeDomainManager getBridgeDomainManager() {
+        return bdManager;
     }
 }