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