Bug 5061: Integrate RIBImplModule with blueprint

Instead of instance creation in RIBImplModule, write
BGP OpenConfig configuration into the config DS and
BGP deployer takes care of instance creation.
Add mapping function RIBImplModule -> OpenConfig BGP to
BGPOpenConfigMappingService.

Change-Id: I34533ca6e4593244948cd109c95f105d4c171bdb
Signed-off-by: Milos Fabian <milfabia@cisco.com>

diff --git a/bgp/openconfig-impl/src/main/java/org/opendaylight/protocol/bgp/openconfig/impl/BGPOpenConfigMappingServiceImpl.java b/bgp/openconfig-impl/src/main/java/org/opendaylight/protocol/bgp/openconfig/impl/BGPOpenConfigMappingServiceImpl.java
index dd3794711bb983cbb3f60f9bbf880b068ab9f3af..588008ee68c307fb41b05ab92bcb5ee190a164d9 100644 (file)
--- a/bgp/openconfig-impl/src/main/java/org/opendaylight/protocol/bgp/openconfig/impl/BGPOpenConfigMappingServiceImpl.java
+++ b/bgp/openconfig-impl/src/main/java/org/opendaylight/protocol/bgp/openconfig/impl/BGPOpenConfigMappingServiceImpl.java
@@ -8,8 +8,11 @@
 
 package org.opendaylight.protocol.bgp.openconfig.impl;
 
+import static org.opendaylight.protocol.bgp.openconfig.impl.util.OpenConfigUtil.APPLICATION_PEER_GROUP_NAME;
+
 import com.google.common.base.Optional;
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -20,17 +23,44 @@ import org.opendaylight.protocol.bgp.mode.impl.add.n.paths.AddPathBestNPathSelec
 import org.opendaylight.protocol.bgp.openconfig.impl.util.OpenConfigUtil;
 import org.opendaylight.protocol.bgp.openconfig.spi.BGPOpenConfigMappingService;
 import org.opendaylight.yang.gen.v1.http.openconfig.net.yang.bgp.multiprotocol.rev151009.bgp.common.afi.safi.list.AfiSafi;
+import org.opendaylight.yang.gen.v1.http.openconfig.net.yang.bgp.rev151009.bgp.global.base.AfiSafisBuilder;
+import org.opendaylight.yang.gen.v1.http.openconfig.net.yang.bgp.rev151009.bgp.global.base.ConfigBuilder;
 import org.opendaylight.yang.gen.v1.http.openconfig.net.yang.bgp.rev151009.bgp.neighbors.Neighbor;
+import org.opendaylight.yang.gen.v1.http.openconfig.net.yang.bgp.rev151009.bgp.peer.group.PeerGroup;
+import org.opendaylight.yang.gen.v1.http.openconfig.net.yang.bgp.rev151009.bgp.peer.group.PeerGroupBuilder;
+import org.opendaylight.yang.gen.v1.http.openconfig.net.yang.bgp.rev151009.bgp.peer.group.PeerGroupKey;
+import org.opendaylight.yang.gen.v1.http.openconfig.net.yang.bgp.rev151009.bgp.top.Bgp;
+import org.opendaylight.yang.gen.v1.http.openconfig.net.yang.bgp.rev151009.bgp.top.BgpBuilder;
+import org.opendaylight.yang.gen.v1.http.openconfig.net.yang.bgp.rev151009.bgp.top.bgp.Global;
+import org.opendaylight.yang.gen.v1.http.openconfig.net.yang.bgp.rev151009.bgp.top.bgp.GlobalBuilder;
+import org.opendaylight.yang.gen.v1.http.openconfig.net.yang.bgp.rev151009.bgp.top.bgp.NeighborsBuilder;
+import org.opendaylight.yang.gen.v1.http.openconfig.net.yang.bgp.rev151009.bgp.top.bgp.PeerGroups;
+import org.opendaylight.yang.gen.v1.http.openconfig.net.yang.bgp.rev151009.bgp.top.bgp.PeerGroupsBuilder;
+import org.opendaylight.yang.gen.v1.http.openconfig.net.yang.network.instance.rev151018.network.instance.top.network.instances.network.instance.protocols.Protocol;
+import org.opendaylight.yang.gen.v1.http.openconfig.net.yang.network.instance.rev151018.network.instance.top.network.instances.network.instance.protocols.ProtocolBuilder;
+import org.opendaylight.yang.gen.v1.http.openconfig.net.yang.network.instance.rev151018.network.instance.top.network.instances.network.instance.protocols.ProtocolKey;
+import org.opendaylight.yang.gen.v1.http.openconfig.net.yang.policy.types.rev151009.BGP;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.AsNumber;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev130919.BgpTableType;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev130919.SendReceive;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev130919.mp.capabilities.add.path.capability.AddressFamilies;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev130919.mp.capabilities.add.path.capability.AddressFamiliesBuilder;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.openconfig.extensions.rev160614.AfiSafi1;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.openconfig.extensions.rev160614.AfiSafi2;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.openconfig.extensions.rev160614.Protocol1;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.openconfig.extensions.rev160614.Protocol1Builder;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev130925.PeerRole;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev130925.RibId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev130925.rib.TablesKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev130919.BgpId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev130919.ClusterIdentifier;
 
 public final class BGPOpenConfigMappingServiceImpl implements BGPOpenConfigMappingService {
 
+    private static final PeerGroup APP_PEER_GROUP = new PeerGroupBuilder().setPeerGroupName(APPLICATION_PEER_GROUP_NAME)
+            .setKey(new PeerGroupKey(APPLICATION_PEER_GROUP_NAME)).build();
+    private static final PeerGroups PEER_GROUPS = new PeerGroupsBuilder().setPeerGroup(Collections.singletonList(APP_PEER_GROUP)).build();
+
     @Override
     public List<BgpTableType> toTableTypes(final List<AfiSafi> afiSafis) {
         return afiSafis.stream()
@@ -95,4 +125,29 @@ public final class BGPOpenConfigMappingServiceImpl implements BGPOpenConfigMappi
         return SendReceive.Receive;
     }
 
+    @Override
+    public Protocol fromRib(final BgpId bgpId, final ClusterIdentifier clusterIdentifier, final RibId ribId,
+            final AsNumber localAs, final List<BgpTableType> localTables,
+            final Map<TablesKey, PathSelectionMode> pathSelectionStrategies) {
+        final Bgp bgp = toGlobalConfiguration(bgpId, clusterIdentifier, localAs, localTables, pathSelectionStrategies);
+        final ProtocolBuilder protocolBuilder = new ProtocolBuilder();
+        protocolBuilder.setIdentifier(BGP.class);
+        protocolBuilder.setName(ribId.getValue());
+        protocolBuilder.setKey(new ProtocolKey(protocolBuilder.getIdentifier(), protocolBuilder.getName()));
+        return protocolBuilder.addAugmentation(Protocol1.class, new Protocol1Builder().setBgp(bgp).build()).build();
+    }
+
+    private static Bgp toGlobalConfiguration(final BgpId bgpId, final ClusterIdentifier clusterIdentifier,
+            final AsNumber localAs, final List<BgpTableType> localTables,
+            final Map<TablesKey, PathSelectionMode> pathSelectionStrategies) {
+        final BgpBuilder bgpBuilder = new BgpBuilder();
+        bgpBuilder.setNeighbors(new NeighborsBuilder().build());
+        bgpBuilder.setPeerGroups(PEER_GROUPS);
+        final Global global = new GlobalBuilder().setAfiSafis(new AfiSafisBuilder().setAfiSafi(OpenConfigUtil.toAfiSafis(localTables,
+                (afiSafi, tableType) -> OpenConfigUtil.toGlobalAfiSafiAddPath(afiSafi, tableType, pathSelectionStrategies))).build())
+                .setConfig(new ConfigBuilder().setAs(localAs).setRouterId(bgpId).build()).build();
+        bgpBuilder.setGlobal(global);
+        return bgpBuilder.build();
+    }
+
 }

