implementing routing for VPP

[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 cf90406a2971cf72bf9ff25035f4db9ea62944de..b0f88e436d8933a16fbc8475f7ed7325cde45204 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
@@ -8,9 +8,8 @@
 
 package org.opendaylight.controller.config.yang.config.vpp_provider.impl;
 
+import java.util.ArrayList;
 import java.util.List;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
 
 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
 import org.opendaylight.controller.md.sal.binding.api.MountPointService;
@@ -19,16 +18,24 @@ import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
 import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
 import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
 import org.opendaylight.controller.sal.binding.api.BindingAwareProvider;
+import org.opendaylight.groupbasedpolicy.renderer.vpp.adapter.VppRpcServiceImpl;
+import org.opendaylight.groupbasedpolicy.renderer.vpp.api.BridgeDomainManager;
+import org.opendaylight.groupbasedpolicy.renderer.vpp.iface.AclManager;
 import org.opendaylight.groupbasedpolicy.renderer.vpp.iface.InterfaceManager;
 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.BridgeDomainManagerImpl;
 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.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;
+import org.opendaylight.groupbasedpolicy.renderer.vpp.sf.IpProtoClassifier;
+import org.opendaylight.groupbasedpolicy.renderer.vpp.sf.L4Classifier;
 import org.opendaylight.groupbasedpolicy.renderer.vpp.util.MountedDataBrokerProvider;
 import org.opendaylight.groupbasedpolicy.renderer.vpp.util.VppIidFactory;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.RendererName;
@@ -50,41 +57,52 @@ import com.google.common.eventbus.EventBus;
 import com.google.common.util.concurrent.CheckedFuture;
 import com.google.common.util.concurrent.FutureCallback;
 import com.google.common.util.concurrent.Futures;
-import com.google.common.util.concurrent.ThreadFactoryBuilder;
 
 public class VppRenderer implements AutoCloseable, BindingAwareProvider {
 
     private static final Logger LOG = LoggerFactory.getLogger(VppRenderer.class);
 
     public static final RendererName NAME = new RendererName("vpp-renderer");
-    /**
-     * Should be used for processing netconf responses so we do not consume netty thread.
-     */
-    private static final ExecutorService NETCONF_WORKER = Executors.newSingleThreadExecutor(
-            new ThreadFactoryBuilder().setNameFormat("netconf-processing-worker-%d").setDaemon(true).build());
 
     private final List<SupportedActionDefinition> actionDefinitions =
             ImmutableList.of(new SupportedActionDefinitionBuilder().setActionDefinitionId(new AllowAction().getId())
                 .setSupportedParameterValues(new AllowAction().getSupportedParameterValues())
                 .build());
-    private final List<SupportedClassifierDefinition> classifierDefinitions = ImmutableList
-        .of(new SupportedClassifierDefinitionBuilder().setClassifierDefinitionId(new EtherTypeClassifier(null).getId())
-            .setSupportedParameterValues(new EtherTypeClassifier(null).getSupportedParameterValues())
-            .build());
+    private final List<SupportedClassifierDefinition> classifierDefinitions;
 
     private final DataBroker dataBroker;
 
     private VppNodeManager vppNodeManager;
     private InterfaceManager interfaceManager;
+    private AclManager aclManager;
     private VppRendererPolicyManager vppRendererPolicyManager;
 
     private VppNodeListener vppNodeListener;
     private VppEndpointListener vppEndpointListener;
     private RendererPolicyListener rendererPolicyListener;
+    private VppRpcServiceImpl vppRpcServiceImpl;
 
     public VppRenderer(DataBroker dataBroker, BindingAwareBroker bindingAwareBroker) {
         this.dataBroker = Preconditions.checkNotNull(dataBroker);
         bindingAwareBroker.registerProvider(this);
+        EtherTypeClassifier etherTypeClassifier = new EtherTypeClassifier(null);
+        IpProtoClassifier ipProtoClassifier = new IpProtoClassifier(etherTypeClassifier);
+        classifierDefinitions =
+                buildClassifierDefinitions(etherTypeClassifier, ipProtoClassifier, new L4Classifier(ipProtoClassifier));
+    }
+
+    private List<SupportedClassifierDefinition> buildClassifierDefinitions(Classifier ... classifs) {
+        List<SupportedClassifierDefinition> clDefs = new ArrayList<>();
+        SupportedClassifierDefinitionBuilder clDefBuilder = new SupportedClassifierDefinitionBuilder();
+        for (Classifier classif : classifs) {
+            if (classif.getParent() != null) {
+                clDefBuilder.setParentClassifierDefinitionId(classif.getParent().getId());
+            }
+            clDefs.add(clDefBuilder.setClassifierDefinitionId(classif.getId())
+                .setSupportedParameterValues(classif.getSupportedParameterValues())
+                .build());
+        }
+        return clDefs;
     }
 
     @Override
@@ -111,20 +129,26 @@ public class VppRenderer implements AutoCloseable, BindingAwareProvider {
 
         MountPointService mountService =
                 Preconditions.checkNotNull(providerContext.getSALService(MountPointService.class));
-        MountedDataBrokerProvider mountDataProvider = new MountedDataBrokerProvider(mountService);
+        MountedDataBrokerProvider mountDataProvider = new MountedDataBrokerProvider(mountService, dataBroker);
         vppNodeManager = new VppNodeManager(dataBroker, providerContext);
 
-        EventBus dtoEventBus = new EventBus("DTO events");
-        interfaceManager = new InterfaceManager(mountDataProvider, dataBroker, NETCONF_WORKER);
+        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);
+        NatManager natManager = new NatManager(dataBroker, mountDataProvider);
         dtoEventBus.register(interfaceManager);
-        ForwardingManager fwManager = new ForwardingManager(interfaceManager, new BridgeDomainManagerImpl(dataBroker));
-        vppRendererPolicyManager = new VppRendererPolicyManager(fwManager, dataBroker);
+        RoutingManager routingManager = new RoutingManager(dataBroker, mountDataProvider);
+        BridgeDomainManager bdManager = new BridgeDomainManagerImpl(dataBroker);
+        ForwardingManager fwManager =
+            new ForwardingManager(interfaceManager, aclManager, natManager, routingManager, bdManager, dataBroker);
+        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);
         registerToRendererManager();
     }
 
@@ -174,4 +198,8 @@ public class VppRenderer implements AutoCloseable, BindingAwareProvider {
             }
         });
     }
+
+    VppRpcServiceImpl getVppRpcServiceImpl() {
+        return vppRpcServiceImpl;
+    }
 }