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