programming/impl/src/test/java/org/opendaylight/controller/config/yang/programming/impl/AbstractInstructionSchedulerTest.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.programming.impl;
   9
  10 import static org.mockito.Matchers.any;
  11 import static org.mockito.Mockito.mock;
  12
  13 import com.google.common.base.Optional;
  14 import com.google.common.collect.Lists;
  15 import com.google.common.io.ByteSource;
  16 import com.google.common.io.Resources;
  17 import java.io.IOException;
  18 import java.lang.reflect.Field;
  19 import java.lang.reflect.Modifier;
  20 import java.net.URL;
  21 import java.util.ArrayList;
  22 import java.util.Collection;
  23 import java.util.Collections;
  24 import java.util.Dictionary;
  25 import java.util.List;
  26 import javax.management.InstanceAlreadyExistsException;
  27 import javax.management.InstanceNotFoundException;
  28 import javax.management.ObjectName;
  29 import org.junit.After;
  30 import org.junit.Assert;
  31 import org.junit.Before;
  32 import org.mockito.Matchers;
  33 import org.mockito.Mock;
  34 import org.mockito.Mockito;
  35 import org.mockito.MockitoAnnotations;
  36 import org.opendaylight.controller.config.manager.impl.AbstractConfigTest;
  37 import org.opendaylight.controller.config.manager.impl.factoriesresolver.HardcodedModuleFactoriesResolver;
  38 import org.opendaylight.controller.config.spi.ModuleFactory;
  39 import org.opendaylight.controller.config.util.ConfigTransactionJMXClient;
  40 import org.opendaylight.controller.config.yang.md.sal.binding.impl.BindingAsyncDataBrokerImplModuleFactory;
  41 import org.opendaylight.controller.config.yang.md.sal.binding.impl.BindingAsyncDataBrokerImplModuleMXBean;
  42 import org.opendaylight.controller.config.yang.md.sal.binding.impl.BindingBrokerImplModuleFactory;
  43 import org.opendaylight.controller.config.yang.md.sal.binding.impl.BindingBrokerImplModuleMXBean;
  44 import org.opendaylight.controller.config.yang.md.sal.binding.impl.ForwardedCompatibleDataBrokerImplModuleFactory;
  45 import org.opendaylight.controller.config.yang.md.sal.binding.impl.ForwardedCompatibleDataBrokerImplModuleMXBean;
  46 import org.opendaylight.controller.config.yang.md.sal.binding.impl.NotificationBrokerImplModuleFactory;
  47 import org.opendaylight.controller.config.yang.md.sal.binding.impl.RpcBrokerImplModuleFactory;
  48 import org.opendaylight.controller.config.yang.md.sal.binding.impl.RuntimeMappingModuleFactory;
  49 import org.opendaylight.controller.config.yang.md.sal.dom.impl.DomBrokerImplModuleFactory;
  50 import org.opendaylight.controller.config.yang.md.sal.dom.impl.DomBrokerImplModuleMXBean;
  51 import org.opendaylight.controller.config.yang.md.sal.dom.impl.DomInmemoryDataBrokerModuleFactory;
  52 import org.opendaylight.controller.config.yang.md.sal.dom.impl.DomInmemoryDataBrokerModuleMXBean;
  53 import org.opendaylight.controller.config.yang.md.sal.dom.impl.SchemaServiceImplSingletonModuleFactory;
  54 import org.opendaylight.controller.config.yang.netty.timer.HashedWheelTimerModuleFactory;
  55 import org.opendaylight.controller.md.sal.common.api.TransactionStatus;
  56 import org.opendaylight.controller.sal.dom.broker.GlobalBundleScanningSchemaServiceImpl;
  57 import org.opendaylight.yangtools.sal.binding.generator.impl.GeneratedClassLoadingStrategy;
  58 import org.opendaylight.yangtools.yang.common.RpcResult;
  59 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
  60 import org.opendaylight.yangtools.yang.model.api.SchemaContextListener;
  61 import org.opendaylight.yangtools.yang.model.parser.api.YangContextParser;
  62 import org.opendaylight.yangtools.yang.model.parser.api.YangSyntaxErrorException;
  63 import org.opendaylight.yangtools.yang.parser.impl.YangParserImpl;
  64 import org.opendaylight.yangtools.yang.parser.repo.URLSchemaContextResolver;
  65 import org.osgi.framework.Bundle;
  66 import org.osgi.framework.BundleListener;
  67 import org.osgi.framework.Filter;
  68 import org.osgi.framework.ServiceListener;
  69 import org.osgi.framework.ServiceReference;
  70
  71 public abstract class AbstractInstructionSchedulerTest extends AbstractConfigTest {
  72
  73     private static final String FACTORY_NAME = InstructionSchedulerImplModuleFactory.NAME;
  74     private static final String INSTANCE_NAME = "instruction-scheduler-impl";
  75
  76     private static final String BINDING_BROKER_INSTANCE_NAME = "binding-broker-impl";
  77     private static final String NOTIFICATION_BROKER_INSTANCE_NAME = "notification-broker-impl";
  78     private static final String COMPATIBLE_DATA_BROKER_INSTANCE_NAME = "binding-data-compatible-broker-instance";
  79     private static final String DOM_BROKER_INSTANCE_NAME = "dom-broker-impl";
  80     private static final String TIMER_INSTANCE_NAME = "timer-impl";
  81     private static final String BINDING_ASYNC_BROKER_INSTANCE_NAME = "binding-async-broker-instance";
  82     private static final String DOM_ASYNC_DATA_BROKER_INSTANCE = "dom-inmemory-data-broker";
  83
  84     @Mock
  85     private RpcResult<TransactionStatus> mockedResult;
  86
  87     @Before
  88     public void setUp() throws Exception {
  89         MockitoAnnotations.initMocks(this);
  90
  91         final List<ModuleFactory> moduleFactories = getModuleFactories();
  92         super.initConfigTransactionManagerImpl(new HardcodedModuleFactoriesResolver(mockedContext, moduleFactories.toArray(new ModuleFactory[moduleFactories.size()])));
  93
  94         final Filter mockedFilter = mock(Filter.class);
  95
  96         Mockito.doReturn(new ServiceReference[] {}).when(mockedContext).getServiceReferences(Matchers.anyString(), Matchers.anyString());
  97
  98         final ServiceReference<?> classLoadingStrategySR = mock(ServiceReference.class, "ClassLoadingStrategy");
  99         final ServiceReference<?> emptyServiceReference = mock(ServiceReference.class, "Empty");
 100
 101         Mockito.doReturn(mockedFilter).when(mockedContext).createFilter(Mockito.anyString());
 102
 103         Mockito.doNothing().when(mockedContext).addServiceListener(any(ServiceListener.class), Mockito.anyString());
 104         Mockito.doNothing().when(mockedContext).removeServiceListener(any(ServiceListener.class));
 105
 106         Mockito.doNothing().when(mockedContext).addBundleListener(any(BundleListener.class));
 107         Mockito.doNothing().when(mockedContext).removeBundleListener(any(BundleListener.class));
 108
 109         Mockito.doReturn(new Bundle[] {}).when(mockedContext).getBundles();
 110
 111         Mockito.doReturn(new ServiceReference[] {}).when(mockedContext).getServiceReferences(Matchers.anyString(), Matchers.anyString());
 112
 113         Mockito.doReturn("Class loading stategy reference").when(classLoadingStrategySR).toString();
 114         Mockito.doReturn("Empty reference").when(emptyServiceReference).toString();
 115
 116         Mockito.doReturn(emptyServiceReference).when(mockedContext).getServiceReference(any(Class.class));
 117         Mockito.doReturn(classLoadingStrategySR).when(mockedContext).getServiceReference(GeneratedClassLoadingStrategy.class);
 118
 119         Mockito.doReturn(GeneratedClassLoadingStrategy.getTCCLClassLoadingStrategy()).when(mockedContext).getService(classLoadingStrategySR);
 120         Mockito.doReturn(null).when(mockedContext).getService(emptyServiceReference);
 121
 122         final GlobalBundleScanningSchemaServiceImpl schemaService = GlobalBundleScanningSchemaServiceImpl.createInstance(this.mockedContext);
 123         final YangContextParser parser = new YangParserImpl();
 124         final SchemaContext context = parser.parseSources(getFilesAsByteSources(getYangModelsPaths()));
 125         final URLSchemaContextResolver mockedContextResolver = Mockito.mock(URLSchemaContextResolver.class);
 126         Mockito.doReturn(Optional.of(context)).when(mockedContextResolver).getSchemaContext();
 127
 128         final Field contextResolverField = schemaService.getClass().getDeclaredField("contextResolver");
 129         contextResolverField.setAccessible(true);
 130
 131         final Field modifiersField = Field.class.getDeclaredField("modifiers");
 132         modifiersField.setAccessible(true);
 133         modifiersField.setInt(contextResolverField, contextResolverField.getModifiers() & ~Modifier.FINAL);
 134
 135         contextResolverField.set(schemaService, mockedContextResolver);
 136     }
 137
 138     @After
 139     public void tearDownGlobalBundleScanningSchemaServiceImpl() throws Exception{
 140         GlobalBundleScanningSchemaServiceImpl.destroyInstance();
 141     }
 142
 143     public ObjectName createInstructionSchedulerModuleInstance(final ConfigTransactionJMXClient transaction, final ObjectName dataBrokerON,
 144             final ObjectName rpcRegistyON, final ObjectName notificationBrokerON) throws Exception {
 145         final ObjectName objectName = transaction.createModule(FACTORY_NAME, INSTANCE_NAME);
 146         final InstructionSchedulerImplModuleMXBean mxBean = transaction.newMXBeanProxy(objectName,
 147                 InstructionSchedulerImplModuleMXBean.class);
 148         mxBean.setDataProvider(dataBrokerON);
 149         mxBean.setRpcRegistry(rpcRegistyON);
 150         mxBean.setNotificationService(notificationBrokerON);
 151         mxBean.setTimer(createTimerInstance(transaction));
 152         return objectName;
 153     }
 154
 155     private ObjectName createTimerInstance(final ConfigTransactionJMXClient transaction) throws InstanceAlreadyExistsException {
 156         ObjectName nameCreated = transaction.createModule(HashedWheelTimerModuleFactory.NAME, TIMER_INSTANCE_NAME);
 157         return nameCreated;
 158
 159     }
 160
 161     public ObjectName createBindingBrokerImpl(final ConfigTransactionJMXClient transaction, final ObjectName dataBrokerON,
 162             final ObjectName notificationBrokerON) throws Exception {
 163         final ObjectName objectName = transaction.createModule(BindingBrokerImplModuleFactory.NAME, BINDING_BROKER_INSTANCE_NAME);
 164         final BindingBrokerImplModuleMXBean mxBean = transaction.newMXBeanProxy(objectName, BindingBrokerImplModuleMXBean.class);
 165         mxBean.setDataBroker(dataBrokerON);
 166         mxBean.setNotificationService(notificationBrokerON);
 167         return objectName;
 168     }
 169
 170     public ObjectName createNotificationBrokerInstance(final ConfigTransactionJMXClient transaction) throws Exception {
 171         final ObjectName objectName = transaction.createModule(NotificationBrokerImplModuleFactory.NAME, NOTIFICATION_BROKER_INSTANCE_NAME);
 172         return objectName;
 173     }
 174
 175     public ObjectName createCompatibleDataBrokerInstance(final ConfigTransactionJMXClient transaction)
 176             throws InstanceAlreadyExistsException, InstanceNotFoundException {
 177         final ObjectName nameCreated = transaction.createModule(ForwardedCompatibleDataBrokerImplModuleFactory.NAME, COMPATIBLE_DATA_BROKER_INSTANCE_NAME);
 178         final ForwardedCompatibleDataBrokerImplModuleMXBean mxBean = transaction.newMXBeanProxy(nameCreated, ForwardedCompatibleDataBrokerImplModuleMXBean.class);
 179         mxBean.setBindingMappingService(lookupMappingServiceInstance(transaction));
 180         mxBean.setDomAsyncBroker(lookupDomBrokerInstance(transaction));
 181         return nameCreated;
 182     }
 183
 184     public ObjectName createAsyncDataBrokerInstance(final ConfigTransactionJMXClient transaction) throws InstanceAlreadyExistsException, InstanceNotFoundException {
 185         final ObjectName nameCreated = transaction.createModule(BindingAsyncDataBrokerImplModuleFactory.NAME, BINDING_ASYNC_BROKER_INSTANCE_NAME);
 186         final BindingAsyncDataBrokerImplModuleMXBean mxBean = transaction.newMXBeanProxy(nameCreated, BindingAsyncDataBrokerImplModuleMXBean.class);
 187         mxBean.setBindingMappingService(lookupMappingServiceInstance(transaction));
 188         mxBean.setDomAsyncBroker(lookupDomBrokerInstance(transaction));
 189         return nameCreated;
 190     }
 191
 192     private static ObjectName createDomAsyncDataBroker(final ConfigTransactionJMXClient transaction) throws InstanceAlreadyExistsException {
 193         final ObjectName nameCreated = transaction.createModule(DomInmemoryDataBrokerModuleFactory.NAME, DOM_ASYNC_DATA_BROKER_INSTANCE);
 194         final DomInmemoryDataBrokerModuleMXBean mxBean = transaction.newMXBeanProxy(nameCreated, DomInmemoryDataBrokerModuleMXBean.class);
 195         mxBean.setSchemaService(lookupSchemaServiceInstance(transaction));
 196         return nameCreated;
 197     }
 198
 199     private static ObjectName lookupMappingServiceInstance(final ConfigTransactionJMXClient transaction) {
 200         try {
 201             return transaction.lookupConfigBean(RuntimeMappingModuleFactory.NAME, RuntimeMappingModuleFactory.SINGLETON_NAME);
 202         } catch (final InstanceNotFoundException e) {
 203             try {
 204                 return transaction.createModule(RuntimeMappingModuleFactory.NAME, RuntimeMappingModuleFactory.SINGLETON_NAME);
 205             } catch (final InstanceAlreadyExistsException e1) {
 206                 throw new IllegalStateException(e1);
 207             }
 208         }
 209     }
 210
 211     private static ObjectName lookupSchemaServiceInstance(final ConfigTransactionJMXClient transaction) {
 212         try {
 213             return transaction.lookupConfigBean(SchemaServiceImplSingletonModuleFactory.NAME, SchemaServiceImplSingletonModuleFactory.SINGLETON_NAME);
 214         } catch (InstanceNotFoundException e) {
 215             try {
 216                 return transaction.createModule(SchemaServiceImplSingletonModuleFactory.NAME, SchemaServiceImplSingletonModuleFactory.SINGLETON_NAME);
 217             } catch (final InstanceAlreadyExistsException e1) {
 218                 throw new IllegalStateException(e1);
 219             }
 220         }
 221     }
 222
 223     public static ObjectName lookupDomBrokerInstance(final ConfigTransactionJMXClient transaction) throws InstanceAlreadyExistsException {
 224         try {
 225             return transaction.lookupConfigBean(DomBrokerImplModuleFactory.NAME, DOM_BROKER_INSTANCE_NAME);
 226         } catch (final InstanceNotFoundException e) {
 227             try {
 228                 final ObjectName nameCreated = transaction.createModule(DomBrokerImplModuleFactory.NAME, DOM_BROKER_INSTANCE_NAME);
 229                 final DomBrokerImplModuleMXBean mxBean = transaction.newMXBeanProxy(nameCreated, DomBrokerImplModuleMXBean.class);
 230                 mxBean.setAsyncDataBroker(createDomAsyncDataBroker(transaction));
 231                 return nameCreated;
 232             } catch (final InstanceAlreadyExistsException e1) {
 233                 throw new IllegalStateException(e1);
 234             }
 235         }
 236     }
 237
 238     @Override
 239     protected BundleContextServiceRegistrationHandler getBundleContextServiceRegistrationHandler(final Class<?> serviceType) {
 240         if (serviceType.equals(SchemaContextListener.class)) {
 241             return new BundleContextServiceRegistrationHandler() {
 242                 @Override
 243                 public void handleServiceRegistration(final Class<?> clazz, final Object serviceInstance, final Dictionary<String, ?> props) {
 244                     final SchemaContextListener listener = (SchemaContextListener) serviceInstance;
 245                     final YangContextParser parser = new YangParserImpl();
 246                     SchemaContext context;
 247                     try {
 248                         context = parser.parseSources(getFilesAsByteSources(getYangModelsPaths()));
 249                     } catch (final IOException | YangSyntaxErrorException e) {
 250                         throw new IllegalStateException("Failed to parse models", e);
 251                     }
 252                     listener.onGlobalContextUpdated(context);
 253                 }
 254             };
 255         }
 256         return super.getBundleContextServiceRegistrationHandler(serviceType);
 257     }
 258
 259     public List<String> getYangModelsPaths() {
 260         List<String> paths = Lists.newArrayList("/META-INF/yang/ietf-inet-types.yang", "/META-INF/yang/programming.yang");
 261         return paths;
 262     }
 263
 264     public List<ModuleFactory> getModuleFactories() {
 265         return Lists.newArrayList(new InstructionSchedulerImplModuleFactory(), new HashedWheelTimerModuleFactory(),
 266                 new NotificationBrokerImplModuleFactory(), new RpcBrokerImplModuleFactory(), new DomBrokerImplModuleFactory(),
 267                 new RuntimeMappingModuleFactory(), new BindingBrokerImplModuleFactory(), new BindingAsyncDataBrokerImplModuleFactory(),
 268                 new DomInmemoryDataBrokerModuleFactory(), new SchemaServiceImplSingletonModuleFactory(),
 269                 new ForwardedCompatibleDataBrokerImplModuleFactory());
 270     }
 271
 272     // TODO move back to AbstractConfigTest
 273     private static Collection<ByteSource> getFilesAsByteSources(final List<String> paths) {
 274         final Collection<ByteSource> resources = new ArrayList<>();
 275         List<String> failedToFind = new ArrayList<>();
 276         for (String path : paths) {
 277             URL url = AbstractInstructionSchedulerTest.class.getResource(path);
 278             if (url == null) {
 279                 failedToFind.add(path);
 280             } else {
 281                 resources.add(Resources.asByteSource(url));
 282             }
 283         }
 284         Assert.assertEquals("Some files were not found", Collections.<String> emptyList(), failedToFind);
 285
 286         return resources;
 287     }
 288
 289 }