package org.opendaylight.controller.config.manager.impl;
import com.google.common.base.Preconditions;
-import com.google.common.collect.Maps;
import junit.framework.Assert;
import org.junit.After;
import org.mockito.Matchers;
import org.opendaylight.controller.config.spi.Module;
import org.opendaylight.controller.config.util.ConfigRegistryJMXClient;
import org.opendaylight.controller.config.util.ConfigTransactionJMXClient;
+import org.opendaylight.yangtools.yang.data.impl.codec.CodecRegistry;
import org.osgi.framework.BundleContext;
import org.osgi.framework.ServiceRegistration;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
import javax.management.InstanceAlreadyExistsException;
import javax.management.MBeanServer;
import javax.management.ObjectName;
+import javax.management.RuntimeMBeanException;
import java.io.Closeable;
import java.io.InputStream;
import java.lang.management.ManagementFactory;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
import java.util.Dictionary;
import java.util.List;
-import java.util.Map;
import java.util.Set;
import static org.junit.Assert.assertEquals;
protected BundleContext mockedContext = mock(BundleContext.class);
protected ServiceRegistration<?> mockedServiceRegistration;
- protected Map<Class, BundleContextServiceRegistrationHandler> getBundleContextServiceRegistrationHandlers() {
- return Maps.newHashMap();
+ private static final Logger logger = LoggerFactory.getLogger(AbstractConfigTest.class);
+
+ // Default handler for OSGi service registration
+ private static final BundleContextServiceRegistrationHandler noopServiceRegHandler = new BundleContextServiceRegistrationHandler() {
+ @Override
+ public void handleServiceRegistration(Object serviceInstance) {}
+ };
+
+ protected BundleContextServiceRegistrationHandler getBundleContextServiceRegistrationHandler(Class<?> serviceType) {
+ return noopServiceRegHandler;
}
// this method should be called in @Before
baseJmxRegistrator = new BaseJMXRegistrator(internalJmxRegistrator);
configRegistry = new ConfigRegistryImpl(resolver,
- platformMBeanServer, baseJmxRegistrator);
+ platformMBeanServer, baseJmxRegistrator, getCodecRegistry());
try {
configRegistryJMXRegistrator.registerToJMX(configRegistry);
protected ObjectName createTestConfigBean(
ConfigTransactionJMXClient transaction, String implementationName,
String name) throws InstanceAlreadyExistsException {
- ObjectName nameCreated = transaction.createModule(implementationName,
+ return transaction.createModule(implementationName,
name);
- return nameCreated;
}
protected void assertBeanCount(int i, String configMXBeanName) {
return new ClassBasedModuleFactory(implementationName, configBeanClass);
}
+ protected CodecRegistry getCodecRegistry() {
+ return mock(CodecRegistry.class);
+ }
public static interface BundleContextServiceRegistrationHandler {
}
- private class RegisterServiceAnswer implements Answer {
+ private class RegisterServiceAnswer implements Answer<ServiceRegistration<?>> {
+
@Override
- public Object answer(InvocationOnMock invocation) throws Throwable {
+ public ServiceRegistration<?> answer(InvocationOnMock invocation) throws Throwable {
Object[] args = invocation.getArguments();
- Preconditions.checkArgument(args.length == 3);
+ Preconditions.checkArgument(args.length == 3, "Unexpected arguments size (expected 3 was %s)", args.length);
- Preconditions.checkArgument(args[0] instanceof Class);
- Class<?> serviceType = (Class<?>) args[0];
+ Object serviceTypeRaw = args[0];
Object serviceInstance = args[1];
- BundleContextServiceRegistrationHandler serviceRegistrationHandler = getBundleContextServiceRegistrationHandlers()
- .get(serviceType);
+ if (serviceTypeRaw instanceof Class) {
+ Class<?> serviceType = (Class<?>) serviceTypeRaw;
+ invokeServiceHandler(serviceInstance, serviceType);
+
+ } else if(serviceTypeRaw instanceof String[]) {
+ for (String className : (String[]) serviceTypeRaw) {
+ try {
+ Class<?> serviceType = Class.forName(className);
+ invokeServiceHandler(serviceInstance, serviceType);
+ } catch (ClassNotFoundException e) {
+ logger.warn("Not handling service registration of type {} ", className, e);
+ }
+ }
+
+ } else
+ logger.debug("Not handling service registration of type {}, Unknown type", serviceTypeRaw);
+
+ return mockedServiceRegistration;
+ }
- Preconditions.checkArgument(serviceType.isAssignableFrom(serviceInstance.getClass()));
+ private void invokeServiceHandler(Object serviceInstance, Class<?> serviceType) {
+ BundleContextServiceRegistrationHandler serviceRegistrationHandler = getBundleContextServiceRegistrationHandler(serviceType);
if (serviceRegistrationHandler != null) {
serviceRegistrationHandler.handleServiceRegistration(serviceType.cast(serviceInstance));
}
-
- return mockedServiceRegistration;
}
}
+
+ /**
+ * Expand inner exception wrapped by JMX
+ *
+ * @param innerObject jmx proxy which will be wrapped and returned
+ */
+ protected <T> T rethrowCause(final T innerObject) {
+
+ Object proxy = Proxy.newProxyInstance(innerObject.getClass().getClassLoader(),
+ innerObject.getClass().getInterfaces(), new InvocationHandler() {
+ @Override
+ public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
+ try {
+ return method.invoke(innerObject, args);
+ } catch (InvocationTargetException e) {
+ try {
+ throw e.getTargetException();
+ } catch (RuntimeMBeanException e2) {
+ throw e2.getTargetException();
+ }
+ }
+ }
+ });
+ return (T) proxy;
+ }
+
}