diff --git a/bgp/openconfig-impl/src/main/java/org/opendaylight/protocol/bgp/openconfig/impl/util/OpenConfigUtil.java b/bgp/openconfig-impl/src/main/java/org/opendaylight/protocol/bgp/openconfig/impl/util/OpenConfigUtil.java
index 6b75eaf0e4a6b57a4416f389827e4631ac22375a..64f54eddac6958c9fed724bdb8b3374ae66edcf3 100644 (file)
--- a/bgp/openconfig-impl/src/main/java/org/opendaylight/protocol/bgp/openconfig/impl/util/OpenConfigUtil.java
+++ b/bgp/openconfig-impl/src/main/java/org/opendaylight/protocol/bgp/openconfig/impl/util/OpenConfigUtil.java
@@ -163,8 +163,8 @@ public final class OpenConfigUtil {
     }
 
     public static AfiSafi toGlobalAfiSafiAddPath(final AfiSafi afiSafi, final BgpTableType tableType,
-            final Map<BgpTableType, PathSelectionMode> multiPathTables) {
-        final PathSelectionMode pathSelection = multiPathTables.get(tableType);
+            final Map<TablesKey, PathSelectionMode> multiPathTables) {
+        final PathSelectionMode pathSelection = multiPathTables.get(new TablesKey(tableType.getAfi(), tableType.getSafi()));
         if (pathSelection == null) {
             return afiSafi;
         }

diff --git a/bgp/openconfig-spi/src/main/java/org/opendaylight/protocol/bgp/openconfig/spi/BGPOpenConfigMappingService.java b/bgp/openconfig-spi/src/main/java/org/opendaylight/protocol/bgp/openconfig/spi/BGPOpenConfigMappingService.java
index 9080fe473e711ef3f462f3bc768133f2ba11af9c..8c6ea298f88787d7e8d671f1ff8d2972a551c223 100644 (file)
--- a/bgp/openconfig-spi/src/main/java/org/opendaylight/protocol/bgp/openconfig/spi/BGPOpenConfigMappingService.java
+++ b/bgp/openconfig-spi/src/main/java/org/opendaylight/protocol/bgp/openconfig/spi/BGPOpenConfigMappingService.java
@@ -13,9 +13,15 @@ import java.util.Map;
 import org.opendaylight.protocol.bgp.mode.api.PathSelectionMode;
 import org.opendaylight.yang.gen.v1.http.openconfig.net.yang.bgp.multiprotocol.rev151009.bgp.common.afi.safi.list.AfiSafi;
 import org.opendaylight.yang.gen.v1.http.openconfig.net.yang.bgp.rev151009.bgp.neighbors.Neighbor;
+import org.opendaylight.yang.gen.v1.http.openconfig.net.yang.network.instance.rev151018.network.instance.top.network.instances.network.instance.protocols.Protocol;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.AsNumber;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev130919.BgpTableType;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev130919.mp.capabilities.add.path.capability.AddressFamilies;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev130925.PeerRole;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev130925.RibId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev130925.rib.TablesKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev130919.BgpId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev130919.ClusterIdentifier;
 
 public interface BGPOpenConfigMappingService {
 
@@ -28,4 +34,7 @@ public interface BGPOpenConfigMappingService {
     boolean isApplicationPeer(Neighbor neighbor);
 
     PeerRole toPeerRole(Neighbor neighbor);
+
+    Protocol fromRib(BgpId bgpId, ClusterIdentifier clusterIdentifier, RibId ribId, AsNumber localAs, List<BgpTableType> localTables,
+            Map<TablesKey, PathSelectionMode> pathSelectionStrategies);
 }

diff --git a/bgp/rib-api/src/main/yang/odl-bgp-rib-cfg.yang b/bgp/rib-api/src/main/yang/odl-bgp-rib-cfg.yang
index 830382b2008e2f8dad7a5cdae441d26c0aefe57d..fb22fc6af96892c850fee5b41f5c7c3dd332050a 100644 (file)
--- a/bgp/rib-api/src/main/yang/odl-bgp-rib-cfg.yang
+++ b/bgp/rib-api/src/main/yang/odl-bgp-rib-cfg.yang
@@ -33,6 +33,7 @@ module odl-bgp-rib-cfg {
 
         base "config:service-type";
         config:java-class "org.opendaylight.protocol.bgp.rib.RibReference";
+        config:disable-osgi-service-registration;
     }
 }
 

diff --git a/bgp/rib-impl/src/main/java/org/opendaylight/controller/config/yang/bgp/rib/impl/RIBImplModule.java b/bgp/rib-impl/src/main/java/org/opendaylight/controller/config/yang/bgp/rib/impl/RIBImplModule.java
index 14ca638db41efbaf8320728e5d3b37117b74c2d5..9a9497704be18451be0f464339de25fbf39c712f 100755 (executable)
--- a/bgp/rib-impl/src/main/java/org/opendaylight/controller/config/yang/bgp/rib/impl/RIBImplModule.java
+++ b/bgp/rib-impl/src/main/java/org/opendaylight/controller/config/yang/bgp/rib/impl/RIBImplModule.java
@@ -16,30 +16,32 @@
  */
 package org.opendaylight.controller.config.yang.bgp.rib.impl;
 
+import com.google.common.reflect.AbstractInvocationHandler;
+import com.google.common.reflect.Reflection;
+import java.lang.reflect.Method;
 import java.util.Collections;
-import java.util.Hashtable;
 import java.util.List;
 import java.util.Map;
 import java.util.stream.Collectors;
 import org.opendaylight.controller.config.api.JmxAttributeValidationException;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
-import org.opendaylight.controller.sal.core.api.model.SchemaService;
+import org.opendaylight.controller.config.api.osgi.WaitingServiceTracker;
 import org.opendaylight.protocol.bgp.mode.api.PathSelectionMode;
-import org.opendaylight.protocol.bgp.openconfig.spi.BGPConfigModuleTracker;
-import org.opendaylight.protocol.bgp.openconfig.spi.BGPOpenconfigMapper;
-import org.opendaylight.protocol.bgp.openconfig.spi.InstanceConfigurationIdentifier;
-import org.opendaylight.protocol.bgp.openconfig.spi.pojo.BGPRibInstanceConfiguration;
-import org.opendaylight.protocol.bgp.rib.impl.RIBImpl;
 import org.opendaylight.protocol.bgp.rib.impl.spi.BGPBestPathSelection;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev130919.BgpTableType;
+import org.opendaylight.protocol.bgp.rib.impl.spi.BgpDeployer;
+import org.opendaylight.protocol.bgp.rib.impl.spi.InstanceType;
+import org.opendaylight.protocol.bgp.rib.impl.spi.RIB;
+import org.opendaylight.yang.gen.v1.http.openconfig.net.yang.network.instance.rev151018.network.instance.top.network.instances.network.instance.Protocols;
+import org.opendaylight.yang.gen.v1.http.openconfig.net.yang.network.instance.rev151018.network.instance.top.network.instances.network.instance.protocols.Protocol;
+import org.opendaylight.yang.gen.v1.http.openconfig.net.yang.network.instance.rev151018.network.instance.top.network.instances.network.instance.protocols.ProtocolKey;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.AsNumber;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev130925.rib.TablesKey;
-import org.opendaylight.yangtools.sal.binding.generator.impl.GeneratedClassLoadingStrategy;
-import org.opendaylight.yangtools.yang.model.api.SchemaContextListener;
+import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier;
 import org.osgi.framework.BundleContext;
 
 /**
  *
  */
+@Deprecated
 public final class RIBImplModule extends org.opendaylight.controller.config.yang.bgp.rib.impl.AbstractRIBImplModule {
 
     private static final String IS_NOT_SET = "is not set.";
@@ -67,74 +69,46 @@ public final class RIBImplModule extends org.opendaylight.controller.config.yang
 
     @Override
     public java.lang.AutoCloseable createInstance() {
-        final Map<TablesKey, PathSelectionMode> pathSelectionStrategies = mapBestPathSelectionStrategyByFamily(getRibPathSelectionModeDependency());
-        final RIBImpl rib = new RIBImpl(getRibId(), getLocalAs(), getBgpRibId(), getClusterId(), getExtensionsDependency(),
-            getBgpDispatcherDependency(), getCodecTreeFactoryDependency(), getDomDataProviderDependency(), getLocalTableDependency(), pathSelectionStrategies, classLoadingStrategy(),
-            new RIBImplModuleTracker(getGlobalWriter()), getOpenconfigProviderDependency());
-        registerSchemaContextListener(rib);
-
-        rib.registerRootRuntimeBean(getRootRuntimeBeanRegistratorWrapper());
-        return rib;
-    }
-
-    private GeneratedClassLoadingStrategy classLoadingStrategy() {
-        return getExtensionsDependency().getClassLoadingStrategy();
-    }
-
-    private void registerSchemaContextListener(final RIBImpl rib) {
-        final DOMDataBroker domBroker = getDomDataProviderDependency();
-        if(domBroker instanceof SchemaService) {
-            ((SchemaService) domBroker).registerSchemaContextListener(rib);
-        } else {
-            // FIXME:Get bundle context and register global schema service from bundle
-            // context.
-            bundleContext.registerService(SchemaContextListener.class, rib, new Hashtable<String,String>());
-        }
-    }
-
-    private Map<TablesKey, PathSelectionMode> mapBestPathSelectionStrategyByFamily(final List<BGPBestPathSelection> bestPathSelectionDependency) {
-        return Collections.unmodifiableMap(bestPathSelectionDependency.stream().collect(
-            Collectors.toMap(st -> new TablesKey(st.getAfi(), st.getSafi()), st -> st.getStrategy())));
+        final WaitingServiceTracker<BgpDeployer> bgpDeployerTracker =
+                WaitingServiceTracker.create(BgpDeployer.class, this.bundleContext);
+        final BgpDeployer bgpDeployer = bgpDeployerTracker.waitForService(WaitingServiceTracker.FIVE_MINUTES);
+        //map configuration to OpenConfig BGP
+        final Protocol protocol = bgpDeployer.getMappingService().fromRib(getBgpRibId(), getClusterId(), getRibId(), new AsNumber(getLocalAs()), getLocalTableDependency(),
+                mapBestPathSelectionStrategyByFamily(getRibPathSelectionModeDependency()));
+        //write to configuration DS
+        final KeyedInstanceIdentifier<Protocol, ProtocolKey> protocolIId = bgpDeployer.getInstanceIdentifier().child(Protocols.class).child(Protocol.class,
+                protocol.getKey());
+        bgpDeployer.writeConfiguration(protocol, protocolIId);
+        //get rib instance service, use filter
+        final WaitingServiceTracker<RIB> ribTracker = WaitingServiceTracker.create(RIB.class,
+                this.bundleContext, "(" + InstanceType.RIB.getBeanName() + "=" + getRibId().getValue() + ")");
+        final RIB rib = ribTracker.waitForService(WaitingServiceTracker.FIVE_MINUTES);
+        final RIBImplRuntimeRegistration register = getRootRuntimeBeanRegistratorWrapper().register(rib.getRenderStats());
+        return Reflection.newProxy(AutoCloseableRIB.class, new AbstractInvocationHandler() {
+            @Override
+            protected Object handleInvocation(final Object proxy, final Method method, final Object[] args) throws Throwable {
+                if (method.getName().equals("close")) {
+                    register.close();
+                    bgpDeployerTracker.close();
+                    ribTracker.close();
+                    return null;
+                } else {
+                    return method.invoke(rib, args);
+                }
+            }
+        });
     }
 
     public void setBundleContext(final BundleContext bundleContext) {
         this.bundleContext = bundleContext;
     }
 
-    private BGPOpenconfigMapper<BGPRibInstanceConfiguration> getGlobalWriter() {
-        if (getOpenconfigProviderDependency() != null) {
-            return getOpenconfigProviderDependency().getOpenConfigMapper(BGPRibInstanceConfiguration.class);
-        }
-        return null;
+    private Map<TablesKey, PathSelectionMode> mapBestPathSelectionStrategyByFamily(final List<BGPBestPathSelection> bestPathSelectionDependency) {
+        return Collections.unmodifiableMap(bestPathSelectionDependency.stream().collect(
+                Collectors.<BGPBestPathSelection, TablesKey, PathSelectionMode>toMap(st -> new TablesKey(st.getAfi(), st.getSafi()), st -> st.getStrategy())));
     }
 
-    private final class RIBImplModuleTracker implements BGPConfigModuleTracker {
-
-        private final BGPOpenconfigMapper<BGPRibInstanceConfiguration> globalWriter;
-        private final BGPRibInstanceConfiguration bgpRibConfig;
-
-        public RIBImplModuleTracker(final BGPOpenconfigMapper<BGPRibInstanceConfiguration> globalWriter) {
-            this.globalWriter = globalWriter;
-            final InstanceConfigurationIdentifier identifier = new InstanceConfigurationIdentifier(getIdentifier().getInstanceName());
-            final List<BgpTableType> tableDependency = getLocalTableDependency();
-            this.bgpRibConfig = new BGPRibInstanceConfiguration(identifier, getLocalAs(), getBgpRibId(), getClusterId(), tableDependency,
-                    mapBestPathSelectionStrategyByFamily(getRibPathSelectionModeDependency()));
-        }
-
-        @Override
-        public void onInstanceCreate() {
-            if (globalWriter != null) {
-                globalWriter.writeConfiguration(this.bgpRibConfig);
-            }
-        }
-
-        @Override
-        public void onInstanceClose() {
-            if (globalWriter != null) {
-                globalWriter.removeConfiguration(this.bgpRibConfig);
-            }
-        }
-
+    private static interface AutoCloseableRIB extends RIB, AutoCloseable {
     }
 
 

diff --git a/bgp/rib-impl/src/main/java/org/opendaylight/controller/config/yang/bgp/rib/impl/RIBImplModuleFactory.java b/bgp/rib-impl/src/main/java/org/opendaylight/controller/config/yang/bgp/rib/impl/RIBImplModuleFactory.java
index b689e14b566ed9f2cdf7629826aa44041a72f69c..78cf16192b3932f05a4626932658aabbdd7a8525 100644 (file)
--- a/bgp/rib-impl/src/main/java/org/opendaylight/controller/config/yang/bgp/rib/impl/RIBImplModuleFactory.java
+++ b/bgp/rib-impl/src/main/java/org/opendaylight/controller/config/yang/bgp/rib/impl/RIBImplModuleFactory.java
@@ -22,23 +22,22 @@ import org.opendaylight.controller.config.spi.Module;
 import org.osgi.framework.BundleContext;
 
 /**
-*
-*/
+ *
+ */
+@Deprecated
 public class RIBImplModuleFactory extends org.opendaylight.controller.config.yang.bgp.rib.impl.AbstractRIBImplModuleFactory {
 
-    // FIXME: Remove this once DataBroker exports schema context
     @Override
-    public Module createModule(String instanceName, DependencyResolver dependencyResolver, BundleContext bundleContext) {
-        RIBImplModule module = (RIBImplModule) super.createModule(instanceName, dependencyResolver, bundleContext);
+    public Module createModule(final String instanceName, final DependencyResolver dependencyResolver, final BundleContext bundleContext) {
+        final RIBImplModule module = (RIBImplModule) super.createModule(instanceName, dependencyResolver, bundleContext);
         module.setBundleContext(bundleContext);
         return module;
     }
 
-    // FIXME: Remove this once DataBroker exports schema context
     @Override
-    public Module createModule(String instanceName, DependencyResolver dependencyResolver,
-            DynamicMBeanWithInstance old, BundleContext bundleContext) throws Exception {
-        RIBImplModule module = (RIBImplModule)  super.createModule(instanceName, dependencyResolver, old, bundleContext);
+    public Module createModule(final String instanceName, final DependencyResolver dependencyResolver,
+            final DynamicMBeanWithInstance old, final BundleContext bundleContext) throws Exception {
+        final RIBImplModule module = (RIBImplModule)  super.createModule(instanceName, dependencyResolver, old, bundleContext);
         module.setBundleContext(bundleContext);
         return module;
     }

diff --git a/bgp/rib-impl/src/main/java/org/opendaylight/protocol/bgp/rib/impl/config/BgpDeployerImpl.java b/bgp/rib-impl/src/main/java/org/opendaylight/protocol/bgp/rib/impl/config/BgpDeployerImpl.java
index 0b53f13549b8b32add83e9063628ebefd8a4778f..34348a46e587ec6479148c047e74fd1a5b881c71 100644 (file)
--- a/bgp/rib-impl/src/main/java/org/opendaylight/protocol/bgp/rib/impl/config/BgpDeployerImpl.java
+++ b/bgp/rib-impl/src/main/java/org/opendaylight/protocol/bgp/rib/impl/config/BgpDeployerImpl.java
@@ -10,10 +10,12 @@ package org.opendaylight.protocol.bgp.rib.impl.config;
 
 import static org.opendaylight.protocol.bgp.rib.impl.config.OpenConfigMappingUtil.getRibInstanceName;
 
+import com.google.common.base.Optional;
 import com.google.common.base.Preconditions;
 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.ListenableFuture;
 import java.util.Collection;
 import java.util.Dictionary;
 import java.util.HashMap;
@@ -25,8 +27,10 @@ import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
 import org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener;
 import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
 import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
+import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
 import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
 import org.opendaylight.protocol.bgp.openconfig.spi.BGPOpenConfigMappingService;
 import org.opendaylight.protocol.bgp.rib.impl.spi.BgpDeployer;
@@ -64,8 +68,11 @@ public final class BgpDeployerImpl implements BgpDeployer, DataTreeChangeListene
     @GuardedBy("this")
     private boolean closed;
 
+    private final DataBroker dataBroker;
+
     public BgpDeployerImpl(final String networkInstanceName, final BlueprintContainer container, final BundleContext bundleContext, final DataBroker dataBroker,
             final BGPOpenConfigMappingService mappingService) {
+        this.dataBroker = Preconditions.checkNotNull(dataBroker);
         this.container = Preconditions.checkNotNull(container);
         this.bundleContext = Preconditions.checkNotNull(bundleContext);
         this.mappingService = Preconditions.checkNotNull(mappingService);
@@ -190,4 +197,39 @@ public final class BgpDeployerImpl implements BgpDeployer, DataTreeChangeListene
         registerRibInstance(ribImpl, ribInstanceName);
     }
 
+    @Override
+    public <T extends DataObject> ListenableFuture<Void> writeConfiguration(final T data,
+            final InstanceIdentifier<T> identifier) {
+        final ReadWriteTransaction wTx = this.dataBroker.newReadWriteTransaction();
+        final CheckedFuture<Optional<T>, ReadFailedException> readFuture = wTx.read(LogicalDatastoreType.CONFIGURATION, identifier);
+        Futures.addCallback(readFuture, new FutureCallback<Optional<T>>() {
+            @Override
+            public void onSuccess(final Optional<T> result) {
+                if (!result.isPresent()) {
+                    wTx.put(LogicalDatastoreType.CONFIGURATION, identifier, data);
+                }
+            }
+            @Override
+            public void onFailure(final Throwable t) {
+                LOG.debug("Failed to ensure presence of {}, try to write configuration.", identifier, t);
+                wTx.put(LogicalDatastoreType.CONFIGURATION, identifier, data);
+            }
+        });
+        return wTx.submit();
+
+    }
+
+    @Override
+    public <T extends DataObject> ListenableFuture<Void> removeConfiguration(
+            final InstanceIdentifier<T> identifier) {
+        final WriteTransaction wTx = this.dataBroker.newWriteOnlyTransaction();
+        wTx.delete(LogicalDatastoreType.CONFIGURATION, identifier);
+        return wTx.submit();
+    }
+
+    @Override
+    public BGPOpenConfigMappingService getMappingService() {
+        return this.mappingService;
+    }
+
 }

diff --git a/bgp/rib-impl/src/main/java/org/opendaylight/protocol/bgp/rib/impl/spi/BgpDeployer.java b/bgp/rib-impl/src/main/java/org/opendaylight/protocol/bgp/rib/impl/spi/BgpDeployer.java
index 7bfd76f2861a8723fbb200160522e5f177fa9664..d5dc75f3eb2af1e8659bd0f0a860781388b47e77 100644 (file)
--- a/bgp/rib-impl/src/main/java/org/opendaylight/protocol/bgp/rib/impl/spi/BgpDeployer.java
+++ b/bgp/rib-impl/src/main/java/org/opendaylight/protocol/bgp/rib/impl/spi/BgpDeployer.java
@@ -8,7 +8,10 @@
 
 package org.opendaylight.protocol.bgp.rib.impl.spi;
 
+import com.google.common.util.concurrent.ListenableFuture;
+import org.opendaylight.protocol.bgp.openconfig.spi.BGPOpenConfigMappingService;
 import org.opendaylight.yang.gen.v1.http.openconfig.net.yang.network.instance.rev151018.network.instance.top.network.instances.NetworkInstance;
+import org.opendaylight.yangtools.yang.binding.DataObject;
 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
 
 /**
@@ -25,4 +28,9 @@ public interface BgpDeployer {
      */
     InstanceIdentifier<NetworkInstance> getInstanceIdentifier();
 
+    BGPOpenConfigMappingService getMappingService();
+
+    <T extends DataObject> ListenableFuture<Void> writeConfiguration(T data, InstanceIdentifier<T> identifier);
+
+    <T extends DataObject> ListenableFuture<Void> removeConfiguration(InstanceIdentifier<T> identifier);
 }

diff --git a/bgp/rib-impl/src/main/java/org/opendaylight/protocol/bgp/rib/impl/stats/rib/impl/BGPRenderStats.java b/bgp/rib-impl/src/main/java/org/opendaylight/protocol/bgp/rib/impl/stats/rib/impl/BGPRenderStats.java
index aec38891fe8a9f4d17317cd6e84ff734bb1c81b8..6648bf9b1c74946dbd4ed7a5628b7584a1425f8e 100644 (file)
--- a/bgp/rib-impl/src/main/java/org/opendaylight/protocol/bgp/rib/impl/stats/rib/impl/BGPRenderStats.java
+++ b/bgp/rib-impl/src/main/java/org/opendaylight/protocol/bgp/rib/impl/stats/rib/impl/BGPRenderStats.java
@@ -7,15 +7,14 @@
  */
 package org.opendaylight.protocol.bgp.rib.impl.stats.rib.impl;
 
-import org.opendaylight.controller.config.yang.bgp.rib.impl.BgpRenderState;
+import org.opendaylight.controller.config.yang.bgp.rib.impl.RIBImplRuntimeMXBean;
 import org.opendaylight.protocol.bgp.rib.impl.stats.UnsignedInt32Counter;
 import org.opendaylight.protocol.bgp.rib.impl.stats.peer.route.PerTableTypeRouteCounter;
 
 /**
  * @author Kevin Wang
  */
-public interface BGPRenderStats {
-    BgpRenderState getBgpRenderState();
+public interface BGPRenderStats extends RIBImplRuntimeMXBean {
 
     PerTableTypeRouteCounter getLocRibRouteCounter();
 

diff --git a/bgp/rib-impl/src/main/java/org/opendaylight/protocol/bgp/rib/impl/stats/rib/impl/RIBImplRuntimeMXBeanImpl.java b/bgp/rib-impl/src/main/java/org/opendaylight/protocol/bgp/rib/impl/stats/rib/impl/RIBImplRuntimeMXBeanImpl.java
index c6870ce4a17c0f5f9d01031160436336ddff2f69..4d9894f5a2cd820160b51074b50f8a1d9463bc0e 100644 (file)
--- a/bgp/rib-impl/src/main/java/org/opendaylight/protocol/bgp/rib/impl/stats/rib/impl/RIBImplRuntimeMXBeanImpl.java
+++ b/bgp/rib-impl/src/main/java/org/opendaylight/protocol/bgp/rib/impl/stats/rib/impl/RIBImplRuntimeMXBeanImpl.java
@@ -10,7 +10,6 @@ package org.opendaylight.protocol.bgp.rib.impl.stats.rib.impl;
 import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
 import org.opendaylight.controller.config.yang.bgp.rib.impl.BgpRenderState;
-import org.opendaylight.controller.config.yang.bgp.rib.impl.RIBImplRuntimeMXBean;
 import org.opendaylight.protocol.bgp.rib.impl.stats.UnsignedInt32Counter;
 import org.opendaylight.protocol.bgp.rib.impl.stats.peer.route.PerTableTypeRouteCounter;
 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.AsNumber;
@@ -21,11 +20,11 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.type
 /**
  * @author Kevin Wang
  */
-public class RIBImplRuntimeMXBeanImpl implements BGPRenderStats, RIBImplRuntimeMXBean {
+public class RIBImplRuntimeMXBeanImpl implements BGPRenderStats {
     private final BGPRenderStats renderStats;
 
     public RIBImplRuntimeMXBeanImpl(@Nonnull final BgpId bgpId, @Nonnull final RibId ribId, @Nonnull final AsNumber localAs, @Nullable final ClusterIdentifier clusterId) {
-        renderStats = new BGPRenderStatsImpl(bgpId, ribId, localAs, clusterId);
+        this.renderStats = new BGPRenderStatsImpl(bgpId, ribId, localAs, clusterId);
     }
 
     @Override

diff --git a/bgp/rib-impl/src/main/yang/odl-bgp-rib-impl-cfg.yang b/bgp/rib-impl/src/main/yang/odl-bgp-rib-impl-cfg.yang
index d92c4277f2a2d8436075da9d64e1825a993b2b7c..ac0502f586fc28b0ba3d8e949da513d6afeb7012 100644 (file)
--- a/bgp/rib-impl/src/main/yang/odl-bgp-rib-impl-cfg.yang
+++ b/bgp/rib-impl/src/main/yang/odl-bgp-rib-impl-cfg.yang
@@ -74,6 +74,7 @@ module odl-bgp-rib-impl-cfg {
 
         base "config:service-type";
         config:java-class "org.opendaylight.protocol.bgp.rib.impl.spi.RIB";
+        config:disable-osgi-service-registration;
     }
 
     identity bgp-peer-registry {

diff --git a/bgp/rib-impl/src/test/java/org/opendaylight/controller/config/yang/bgp/rib/impl/AbstractRIBImplModuleTest.java b/bgp/rib-impl/src/test/java/org/opendaylight/controller/config/yang/bgp/rib/impl/AbstractRIBImplModuleTest.java
index 1d65554a2b8757dca13e7f9861de6652b9d0e492..1d797879b68754132296256da7c890775c193d74 100755 (executable)
--- a/bgp/rib-impl/src/test/java/org/opendaylight/controller/config/yang/bgp/rib/impl/AbstractRIBImplModuleTest.java
+++ b/bgp/rib-impl/src/test/java/org/opendaylight/controller/config/yang/bgp/rib/impl/AbstractRIBImplModuleTest.java
@@ -15,6 +15,7 @@ import static org.mockito.Mockito.doAnswer;
 import static org.mockito.Mockito.doNothing;
 import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.mock;
+
 import com.google.common.base.Optional;
 import com.google.common.collect.Lists;
 import com.google.common.io.ByteSource;
@@ -30,7 +31,6 @@ import java.net.URL;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
-import java.util.Dictionary;
 import java.util.List;
 import javax.management.InstanceAlreadyExistsException;
 import javax.management.InstanceNotFoundException;
@@ -42,8 +42,6 @@ import org.mockito.Matchers;
 import org.mockito.Mock;
 import org.mockito.Mockito;
 import org.mockito.MockitoAnnotations;
-import org.mockito.invocation.InvocationOnMock;
-import org.mockito.stubbing.Answer;
 import org.opendaylight.controller.config.api.jmx.CommitStatus;
 import org.opendaylight.controller.config.manager.impl.AbstractConfigTest;
 import org.opendaylight.controller.config.manager.impl.factoriesresolver.HardcodedModuleFactoriesResolver;
@@ -76,31 +74,49 @@ import org.opendaylight.controller.md.sal.binding.impl.BindingToNormalizedNodeCo
 import org.opendaylight.controller.md.sal.common.api.TransactionStatus;
 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
 import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
+import org.opendaylight.controller.md.sal.dom.api.DOMDataTreeChangeService;
+import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
 import org.opendaylight.controller.md.sal.dom.api.DOMMountPointService;
 import org.opendaylight.controller.md.sal.dom.api.DOMNotificationPublishService;
 import org.opendaylight.controller.md.sal.dom.api.DOMNotificationService;
 import org.opendaylight.controller.md.sal.dom.api.DOMRpcProviderService;
 import org.opendaylight.controller.md.sal.dom.api.DOMRpcService;
+import org.opendaylight.controller.md.sal.dom.api.DOMTransactionChain;
 import org.opendaylight.controller.sal.core.api.model.SchemaService;
 import org.opendaylight.controller.sal.core.api.model.YangTextSourceProvider;
+import org.opendaylight.protocol.bgp.openconfig.spi.BGPOpenConfigMappingService;
 import org.opendaylight.protocol.bgp.parser.spi.BGPExtensionProviderContext;
 import org.opendaylight.protocol.bgp.parser.spi.MessageRegistry;
 import org.opendaylight.protocol.bgp.rib.impl.StrictBGPPeerRegistry;
 import org.opendaylight.protocol.bgp.rib.impl.spi.BGPDispatcher;
 import org.opendaylight.protocol.bgp.rib.impl.spi.BGPPeerRegistry;
+import org.opendaylight.protocol.bgp.rib.impl.spi.BgpDeployer;
+import org.opendaylight.protocol.bgp.rib.impl.spi.ImportPolicyPeerTracker;
+import org.opendaylight.protocol.bgp.rib.impl.spi.RIB;
+import org.opendaylight.protocol.bgp.rib.impl.spi.RIBSupportContextRegistry;
+import org.opendaylight.protocol.bgp.rib.impl.stats.UnsignedInt32Counter;
+import org.opendaylight.protocol.bgp.rib.impl.stats.rib.impl.BGPRenderStats;
 import org.opendaylight.protocol.bgp.rib.spi.RIBExtensionProviderContext;
 import org.opendaylight.protocol.bgp.rib.spi.SimpleRIBExtensionProviderContext;
+import org.opendaylight.yang.gen.v1.http.openconfig.net.yang.network.instance.rev151018.network.instance.top.NetworkInstances;
+import org.opendaylight.yang.gen.v1.http.openconfig.net.yang.network.instance.rev151018.network.instance.top.network.instances.NetworkInstance;
+import org.opendaylight.yang.gen.v1.http.openconfig.net.yang.network.instance.rev151018.network.instance.top.network.instances.NetworkInstanceKey;
+import org.opendaylight.yang.gen.v1.http.openconfig.net.yang.network.instance.rev151018.network.instance.top.network.instances.network.instance.protocols.ProtocolBuilder;
+import org.opendaylight.yang.gen.v1.http.openconfig.net.yang.network.instance.rev151018.network.instance.top.network.instances.network.instance.protocols.ProtocolKey;
+import org.opendaylight.yang.gen.v1.http.openconfig.net.yang.policy.types.rev151009.BGP;
 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.AsNumber;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev130925.BgpRib;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev130925.RibId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev130925.bgp.rib.Rib;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev130925.bgp.rib.RibKey;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev130919.BgpId;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev130919.ClusterIdentifier;
 import org.opendaylight.yangtools.concepts.ListenerRegistration;
 import org.opendaylight.yangtools.sal.binding.generator.api.ClassLoadingStrategy;
 import org.opendaylight.yangtools.sal.binding.generator.impl.GeneratedClassLoadingStrategy;
-import org.opendaylight.yangtools.yang.binding.DataObject;
 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
 import org.opendaylight.yangtools.yang.common.RpcResult;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
 import org.opendaylight.yangtools.yang.model.api.SchemaContextListener;
 import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
@@ -133,6 +149,9 @@ public abstract class AbstractRIBImplModuleTest extends AbstractConfigTest {
     private static final String COMPATIBLE_DATA_BROKER_INSTANCE_NAME = "binding-data-compatible-broker-instance";
     private static final String NOTIFICATION_BROKER_INSTANCE_NAME = "notification-broker-impl";
 
+    private static final InstanceIdentifier<NetworkInstance> OPENCONFIG_IID = InstanceIdentifier.create(NetworkInstances.class).child(NetworkInstance.class,
+            new NetworkInstanceKey("global-bgp"));
+
     @Mock
     private ReadWriteTransaction mockedTransaction;
 
@@ -148,6 +167,15 @@ public abstract class AbstractRIBImplModuleTest extends AbstractConfigTest {
     @Mock
     protected BGPDispatcher mockedBGPDispatcher;
 
+    @Mock
+    private RIB mockedRIB;
+
+    @Mock
+    private BgpDeployer bgpDeployer;
+
+    @Mock
+    private BGPOpenConfigMappingService bgpMappingService;
+
     @SuppressWarnings("unchecked")
     @Before
     public void setUp() throws Exception {
@@ -156,15 +184,12 @@ public abstract class AbstractRIBImplModuleTest extends AbstractConfigTest {
         final List<ModuleFactory> moduleFactories = getModuleFactories();
         super.initConfigTransactionManagerImpl(new HardcodedModuleFactoriesResolver(this.mockedContext, moduleFactories.toArray(new ModuleFactory[moduleFactories.size()])));
 
-        doAnswer(new Answer<Filter>() {
-            @Override
-            public Filter answer(final InvocationOnMock invocation) {
-                final String str = invocation.getArgumentAt(0, String.class);
-                final Filter mockFilter = mock(Filter.class);
-                doReturn(str).when(mockFilter).toString();
-                return mockFilter;
-            }
-        }).when(mockedContext).createFilter(anyString());
+        doAnswer(invocation -> {
+            final String str = invocation.getArgumentAt(0, String.class);
+            final Filter mockFilter = mock(Filter.class);
+            doReturn(str).when(mockFilter).toString();
+            return mockFilter;
+        }).when(this.mockedContext).createFilter(anyString());
 
         final ServiceReference<?> emptyServiceReference = mock(ServiceReference.class, "Empty");
         final ServiceReference<?> classLoadingStrategySR = mock(ServiceReference.class, "ClassLoadingStrategy");
@@ -184,7 +209,7 @@ public abstract class AbstractRIBImplModuleTest extends AbstractConfigTest {
         Mockito.doReturn("Data Provider Service Reference").when(dataProviderServiceReference).toString();
         Mockito.doReturn("Class loading stategy reference").when(classLoadingStrategySR).toString();
 
-        Mockito.doReturn(emptyServiceReference).when(this.mockedContext).getServiceReference(any(Class.class));
+        Mockito.doReturn(emptyServiceReference).when(this.mockedContext).getServiceReference(Mockito.anyString());
         Mockito.doReturn(dataProviderServiceReference).when(this.mockedContext).getServiceReference(DataBroker.class);
         Mockito.doReturn(classLoadingStrategySR).when(this.mockedContext).getServiceReference(GeneratedClassLoadingStrategy.class);
         Mockito.doReturn(classLoadingStrategySR).when(this.mockedContext).getServiceReference(ClassLoadingStrategy.class);
@@ -195,37 +220,35 @@ public abstract class AbstractRIBImplModuleTest extends AbstractConfigTest {
 
         Mockito.doReturn(this.mockedTransaction).when(this.mockedDataProvider).newReadWriteTransaction();
 
-        Mockito.doReturn(null).when(this.mockedTransaction).read(Mockito.eq(LogicalDatastoreType.OPERATIONAL), any(InstanceIdentifier.class));
-        Mockito.doNothing().when(this.mockedTransaction).put(Mockito.eq(LogicalDatastoreType.OPERATIONAL), any(InstanceIdentifier.class), any(DataObject.class));
+        Mockito.doReturn(null).when(this.mockedTransaction).read(Mockito.eq(LogicalDatastoreType.OPERATIONAL), Mockito.any());
+        Mockito.doNothing().when(this.mockedTransaction).put(Mockito.eq(LogicalDatastoreType.OPERATIONAL), Mockito.any(), Mockito.any());
         Mockito.doNothing().when(this.mockedTransaction).delete(Mockito.eq(LogicalDatastoreType.OPERATIONAL), any(InstanceIdentifier.class));
 
         Mockito.doReturn(this.mockedFuture).when(this.mockedTransaction).submit();
         Mockito.doReturn(TRANSACTION_NAME).when(this.mockedTransaction).getIdentifier();
 
         Mockito.doReturn(null).when(this.mockedFuture).get();
+        Mockito.doReturn(null).when(this.mockedFuture).checkedGet();
 
         final SchemaContext context = parseYangStreams(getFilesAsByteSources(getYangModelsPaths()));
         final SchemaService mockedSchemaService = mock(SchemaService.class);
         doReturn(context).when(mockedSchemaService).getGlobalContext();
-        doAnswer(new Answer<ListenerRegistration<SchemaContextListener>>() {
-            @Override
-            public ListenerRegistration<SchemaContextListener> answer(InvocationOnMock invocation) {
-                invocation.getArgumentAt(0, SchemaContextListener.class).onGlobalContextUpdated(context);
-                ListenerRegistration<SchemaContextListener> reg = mock(ListenerRegistration.class);
-                doNothing().when(reg).close();
-                return reg;
-            }
+        doAnswer(invocation -> {
+            invocation.getArgumentAt(0, SchemaContextListener.class).onGlobalContextUpdated(context);
+            final ListenerRegistration<SchemaContextListener> reg = mock(ListenerRegistration.class);
+            doNothing().when(reg).close();
+            return reg;
         }).when(mockedSchemaService).registerSchemaContextListener(any(SchemaContextListener.class));
 
         setupMockService(SchemaService.class, mockedSchemaService);
         setupMockService(YangTextSourceProvider.class, mock(YangTextSourceProvider.class));
 
-        BindingToNormalizedNodeCodec bindingCodec = BindingToNormalizedNodeCodecFactory.newInstance(
+        final BindingToNormalizedNodeCodec bindingCodec = BindingToNormalizedNodeCodecFactory.newInstance(
                 GeneratedClassLoadingStrategy.getTCCLClassLoadingStrategy());
         BindingToNormalizedNodeCodecFactory.registerInstance(bindingCodec, mockedSchemaService);
         setupMockService(BindingToNormalizedNodeCodec.class, bindingCodec);
 
-        BGPExtensionProviderContext mockContext = mock(BGPExtensionProviderContext.class);
+        final BGPExtensionProviderContext mockContext = mock(BGPExtensionProviderContext.class);
         doReturn(mock(MessageRegistry.class)).when(mockContext).getMessageRegistry();
         setupMockService(BGPExtensionProviderContext.class, mockContext);
 
@@ -238,10 +261,48 @@ public abstract class AbstractRIBImplModuleTest extends AbstractConfigTest {
         setupMockService(DOMRpcProviderService.class, mock(DOMRpcProviderService.class));
         setupMockService(DOMMountPointService.class, mock(DOMMountPointService.class));
 
-        setupMockService(BGPDispatcher.class, mockedBGPDispatcher);
-        doReturn(new SucceededFuture<>(ImmediateEventExecutor.INSTANCE, null)).when(mockedBGPDispatcher).createReconnectingClient(
+        setupMockService(BGPDispatcher.class, this.mockedBGPDispatcher);
+        doReturn(new SucceededFuture<>(ImmediateEventExecutor.INSTANCE, null)).when(this.mockedBGPDispatcher).createReconnectingClient(
                 any(InetSocketAddress.class), any(BGPPeerRegistry.class), anyInt(), any(Optional.class));
 
+        setupMockService(BgpDeployer.class, this.bgpDeployer);
+        doReturn(new ProtocolBuilder().setKey(new ProtocolKey(BGP.class, "bgp")).build()).when(this.bgpMappingService).fromRib(any(), any(), any(), any(), any(), any());
+        doReturn(this.mockedFuture).when(this.bgpDeployer).writeConfiguration(any(), any());
+        doReturn(this.mockedFuture).when(this.bgpDeployer).removeConfiguration(any());
+        doReturn(this.bgpMappingService).when(this.bgpDeployer).getMappingService();
+        doReturn(OPENCONFIG_IID).when(this.bgpDeployer).getInstanceIdentifier();
+        final DOMTransactionChain mockedChain = mock(DOMTransactionChain.class);
+        final DOMDataWriteTransaction mockedWTx = mock(DOMDataWriteTransaction.class);
+        doNothing().when(mockedWTx).put(any(), any(), any());
+        doNothing().when(mockedWTx).delete(any(), any());
+        doReturn(this.mockedFuture).when(mockedWTx).submit();
+        doReturn(mockedWTx).when(mockedChain).newWriteOnlyTransaction();
+        doReturn(mockedChain).when(this.mockedRIB).createPeerChain(any());
+        doNothing().when(mockedChain).close();
+        doReturn(YangInstanceIdentifier.of(BgpRib.QNAME)).when(this.mockedRIB).getYangRibId();
+        doReturn(new AsNumber(123456l)).when(this.mockedRIB).getLocalAs();
+        doReturn(BGP_ID).when(this.mockedRIB).getBgpIdentifier();
+        doReturn(Optional.absent()).when(this.mockedRIB).getOpenConfigProvider();
+        final BGPRenderStats mockedRenderStats = mock(BGPRenderStats.class);
+        doReturn(new UnsignedInt32Counter("counter")).when(mockedRenderStats).getConfiguredPeerCounter();
+        doReturn(mockedRenderStats).when(this.mockedRIB).getRenderStats();
+        final DOMDataTreeChangeService mockedTreeChangeService = mock(DOMDataTreeChangeService.class);
+        final ListenerRegistration mockedListenerReg = mock(ListenerRegistration.class);
+        doNothing().when(mockedListenerReg).close();
+        doReturn(mockedListenerReg).when(mockedTreeChangeService).registerDataTreeChangeListener(any(), any());
+        doReturn(mockedTreeChangeService).when(this.mockedRIB).getService();
+        final ImportPolicyPeerTracker mockedImportPolicy = mock(ImportPolicyPeerTracker.class);
+        doNothing().when(mockedImportPolicy).peerRoleChanged(any(), any());
+        doReturn(null).when(mockedImportPolicy).policyFor(any());
+        doReturn(mockedImportPolicy).when(this.mockedRIB).getImportPolicyPeerTracker();
+        doReturn(mock(RIBSupportContextRegistry.class)).when(this.mockedRIB).getRibSupportContext();
+        doReturn(Collections.emptySet()).when(this.mockedRIB).getLocalTablesKeys();
+        doReturn(Collections.emptySet()).when(this.mockedRIB).getLocalTables();
+        doReturn(this.mockedBGPDispatcher).when(this.mockedRIB).getDispatcher();
+        doReturn(InstanceIdentifier.create(BgpRib.class).child(Rib.class, new RibKey(RIB_ID))).when(this.mockedRIB).getInstanceIdentifier();
+
+        setupMockService(RIB.class, this.mockedRIB);
+
         setupMockService(RIBExtensionProviderContext.class, new SimpleRIBExtensionProviderContext());
 
         setupMockService(BGPPeerRegistry.class, StrictBGPPeerRegistry.GLOBAL);
@@ -249,11 +310,11 @@ public abstract class AbstractRIBImplModuleTest extends AbstractConfigTest {
 
     protected void setupMockService(final Class<?> serviceInterface, final Object instance) throws Exception {
         final ServiceReference<?> mockServiceRef = mock(ServiceReference.class);
-        doReturn(new ServiceReference[]{mockServiceRef}).when(mockedContext).
-                getServiceReferences(anyString(), contains(serviceInterface.getName()));
-        doReturn(new ServiceReference[]{mockServiceRef}).when(mockedContext).
-                getServiceReferences(serviceInterface.getName(), null);
-        doReturn(instance).when(mockedContext).getService(mockServiceRef);
+        doReturn(new ServiceReference[]{mockServiceRef}).when(this.mockedContext).
+        getServiceReferences(anyString(), contains(serviceInterface.getName()));
+        doReturn(new ServiceReference[]{mockServiceRef}).when(this.mockedContext).
+        getServiceReferences(serviceInterface.getName(), null);
+        doReturn(instance).when(this.mockedContext).getService(mockServiceRef);
     }
 
     private static SchemaContext parseYangStreams(final Collection<ByteSource> streams) {
@@ -279,13 +340,10 @@ public abstract class AbstractRIBImplModuleTest extends AbstractConfigTest {
     @Override
     protected BundleContextServiceRegistrationHandler getBundleContextServiceRegistrationHandler(final Class<?> serviceType) {
         if (serviceType.equals(SchemaContextListener.class)) {
-            return new BundleContextServiceRegistrationHandler() {
-                @Override
-                public void handleServiceRegistration(final Class<?> clazz, final Object serviceInstance, final Dictionary<String, ?> props) {
-                    final SchemaContextListener listener = (SchemaContextListener) serviceInstance;
-                    final SchemaContext context = parseYangStreams(getFilesAsByteSources(getYangModelsPaths()));
-                    listener.onGlobalContextUpdated(context);
-                }
+            return (clazz, serviceInstance, props) -> {
+                final SchemaContextListener listener = (SchemaContextListener) serviceInstance;
+                final SchemaContext context = parseYangStreams(getFilesAsByteSources(getYangModelsPaths()));
+                listener.onGlobalContextUpdated(context);
             };
         }
 
@@ -421,7 +479,7 @@ public abstract class AbstractRIBImplModuleTest extends AbstractConfigTest {
     }
 
     public ObjectName createBindingBrokerImpl(final ConfigTransactionJMXClient transaction, final ObjectName dataBrokerON,
-        final ObjectName notificationBrokerON) throws Exception {
+            final ObjectName notificationBrokerON) throws Exception {
         final ObjectName objectName = transaction.createModule(BindingBrokerImplModuleFactory.NAME, BINDING_BROKER_INSTANCE_NAME);
         final BindingBrokerImplModuleMXBean mxBean = transaction.newMXBeanProxy(objectName, BindingBrokerImplModuleMXBean.class);
         mxBean.setDataBroker(dataBrokerON);
@@ -447,7 +505,7 @@ public abstract class AbstractRIBImplModuleTest extends AbstractConfigTest {
     }
 
     public ObjectName createCompatibleDataBrokerInstance(final ConfigTransactionJMXClient transaction)
-        throws InstanceAlreadyExistsException, InstanceNotFoundException {
+            throws InstanceAlreadyExistsException, InstanceNotFoundException {
         final ObjectName nameCreated = transaction.createModule(ForwardedCompatibleDataBrokerImplModuleFactory.NAME, COMPATIBLE_DATA_BROKER_INSTANCE_NAME);
         final ForwardedCompatibleDataBrokerImplModuleMXBean mxBean = transaction.newMXBeanProxy(nameCreated, ForwardedCompatibleDataBrokerImplModuleMXBean.class);
         mxBean.setDataBroker(lookupDataBrokerInstance(transaction));