|
1
8
9 package test.javax.management.remote.rmi;
10
11 import java.lang.reflect.Constructor  ;
12 import java.lang.reflect.Method ;
13 import java.util.Map ;
14 import javax.management.MBeanInfo ;
15 import javax.management.MBeanServer ;
16 import javax.management.MBeanServerConnection ;
17 import javax.management.MBeanServerFactory ;
18 import javax.management.Notification ;
19 import javax.management.NotificationFilter ;
20 import javax.management.NotificationListener ;
21 import javax.management.ObjectName ;
22 import javax.management.loading.MLet ;
23 import javax.management.remote.JMXConnector ;
24 import javax.management.remote.JMXConnectorFactory ;
25 import javax.management.remote.JMXConnectorServer ;
26 import javax.management.remote.JMXConnectorServerFactory ;
27 import javax.management.remote.JMXServiceURL ;
28
29 import test.MX4JTestCase;
30 import test.MutableObject;
31
32
35 public class RMIInteroperabilityTest extends MX4JTestCase
36 {
37 public RMIInteroperabilityTest(String s)
38 {
39 super(s);
40 }
41
42 private Object startJMXRIRMIConnectorServer() throws Exception
43 {
44 ClassLoader ri = createRemoteJMXRIWithTestsClassLoader();
45
46 Class mbeanServerFactoryClass = ri.loadClass(MBeanServerFactory .class.getName());
47 Method method = mbeanServerFactoryClass.getMethod("newMBeanServer", new Class [0]);
48 Object mbeanServer = method.invoke(null, new Object [0]);
49 if (!mbeanServer.getClass().getName().startsWith("com.sun")) fail();
50 Class mbeanServerClass = ri.loadClass(MBeanServer .class.getName());
51
52 Class serviceURLClass = ri.loadClass(JMXServiceURL .class.getName());
53 Constructor constructor = serviceURLClass.getConstructor(new Class []{String .class});
54 Object serviceURL = constructor.newInstance(new Object []{"service:jmx:rmi://localhost"});
55 Class cntorServerFactoryClass = ri.loadClass(JMXConnectorServerFactory .class.getName());
56 method = cntorServerFactoryClass.getMethod("newJMXConnectorServer", new Class []{serviceURLClass, Map .class, mbeanServerClass});
57 Object cntorServer = method.invoke(null, new Object []{serviceURL, null, mbeanServer});
58
59 method = cntorServer.getClass().getMethod("start", new Class [0]);
60 method.invoke(cntorServer, new Object [0]);
61
62 return cntorServer;
63 }
64
65 public void testJMXRIOnServerMX4JOnClientGetMBeanInfo() throws Exception
66 {
67 Object cntorServer = startJMXRIRMIConnectorServer();
68 Method method = cntorServer.getClass().getMethod("getAddress", new Class [0]);
69 Object address = method.invoke(cntorServer, new Object [0]);
70 String url = address.toString();
71
72 JMXConnector cntor = JMXConnectorFactory.connect(new JMXServiceURL (url));
73 MBeanServerConnection cntion = cntor.getMBeanServerConnection();
74
75 MBeanInfo info = cntion.getMBeanInfo(ObjectName.getInstance("JMImplementation", "type", "MBeanServerDelegate"));
76 assertNotNull(info);
77
78 cntor.close();
79
80 method = cntorServer.getClass().getMethod("stop", new Class [0]);
81 method.invoke(cntorServer, new Object [0]);
82 sleep(2000);
83 }
84
85 public void testJMXRIOnServerMX4JOnClientNotificationReceiving() throws Exception
86 {
87 Object cntorServer = startJMXRIRMIConnectorServer();
88 Method method = cntorServer.getClass().getMethod("getAddress", new Class [0]);
89 Object address = method.invoke(cntorServer, new Object [0]);
90 String url = address.toString();
91
92 JMXConnector cntor = JMXConnectorFactory.connect(new JMXServiceURL (url));
93 MBeanServerConnection cntion = cntor.getMBeanServerConnection();
94
95 InteroperabilityListener listener = new InteroperabilityListener();
96 ObjectName delegateName = ObjectName.getInstance("JMImplementation:type=MBeanServerDelegate");
97 cntion.addNotificationListener(delegateName, listener, null, null);
98 sleep(1000);
99
100 ObjectName name = ObjectName.getInstance(":mbean=mlet");
101 cntion.createMBean(MLet .class.getName(), name, null);
102 sleep(1000);
103 Notification notification = (Notification )listener.get();
104 assertNotNull(notification);
105 listener.reset();
106
107 cntion.removeNotificationListener(delegateName, listener);
108
109 cntion.unregisterMBean(name);
110 sleep(1000);
111
112 notification = (Notification )listener.get();
113 assertNull(notification);
114
115 cntor.close();
116
117 method = cntorServer.getClass().getMethod("stop", new Class [0]);
118 method.invoke(cntorServer, new Object [0]);
119 sleep(2000);
120 }
121
122 private Object connectJMXRIConnector(ClassLoader ri, String url) throws Exception
123 {
124 Class serviceURLClass = ri.loadClass(JMXServiceURL .class.getName());
125 Constructor constructor = serviceURLClass.getConstructor(new Class []{String .class});
126 Object serviceURL = constructor.newInstance(new Object []{url});
127 Class cntorFactoryClass = ri.loadClass(JMXConnectorFactory .class.getName());
128 Method method = cntorFactoryClass.getMethod("connect", new Class []{serviceURLClass});
129 return method.invoke(null, new Object []{serviceURL});
130 }
131
132 public void testMX4JOnServerJMXRIOnClientGetMBeanInfo() throws Exception
133 {
134 MBeanServer server = newMBeanServer();
135 JMXServiceURL url = new JMXServiceURL ("service:jmx:rmi://localhost");
136 JMXConnectorServer cntorServer = JMXConnectorServerFactory.newJMXConnectorServer(url, null, server);
137 cntorServer.start();
138 url = cntorServer.getAddress();
139
140 ClassLoader ri = createRemoteJMXRIWithTestsClassLoader();
141 ClassLoader tccl = Thread.currentThread().getContextClassLoader();
142 Thread.currentThread().setContextClassLoader(ri);
143 Object cntor = connectJMXRIConnector(ri, url.toString());
144
145 Method method = cntor.getClass().getMethod("getMBeanServerConnection", new Class [0]);
146 Object cntion = method.invoke(cntor, new Object [0]);
147 Class cntionClass = ri.loadClass(MBeanServerConnection .class.getName());
148
149 Class objectNameClass = ri.loadClass(ObjectName .class.getName());
150 method = objectNameClass.getMethod("getInstance", new Class []{String .class});
151 Object objectName = method.invoke(null, new Object []{"JMImplementation:type=MBeanServerDelegate"});
152 method = cntionClass.getMethod("getMBeanInfo", new Class []{objectNameClass});
153 Object info = method.invoke(cntion, new Object []{objectName});
154 assertNotNull(info);
155
156 method = cntor.getClass().getMethod("close", new Class [0]);
157 method.invoke(cntor, new Object [0]);
158
159 Thread.currentThread().setContextClassLoader(tccl);
160 cntorServer.stop();
161 sleep(2000);
162 }
163
164 public void testMX4JOnServerJMXRIOnClientNotificationReceiving() throws Exception
165 {
166 MBeanServer server = newMBeanServer();
167 JMXServiceURL url = new JMXServiceURL ("service:jmx:rmi://localhost");
168 JMXConnectorServer cntorServer = JMXConnectorServerFactory.newJMXConnectorServer(url, null, server);
169 cntorServer.start();
170 url = cntorServer.getAddress();
171
172 ClassLoader ri = createRemoteJMXRIWithTestsClassLoader();
173 ClassLoader tccl = Thread.currentThread().getContextClassLoader();
174 Thread.currentThread().setContextClassLoader(ri);
175 Object cntor = connectJMXRIConnector(ri, url.toString());
176
177 Method method = cntor.getClass().getMethod("getMBeanServerConnection", new Class [0]);
178 Object cntion = method.invoke(cntor, new Object [0]);
179 Class cntionClass = ri.loadClass(MBeanServerConnection .class.getName());
180
181 Class objectNameClass = ri.loadClass(ObjectName .class.getName());
182 method = objectNameClass.getMethod("getInstance", new Class []{String .class});
183 Object delegateName = method.invoke(null, new Object []{"JMImplementation:type=MBeanServerDelegate"});
184 Class notificationListenerClass = ri.loadClass(NotificationListener .class.getName());
185 Class notificationFilterClass = ri.loadClass(NotificationFilter .class.getName());
186 Object listener = ri.loadClass(InteroperabilityListener.class.getName()).newInstance();
187 method = cntionClass.getMethod("addNotificationListener", new Class []{objectNameClass, notificationListenerClass, notificationFilterClass, Object .class});
188 method.invoke(cntion, new Object []{delegateName, listener, null, null});
189 sleep(1000);
190
191 method = objectNameClass.getMethod("getInstance", new Class []{String .class});
192 Object mletName = method.invoke(null, new Object []{":mbean=mlet"});
193
194 method = cntionClass.getMethod("createMBean", new Class []{String .class, objectNameClass, objectNameClass});
195 method.invoke(cntion, new Object []{MLet .class.getName(), mletName, null});
196 sleep(1000);
197
198 method = listener.getClass().getMethod("get", new Class [0]);
199 Object notification = method.invoke(listener, new Object [0]);
200 assertNotNull(notification);
201
202 method = listener.getClass().getMethod("reset", new Class [0]);
203 method.invoke(listener, new Object [0]);
204
205 method = cntionClass.getMethod("removeNotificationListener", new Class []{objectNameClass, notificationListenerClass});
206 method.invoke(cntion, new Object []{delegateName, listener});
207
208 method = cntionClass.getMethod("unregisterMBean", new Class []{objectNameClass});
209 method.invoke(cntion, new Object []{mletName});
210 sleep(1000);
211
212 method = listener.getClass().getMethod("get", new Class [0]);
213 notification = method.invoke(listener, new Object [0]);
214 assertNull(notification);
215
216 method = cntor.getClass().getMethod("close", new Class [0]);
217 method.invoke(cntor, new Object [0]);
218
219 Thread.currentThread().setContextClassLoader(tccl);
220 cntorServer.stop();
221 sleep(2000);
222 }
223
224 public static class InteroperabilityListener implements NotificationListener
225 {
226 private final MutableObject holder;
227
228 public InteroperabilityListener()
229 {
230 this.holder = new MutableObject(null);
231 }
232
233 public void handleNotification(Notification notification, Object handback)
234 {
235 holder.set(notification);
236 }
237
238 public void reset()
239 {
240 holder.set(null);
241 }
242
243 public Object get()
244 {
245 return holder.get();
246 }
247 }
248 }
249 |
Popular Tags |
Java API By Example, From Geeks To Geeks.