bgp/rib-impl/src/test/java/org/opendaylight/controller/config/yang/bgp/rib/impl/AbstractRIBImplModuleTest.java

   1 /*
   2  * Copyright (c) 2014 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 package org.opendaylight.controller.config.yang.bgp.rib.impl;
   9
  10 import static org.mockito.Matchers.any;
  11 import static org.mockito.Matchers.anyInt;
  12 import static org.mockito.Matchers.anyString;
  13 import static org.mockito.Matchers.contains;
  14 import static org.mockito.Mockito.doAnswer;
  15 import static org.mockito.Mockito.doNothing;
  16 import static org.mockito.Mockito.doReturn;
  17 import static org.mockito.Mockito.mock;
  18
  19 import com.google.common.base.Optional;
  20 import com.google.common.collect.Lists;
  21 import com.google.common.util.concurrent.CheckedFuture;
  22 import io.netty.channel.EventLoopGroup;
  23 import io.netty.util.concurrent.EventExecutor;
  24 import io.netty.util.concurrent.ImmediateEventExecutor;
  25 import io.netty.util.concurrent.SucceededFuture;
  26 import java.io.InputStream;
  27 import java.net.InetSocketAddress;
  28 import java.net.URL;
  29 import java.util.ArrayList;
  30 import java.util.Collection;
  31 import java.util.Collections;
  32 import java.util.List;
  33 import java.util.concurrent.atomic.LongAdder;
  34 import javax.management.InstanceAlreadyExistsException;
  35 import javax.management.InstanceNotFoundException;
  36 import javax.management.ObjectName;
  37 import org.junit.After;
  38 import org.junit.Assert;
  39 import org.junit.Before;
  40 import org.mockito.Matchers;
  41 import org.mockito.Mock;
  42 import org.mockito.Mockito;
  43 import org.mockito.MockitoAnnotations;
  44 import org.opendaylight.controller.config.api.jmx.CommitStatus;
  45 import org.opendaylight.controller.config.manager.impl.AbstractConfigTest;
  46 import org.opendaylight.controller.config.manager.impl.factoriesresolver.HardcodedModuleFactoriesResolver;
  47 import org.opendaylight.controller.config.spi.ModuleFactory;
  48 import org.opendaylight.controller.config.util.ConfigTransactionJMXClient;
  49 import org.opendaylight.controller.config.yang.bgp.rib.spi.RIBExtensionsImplModuleFactory;
  50 import org.opendaylight.controller.config.yang.bgp.rib.spi.RIBExtensionsImplModuleMXBean;
  51 import org.opendaylight.controller.config.yang.md.sal.binding.impl.BindingAsyncDataBrokerImplModuleFactory;
  52 import org.opendaylight.controller.config.yang.md.sal.binding.impl.BindingAsyncDataBrokerImplModuleMXBean;
  53 import org.opendaylight.controller.config.yang.md.sal.binding.impl.BindingBrokerImplModuleFactory;
  54 import org.opendaylight.controller.config.yang.md.sal.binding.impl.BindingBrokerImplModuleMXBean;
  55 import org.opendaylight.controller.config.yang.md.sal.binding.impl.ForwardedCompatibleDataBrokerImplModuleFactory;
  56 import org.opendaylight.controller.config.yang.md.sal.binding.impl.ForwardedCompatibleDataBrokerImplModuleMXBean;
  57 import org.opendaylight.controller.config.yang.md.sal.binding.impl.NotificationBrokerImplModuleFactory;
  58 import org.opendaylight.controller.config.yang.md.sal.binding.impl.RuntimeMappingModuleFactory;
  59 import org.opendaylight.controller.config.yang.md.sal.dom.impl.DomBrokerImplModuleFactory;
  60 import org.opendaylight.controller.config.yang.md.sal.dom.impl.DomBrokerImplModuleMXBean;
  61 import org.opendaylight.controller.config.yang.md.sal.dom.impl.DomInmemoryDataBrokerModuleFactory;
  62 import org.opendaylight.controller.config.yang.md.sal.dom.impl.DomInmemoryDataBrokerModuleMXBean;
  63 import org.opendaylight.controller.config.yang.md.sal.dom.impl.SchemaServiceImplSingletonModuleFactory;
  64 import org.opendaylight.controller.config.yang.netty.eventexecutor.AutoCloseableEventExecutor;
  65 import org.opendaylight.controller.config.yang.netty.eventexecutor.GlobalEventExecutorModuleFactory;
  66 import org.opendaylight.controller.config.yang.netty.threadgroup.NettyThreadgroupModuleFactory;
  67 import org.opendaylight.controller.config.yang.netty.threadgroup.NioEventLoopGroupCloseable;
  68 import org.opendaylight.controller.config.yang.netty.timer.HashedWheelTimerModuleFactory;
  69 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  70 import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
  71 import org.opendaylight.controller.md.sal.binding.impl.BindingToNormalizedNodeCodec;
  72 import org.opendaylight.controller.md.sal.binding.impl.BindingToNormalizedNodeCodecFactory;
  73 import org.opendaylight.controller.md.sal.common.api.TransactionStatus;
  74 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  75 import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
  76 import org.opendaylight.controller.md.sal.dom.api.DOMDataTreeChangeService;
  77 import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
  78 import org.opendaylight.controller.md.sal.dom.api.DOMMountPointService;
  79 import org.opendaylight.controller.md.sal.dom.api.DOMNotificationPublishService;
  80 import org.opendaylight.controller.md.sal.dom.api.DOMNotificationService;
  81 import org.opendaylight.controller.md.sal.dom.api.DOMRpcProviderService;
  82 import org.opendaylight.controller.md.sal.dom.api.DOMRpcService;
  83 import org.opendaylight.controller.md.sal.dom.api.DOMTransactionChain;
  84 import org.opendaylight.controller.sal.core.api.model.SchemaService;
  85 import org.opendaylight.controller.sal.core.api.model.YangTextSourceProvider;
  86 import org.opendaylight.protocol.bgp.openconfig.spi.BGPTableTypeRegistryConsumer;
  87 import org.opendaylight.protocol.bgp.parser.spi.BGPExtensionProviderContext;
  88 import org.opendaylight.protocol.bgp.parser.spi.MessageRegistry;
  89 import org.opendaylight.protocol.bgp.rib.impl.StrictBGPPeerRegistry;
  90 import org.opendaylight.protocol.bgp.rib.impl.spi.BGPDispatcher;
  91 import org.opendaylight.protocol.bgp.rib.impl.spi.BGPPeerRegistry;
  92 import org.opendaylight.protocol.bgp.rib.impl.spi.BgpDeployer;
  93 import org.opendaylight.protocol.bgp.rib.impl.spi.ImportPolicyPeerTracker;
  94 import org.opendaylight.protocol.bgp.rib.impl.spi.RIB;
  95 import org.opendaylight.protocol.bgp.rib.impl.spi.RIBSupportContextRegistry;
  96 import org.opendaylight.protocol.bgp.rib.impl.stats.rib.impl.BGPRenderStats;
  97 import org.opendaylight.protocol.bgp.rib.spi.RIBExtensionProviderContext;
  98 import org.opendaylight.protocol.bgp.rib.spi.SimpleRIBExtensionProviderContext;
  99 import org.opendaylight.yang.gen.v1.http.openconfig.net.yang.bgp.rev151009.bgp.top.Bgp;
 100 import org.opendaylight.yang.gen.v1.http.openconfig.net.yang.bgp.rev151009.bgp.top.bgp.Global;
 101 import org.opendaylight.yang.gen.v1.http.openconfig.net.yang.bgp.types.rev151009.IPV4UNICAST;
 102 import org.opendaylight.yang.gen.v1.http.openconfig.net.yang.network.instance.rev151018.network.instance.top.NetworkInstances;
 103 import org.opendaylight.yang.gen.v1.http.openconfig.net.yang.network.instance.rev151018.network.instance.top.network.instances.NetworkInstance;
 104 import org.opendaylight.yang.gen.v1.http.openconfig.net.yang.network.instance.rev151018.network.instance.top.network.instances.NetworkInstanceKey;
 105 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.AsNumber;
 106 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev130925.BgpRib;
 107 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev130925.RibId;
 108 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev130925.bgp.rib.Rib;
 109 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev130925.bgp.rib.RibKey;
 110 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev130919.BgpId;
 111 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev130919.ClusterIdentifier;
 112 import org.opendaylight.yangtools.concepts.ListenerRegistration;
 113 import org.opendaylight.yangtools.sal.binding.generator.api.ClassLoadingStrategy;
 114 import org.opendaylight.yangtools.sal.binding.generator.impl.GeneratedClassLoadingStrategy;
 115 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
 116 import org.opendaylight.yangtools.yang.common.RpcResult;
 117 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
 118 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
 119 import org.opendaylight.yangtools.yang.model.api.SchemaContextListener;
 120 import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
 121 import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
 122 import org.osgi.framework.Bundle;
 123 import org.osgi.framework.BundleListener;
 124 import org.osgi.framework.Filter;
 125 import org.osgi.framework.ServiceListener;
 126 import org.osgi.framework.ServiceReference;
 127
 128 public abstract class AbstractRIBImplModuleTest extends AbstractConfigTest {
 129
 130     private static final String INSTANCE_NAME = "rib-impl";
 131     private static final String FACTORY_NAME = RIBImplModuleFactory.NAME;
 132     private static final String TRANSACTION_NAME = "testTransaction";
 133
 134     protected static final RibId RIB_ID = new RibId("test");
 135     protected static final BgpId BGP_ID = new BgpId("192.168.1.1");
 136     protected static final ClusterIdentifier CLUSTER_ID = new ClusterIdentifier("192.168.1.2");
 137
 138     private static final AsNumber AS_NUMBER = new AsNumber(5000L);
 139     private static final String RIB_EXTENSIONS_INSTANCE_NAME = "rib-extensions-impl";
 140     private static final String DOM_BROKER_INSTANCE_NAME = "dom-broker-impl";
 141     private static final String BINDING_ASYNC_BROKER_INSTANCE_NAME = "binding-async-broker-instance";
 142     private static final String BINDING_BROKER_INSTANCE_NAME = "binding-broker-impl";
 143     private static final String COMPATIBLE_DATA_BROKER_INSTANCE_NAME = "binding-data-compatible-broker-instance";
 144     private static final String NOTIFICATION_BROKER_INSTANCE_NAME = "notification-broker-impl";
 145
 146     private static final InstanceIdentifier<NetworkInstance> OPENCONFIG_IID = InstanceIdentifier.create(NetworkInstances.class).child(NetworkInstance.class,
 147             new NetworkInstanceKey("global-bgp"));
 148
 149     @Mock
 150     private ReadWriteTransaction mockedTransaction;
 151
 152     @Mock
 153     private DataBroker mockedDataProvider;
 154
 155     @Mock
 156     private CheckedFuture<Void, TransactionCommitFailedException> mockedFuture;
 157
 158     @Mock
 159     private RpcResult<TransactionStatus> mockedResult;
 160
 161     @Mock
 162     protected BGPDispatcher mockedBGPDispatcher;
 163
 164     @Mock
 165     private RIB mockedRIB;
 166
 167     @Mock
 168     private BgpDeployer bgpDeployer;
 169
 170     @Mock
 171     private BGPTableTypeRegistryConsumer tableTypeREgistry;
 172
 173     @Mock
 174     private BGPPeerRuntimeMXBean mockedPeer;
 175
 176     @SuppressWarnings("unchecked")
 177     @Before
 178     public void setUp() throws Exception {
 179         MockitoAnnotations.initMocks(this);
 180
 181         final List<ModuleFactory> moduleFactories = getModuleFactories();
 182         super.initConfigTransactionManagerImpl(new HardcodedModuleFactoriesResolver(this.mockedContext, moduleFactories.toArray(new ModuleFactory[moduleFactories.size()])));
 183
 184         doAnswer(invocation -> {
 185             final String str = invocation.getArgumentAt(0, String.class);
 186             final Filter mockFilter = mock(Filter.class);
 187             doReturn(str).when(mockFilter).toString();
 188             return mockFilter;
 189         }).when(this.mockedContext).createFilter(anyString());
 190
 191         final ServiceReference<?> emptyServiceReference = mock(ServiceReference.class, "Empty");
 192         final ServiceReference<?> classLoadingStrategySR = mock(ServiceReference.class, "ClassLoadingStrategy");
 193         final ServiceReference<?> dataProviderServiceReference = mock(ServiceReference.class, "Data Provider");
 194
 195         Mockito.doNothing().when(this.mockedContext).addServiceListener(any(ServiceListener.class), Mockito.anyString());
 196         Mockito.doNothing().when(this.mockedContext).removeServiceListener(any(ServiceListener.class));
 197
 198         Mockito.doNothing().when(this.mockedContext).addBundleListener(any(BundleListener.class));
 199         Mockito.doNothing().when(this.mockedContext).removeBundleListener(any(BundleListener.class));
 200
 201         Mockito.doReturn(new Bundle[] {}).when(this.mockedContext).getBundles();
 202
 203         Mockito.doReturn(new ServiceReference[] {}).when(this.mockedContext).getServiceReferences(Matchers.anyString(), Matchers.anyString());
 204
 205         Mockito.doReturn("Empty reference").when(emptyServiceReference).toString();
 206         Mockito.doReturn("Data Provider Service Reference").when(dataProviderServiceReference).toString();
 207         Mockito.doReturn("Class loading stategy reference").when(classLoadingStrategySR).toString();
 208
 209         Mockito.doReturn(emptyServiceReference).when(this.mockedContext).getServiceReference(Mockito.anyString());
 210         Mockito.doReturn(dataProviderServiceReference).when(this.mockedContext).getServiceReference(DataBroker.class);
 211         Mockito.doReturn(classLoadingStrategySR).when(this.mockedContext).getServiceReference(GeneratedClassLoadingStrategy.class);
 212         Mockito.doReturn(classLoadingStrategySR).when(this.mockedContext).getServiceReference(ClassLoadingStrategy.class);
 213
 214         Mockito.doReturn(this.mockedDataProvider).when(this.mockedContext).getService(dataProviderServiceReference);
 215         Mockito.doReturn(GeneratedClassLoadingStrategy.getTCCLClassLoadingStrategy()).when(this.mockedContext).getService(classLoadingStrategySR);
 216         Mockito.doReturn(null).when(this.mockedContext).getService(emptyServiceReference);
 217
 218         Mockito.doReturn(this.mockedTransaction).when(this.mockedDataProvider).newReadWriteTransaction();
 219
 220         Mockito.doReturn(null).when(this.mockedTransaction).read(Mockito.eq(LogicalDatastoreType.OPERATIONAL), Mockito.any());
 221         Mockito.doNothing().when(this.mockedTransaction).put(Mockito.eq(LogicalDatastoreType.OPERATIONAL), Mockito.any(), Mockito.any());
 222         Mockito.doNothing().when(this.mockedTransaction).delete(Mockito.eq(LogicalDatastoreType.OPERATIONAL), any(InstanceIdentifier.class));
 223
 224         Mockito.doReturn(this.mockedFuture).when(this.mockedTransaction).submit();
 225         Mockito.doReturn(TRANSACTION_NAME).when(this.mockedTransaction).getIdentifier();
 226
 227         Mockito.doReturn(null).when(this.mockedFuture).get();
 228         Mockito.doReturn(null).when(this.mockedFuture).checkedGet();
 229
 230         final SchemaContext context = parseYangStreams(getFilesAsStreams(getYangModelsPaths()));
 231         final SchemaService mockedSchemaService = mock(SchemaService.class);
 232         doReturn(context).when(mockedSchemaService).getGlobalContext();
 233         doAnswer(invocation -> {
 234             invocation.getArgumentAt(0, SchemaContextListener.class).onGlobalContextUpdated(context);
 235             final ListenerRegistration<SchemaContextListener> reg = mock(ListenerRegistration.class);
 236             doNothing().when(reg).close();
 237             return reg;
 238         }).when(mockedSchemaService).registerSchemaContextListener(any(SchemaContextListener.class));
 239
 240         setupMockService(SchemaService.class, mockedSchemaService);
 241         setupMockService(YangTextSourceProvider.class, mock(YangTextSourceProvider.class));
 242
 243         final BindingToNormalizedNodeCodec bindingCodec = BindingToNormalizedNodeCodecFactory.newInstance(
 244                 GeneratedClassLoadingStrategy.getTCCLClassLoadingStrategy());
 245         BindingToNormalizedNodeCodecFactory.registerInstance(bindingCodec, mockedSchemaService);
 246         setupMockService(BindingToNormalizedNodeCodec.class, bindingCodec);
 247
 248         final BGPExtensionProviderContext mockContext = mock(BGPExtensionProviderContext.class);
 249         doReturn(mock(MessageRegistry.class)).when(mockContext).getMessageRegistry();
 250         setupMockService(BGPExtensionProviderContext.class, mockContext);
 251
 252         setupMockService(EventLoopGroup.class, NioEventLoopGroupCloseable.newInstance(0));
 253         setupMockService(EventExecutor.class, AutoCloseableEventExecutor.CloseableEventExecutorMixin.globalEventExecutor());
 254
 255         setupMockService(DOMNotificationService.class, mock(DOMNotificationService.class));
 256         setupMockService(DOMNotificationPublishService.class, mock(DOMNotificationPublishService.class));
 257         setupMockService(DOMRpcService.class, mock(DOMRpcService.class));
 258         setupMockService(DOMRpcProviderService.class, mock(DOMRpcProviderService.class));
 259         setupMockService(DOMMountPointService.class, mock(DOMMountPointService.class));
 260
 261         setupMockService(BGPDispatcher.class, this.mockedBGPDispatcher);
 262         doReturn(new SucceededFuture<>(ImmediateEventExecutor.INSTANCE, null)).when(this.mockedBGPDispatcher).createReconnectingClient(
 263                 any(InetSocketAddress.class), any(BGPPeerRegistry.class), anyInt(), any(Optional.class));
 264
 265         setupMockService(BgpDeployer.class, this.bgpDeployer);
 266         final Global global = mock(Global.class);
 267         final Bgp globalBgp = mock(Bgp.class);
 268         doReturn(global).when(globalBgp).getGlobal();
 269         doReturn("global").when(global).toString();
 270         doNothing().when(this.bgpDeployer).onGlobalModified(any(),any(),any());
 271         doNothing().when(this.bgpDeployer).onNeighborModified(any(),any(),any());
 272         doReturn(this.mockedFuture).when(this.bgpDeployer).writeConfiguration(any(), any());
 273         doReturn(this.mockedFuture).when(this.bgpDeployer).removeConfiguration(any());
 274         doReturn(java.util.Optional.of(IPV4UNICAST.class)).when(this.tableTypeREgistry).getAfiSafiType(any());
 275         doReturn(this.tableTypeREgistry).when(this.bgpDeployer).getTableTypeRegistry();
 276         doReturn(OPENCONFIG_IID).when(this.bgpDeployer).getInstanceIdentifier();
 277         final DOMTransactionChain mockedChain = mock(DOMTransactionChain.class);
 278         final DOMDataWriteTransaction mockedWTx = mock(DOMDataWriteTransaction.class);
 279         doNothing().when(mockedWTx).put(any(), any(), any());
 280         doNothing().when(mockedWTx).delete(any(), any());
 281         doReturn(this.mockedFuture).when(mockedWTx).submit();
 282         doReturn(mockedWTx).when(mockedChain).newWriteOnlyTransaction();
 283         doReturn(mockedChain).when(this.mockedRIB).createPeerChain(any());
 284         doNothing().when(mockedChain).close();
 285         doReturn(YangInstanceIdentifier.of(BgpRib.QNAME)).when(this.mockedRIB).getYangRibId();
 286         doReturn(new AsNumber(123456l)).when(this.mockedRIB).getLocalAs();
 287         doReturn(BGP_ID).when(this.mockedRIB).getBgpIdentifier();
 288         final BGPRenderStats mockedRenderStats = mock(BGPRenderStats.class);
 289         doReturn(new LongAdder()).when(mockedRenderStats).getConfiguredPeerCounter();
 290         doReturn(mockedRenderStats).when(this.mockedRIB).getRenderStats();
 291         final DOMDataTreeChangeService mockedTreeChangeService = mock(DOMDataTreeChangeService.class);
 292         final ListenerRegistration<?> mockedListenerReg = mock(ListenerRegistration.class);
 293         doNothing().when(mockedListenerReg).close();
 294         doReturn(mockedListenerReg).when(mockedTreeChangeService).registerDataTreeChangeListener(any(), any());
 295         doReturn(mockedTreeChangeService).when(this.mockedRIB).getService();
 296         final ImportPolicyPeerTracker mockedImportPolicy = mock(ImportPolicyPeerTracker.class);
 297         doNothing().when(mockedImportPolicy).peerRoleChanged(any(), any());
 298         doReturn(null).when(mockedImportPolicy).policyFor(any());
 299         doReturn(mockedImportPolicy).when(this.mockedRIB).getImportPolicyPeerTracker();
 300         doReturn(mock(RIBSupportContextRegistry.class)).when(this.mockedRIB).getRibSupportContext();
 301         doReturn(Collections.emptySet()).when(this.mockedRIB).getLocalTablesKeys();
 302         doReturn(Collections.emptySet()).when(this.mockedRIB).getLocalTables();
 303         doReturn(this.mockedBGPDispatcher).when(this.mockedRIB).getDispatcher();
 304         doReturn(InstanceIdentifier.create(BgpRib.class).child(Rib.class, new RibKey(RIB_ID))).when(this.mockedRIB).getInstanceIdentifier();
 305
 306         setupMockService(RIB.class, this.mockedRIB);
 307
 308         setupMockService(RIBExtensionProviderContext.class, new SimpleRIBExtensionProviderContext());
 309
 310         setupMockService(BGPPeerRegistry.class, StrictBGPPeerRegistry.GLOBAL);
 311
 312         setupMockService(BGPPeerRuntimeMXBean.class, this.mockedPeer);
 313     }
 314
 315     protected void setupMockService(final Class<?> serviceInterface, final Object instance) throws Exception {
 316         final ServiceReference<?> mockServiceRef = mock(ServiceReference.class);
 317         doReturn(new ServiceReference[]{mockServiceRef}).when(this.mockedContext).
 318         getServiceReferences(anyString(), contains(serviceInterface.getName()));
 319         doReturn(new ServiceReference[]{mockServiceRef}).when(this.mockedContext).
 320         getServiceReferences(serviceInterface.getName(), null);
 321         doReturn(instance).when(this.mockedContext).getService(mockServiceRef);
 322         doReturn("test").when(mockServiceRef).toString();
 323     }
 324
 325     private static SchemaContext parseYangStreams(final List<InputStream> streams) {
 326         try {
 327             return YangParserTestUtils.parseYangStreams(streams);
 328         } catch (final ReactorException e) {
 329             throw new RuntimeException("Unable to build schema context from " + streams, e);
 330         }
 331     }
 332
 333     protected List<ModuleFactory> getModuleFactories() {
 334         return Lists.newArrayList(new RIBImplModuleFactory(), new GlobalEventExecutorModuleFactory(),
 335                 new BGPDispatcherImplModuleFactory(), new NettyThreadgroupModuleFactory(),
 336                 new RIBExtensionsImplModuleFactory(), new DomBrokerImplModuleFactory(), new RuntimeMappingModuleFactory(),
 337                 new HashedWheelTimerModuleFactory(), new BindingAsyncDataBrokerImplModuleFactory(),
 338                 new DomInmemoryDataBrokerModuleFactory(), new SchemaServiceImplSingletonModuleFactory(),
 339                 new NotificationBrokerImplModuleFactory(), new ForwardedCompatibleDataBrokerImplModuleFactory(),
 340                 new BindingBrokerImplModuleFactory());
 341     }
 342
 343     @Override
 344     protected BundleContextServiceRegistrationHandler getBundleContextServiceRegistrationHandler(final Class<?> serviceType) {
 345         if (serviceType.equals(SchemaContextListener.class)) {
 346             return (clazz, serviceInstance, props) -> {
 347                 final SchemaContextListener listener = (SchemaContextListener) serviceInstance;
 348                 final SchemaContext context = parseYangStreams(getFilesAsStreams(getYangModelsPaths()));
 349                 listener.onGlobalContextUpdated(context);
 350             };
 351         }
 352
 353         return super.getBundleContextServiceRegistrationHandler(serviceType);
 354     }
 355
 356     @After
 357     public void closeAllModules() throws Exception {
 358         super.destroyAllConfigBeans();
 359
 360     }
 361
 362     protected CommitStatus createInstance() throws Exception {
 363         final ConfigTransactionJMXClient transaction = this.configRegistryClient.createTransaction();
 364         createRIBImplModuleInstance(transaction);
 365         return transaction.commit();
 366     }
 367
 368     protected CommitStatus createRIBImplModuleInstance(final RibId ribId, final AsNumber localAs, final BgpId bgpId, final ClusterIdentifier clusterId) throws Exception {
 369         final ConfigTransactionJMXClient transaction = this.configRegistryClient.createTransaction();
 370         createRIBImplModuleInstance(transaction, ribId, localAs, bgpId, clusterId, createAsyncDataBrokerInstance(transaction));
 371         return transaction.commit();
 372     }
 373
 374     private ObjectName createRIBImplModuleInstance(final ConfigTransactionJMXClient transaction, final RibId ribId, final AsNumber localAs,
 375             final BgpId bgpId, final ClusterIdentifier clusterId, final ObjectName dataBroker) throws Exception {
 376         final ObjectName nameCreated = transaction.createModule(FACTORY_NAME, INSTANCE_NAME);
 377         final RIBImplModuleMXBean mxBean = transaction.newMXBeanProxy(nameCreated, RIBImplModuleMXBean.class);
 378         mxBean.setDataProvider(dataBroker);
 379         mxBean.setDomDataProvider(lookupDomAsyncDataBroker(transaction));
 380         mxBean.setCodecTreeFactory(lookupMappingServiceInstance(transaction));
 381         mxBean.setBgpDispatcher(createBGPDispatcherImplInstance(transaction));
 382         mxBean.setExtensions(createRibExtensionsInstance(transaction));
 383         mxBean.setRibId(ribId);
 384         mxBean.setLocalAs(localAs);
 385         mxBean.setBgpRibId(bgpId);
 386         mxBean.setClusterId(clusterId);
 387         return nameCreated;
 388     }
 389
 390     public static ObjectName createBGPDispatcherImplInstance(final ConfigTransactionJMXClient transaction) throws InstanceAlreadyExistsException {
 391         final ObjectName nameCreated = transaction.createModule(BGPDispatcherImplModuleFactory.NAME, "bgp-message-fct");
 392         final BGPDispatcherImplModuleMXBean mxBean = transaction.newMXBeanProxy(nameCreated, BGPDispatcherImplModuleMXBean.class);
 393         return nameCreated;
 394     }
 395
 396     protected ObjectName createRIBImplModuleInstance(final ConfigTransactionJMXClient transaction) throws Exception {
 397         return createRIBImplModuleInstance(transaction, RIB_ID, AS_NUMBER, BGP_ID, CLUSTER_ID,
 398                 createAsyncDataBrokerInstance(transaction));
 399     }
 400
 401     public ObjectName createRIBImplModuleInstance(final ConfigTransactionJMXClient transaction, final ObjectName dataBroker)
 402             throws Exception {
 403         return createRIBImplModuleInstance(transaction, RIB_ID, AS_NUMBER, BGP_ID, CLUSTER_ID, dataBroker);
 404     }
 405
 406     public ObjectName createAsyncDataBrokerInstance(final ConfigTransactionJMXClient transaction) throws InstanceAlreadyExistsException, InstanceNotFoundException {
 407         final ObjectName nameCreated = transaction.createModule(BindingAsyncDataBrokerImplModuleFactory.NAME, BINDING_ASYNC_BROKER_INSTANCE_NAME);
 408         final BindingAsyncDataBrokerImplModuleMXBean mxBean = transaction.newMXBeanProxy(nameCreated, BindingAsyncDataBrokerImplModuleMXBean.class);
 409         mxBean.setBindingMappingService(lookupMappingServiceInstance(transaction));
 410         mxBean.setDomAsyncBroker(lookupDomAsyncDataBroker(transaction));
 411         mxBean.setSchemaService(lookupSchemaServiceInstance(transaction));
 412         return nameCreated;
 413     }
 414
 415     public static ObjectName lookupDomAsyncDataBroker(final ConfigTransactionJMXClient transaction) throws InstanceAlreadyExistsException {
 416         try {
 417             return transaction.lookupConfigBean(DomInmemoryDataBrokerModuleFactory.NAME, DOM_BROKER_INSTANCE_NAME);
 418         } catch (final InstanceNotFoundException e) {
 419             try {
 420                 final ObjectName nameCreated = transaction.createModule(DomInmemoryDataBrokerModuleFactory.NAME, DOM_BROKER_INSTANCE_NAME);
 421                 final DomInmemoryDataBrokerModuleMXBean mxBean = transaction.newMXBeanProxy(nameCreated, DomInmemoryDataBrokerModuleMXBean.class);
 422                 mxBean.setSchemaService(lookupSchemaServiceInstance(transaction));
 423                 return nameCreated;
 424             } catch (final InstanceAlreadyExistsException e1) {
 425                 throw new IllegalStateException(e1);
 426             }
 427         }
 428     }
 429
 430     private static ObjectName lookupMappingServiceInstance(final ConfigTransactionJMXClient transaction) {
 431         try {
 432             return transaction.lookupConfigBean(RuntimeMappingModuleFactory.NAME, RuntimeMappingModuleFactory.SINGLETON_NAME);
 433         } catch (final InstanceNotFoundException e) {
 434             try {
 435                 return transaction.createModule(RuntimeMappingModuleFactory.NAME, RuntimeMappingModuleFactory.SINGLETON_NAME);
 436             } catch (final InstanceAlreadyExistsException e1) {
 437                 throw new IllegalStateException(e1);
 438             }
 439         }
 440     }
 441
 442     private static ObjectName lookupSchemaServiceInstance(final ConfigTransactionJMXClient transaction) {
 443         try {
 444             return transaction.lookupConfigBean(SchemaServiceImplSingletonModuleFactory.NAME, SchemaServiceImplSingletonModuleFactory.SINGLETON_NAME);
 445         } catch (final InstanceNotFoundException e) {
 446             try {
 447                 return transaction.createModule(SchemaServiceImplSingletonModuleFactory.NAME, SchemaServiceImplSingletonModuleFactory.SINGLETON_NAME);
 448             } catch (final InstanceAlreadyExistsException e1) {
 449                 throw new IllegalStateException(e1);
 450             }
 451         }
 452     }
 453
 454     private static ObjectName createRibExtensionsInstance(final ConfigTransactionJMXClient transaction) throws InstanceAlreadyExistsException {
 455         final ObjectName nameCreated = transaction.createModule(RIBExtensionsImplModuleFactory.NAME, RIB_EXTENSIONS_INSTANCE_NAME);
 456         transaction.newMXBeanProxy(nameCreated, RIBExtensionsImplModuleMXBean.class);
 457         return nameCreated;
 458     }
 459
 460     public List<String> getYangModelsPaths() {
 461         final List<String> paths = Lists.newArrayList("/META-INF/yang/bgp-rib.yang", "/META-INF/yang/ietf-inet-types@2013-07-15.yang",
 462                 "/META-INF/yang/bgp-message.yang", "/META-INF/yang/bgp-multiprotocol.yang", "/META-INF/yang/bgp-types.yang",
 463                 "/META-INF/yang/network-concepts.yang", "/META-INF/yang/ieee754.yang", "/META-INF/yang/yang-ext.yang");
 464         return paths;
 465     }
 466
 467     // TODO move back to AbstractConfigTest
 468     private static List<InputStream> getFilesAsStreams(final List<String> paths) {
 469         final List<InputStream> resources = new ArrayList<>();
 470         final List<String> failedToFind = new ArrayList<>();
 471         for (final String path : paths) {
 472             final InputStream is = AbstractRIBImplModuleTest.class.getResourceAsStream(path);
 473             if (is == null) {
 474                 failedToFind.add(path);
 475             } else {
 476                 resources.add(is);
 477             }
 478         }
 479         Assert.assertEquals("Some files were not found", Collections.<String> emptyList(), failedToFind);
 480
 481         return resources;
 482     }
 483
 484     public ObjectName createBindingBrokerImpl(final ConfigTransactionJMXClient transaction, final ObjectName dataBrokerON,
 485             final ObjectName notificationBrokerON) throws Exception {
 486         final ObjectName objectName = transaction.createModule(BindingBrokerImplModuleFactory.NAME, BINDING_BROKER_INSTANCE_NAME);
 487         final BindingBrokerImplModuleMXBean mxBean = transaction.newMXBeanProxy(objectName, BindingBrokerImplModuleMXBean.class);
 488         mxBean.setDataBroker(dataBrokerON);
 489         mxBean.setNotificationService(notificationBrokerON);
 490         mxBean.setBindingMappingService(lookupMappingServiceInstance(transaction));
 491         mxBean.setDomAsyncBroker(lookupDomBrokerInstance(transaction));
 492         return objectName;
 493     }
 494
 495     public static ObjectName lookupDomBrokerInstance(final ConfigTransactionJMXClient transaction) throws InstanceAlreadyExistsException {
 496         try {
 497             return transaction.lookupConfigBean(DomBrokerImplModuleFactory.NAME, DOM_BROKER_INSTANCE_NAME);
 498         } catch (final InstanceNotFoundException e) {
 499             try {
 500                 final ObjectName nameCreated = transaction.createModule(DomBrokerImplModuleFactory.NAME, DOM_BROKER_INSTANCE_NAME);
 501                 final DomBrokerImplModuleMXBean mxBean = transaction.newMXBeanProxy(nameCreated, DomBrokerImplModuleMXBean.class);
 502                 mxBean.setAsyncDataBroker(lookupDomAsyncDataBroker(transaction));
 503                 return nameCreated;
 504             } catch (final InstanceAlreadyExistsException e1) {
 505                 throw new IllegalStateException(e1);
 506             }
 507         }
 508     }
 509
 510     public ObjectName createCompatibleDataBrokerInstance(final ConfigTransactionJMXClient transaction)
 511             throws InstanceAlreadyExistsException, InstanceNotFoundException {
 512         final ObjectName nameCreated = transaction.createModule(ForwardedCompatibleDataBrokerImplModuleFactory.NAME, COMPATIBLE_DATA_BROKER_INSTANCE_NAME);
 513         final ForwardedCompatibleDataBrokerImplModuleMXBean mxBean = transaction.newMXBeanProxy(nameCreated, ForwardedCompatibleDataBrokerImplModuleMXBean.class);
 514         mxBean.setDataBroker(lookupDataBrokerInstance(transaction));
 515         return nameCreated;
 516     }
 517
 518     private static ObjectName lookupDataBrokerInstance(final ConfigTransactionJMXClient transaction) {
 519         try {
 520             return transaction.lookupConfigBean(BindingAsyncDataBrokerImplModuleFactory.NAME, BINDING_ASYNC_BROKER_INSTANCE_NAME);
 521         } catch (final InstanceNotFoundException e) {
 522             try {
 523                 return transaction.createModule(RuntimeMappingModuleFactory.NAME, RuntimeMappingModuleFactory.SINGLETON_NAME);
 524             } catch (final InstanceAlreadyExistsException e1) {
 525                 throw new IllegalStateException(e1);
 526             }
 527         }
 528     }
 529
 530     public ObjectName createNotificationBrokerInstance(final ConfigTransactionJMXClient transaction) throws Exception {
 531         final ObjectName objectName = transaction.createModule(NotificationBrokerImplModuleFactory.NAME, NOTIFICATION_BROKER_INSTANCE_NAME);
 532         return objectName;
 533     }
 534 }