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