KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > javax > management > relation > MBeanServerNotificationFilter


1 /*
2  * @(#)MBeanServerNotificationFilter.java 1.33 04/02/10
3  *
4  * Copyright 2004 Sun Microsystems, Inc. All rights reserved.
5  * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
6  */
7
8 package javax.management.relation;
9
10 import java.io.IOException JavaDoc;
11 import java.io.ObjectInputStream JavaDoc;
12 import java.io.ObjectOutputStream JavaDoc;
13 import java.io.ObjectStreamField JavaDoc;
14 import java.security.AccessController JavaDoc;
15 import java.security.PrivilegedAction JavaDoc;
16
17 import javax.management.Notification JavaDoc;
18 import javax.management.NotificationFilterSupport JavaDoc;
19 import javax.management.MBeanServerNotification JavaDoc;
20 import javax.management.ObjectName JavaDoc;
21
22 import java.util.List JavaDoc;
23 import java.util.Vector JavaDoc;
24
25 import com.sun.jmx.mbeanserver.GetPropertyAction;
26 import com.sun.jmx.trace.Trace;
27
28 /**
29  * Filter for {@link MBeanServerNotification}.
30  * This filter filters MBeanServerNotification notifications by
31  * selecting the ObjectNames of interest and the operations (registration,
32  * unregistration, both) of interest (corresponding to notification
33  * types).
34  *
35  * @since 1.5
36  */
37 public class MBeanServerNotificationFilter extends NotificationFilterSupport JavaDoc {
38
39     // Serialization compatibility stuff:
40 // Two serial forms are supported in this class. The selected form depends
41 // on system property "jmx.serial.form":
42 // - "1.0" for JMX 1.0
43 // - any other value for JMX 1.1 and higher
44 //
45 // Serial version for old serial form
46 private static final long oldSerialVersionUID = 6001782699077323605L;
47     //
48 // Serial version for new serial form
49 private static final long newSerialVersionUID = 2605900539589789736L;
50     //
51 // Serializable fields in old serial form
52 private static final ObjectStreamField JavaDoc[] oldSerialPersistentFields =
53     {
54       new ObjectStreamField JavaDoc("mySelectObjNameList", Vector JavaDoc.class),
55       new ObjectStreamField JavaDoc("myDeselectObjNameList", Vector JavaDoc.class)
56     };
57     //
58 // Serializable fields in new serial form
59 private static final ObjectStreamField JavaDoc[] newSerialPersistentFields =
60     {
61       new ObjectStreamField JavaDoc("selectedNames", List JavaDoc.class),
62       new ObjectStreamField JavaDoc("deselectedNames", List JavaDoc.class)
63     };
64     //
65 // Actual serial version and serial form
66 private static final long serialVersionUID;
67     /**
68      * @serialField selectedNames List List of {@link ObjectName}s of interest
69      * <ul>
70      * <li><code>null</code> means that all {@link ObjectName}s are implicitly selected
71      * (check for explicit deselections)</li>
72      * <li>Empty vector means that no {@link ObjectName} is explicitly selected</li>
73      * </ul>
74      * @serialField deselectedNames List List of {@link ObjectName}s with no interest
75      * <ul>
76      * <li><code>null</code> means that all {@link ObjectName}s are implicitly deselected
77      * (check for explicit selections))</li>
78      * <li>Empty vector means that no {@link ObjectName} is explicitly deselected</li>
79      * </ul>
80      */
81     private static final ObjectStreamField JavaDoc[] serialPersistentFields;
82     private static boolean compat = false;
83     static {
84     try {
85         PrivilegedAction JavaDoc act = new GetPropertyAction("jmx.serial.form");
86         String JavaDoc form = (String JavaDoc) AccessController.doPrivileged(act);
87         compat = (form != null && form.equals("1.0"));
88     } catch (Exception JavaDoc e) {
89         // OK : Too bad, no compat with 1.0
90 }
91     if (compat) {
92         serialPersistentFields = oldSerialPersistentFields;
93         serialVersionUID = oldSerialVersionUID;
94     } else {
95         serialPersistentFields = newSerialPersistentFields;
96         serialVersionUID = newSerialVersionUID;
97     }
98     }
99     //
100 // END Serialization compatibility stuff
101
102     //
103 // Private members
104 //
105
106     /**
107      * @serial List of {@link ObjectName}s of interest
108      * <ul>
109      * <li><code>null</code> means that all {@link ObjectName}s are implicitly selected
110      * (check for explicit deselections)</li>
111      * <li>Empty vector means that no {@link ObjectName} is explicitly selected</li>
112      * </ul>
113      */
114     private List JavaDoc selectedNames = new Vector JavaDoc();
115
116     /**
117      * @serial List of {@link ObjectName}s with no interest
118      * <ul>
119      * <li><code>null</code> means that all {@link ObjectName}s are implicitly deselected
120      * (check for explicit selections))</li>
121      * <li>Empty vector means that no {@link ObjectName} is explicitly deselected</li>
122      * </ul>
123      */
124     private List JavaDoc deselectedNames = null;
125   
126     //
127 // Constructor
128 //
129
130     /**
131      * Creates a filter selecting all MBeanServerNotification notifications for
132      * all ObjectNames.
133      */
134     public MBeanServerNotificationFilter() {
135
136     super();
137
138         if (isTraceOn())
139             trace("Constructor: entering", null);
140
141     enableType(MBeanServerNotification.REGISTRATION_NOTIFICATION);
142     enableType(MBeanServerNotification.UNREGISTRATION_NOTIFICATION);
143
144         if (isTraceOn())
145             trace("Constructor: exiting", null);
146     return;
147     }
148
149     //
150 // Accessors
151 //
152
153     /**
154      * Disables any MBeanServerNotification (all ObjectNames are
155      * deselected).
156      */
157     public synchronized void disableAllObjectNames() {
158
159         if (isTraceOn())
160             trace("disableAllObjectNames: entering", null);
161
162     selectedNames = new Vector JavaDoc();
163     deselectedNames = null;
164
165         if (isTraceOn())
166             trace("disableAllObjectNames: exiting", null);
167     return;
168     }
169
170     /**
171      * Disables MBeanServerNotifications concerning given ObjectName.
172      *
173      * @param theObjName ObjectName no longer of interest
174      *
175      * @exception IllegalArgumentException if the given ObjectName is null
176      */
177     public synchronized void disableObjectName(ObjectName JavaDoc theObjName)
178     throws IllegalArgumentException JavaDoc {
179
180     if (theObjName == null) {
181         // Revisit [cebro] Localize message
182 String JavaDoc excMsg = "Invalid parameter.";
183         throw new IllegalArgumentException JavaDoc(excMsg);
184     }
185
186     if (isTraceOn())
187             trace("disableObjectName: entering", theObjName.toString());
188
189     // Removes from selected ObjectNames, if present
190 if (selectedNames != null) {
191         if (selectedNames.size() != 0) {
192         selectedNames.remove(theObjName);
193         }
194     }
195
196     // Adds it in deselected ObjectNames
197 if (deselectedNames != null) {
198         // If all are deselected, no need to do anything :)
199 if (!(deselectedNames.contains(theObjName))) {
200         // ObjectName was not already deselected
201 deselectedNames.add(theObjName);
202         }
203     }
204
205         if (isTraceOn())
206             trace("disableObjectName: exiting", null);
207     return;
208     }
209
210     /**
211      * Enables all MBeanServerNotifications (all ObjectNames are selected).
212      */
213     public synchronized void enableAllObjectNames() {
214
215     if (isTraceOn())
216             trace("enableAllObjectNames: entering", null);
217
218         selectedNames = null;
219     deselectedNames = new Vector JavaDoc();
220
221         if (isTraceOn())
222             trace("enableAllObjectNames: exiting", null);
223     return;
224     }
225
226     /**
227      * Enables MBeanServerNotifications concerning given ObjectName.
228      *
229      * @param theObjName ObjectName of interest
230      *
231      * @exception IllegalArgumentException if the given ObjectName is null
232      */
233     public synchronized void enableObjectName(ObjectName JavaDoc theObjName)
234     throws IllegalArgumentException JavaDoc {
235
236     if (theObjName == null) {
237         // Revisit [cebro] Localize message
238 String JavaDoc excMsg = "Invalid parameter.";
239         throw new IllegalArgumentException JavaDoc(excMsg);
240     }
241
242     if (isTraceOn())
243             trace("enableObjectName: entering", theObjName.toString());
244
245     // Removes from deselected ObjectNames, if present
246 if (deselectedNames != null) {
247         if (deselectedNames.size() != 0) {
248         deselectedNames.remove(theObjName);
249         }
250     }
251
252     // Adds it in selected ObjectNames
253 if (selectedNames != null) {
254         // If all are selected, no need to do anything :)
255 if (!(selectedNames.contains(theObjName))) {
256         // ObjectName was not already selected
257 selectedNames.add(theObjName);
258         }
259     }
260
261         if (isTraceOn())
262             trace("enableObjectName: exiting", null);
263     return;
264     }
265         
266     /**
267      * Gets all the ObjectNames enabled.
268      *
269      * @return Vector of ObjectNames:
270      * <P>- null means all ObjectNames are implicitly selected, except the
271      * ObjectNames explicitly deselected
272      * <P>- empty means all ObjectNames are deselected, i.e. no ObjectName
273      * selected.
274      */
275     public synchronized Vector JavaDoc getEnabledObjectNames() {
276     if (selectedNames != null) {
277         return (Vector JavaDoc)((Vector JavaDoc)selectedNames).clone();
278     } else {
279         return null;
280     }
281     }
282
283     /**
284      * Gets all the ObjectNames disabled.
285      *
286      * @return Vector of ObjectNames:
287      * <P>- null means all ObjectNames are implicitly deselected, except the
288      * ObjectNames explicitly selected
289      * <P>- empty means all ObjectNames are selected, i.e. no ObjectName
290      * deselected.
291      */
292     public synchronized Vector JavaDoc getDisabledObjectNames() {
293     if (deselectedNames != null) {
294         return (Vector JavaDoc)((Vector JavaDoc)deselectedNames).clone();
295     } else {
296         return null;
297     }
298     }
299
300     //
301 // NotificationFilter interface
302 //
303
304     /**
305      * Invoked before sending the specified notification to the listener.
306      * <P>If:
307      * <P>- the ObjectName of the concerned MBean is selected (explicitly OR
308      * (implicitly and not explicitly deselected))
309      * <P>AND
310      * <P>- the type of the operation (registration or unregistration) is
311      * selected
312      * <P>then the notification is sent to the listener.
313      *
314      * @param theNtf The notification to be sent.
315      *
316      * @return true if the notification has to be sent to the listener, false
317      * otherwise.
318      *
319      * @exception IllegalArgumentException if null parameter
320      */
321     public synchronized boolean isNotificationEnabled(Notification JavaDoc theNtf)
322     throws IllegalArgumentException JavaDoc {
323
324     if (theNtf == null) {
325         // Revisit [cebro] Localize message
326 String JavaDoc excMsg = "Invalid parameter.";
327         throw new IllegalArgumentException JavaDoc(excMsg);
328     }
329
330     if (isTraceOn())
331             trace("isNotificationEnabled: entering", theNtf.toString());
332
333     // Checks the type first
334 String JavaDoc ntfType = theNtf.getType();
335     Vector JavaDoc enabledTypes = getEnabledTypes();
336     if (!(enabledTypes.contains(ntfType))) {
337
338         if (isTraceOn())
339         trace("isNotificationEnabled: type not selected, exiting", null);
340         return false;
341     }
342
343     // We have a MBeanServerNotification: downcasts it
344 MBeanServerNotification JavaDoc mbsNtf = (MBeanServerNotification JavaDoc)theNtf;
345
346     // Checks the ObjectName
347 ObjectName JavaDoc objName = mbsNtf.getMBeanName();
348     // Is it selected?
349 boolean isSelectedFlg = false;
350     if (selectedNames != null) {
351         // Not all are implicitly selected:
352 // checks for explicit selection
353 if (selectedNames.size() == 0) {
354         // All are explicitly not selected
355 if (isTraceOn())
356             trace("isNotificationEnabled: no ObjectNames selected, exiting", null);
357         return false;
358         }
359
360         isSelectedFlg = selectedNames.contains(objName);
361         if (!isSelectedFlg) {
362         // Not in the explicit selected list
363 if (isTraceOn())
364             trace("isNotificationEnabled: ObjectName not in selected list, exiting", null);
365         return false;
366         }
367     }
368
369     if (!isSelectedFlg) {
370         // Not explicitly selected: is it deselected?
371
372         if (deselectedNames == null) {
373         // All are implicitly deselected and it is not explicitly
374 // selected
375 if (isTraceOn())
376             trace("isNotificationEnabled: ObjectName not selected and all deselectedm, exiting", null);
377         return false;
378
379         } else if (deselectedNames.contains(objName)) {
380         // Explicitly deselected
381 if (isTraceOn())
382             trace("isNotificationEnabled: ObjectName explicitly not selected, exiting", null);
383         return false;
384         }
385     }
386
387     if (isTraceOn())
388         trace("isNotificationEnabled: ObjectName selected, exiting", null);
389     return true;
390     }
391
392     // stuff for Tracing
393
394     private static String JavaDoc localClassName = "MBeanServerNotificationFilter";
395
396     // trace level
397 private boolean isTraceOn() {
398         return Trace.isSelected(Trace.LEVEL_TRACE, Trace.INFO_RELATION);
399     }
400
401 // private void trace(String className, String methodName, String info) {
402 // Trace.send(Trace.LEVEL_TRACE, Trace.INFO_RELATION, className, methodName, info);
403 // }
404
405     private void trace(String JavaDoc methodName, String JavaDoc info) {
406         Trace.send(Trace.LEVEL_TRACE, Trace.INFO_RELATION, localClassName, methodName, info);
407     Trace.send(Trace.LEVEL_TRACE, Trace.INFO_RELATION, "", "", "\n");
408     }
409
410 // private void trace(String className, String methodName, Exception e) {
411 // Trace.send(Trace.LEVEL_TRACE, Trace.INFO_RELATION, className, methodName, e);
412 // }
413
414 // private void trace(String methodName, Exception e) {
415 // Trace.send(Trace.LEVEL_TRACE, Trace.INFO_RELATION, localClassName, methodName, e);
416 // }
417
418     // debug level
419 private boolean isDebugOn() {
420         return Trace.isSelected(Trace.LEVEL_DEBUG, Trace.INFO_RELATION);
421     }
422
423 // private void debug(String className, String methodName, String info) {
424 // Trace.send(Trace.LEVEL_DEBUG, Trace.INFO_RELATION, className, methodName, info);
425 // }
426
427     private void debug(String JavaDoc methodName, String JavaDoc info) {
428         Trace.send(Trace.LEVEL_DEBUG, Trace.INFO_RELATION, localClassName, methodName, info);
429     Trace.send(Trace.LEVEL_DEBUG, Trace.INFO_RELATION, "", "", "\n");
430     }
431
432 // private void debug(String className, String methodName, Exception e) {
433 // Trace.send(Trace.LEVEL_DEBUG, Trace.INFO_RELATION, className, methodName, e);
434 // }
435
436 // private void debug(String methodName, Exception e) {
437 // Trace.send(Trace.LEVEL_DEBUG, Trace.INFO_RELATION, localClassName, methodName, e);
438 // }
439
440     /**
441      * Deserializes an {@link MBeanServerNotificationFilter} from an {@link ObjectInputStream}.
442      */
443     private void readObject(ObjectInputStream JavaDoc in)
444         throws IOException JavaDoc, ClassNotFoundException JavaDoc {
445       if (compat)
446       {
447         // Read an object serialized in the old serial form
448 //
449 ObjectInputStream.GetField JavaDoc fields = in.readFields();
450     selectedNames = (List JavaDoc) fields.get("mySelectObjNameList", null);
451     if (fields.defaulted("mySelectObjNameList"))
452         {
453           throw new NullPointerException JavaDoc("mySelectObjNameList");
454         }
455     deselectedNames = (List JavaDoc) fields.get("myDeselectObjNameList", null);
456     if (fields.defaulted("myDeselectObjNameList"))
457         {
458           throw new NullPointerException JavaDoc("myDeselectObjNameList");
459         }
460       }
461       else
462       {
463         // Read an object serialized in the new serial form
464 //
465 in.defaultReadObject();
466       }
467     }
468
469
470     /**
471      * Serializes an {@link MBeanServerNotificationFilter} to an {@link ObjectOutputStream}.
472      */
473     private void writeObject(ObjectOutputStream JavaDoc out)
474         throws IOException JavaDoc {
475       if (compat)
476       {
477         // Serializes this instance in the old serial form
478 //
479 ObjectOutputStream.PutField JavaDoc fields = out.putFields();
480     fields.put("mySelectObjNameList", (Vector JavaDoc)selectedNames);
481     fields.put("myDeselectObjNameList", (Vector JavaDoc)deselectedNames);
482     out.writeFields();
483       }
484       else
485       {
486         // Serializes this instance in the new serial form
487 //
488 out.defaultWriteObject();
489       }
490     }
491 }
492
Popular Tags