ab227cb671
Support for client contexts and also for localization of descriptions Reviewed-by: dfuchs
329 lines
13 KiB
Java
329 lines
13 KiB
Java
/*
|
|
* Copyright 2008 Sun Microsystems, Inc. All Rights Reserved.
|
|
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
*
|
|
* This code is free software; you can redistribute it and/or modify it
|
|
* under the terms of the GNU General Public License version 2 only, as
|
|
* published by the Free Software Foundation.
|
|
*
|
|
* This code is distributed in the hope that it will be useful, but WITHOUT
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
* version 2 for more details (a copy is included in the LICENSE file that
|
|
* accompanied this code).
|
|
*
|
|
* You should have received a copy of the GNU General Public License version
|
|
* 2 along with this work; if not, write to the Free Software Foundation,
|
|
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*
|
|
* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
|
|
* CA 95054 USA or visit www.sun.com if you need additional information or
|
|
* have any questions.
|
|
*/
|
|
|
|
/*
|
|
* @test
|
|
* @bug 5072267
|
|
* @summary Test that an MBean can handle localized Notification messages.
|
|
* @author Eamonn McManus
|
|
*/
|
|
|
|
import java.util.Collections;
|
|
import java.util.ListResourceBundle;
|
|
import java.util.Locale;
|
|
import java.util.Map;
|
|
import java.util.MissingResourceException;
|
|
import java.util.ResourceBundle;
|
|
import java.util.concurrent.ArrayBlockingQueue;
|
|
import java.util.concurrent.BlockingQueue;
|
|
import java.util.concurrent.Callable;
|
|
import java.util.concurrent.ConcurrentHashMap;
|
|
import java.util.concurrent.ConcurrentMap;
|
|
import java.util.concurrent.TimeUnit;
|
|
import javax.management.ClientContext;
|
|
import javax.management.JMX;
|
|
import javax.management.ListenerNotFoundException;
|
|
import javax.management.MBeanNotificationInfo;
|
|
import javax.management.MBeanServer;
|
|
import javax.management.MBeanServerConnection;
|
|
import javax.management.MBeanServerFactory;
|
|
import javax.management.Notification;
|
|
import javax.management.NotificationBroadcasterSupport;
|
|
import javax.management.NotificationEmitter;
|
|
import javax.management.NotificationFilter;
|
|
import javax.management.NotificationListener;
|
|
import javax.management.ObjectName;
|
|
import javax.management.SendNotification;
|
|
import javax.management.remote.JMXConnector;
|
|
import javax.management.remote.JMXConnectorFactory;
|
|
import javax.management.remote.JMXConnectorServer;
|
|
import javax.management.remote.JMXConnectorServerFactory;
|
|
import javax.management.remote.JMXServiceURL;
|
|
|
|
public class LocaleAwareBroadcasterTest {
|
|
static final ObjectName mbeanName = ObjectName.valueOf("d:type=LocaleAware");
|
|
|
|
static final String
|
|
messageKey = "broken.window",
|
|
defaultMessage = "broken window",
|
|
frenchMessage = "fen\u00eatre bris\u00e9e",
|
|
irishMessage = "fuinneog briste";
|
|
|
|
public static class Bundle extends ListResourceBundle {
|
|
@Override
|
|
protected Object[][] getContents() {
|
|
return new Object[][] {
|
|
{messageKey, defaultMessage},
|
|
};
|
|
}
|
|
}
|
|
|
|
public static class Bundle_fr extends ListResourceBundle {
|
|
@Override
|
|
protected Object[][] getContents() {
|
|
return new Object[][] {
|
|
{messageKey, frenchMessage},
|
|
};
|
|
}
|
|
}
|
|
|
|
public static class Bundle_ga extends ListResourceBundle {
|
|
@Override
|
|
protected Object[][] getContents() {
|
|
return new Object[][] {
|
|
{messageKey, irishMessage},
|
|
};
|
|
}
|
|
}
|
|
|
|
static volatile String failure;
|
|
|
|
public static interface LocaleAwareMBean {
|
|
public void sendNotification(Notification n);
|
|
}
|
|
|
|
public static class LocaleAware
|
|
implements LocaleAwareMBean, NotificationEmitter, SendNotification {
|
|
|
|
private final ConcurrentMap<Locale, NotificationBroadcasterSupport>
|
|
localeToEmitter = newConcurrentMap();
|
|
|
|
public void sendNotification(Notification n) {
|
|
for (Map.Entry<Locale, NotificationBroadcasterSupport> entry :
|
|
localeToEmitter.entrySet()) {
|
|
Notification localizedNotif =
|
|
localizeNotification(n, entry.getKey());
|
|
entry.getValue().sendNotification(localizedNotif);
|
|
}
|
|
}
|
|
|
|
public void addNotificationListener(
|
|
NotificationListener listener,
|
|
NotificationFilter filter,
|
|
Object handback)
|
|
throws IllegalArgumentException {
|
|
Locale locale = ClientContext.getLocale();
|
|
NotificationBroadcasterSupport broadcaster;
|
|
broadcaster = localeToEmitter.get(locale);
|
|
if (broadcaster == null) {
|
|
broadcaster = new NotificationBroadcasterSupport();
|
|
NotificationBroadcasterSupport old =
|
|
localeToEmitter.putIfAbsent(locale, broadcaster);
|
|
if (old != null)
|
|
broadcaster = old;
|
|
}
|
|
broadcaster.addNotificationListener(listener, filter, handback);
|
|
}
|
|
|
|
public void removeNotificationListener(NotificationListener listener)
|
|
throws ListenerNotFoundException {
|
|
Locale locale = ClientContext.getLocale();
|
|
NotificationBroadcasterSupport broadcaster =
|
|
localeToEmitter.get(locale);
|
|
if (broadcaster == null)
|
|
throw new ListenerNotFoundException();
|
|
broadcaster.removeNotificationListener(listener);
|
|
}
|
|
|
|
public void removeNotificationListener(
|
|
NotificationListener listener,
|
|
NotificationFilter filter,
|
|
Object handback)
|
|
throws ListenerNotFoundException {
|
|
Locale locale = ClientContext.getLocale();
|
|
NotificationBroadcasterSupport broadcaster =
|
|
localeToEmitter.get(locale);
|
|
if (broadcaster == null)
|
|
throw new ListenerNotFoundException();
|
|
broadcaster.removeNotificationListener(listener, filter, handback);
|
|
}
|
|
|
|
public MBeanNotificationInfo[] getNotificationInfo() {
|
|
return new MBeanNotificationInfo[0];
|
|
}
|
|
}
|
|
|
|
// Localize notif using the convention that the message looks like
|
|
// [resourcebundlename:resourcekey]defaultmessage
|
|
// for example [foo.bar.Resources:unknown.problem]
|
|
static Notification localizeNotification(Notification n, Locale locale) {
|
|
String msg = n.getMessage();
|
|
if (!msg.startsWith("["))
|
|
return n;
|
|
int close = msg.indexOf(']');
|
|
if (close < 0)
|
|
throw new IllegalArgumentException("Bad notification message: " + msg);
|
|
int colon = msg.indexOf(':');
|
|
if (colon < 0 || colon > close)
|
|
throw new IllegalArgumentException("Bad notification message: " + msg);
|
|
String bundleName = msg.substring(1, colon);
|
|
String key = msg.substring(colon + 1, close);
|
|
ClassLoader loader = LocaleAwareBroadcasterTest.class.getClassLoader();
|
|
ResourceBundle bundle =
|
|
ResourceBundle.getBundle(bundleName, locale, loader);
|
|
try {
|
|
msg = bundle.getString(key);
|
|
} catch (MissingResourceException e) {
|
|
msg = msg.substring(close + 1);
|
|
}
|
|
n = (Notification) n.clone();
|
|
n.setMessage(msg);
|
|
return n;
|
|
}
|
|
|
|
public static void main(String[] args) throws Exception {
|
|
Locale.setDefault(new Locale("en"));
|
|
testLocal();
|
|
testRemote();
|
|
if (failure == null)
|
|
System.out.println("TEST PASSED");
|
|
else
|
|
throw new Exception("TEST FAILED: " + failure);
|
|
}
|
|
|
|
static interface AddListenerInLocale {
|
|
public void addListenerInLocale(
|
|
MBeanServerConnection mbsc,
|
|
NotificationListener listener,
|
|
Locale locale) throws Exception;
|
|
}
|
|
|
|
private static void testLocal() throws Exception {
|
|
System.out.println("Test local MBeanServer using doWithContext");
|
|
MBeanServer mbs = makeMBS();
|
|
AddListenerInLocale addListener = new AddListenerInLocale() {
|
|
public void addListenerInLocale(
|
|
final MBeanServerConnection mbsc,
|
|
final NotificationListener listener,
|
|
Locale locale) throws Exception {
|
|
Map<String, String> localeContext = Collections.singletonMap(
|
|
ClientContext.LOCALE_KEY, locale.toString());
|
|
ClientContext.doWithContext(
|
|
localeContext, new Callable<Void>() {
|
|
public Void call() throws Exception {
|
|
mbsc.addNotificationListener(
|
|
mbeanName, listener, null, null);
|
|
return null;
|
|
}
|
|
});
|
|
}
|
|
};
|
|
test(mbs, addListener);
|
|
}
|
|
|
|
private static void testRemote() throws Exception {
|
|
System.out.println("Test remote MBeanServer using withLocale");
|
|
MBeanServer mbs = makeMBS();
|
|
JMXServiceURL url = new JMXServiceURL("service:jmx:rmi://");
|
|
JMXConnectorServer cs =
|
|
JMXConnectorServerFactory.newJMXConnectorServer(url, null, mbs);
|
|
cs.start();
|
|
JMXServiceURL addr = cs.getAddress();
|
|
JMXConnector cc = JMXConnectorFactory.connect(addr);
|
|
MBeanServerConnection mbsc = cc.getMBeanServerConnection();
|
|
AddListenerInLocale addListenerInLocale = new AddListenerInLocale() {
|
|
public void addListenerInLocale(
|
|
MBeanServerConnection mbsc,
|
|
NotificationListener listener,
|
|
Locale locale) throws Exception {
|
|
mbsc = ClientContext.withLocale(mbsc, locale);
|
|
mbsc.addNotificationListener(mbeanName, listener, null, null);
|
|
}
|
|
};
|
|
try {
|
|
test(mbsc, addListenerInLocale);
|
|
} finally {
|
|
try {
|
|
cc.close();
|
|
} catch (Exception e) {}
|
|
cs.stop();
|
|
}
|
|
}
|
|
|
|
static class QueueListener implements NotificationListener {
|
|
final BlockingQueue<Notification> queue =
|
|
new ArrayBlockingQueue<Notification>(10);
|
|
|
|
public void handleNotification(Notification notification,
|
|
Object handback) {
|
|
queue.add(notification);
|
|
}
|
|
}
|
|
|
|
private static void test(
|
|
MBeanServerConnection mbsc, AddListenerInLocale addListener)
|
|
throws Exception {
|
|
QueueListener defaultListener = new QueueListener();
|
|
QueueListener frenchListener = new QueueListener();
|
|
QueueListener irishListener = new QueueListener();
|
|
mbsc.addNotificationListener(mbeanName, defaultListener, null, null);
|
|
addListener.addListenerInLocale(mbsc, frenchListener, new Locale("fr"));
|
|
addListener.addListenerInLocale(mbsc, irishListener, new Locale("ga"));
|
|
|
|
LocaleAwareMBean proxy =
|
|
JMX.newMBeanProxy(mbsc, mbeanName, LocaleAwareMBean.class);
|
|
String notifMsg = "[" + Bundle.class.getName() + ":" + messageKey + "]" +
|
|
"broken window (default message that should never be seen)";
|
|
Notification notif = new Notification(
|
|
"notif.type", mbeanName, 0L, notifMsg);
|
|
proxy.sendNotification(notif);
|
|
|
|
final Object[][] expected = {
|
|
{defaultListener, defaultMessage},
|
|
{frenchListener, frenchMessage},
|
|
{irishListener, irishMessage},
|
|
};
|
|
for (Object[] exp : expected) {
|
|
QueueListener ql = (QueueListener) exp[0];
|
|
String msg = (String) exp[1];
|
|
System.out.println("Checking: " + msg);
|
|
Notification n = ql.queue.poll(1, TimeUnit.SECONDS);
|
|
if (n == null)
|
|
fail("Did not receive expected notif: " + msg);
|
|
if (!n.getMessage().equals(msg)) {
|
|
fail("Received notif with wrong message: got " +
|
|
n.getMessage() + ", expected " + msg);
|
|
}
|
|
n = ql.queue.poll(2, TimeUnit.MILLISECONDS);
|
|
if (n != null)
|
|
fail("Received unexpected extra notif: " + n);
|
|
}
|
|
}
|
|
|
|
private static MBeanServer makeMBS() throws Exception {
|
|
MBeanServer mbs = MBeanServerFactory.newMBeanServer();
|
|
LocaleAware aware = new LocaleAware();
|
|
mbs.registerMBean(aware, mbeanName);
|
|
return mbs;
|
|
}
|
|
|
|
static <K, V> ConcurrentMap<K, V> newConcurrentMap() {
|
|
return new ConcurrentHashMap<K, V>();
|
|
}
|
|
|
|
static void fail(String why) {
|
|
System.out.println("FAIL: " + why);
|
|
failure = why;
|
|
}
|
|
}
|