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.anyString;
  12 import static org.mockito.Matchers.contains;
  13 import static org.mockito.Mockito.doAnswer;
  14 import static org.mockito.Mockito.doNothing;
  15 import static org.mockito.Mockito.doReturn;
  16 import static org.mockito.Mockito.mock;
  17 import com.google.common.collect.Lists;
  18 import com.google.common.io.ByteSource;
  19 import com.google.common.io.Resources;
  20 import com.google.common.util.concurrent.CheckedFuture;
  21 import io.netty.channel.EventLoopGroup;
  22 import io.netty.util.concurrent.EventExecutor;
  23 import java.io.IOException;
  24 import java.net.URL;
  25 import java.util.ArrayList;
  26 import java.util.Collection;
  27 import java.util.Collections;
  28 import java.util.Dictionary;
  29 import java.util.List;
  30 import javax.management.InstanceAlreadyExistsException;
  31 import javax.management.InstanceNotFoundException;
  32 import javax.management.ObjectName;
  33 import org.junit.After;
  34 import org.junit.Assert;
  35 import org.junit.Before;
  36 import org.mockito.Matchers;
  37 import org.mockito.Mock;
  38 import org.mockito.Mockito;
  39 import org.mockito.MockitoAnnotations;
  40 import org.mockito.invocation.InvocationOnMock;
  41 import org.mockito.stubbing.Answer;
  42 import org.opendaylight.controller.config.api.jmx.CommitStatus;
  43 import org.opendaylight.controller.config.manager.impl.AbstractConfigTest;
  44 import org.opendaylight.controller.config.manager.impl.factoriesresolver.HardcodedModuleFactoriesResolver;
  45 import org.opendaylight.controller.config.spi.ModuleFactory;
  46 import org.opendaylight.controller.config.util.ConfigTransactionJMXClient;
  47 import org.opendaylight.controller.config.yang.bgp.parser.spi.SimpleBGPExtensionProviderContextModuleFactory;
  48 import org.opendaylight.controller.config.yang.bgp.rib.spi.RIBExtensionsImplModuleFactory;
  49 import org.opendaylight.controller.config.yang.bgp.rib.spi.RIBExtensionsImplModuleMXBean;
  50 import org.opendaylight.controller.config.yang.md.sal.binding.impl.BindingAsyncDataBrokerImplModuleFactory;
  51 import org.opendaylight.controller.config.yang.md.sal.binding.impl.BindingAsyncDataBrokerImplModuleMXBean;
  52 import org.opendaylight.controller.config.yang.md.sal.binding.impl.BindingBrokerImplModuleFactory;
  53 import org.opendaylight.controller.config.yang.md.sal.binding.impl.BindingBrokerImplModuleMXBean;
  54 import org.opendaylight.controller.config.yang.md.sal.binding.impl.ForwardedCompatibleDataBrokerImplModuleFactory;
  55 import org.opendaylight.controller.config.yang.md.sal.binding.impl.ForwardedCompatibleDataBrokerImplModuleMXBean;
  56 import org.opendaylight.controller.config.yang.md.sal.binding.impl.NotificationBrokerImplModuleFactory;
  57 import org.opendaylight.controller.config.yang.md.sal.binding.impl.RuntimeMappingModuleFactory;
  58 import org.opendaylight.controller.config.yang.md.sal.dom.impl.DomBrokerImplModuleFactory;
  59 import org.opendaylight.controller.config.yang.md.sal.dom.impl.DomBrokerImplModuleMXBean;
  60 import org.opendaylight.controller.config.yang.md.sal.dom.impl.DomInmemoryDataBrokerModuleFactory;
  61 import org.opendaylight.controller.config.yang.md.sal.dom.impl.DomInmemoryDataBrokerModuleMXBean;
  62 import org.opendaylight.controller.config.yang.md.sal.dom.impl.SchemaServiceImplSingletonModuleFactory;
  63 import org.opendaylight.controller.config.yang.netty.eventexecutor.AutoCloseableEventExecutor;
  64 import org.opendaylight.controller.config.yang.netty.eventexecutor.GlobalEventExecutorModuleFactory;
  65 import org.opendaylight.controller.config.yang.netty.threadgroup.NettyThreadgroupModuleFactory;
  66 import org.opendaylight.controller.config.yang.netty.threadgroup.NioEventLoopGroupCloseable;
  67 import org.opendaylight.controller.config.yang.netty.timer.HashedWheelTimerModuleFactory;
  68 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  69 import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
  70 import org.opendaylight.controller.md.sal.binding.impl.BindingToNormalizedNodeCodecFactory;
  71 import org.opendaylight.controller.md.sal.common.api.TransactionStatus;
  72 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  73 import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
  74 import org.opendaylight.controller.md.sal.dom.api.DOMMountPointService;
  75 import org.opendaylight.controller.md.sal.dom.api.DOMNotificationPublishService;
  76 import org.opendaylight.controller.md.sal.dom.api.DOMNotificationService;
  77 import org.opendaylight.controller.md.sal.dom.api.DOMRpcProviderService;
  78 import org.opendaylight.controller.md.sal.dom.api.DOMRpcService;
  79 import org.opendaylight.controller.sal.core.api.model.SchemaService;
  80 import org.opendaylight.controller.sal.core.api.model.YangTextSourceProvider;
  81 import org.opendaylight.protocol.bgp.parser.spi.BGPExtensionProviderContext;
  82 import org.opendaylight.protocol.bgp.parser.spi.MessageRegistry;
  83 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Ipv4Address;
  84 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev130925.RibId;
  85 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev130919.BgpId;
  86 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev130919.ClusterIdentifier;
  87 import org.opendaylight.yangtools.concepts.ListenerRegistration;
  88 import org.opendaylight.yangtools.sal.binding.generator.api.ClassLoadingStrategy;
  89 import org.opendaylight.yangtools.sal.binding.generator.impl.GeneratedClassLoadingStrategy;
  90 import org.opendaylight.yangtools.yang.binding.DataObject;
  91 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  92 import org.opendaylight.yangtools.yang.common.RpcResult;
  93 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
  94 import org.opendaylight.yangtools.yang.model.api.SchemaContextListener;
  95 import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
  96 import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor;
  97 import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.YangInferencePipeline;
  98 import org.osgi.framework.Bundle;
  99 import org.osgi.framework.BundleListener;
 100 import org.osgi.framework.Filter;
 101 import org.osgi.framework.ServiceListener;
 102 import org.osgi.framework.ServiceReference;
 103
 104 public abstract class AbstractRIBImplModuleTest extends AbstractConfigTest {
 105
 106     private static final String INSTANCE_NAME = "rib-impl";
 107     private static final String FACTORY_NAME = RIBImplModuleFactory.NAME;
 108     private static final String TRANSACTION_NAME = "testTransaction";
 109
 110     protected static final RibId RIB_ID = new RibId("test");
 111     protected static final Ipv4Address BGP_ID = new Ipv4Address("192.168.1.1");
 112     protected static final Ipv4Address CLUSTER_ID = new Ipv4Address("192.168.1.2");
 113
 114     private static final String SESSION_RS_INSTANCE_NAME = "session-reconnect-strategy-factory";
 115     private static final String TCP_RS_INSTANCE_NAME = "tcp-reconnect-strategy-factory";
 116     private static final String RIB_EXTENSIONS_INSTANCE_NAME = "rib-extensions-impl";
 117     private static final String DOM_BROKER_INSTANCE_NAME = "dom-broker-impl";
 118     private static final String BINDING_ASYNC_BROKER_INSTANCE_NAME = "binding-async-broker-instance";
 119     private static final String DOM_ASYNC_DATA_BROKER_INSTANCE = "dom-inmemory-data-broker";
 120     private static final String BINDING_BROKER_INSTANCE_NAME = "binding-broker-impl";
 121     private static final String COMPATIBLE_DATA_BROKER_INSTANCE_NAME = "binding-data-compatible-broker-instance";
 122     private static final String NOTIFICATION_BROKER_INSTANCE_NAME = "notification-broker-impl";
 123
 124     @Mock
 125     private ReadWriteTransaction mockedTransaction;
 126
 127     @Mock
 128     private DataBroker mockedDataProvider;
 129
 130     @Mock
 131     private CheckedFuture<Void, TransactionCommitFailedException> mockedFuture;
 132
 133     @Mock
 134     private RpcResult<TransactionStatus> mockedResult;
 135
 136     @SuppressWarnings("unchecked")
 137     @Before
 138     public void setUp() throws Exception {
 139         MockitoAnnotations.initMocks(this);
 140
 141         final List<ModuleFactory> moduleFactories = getModuleFactories();
 142         super.initConfigTransactionManagerImpl(new HardcodedModuleFactoriesResolver(this.mockedContext, moduleFactories.toArray(new ModuleFactory[moduleFactories.size()])));
 143
 144         doAnswer(new Answer<Filter>() {
 145             @Override
 146             public Filter answer(final InvocationOnMock invocation) {
 147                 final String str = invocation.getArgumentAt(0, String.class);
 148                 final Filter mockFilter = mock(Filter.class);
 149                 doReturn(str).when(mockFilter).toString();
 150                 return mockFilter;
 151             }
 152         }).when(mockedContext).createFilter(anyString());
 153
 154         final ServiceReference<?> emptyServiceReference = mock(ServiceReference.class, "Empty");
 155         final ServiceReference<?> classLoadingStrategySR = mock(ServiceReference.class, "ClassLoadingStrategy");
 156         final ServiceReference<?> dataProviderServiceReference = mock(ServiceReference.class, "Data Provider");
 157
 158         Mockito.doNothing().when(this.mockedContext).addServiceListener(any(ServiceListener.class), Mockito.anyString());
 159         Mockito.doNothing().when(this.mockedContext).removeServiceListener(any(ServiceListener.class));
 160
 161         Mockito.doNothing().when(this.mockedContext).addBundleListener(any(BundleListener.class));
 162         Mockito.doNothing().when(this.mockedContext).removeBundleListener(any(BundleListener.class));
 163
 164         Mockito.doReturn(new Bundle[] {}).when(this.mockedContext).getBundles();
 165
 166         Mockito.doReturn(new ServiceReference[] {}).when(this.mockedContext).getServiceReferences(Matchers.anyString(), Matchers.anyString());
 167
 168         Mockito.doReturn("Empty reference").when(emptyServiceReference).toString();
 169         Mockito.doReturn("Data Provider Service Reference").when(dataProviderServiceReference).toString();
 170         Mockito.doReturn("Class loading stategy reference").when(classLoadingStrategySR).toString();
 171
 172         Mockito.doReturn(emptyServiceReference).when(this.mockedContext).getServiceReference(any(Class.class));
 173         Mockito.doReturn(dataProviderServiceReference).when(this.mockedContext).getServiceReference(DataBroker.class);
 174         Mockito.doReturn(classLoadingStrategySR).when(this.mockedContext).getServiceReference(GeneratedClassLoadingStrategy.class);
 175         Mockito.doReturn(classLoadingStrategySR).when(this.mockedContext).getServiceReference(ClassLoadingStrategy.class);
 176
 177         Mockito.doReturn(this.mockedDataProvider).when(this.mockedContext).getService(dataProviderServiceReference);
 178         Mockito.doReturn(GeneratedClassLoadingStrategy.getTCCLClassLoadingStrategy()).when(this.mockedContext).getService(classLoadingStrategySR);
 179         Mockito.doReturn(null).when(this.mockedContext).getService(emptyServiceReference);
 180
 181         Mockito.doReturn(this.mockedTransaction).when(this.mockedDataProvider).newReadWriteTransaction();
 182
 183         Mockito.doReturn(null).when(this.mockedTransaction).read(Mockito.eq(LogicalDatastoreType.OPERATIONAL), any(InstanceIdentifier.class));
 184         Mockito.doNothing().when(this.mockedTransaction).put(Mockito.eq(LogicalDatastoreType.OPERATIONAL), any(InstanceIdentifier.class), any(DataObject.class));
 185         Mockito.doNothing().when(this.mockedTransaction).delete(Mockito.eq(LogicalDatastoreType.OPERATIONAL), any(InstanceIdentifier.class));
 186
 187         Mockito.doReturn(this.mockedFuture).when(this.mockedTransaction).submit();
 188         Mockito.doReturn(TRANSACTION_NAME).when(this.mockedTransaction).getIdentifier();
 189
 190         Mockito.doReturn(null).when(this.mockedFuture).get();
 191
 192         final SchemaContext context = parseYangStreams(getFilesAsByteSources(getYangModelsPaths()));
 193         final SchemaService mockedSchemaService = mock(SchemaService.class);
 194         doReturn(context).when(mockedSchemaService).getGlobalContext();
 195         doAnswer(new Answer<ListenerRegistration<SchemaContextListener>>() {
 196             @Override
 197             public ListenerRegistration<SchemaContextListener> answer(InvocationOnMock invocation) {
 198                 invocation.getArgumentAt(0, SchemaContextListener.class).onGlobalContextUpdated(context);
 199                 ListenerRegistration<SchemaContextListener> reg = mock(ListenerRegistration.class);
 200                 doNothing().when(reg).close();
 201                 return reg;
 202             }
 203         }).when(mockedSchemaService).registerSchemaContextListener(any(SchemaContextListener.class));
 204
 205         setupMockService(SchemaService.class, mockedSchemaService);
 206         setupMockService(YangTextSourceProvider.class, mock(YangTextSourceProvider.class));
 207
 208         BindingToNormalizedNodeCodecFactory.getOrCreateInstance(
 209                 GeneratedClassLoadingStrategy.getTCCLClassLoadingStrategy(), mockedSchemaService);
 210
 211         BGPExtensionProviderContext mockContext = mock(BGPExtensionProviderContext.class);
 212         doReturn(mock(MessageRegistry.class)).when(mockContext).getMessageRegistry();
 213         setupMockService(BGPExtensionProviderContext.class, mockContext);
 214
 215         setupMockService(EventLoopGroup.class, NioEventLoopGroupCloseable.newInstance(0));
 216         setupMockService(EventExecutor.class, AutoCloseableEventExecutor.CloseableEventExecutorMixin.globalEventExecutor());
 217
 218         setupMockService(DOMNotificationService.class, mock(DOMNotificationService.class));
 219         setupMockService(DOMNotificationPublishService.class, mock(DOMNotificationPublishService.class));
 220         setupMockService(DOMRpcService.class, mock(DOMRpcService.class));
 221         setupMockService(DOMRpcProviderService.class, mock(DOMRpcProviderService.class));
 222         setupMockService(DOMMountPointService.class, mock(DOMMountPointService.class));
 223     }
 224
 225     protected void setupMockService(final Class<?> serviceInterface, final Object instance) throws Exception {
 226         final ServiceReference<?> mockServiceRef = mock(ServiceReference.class);
 227         doReturn(new ServiceReference[]{mockServiceRef}).when(mockedContext).
 228                 getServiceReferences(anyString(), contains(serviceInterface.getName()));
 229         doReturn(new ServiceReference[]{mockServiceRef}).when(mockedContext).
 230                 getServiceReferences(serviceInterface.getName(), null);
 231         doReturn(instance).when(mockedContext).getService(mockServiceRef);
 232     }
 233
 234     private static SchemaContext parseYangStreams(final Collection<ByteSource> streams) {
 235         final CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR
 236                 .newBuild();
 237         try {
 238             return reactor.buildEffective(streams);
 239         } catch (final ReactorException | IOException e) {
 240             throw new RuntimeException("Unable to build schema context from " + streams, e);
 241         }
 242     }
 243
 244     protected List<ModuleFactory> getModuleFactories() {
 245         return Lists.newArrayList(new RIBImplModuleFactory(), new GlobalEventExecutorModuleFactory(),
 246                 new BGPDispatcherImplModuleFactory(), new NettyThreadgroupModuleFactory(),
 247                 new SimpleBGPExtensionProviderContextModuleFactory(),
 248                 new RIBExtensionsImplModuleFactory(), new DomBrokerImplModuleFactory(), new RuntimeMappingModuleFactory(),
 249                 new HashedWheelTimerModuleFactory(), new BindingAsyncDataBrokerImplModuleFactory(),
 250                 new DomInmemoryDataBrokerModuleFactory(), new SchemaServiceImplSingletonModuleFactory(),
 251                 new NotificationBrokerImplModuleFactory(), new ForwardedCompatibleDataBrokerImplModuleFactory(),
 252                 new BindingBrokerImplModuleFactory());
 253     }
 254
 255     @Override
 256     protected BundleContextServiceRegistrationHandler getBundleContextServiceRegistrationHandler(final Class<?> serviceType) {
 257         if (serviceType.equals(SchemaContextListener.class)) {
 258             return new BundleContextServiceRegistrationHandler() {
 259                 @Override
 260                 public void handleServiceRegistration(final Class<?> clazz, final Object serviceInstance, final Dictionary<String, ?> props) {
 261                     final SchemaContextListener listener = (SchemaContextListener) serviceInstance;
 262                     final SchemaContext context = parseYangStreams(getFilesAsByteSources(getYangModelsPaths()));
 263                     listener.onGlobalContextUpdated(context);
 264                 }
 265             };
 266         }
 267
 268         return super.getBundleContextServiceRegistrationHandler(serviceType);
 269     }
 270
 271     @After
 272     public void closeAllModules() throws Exception {
 273         super.destroyAllConfigBeans();
 274
 275     }
 276
 277     protected CommitStatus createInstance() throws Exception {
 278         final ConfigTransactionJMXClient transaction = this.configRegistryClient.createTransaction();
 279         createRIBImplModuleInstance(transaction);
 280         return transaction.commit();
 281     }
 282
 283     protected CommitStatus createRIBImplModuleInstance(final RibId ribId, final Long localAs, final Ipv4Address bgpId, final Ipv4Address clusterId) throws Exception {
 284         final ConfigTransactionJMXClient transaction = this.configRegistryClient.createTransaction();
 285         createRIBImplModuleInstance(transaction, ribId, localAs, bgpId, clusterId, createAsyncDataBrokerInstance(transaction));
 286         return transaction.commit();
 287     }
 288
 289     private ObjectName createRIBImplModuleInstance(final ConfigTransactionJMXClient transaction, final RibId ribId, final Long localAs,
 290             final Ipv4Address bgpId, final Ipv4Address clusterId, final ObjectName dataBroker) throws Exception {
 291         final ObjectName nameCreated = transaction.createModule(FACTORY_NAME, INSTANCE_NAME);
 292         final RIBImplModuleMXBean mxBean = transaction.newMXBeanProxy(nameCreated, RIBImplModuleMXBean.class);
 293         mxBean.setDataProvider(dataBroker);
 294         mxBean.setDomDataProvider(lookupDomAsyncDataBroker(transaction));
 295         mxBean.setCodecTreeFactory(lookupMappingServiceInstance(transaction));
 296         mxBean.setBgpDispatcher(BGPDispatcherImplModuleTest.createInstance(transaction));
 297         mxBean.setExtensions(createRibExtensionsInstance(transaction));
 298         mxBean.setRibId(ribId);
 299         mxBean.setLocalAs(localAs);
 300         mxBean.setBgpRibId(bgpId != null ? new BgpId(bgpId) : null);
 301         mxBean.setClusterId(clusterId != null ? new ClusterIdentifier(clusterId) : null);
 302         return nameCreated;
 303     }
 304
 305     protected ObjectName createRIBImplModuleInstance(final ConfigTransactionJMXClient transaction) throws Exception {
 306         return createRIBImplModuleInstance(transaction, RIB_ID, 5000L, BGP_ID, CLUSTER_ID,
 307                 createAsyncDataBrokerInstance(transaction));
 308     }
 309
 310     public ObjectName createRIBImplModuleInstance(final ConfigTransactionJMXClient transaction, final ObjectName dataBroker)
 311             throws Exception {
 312         return createRIBImplModuleInstance(transaction, RIB_ID, 5000L, BGP_ID, CLUSTER_ID, dataBroker);
 313     }
 314
 315     public ObjectName createAsyncDataBrokerInstance(final ConfigTransactionJMXClient transaction) throws InstanceAlreadyExistsException, InstanceNotFoundException {
 316         final ObjectName nameCreated = transaction.createModule(BindingAsyncDataBrokerImplModuleFactory.NAME, BINDING_ASYNC_BROKER_INSTANCE_NAME);
 317         final BindingAsyncDataBrokerImplModuleMXBean mxBean = transaction.newMXBeanProxy(nameCreated, BindingAsyncDataBrokerImplModuleMXBean.class);
 318         mxBean.setBindingMappingService(lookupMappingServiceInstance(transaction));
 319         mxBean.setDomAsyncBroker(lookupDomAsyncDataBroker(transaction));
 320         mxBean.setSchemaService(lookupSchemaServiceInstance(transaction));
 321         return nameCreated;
 322     }
 323
 324     public static ObjectName lookupDomAsyncDataBroker(final ConfigTransactionJMXClient transaction) throws InstanceAlreadyExistsException {
 325         try {
 326             return transaction.lookupConfigBean(DomInmemoryDataBrokerModuleFactory.NAME, DOM_BROKER_INSTANCE_NAME);
 327         } catch (final InstanceNotFoundException e) {
 328             try {
 329                 final ObjectName nameCreated = transaction.createModule(DomInmemoryDataBrokerModuleFactory.NAME, DOM_BROKER_INSTANCE_NAME);
 330                 final DomInmemoryDataBrokerModuleMXBean mxBean = transaction.newMXBeanProxy(nameCreated, DomInmemoryDataBrokerModuleMXBean.class);
 331                 mxBean.setSchemaService(lookupSchemaServiceInstance(transaction));
 332                 return nameCreated;
 333             } catch (final InstanceAlreadyExistsException e1) {
 334                 throw new IllegalStateException(e1);
 335             }
 336         }
 337     }
 338
 339     private static ObjectName lookupMappingServiceInstance(final ConfigTransactionJMXClient transaction) {
 340         try {
 341             return transaction.lookupConfigBean(RuntimeMappingModuleFactory.NAME, RuntimeMappingModuleFactory.SINGLETON_NAME);
 342         } catch (final InstanceNotFoundException e) {
 343             try {
 344                 return transaction.createModule(RuntimeMappingModuleFactory.NAME, RuntimeMappingModuleFactory.SINGLETON_NAME);
 345             } catch (final InstanceAlreadyExistsException e1) {
 346                 throw new IllegalStateException(e1);
 347             }
 348         }
 349     }
 350
 351     private static ObjectName lookupSchemaServiceInstance(final ConfigTransactionJMXClient transaction) {
 352         try {
 353             return transaction.lookupConfigBean(SchemaServiceImplSingletonModuleFactory.NAME, SchemaServiceImplSingletonModuleFactory.SINGLETON_NAME);
 354         } catch (final InstanceNotFoundException e) {
 355             try {
 356                 return transaction.createModule(SchemaServiceImplSingletonModuleFactory.NAME, SchemaServiceImplSingletonModuleFactory.SINGLETON_NAME);
 357             } catch (final InstanceAlreadyExistsException e1) {
 358                 throw new IllegalStateException(e1);
 359             }
 360         }
 361     }
 362
 363     private static ObjectName createRibExtensionsInstance(final ConfigTransactionJMXClient transaction) throws InstanceAlreadyExistsException {
 364         final ObjectName nameCreated = transaction.createModule(RIBExtensionsImplModuleFactory.NAME, RIB_EXTENSIONS_INSTANCE_NAME);
 365         transaction.newMXBeanProxy(nameCreated, RIBExtensionsImplModuleMXBean.class);
 366         return nameCreated;
 367     }
 368
 369     public List<String> getYangModelsPaths() {
 370         final List<String> paths = Lists.newArrayList("/META-INF/yang/bgp-rib.yang", "/META-INF/yang/ietf-inet-types.yang",
 371                 "/META-INF/yang/bgp-message.yang", "/META-INF/yang/bgp-multiprotocol.yang", "/META-INF/yang/bgp-types.yang",
 372                 "/META-INF/yang/network-concepts.yang", "/META-INF/yang/ieee754.yang", "/META-INF/yang/yang-ext.yang");
 373         return paths;
 374     }
 375
 376     // TODO move back to AbstractConfigTest
 377     private static Collection<ByteSource> getFilesAsByteSources(final List<String> paths) {
 378         final Collection<ByteSource> resources = new ArrayList<>();
 379         final List<String> failedToFind = new ArrayList<>();
 380         for (final String path : paths) {
 381             final URL url = AbstractRIBImplModuleTest.class.getResource(path);
 382             if (url == null) {
 383                 failedToFind.add(path);
 384             } else {
 385                 resources.add(Resources.asByteSource(url));
 386             }
 387         }
 388         Assert.assertEquals("Some files were not found", Collections.<String> emptyList(), failedToFind);
 389
 390         return resources;
 391     }
 392
 393     public ObjectName createBindingBrokerImpl(final ConfigTransactionJMXClient transaction, final ObjectName dataBrokerON,
 394         final ObjectName notificationBrokerON) throws Exception {
 395         final ObjectName objectName = transaction.createModule(BindingBrokerImplModuleFactory.NAME, BINDING_BROKER_INSTANCE_NAME);
 396         final BindingBrokerImplModuleMXBean mxBean = transaction.newMXBeanProxy(objectName, BindingBrokerImplModuleMXBean.class);
 397         mxBean.setDataBroker(dataBrokerON);
 398         mxBean.setNotificationService(notificationBrokerON);
 399         mxBean.setBindingMappingService(lookupMappingServiceInstance(transaction));
 400         mxBean.setDomAsyncBroker(lookupDomBrokerInstance(transaction));
 401         return objectName;
 402     }
 403
 404     public static ObjectName lookupDomBrokerInstance(final ConfigTransactionJMXClient transaction) throws InstanceAlreadyExistsException {
 405         try {
 406             return transaction.lookupConfigBean(DomBrokerImplModuleFactory.NAME, DOM_BROKER_INSTANCE_NAME);
 407         } catch (final InstanceNotFoundException e) {
 408             try {
 409                 final ObjectName nameCreated = transaction.createModule(DomBrokerImplModuleFactory.NAME, DOM_BROKER_INSTANCE_NAME);
 410                 final DomBrokerImplModuleMXBean mxBean = transaction.newMXBeanProxy(nameCreated, DomBrokerImplModuleMXBean.class);
 411                 mxBean.setAsyncDataBroker(lookupDomAsyncDataBroker(transaction));
 412                 return nameCreated;
 413             } catch (final InstanceAlreadyExistsException e1) {
 414                 throw new IllegalStateException(e1);
 415             }
 416         }
 417     }
 418
 419     public ObjectName createCompatibleDataBrokerInstance(final ConfigTransactionJMXClient transaction)
 420         throws InstanceAlreadyExistsException, InstanceNotFoundException {
 421         final ObjectName nameCreated = transaction.createModule(ForwardedCompatibleDataBrokerImplModuleFactory.NAME, COMPATIBLE_DATA_BROKER_INSTANCE_NAME);
 422         final ForwardedCompatibleDataBrokerImplModuleMXBean mxBean = transaction.newMXBeanProxy(nameCreated, ForwardedCompatibleDataBrokerImplModuleMXBean.class);
 423         mxBean.setDataBroker(lookupDataBrokerInstance(transaction));
 424         return nameCreated;
 425     }
 426
 427     private static ObjectName lookupDataBrokerInstance(final ConfigTransactionJMXClient transaction) {
 428         try {
 429             return transaction.lookupConfigBean(BindingAsyncDataBrokerImplModuleFactory.NAME, BINDING_ASYNC_BROKER_INSTANCE_NAME);
 430         } catch (final InstanceNotFoundException e) {
 431             try {
 432                 return transaction.createModule(RuntimeMappingModuleFactory.NAME, RuntimeMappingModuleFactory.SINGLETON_NAME);
 433             } catch (final InstanceAlreadyExistsException e1) {
 434                 throw new IllegalStateException(e1);
 435             }
 436         }
 437     }
 438
 439     public ObjectName createNotificationBrokerInstance(final ConfigTransactionJMXClient transaction) throws Exception {
 440         final ObjectName objectName = transaction.createModule(NotificationBrokerImplModuleFactory.NAME, NOTIFICATION_BROKER_INSTANCE_NAME);
 441         return objectName;
 442     }
 443 }