programming/impl-config/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.collect.Lists;
  14 import com.google.common.collect.Sets;
  15
  16 import java.io.InputStream;
  17 import java.util.ArrayList;
  18 import java.util.Collection;
  19 import java.util.Collections;
  20 import java.util.Dictionary;
  21 import java.util.List;
  22 import java.util.Map;
  23 import java.util.concurrent.Future;
  24
  25 import javax.management.InstanceAlreadyExistsException;
  26 import javax.management.InstanceNotFoundException;
  27 import javax.management.ObjectName;
  28
  29 import org.junit.Assert;
  30 import org.junit.Before;
  31 import org.mockito.Matchers;
  32 import org.mockito.Mock;
  33 import org.mockito.Mockito;
  34 import org.mockito.MockitoAnnotations;
  35 import org.opendaylight.controller.config.manager.impl.AbstractConfigTest;
  36 import org.opendaylight.controller.config.manager.impl.factoriesresolver.HardcodedModuleFactoriesResolver;
  37 import org.opendaylight.controller.config.spi.ModuleFactory;
  38 import org.opendaylight.controller.config.util.ConfigTransactionJMXClient;
  39 import org.opendaylight.controller.config.yang.md.sal.binding.impl.BindingBrokerImplModuleFactory;
  40 import org.opendaylight.controller.config.yang.md.sal.binding.impl.BindingBrokerImplModuleMXBean;
  41 import org.opendaylight.controller.config.yang.md.sal.binding.impl.DataBrokerImplModuleFactory;
  42 import org.opendaylight.controller.config.yang.md.sal.binding.impl.DataBrokerImplModuleMXBean;
  43 import org.opendaylight.controller.config.yang.md.sal.binding.impl.NotificationBrokerImplModuleFactory;
  44 import org.opendaylight.controller.config.yang.md.sal.binding.impl.RpcBrokerImplModuleFactory;
  45 import org.opendaylight.controller.config.yang.md.sal.binding.impl.RuntimeMappingModuleFactory;
  46 import org.opendaylight.controller.config.yang.md.sal.dom.impl.DomBrokerImplModuleFactory;
  47 import org.opendaylight.controller.config.yang.md.sal.dom.impl.DomBrokerImplModuleMXBean;
  48 import org.opendaylight.controller.config.yang.md.sal.dom.impl.HashMapDataStoreModuleFactory;
  49 import org.opendaylight.controller.config.yang.md.sal.dom.impl.HashMapDataStoreModuleMXBean;
  50 import org.opendaylight.controller.config.yang.netty.timer.HashedWheelTimerModuleFactory;
  51 import org.opendaylight.controller.md.sal.common.api.TransactionStatus;
  52 import org.opendaylight.controller.md.sal.common.api.data.DataCommitHandler;
  53 import org.opendaylight.controller.sal.core.api.RpcProvisionRegistry;
  54 import org.opendaylight.controller.sal.core.api.data.DataModificationTransaction;
  55 import org.opendaylight.controller.sal.core.api.data.DataProviderService;
  56 import org.opendaylight.controller.sal.core.api.mount.MountProvisionService;
  57 import org.opendaylight.controller.sal.core.api.mount.MountProvisionService.MountProvisionListener;
  58 import org.opendaylight.controller.sal.core.api.notify.NotificationPublishService;
  59 import org.opendaylight.yangtools.concepts.Registration;
  60 import org.opendaylight.yangtools.yang.common.RpcResult;
  61 import org.opendaylight.yangtools.yang.data.api.CompositeNode;
  62 import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
  63 import org.opendaylight.yangtools.yang.model.api.Module;
  64 import org.opendaylight.yangtools.yang.model.api.SchemaServiceListener;
  65 import org.opendaylight.yangtools.yang.model.parser.api.YangModelParser;
  66 import org.opendaylight.yangtools.yang.parser.impl.YangParserImpl;
  67 import org.osgi.framework.Bundle;
  68 import org.osgi.framework.BundleListener;
  69 import org.osgi.framework.Filter;
  70 import org.osgi.framework.ServiceListener;
  71 import org.osgi.framework.ServiceReference;
  72
  73 public abstract class AbstractInstructionSchedulerTest extends AbstractConfigTest {
  74
  75     private static final String FACTORY_NAME = InstructionSchedulerImplModuleFactory.NAME;
  76     private static final String INSTANCE_NAME = "instruction-scheduler-impl";
  77
  78     private static final String TRANSACTION_NAME = "testTransaction";
  79
  80     private static final String BINDING_BROKER_INSTANCE_NAME = "binding-broker-impl";
  81     private static final String NOTIFICATION_BROKER_INSTANCE_NAME = "notification-broker-impl";
  82     private static final String DATA_BROKER_INSTANCE_NAME = "data-broker-impl";
  83     private static final String DOM_BROKER_INSTANCE_NAME = "dom-broker-impl";
  84     private static final String DATA_STORE_INSTANCE_NAME = "data-store-impl";
  85     private static final String TIMER_INSTANCE_NAME = "timer-impl";
  86
  87     @Mock
  88     private DataModificationTransaction mockedTransaction;
  89
  90     @Mock
  91     private DataProviderService mockedDataProvider;
  92
  93     @Mock
  94     private RpcProvisionRegistry mockedRpcProvision;
  95
  96     @Mock
  97     private NotificationPublishService mockedNotificationPublish;
  98
  99     @Mock
 100     private MountProvisionService mockedMountProvision;
 101
 102     @Mock
 103     private Future<RpcResult<TransactionStatus>> mockedFuture;
 104
 105     @Mock
 106     private RpcResult<TransactionStatus> mockedResult;
 107
 108     @SuppressWarnings("unchecked")
 109     @Before
 110     public void setUp() throws Exception {
 111         MockitoAnnotations.initMocks(this);
 112
 113         List<ModuleFactory> moduleFactories = getModuleFactories();
 114         super.initConfigTransactionManagerImpl(new HardcodedModuleFactoriesResolver(mockedContext, moduleFactories.toArray(new ModuleFactory[moduleFactories.size()])));
 115
 116         Filter mockedFilter = mock(Filter.class);
 117         Mockito.doReturn(mockedFilter).when(mockedContext).createFilter(Mockito.anyString());
 118
 119         Mockito.doNothing().when(mockedContext).addServiceListener(any(ServiceListener.class), Mockito.anyString());
 120
 121         Mockito.doNothing().when(mockedContext).addBundleListener(any(BundleListener.class));
 122
 123         Mockito.doReturn(new Bundle[] {}).when(mockedContext).getBundles();
 124
 125         Mockito.doReturn(new ServiceReference[] {}).when(mockedContext).getServiceReferences(Matchers.anyString(), Matchers.anyString());
 126
 127         ServiceReference<?> emptyServiceReference = mock(ServiceReference.class, "Empty");
 128
 129         ServiceReference<?> dataProviderServiceReference = mock(ServiceReference.class, "Data Provider");
 130         ServiceReference<?> rpcProvisionServiceReference = mock(ServiceReference.class, "Rpc Provision");
 131         ServiceReference<?> mountProvisionServiceReference = mock(ServiceReference.class, "Mount Provision");
 132         ServiceReference<?> notificationPublishServiceReference = mock(ServiceReference.class, "Notification Publish");
 133
 134         Mockito.doReturn(mockedFilter).when(mockedContext).createFilter(Mockito.anyString());
 135
 136         Mockito.doNothing().when(mockedContext).addServiceListener(any(ServiceListener.class), Mockito.anyString());
 137
 138         Mockito.doNothing().when(mockedContext).addBundleListener(any(BundleListener.class));
 139
 140         Mockito.doReturn(new Bundle[] {}).when(mockedContext).getBundles();
 141
 142         Mockito.doReturn(new ServiceReference[] {}).when(mockedContext).getServiceReferences(Matchers.anyString(), Matchers.anyString());
 143
 144         Mockito.doReturn("Empty reference").when(emptyServiceReference).toString();
 145         Mockito.doReturn("Data Provider Service Reference").when(dataProviderServiceReference).toString();
 146         Mockito.doReturn("Rpc Provision Service Reference").when(rpcProvisionServiceReference).toString();
 147         Mockito.doReturn("Mount Provision Service Reference").when(mountProvisionServiceReference).toString();
 148         Mockito.doReturn("Notification Publish Service Reference").when(notificationPublishServiceReference).toString();
 149         //
 150         Mockito.doReturn(emptyServiceReference).when(mockedContext).getServiceReference(any(Class.class));
 151         Mockito.doReturn(dataProviderServiceReference).when(mockedContext).getServiceReference(DataProviderService.class);
 152         Mockito.doReturn(rpcProvisionServiceReference).when(mockedContext).getServiceReference(RpcProvisionRegistry.class);
 153         Mockito.doReturn(notificationPublishServiceReference).when(mockedContext).getServiceReference(NotificationPublishService.class);
 154         Mockito.doReturn(mountProvisionServiceReference).when(mockedContext).getServiceReference(MountProvisionService.class);
 155
 156         Mockito.doReturn(mockedDataProvider).when(mockedContext).getService(dataProviderServiceReference);
 157         Mockito.doReturn(mockedRpcProvision).when(mockedContext).getService(rpcProvisionServiceReference);
 158         Mockito.doReturn(mockedMountProvision).when(mockedContext).getService(mountProvisionServiceReference);
 159         Mockito.doReturn(mockedNotificationPublish).when(mockedContext).getService(notificationPublishServiceReference);
 160
 161         Mockito.doReturn(null).when(mockedContext).getService(emptyServiceReference);
 162
 163         Registration<DataCommitHandler<InstanceIdentifier, CompositeNode>> registration = mock(Registration.class);
 164         Mockito.doReturn(registration).when(mockedDataProvider).registerCommitHandler(any(InstanceIdentifier.class),
 165                 any(DataCommitHandler.class));
 166         Mockito.doReturn(registration).when(mockedDataProvider).registerCommitHandler(any(InstanceIdentifier.class),
 167                 any(DataCommitHandler.class));
 168
 169         Mockito.doReturn(null).when(mockedMountProvision).registerProvisionListener(any(MountProvisionListener.class));
 170
 171         Mockito.doReturn(null).when(mockedDataProvider).readOperationalData(any(InstanceIdentifier.class));
 172         Mockito.doReturn(mockedTransaction).when(mockedDataProvider).beginTransaction();
 173
 174         Mockito.doNothing().when(mockedTransaction).putOperationalData(any(InstanceIdentifier.class), any(CompositeNode.class));
 175         Mockito.doNothing().when(mockedTransaction).removeOperationalData(any(InstanceIdentifier.class));
 176
 177         Mockito.doReturn(mockedFuture).when(mockedTransaction).commit();
 178         Mockito.doReturn(TRANSACTION_NAME).when(mockedTransaction).getIdentifier();
 179
 180         Mockito.doReturn(mockedResult).when(mockedFuture).get();
 181         Mockito.doReturn(true).when(mockedResult).isSuccessful();
 182         Mockito.doReturn(Collections.emptySet()).when(mockedResult).getErrors();
 183
 184         Mockito.doReturn(null).when(mockedDataProvider).readConfigurationData(any(InstanceIdentifier.class));
 185     }
 186
 187     public ObjectName createInstructionSchedulerModuleInstance(final ConfigTransactionJMXClient transaction, final ObjectName dataBrokerON,
 188             final ObjectName rpcRegistyON, final ObjectName notificationBrokerON) throws Exception {
 189         final ObjectName objectName = transaction.createModule(FACTORY_NAME, INSTANCE_NAME);
 190         final InstructionSchedulerImplModuleMXBean mxBean = transaction.newMBeanProxy(objectName,
 191                 InstructionSchedulerImplModuleMXBean.class);
 192         mxBean.setDataProvider(dataBrokerON);
 193         mxBean.setRpcRegistry(rpcRegistyON);
 194         mxBean.setNotificationService(notificationBrokerON);
 195         mxBean.setTimer(createTimerInstance(transaction));
 196         return objectName;
 197     }
 198
 199     private ObjectName createTimerInstance(final ConfigTransactionJMXClient transaction) throws InstanceAlreadyExistsException {
 200         ObjectName nameCreated = transaction.createModule(HashedWheelTimerModuleFactory.NAME, TIMER_INSTANCE_NAME);
 201         return nameCreated;
 202
 203     }
 204
 205     public ObjectName createBindingBrokerImpl(final ConfigTransactionJMXClient transaction, final ObjectName dataBrokerON,
 206             final ObjectName notificationBrokerON) throws Exception {
 207         final ObjectName objectName = transaction.createModule(BindingBrokerImplModuleFactory.NAME, BINDING_BROKER_INSTANCE_NAME);
 208         final BindingBrokerImplModuleMXBean mxBean = transaction.newMBeanProxy(objectName, BindingBrokerImplModuleMXBean.class);
 209         mxBean.setDataBroker(dataBrokerON);
 210         mxBean.setNotificationService(notificationBrokerON);
 211         return objectName;
 212     }
 213
 214     public ObjectName createNotificationBrokerInstance(final ConfigTransactionJMXClient transaction) throws Exception {
 215         final ObjectName objectName = transaction.createModule(NotificationBrokerImplModuleFactory.NAME, NOTIFICATION_BROKER_INSTANCE_NAME);
 216         return objectName;
 217     }
 218
 219     public ObjectName createDataBrokerInstance(final ConfigTransactionJMXClient transaction) throws InstanceAlreadyExistsException,
 220             InstanceNotFoundException {
 221         ObjectName nameCreated = transaction.createModule(DataBrokerImplModuleFactory.NAME, DATA_BROKER_INSTANCE_NAME);
 222         DataBrokerImplModuleMXBean mxBean = transaction.newMBeanProxy(nameCreated, DataBrokerImplModuleMXBean.class);
 223         mxBean.setDomBroker(createDomBrokerInstance(transaction));
 224         mxBean.setMappingService(lookupMappingServiceInstance(transaction));
 225         return nameCreated;
 226     }
 227
 228     private ObjectName createDomBrokerInstance(final ConfigTransactionJMXClient transaction) throws InstanceAlreadyExistsException {
 229         ObjectName nameCreated = transaction.createModule(DomBrokerImplModuleFactory.NAME, DOM_BROKER_INSTANCE_NAME);
 230         DomBrokerImplModuleMXBean mxBean = transaction.newMBeanProxy(nameCreated, DomBrokerImplModuleMXBean.class);
 231         mxBean.setDataStore(createDataStoreInstance(transaction));
 232         return nameCreated;
 233     }
 234
 235     private ObjectName createDataStoreInstance(final ConfigTransactionJMXClient transaction) throws InstanceAlreadyExistsException {
 236         ObjectName nameCreated = transaction.createModule(HashMapDataStoreModuleFactory.NAME, DATA_STORE_INSTANCE_NAME);
 237         transaction.newMBeanProxy(nameCreated, HashMapDataStoreModuleMXBean.class);
 238         return nameCreated;
 239     }
 240
 241     private static ObjectName lookupMappingServiceInstance(final ConfigTransactionJMXClient transaction) {
 242
 243         try {
 244             return transaction.lookupConfigBean(RuntimeMappingModuleFactory.NAME, RuntimeMappingModuleFactory.SINGLETON_NAME);
 245         } catch (InstanceNotFoundException e) {
 246             try {
 247                 return transaction.createModule(RuntimeMappingModuleFactory.NAME, RuntimeMappingModuleFactory.SINGLETON_NAME);
 248             } catch (InstanceAlreadyExistsException e1) {
 249                 throw new IllegalStateException(e1);
 250             }
 251         }
 252     }
 253
 254     @Override
 255     protected BundleContextServiceRegistrationHandler getBundleContextServiceRegistrationHandler(final Class<?> serviceType) {
 256         if (serviceType.equals(SchemaServiceListener.class)) {
 257             return new BundleContextServiceRegistrationHandler() {
 258                 @Override
 259                 public void handleServiceRegistration(Class<?> clazz, Object serviceInstance, Dictionary<String, ?> props) {
 260                     SchemaServiceListener listener = (SchemaServiceListener) serviceInstance;
 261                     YangModelParser parser = new YangParserImpl();
 262                     Map<InputStream, Module> inputStreamModuleMap = parser.parseYangModelsFromStreamsMapped(new ArrayList<>(getFilesAsInputStreams(getYangModelsPaths())));
 263                     listener.onGlobalContextUpdated(parser.resolveSchemaContext(Sets.newHashSet(inputStreamModuleMap.values())));
 264                 }
 265             };
 266         }
 267
 268         return super.getBundleContextServiceRegistrationHandler(serviceType);
 269     }
 270
 271     public List<String> getYangModelsPaths() {
 272         List<String> paths = Lists.newArrayList("/META-INF/yang/ietf-inet-types.yang", "/META-INF/yang/programming.yang");
 273         return paths;
 274     }
 275
 276     public List<ModuleFactory> getModuleFactories() {
 277         return Lists.newArrayList(new InstructionSchedulerImplModuleFactory(), new HashedWheelTimerModuleFactory(),
 278                 new NotificationBrokerImplModuleFactory(), new RpcBrokerImplModuleFactory(), new DataBrokerImplModuleFactory(),
 279                 new DomBrokerImplModuleFactory(), new HashMapDataStoreModuleFactory(), new RuntimeMappingModuleFactory(),
 280                 new BindingBrokerImplModuleFactory());
 281     }
 282
 283     // TODO move back to AbstractConfigTest
 284     private static Collection<InputStream> getFilesAsInputStreams(List<String> paths) {
 285         final Collection<InputStream> resources = new ArrayList<>();
 286         List<String> failedToFind = new ArrayList<>();
 287         for (String path : paths) {
 288             InputStream resourceAsStream = AbstractInstructionSchedulerTest.class.getResourceAsStream(path);
 289             if (resourceAsStream == null) {
 290                 failedToFind.add(path);
 291             } else {
 292                 resources.add(resourceAsStream);
 293             }
 294         }
 295         Assert.assertEquals("Some files were not found", Collections.<String> emptyList(), failedToFind);
 296
 297         return resources;
 298     }
 299
 300 }