History

My first initial commit with all of mine experimental changes.

Dmitry Kabak (userdima committed 13 years ago

Commit d37b88d1 parent 3f5b46618352 files · +2598093 −-8690Browse files

Showing the changes to java/pkg/javax/management/relation/RelationNotification.java (1 of 18352 files). Show all

Unified · Split

java/pkg/javax/management/relation/RelationNotification.java+626−0
@@ -0,0 +1,626 @@
1+/*
2+ * Copyright (c) 2000, 2008, Oracle and/or its affiliates. All rights reserved.
3+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4+ *
5+ * This code is free software; you can redistribute it and/or modify it
6+ * under the terms of the GNU General Public License version 2 only, as
7+ * published by the Free Software Foundation. Oracle designates this
8+ * particular file as subject to the "Classpath" exception as provided
9+ * by Oracle in the LICENSE file that accompanied this code.
10+ *
11+ * This code is distributed in the hope that it will be useful, but WITHOUT
12+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14+ * version 2 for more details (a copy is included in the LICENSE file that
15+ * accompanied this code).
16+ *
17+ * You should have received a copy of the GNU General Public License version
18+ * 2 along with this work; if not, write to the Free Software Foundation,
19+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20+ *
21+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22+ * or visit www.oracle.com if you need additional information or have any
23+ * questions.
24+ */
25+
26+package javax.management.relation;
27+
28+import javax.management.Notification;
29+import javax.management.ObjectName;
30+
31+import java.io.IOException;
32+import java.io.ObjectInputStream;
33+import java.io.ObjectOutputStream;
34+import java.io.ObjectStreamField;
35+
36+import java.security.AccessController;
37+import java.security.PrivilegedAction;
38+
39+import java.util.ArrayList;
40+import java.util.Collections;
41+import java.util.List;
42+
43+import com.sun.jmx.mbeanserver.GetPropertyAction;
44+import static com.sun.jmx.mbeanserver.Util.cast;
45+
46+/**
47+ * A notification of a change in the Relation Service.
48+ * A RelationNotification notification is sent when a relation is created via
49+ * the Relation Service, or an MBean is added as a relation in the Relation
50+ * Service, or a role is updated in a relation, or a relation is removed from
51+ * the Relation Service.
52+ *
53+ * <p>The <b>serialVersionUID</b> of this class is <code>-6871117877523310399L</code>.
54+ *
55+ * @since 1.5
56+ */
57+@SuppressWarnings("serial") // serialVersionUID not constant
58+public class RelationNotification extends Notification {
59+
60+ // Serialization compatibility stuff:
61+ // Two serial forms are supported in this class. The selected form depends
62+ // on system property "jmx.serial.form":
63+ // - "1.0" for JMX 1.0
64+ // - any other value for JMX 1.1 and higher
65+ //
66+ // Serial version for old serial form
67+ private static final long oldSerialVersionUID = -2126464566505527147L;
68+ //
69+ // Serial version for new serial form
70+ private static final long newSerialVersionUID = -6871117877523310399L;
71+ //
72+ // Serializable fields in old serial form
73+ private static final ObjectStreamField[] oldSerialPersistentFields =
74+ {
75+ new ObjectStreamField("myNewRoleValue", ArrayList.class),
76+ new ObjectStreamField("myOldRoleValue", ArrayList.class),
77+ new ObjectStreamField("myRelId", String.class),
78+ new ObjectStreamField("myRelObjName", ObjectName.class),
79+ new ObjectStreamField("myRelTypeName", String.class),
80+ new ObjectStreamField("myRoleName", String.class),
81+ new ObjectStreamField("myUnregMBeanList", ArrayList.class)
82+ };
83+ //
84+ // Serializable fields in new serial form
85+ private static final ObjectStreamField[] newSerialPersistentFields =
86+ {
87+ new ObjectStreamField("newRoleValue", List.class),
88+ new ObjectStreamField("oldRoleValue", List.class),
89+ new ObjectStreamField("relationId", String.class),
90+ new ObjectStreamField("relationObjName", ObjectName.class),
91+ new ObjectStreamField("relationTypeName", String.class),
92+ new ObjectStreamField("roleName", String.class),
93+ new ObjectStreamField("unregisterMBeanList", List.class)
94+ };
95+ //
96+ // Actual serial version and serial form
97+ private static final long serialVersionUID;
98+ /**
99+ * @serialField relationId String Relation identifier of
100+ * created/removed/updated relation
101+ * @serialField relationTypeName String Relation type name of
102+ * created/removed/updated relation
103+ * @serialField relationObjName ObjectName {@link ObjectName} of
104+ * the relation MBean of created/removed/updated relation (only if
105+ * the relation is represented by an MBean)
106+ * @serialField unregisterMBeanList List List of {@link
107+ * ObjectName}s of referenced MBeans to be unregistered due to
108+ * relation removal
109+ * @serialField roleName String Name of updated role (only for role update)
110+ * @serialField oldRoleValue List Old role value ({@link
111+ * ArrayList} of {@link ObjectName}s) (only for role update)
112+ * @serialField newRoleValue List New role value ({@link
113+ * ArrayList} of {@link ObjectName}s) (only for role update)
114+ */
115+ private static final ObjectStreamField[] serialPersistentFields;
116+ private static boolean compat = false;
117+ static {
118+ try {
119+ GetPropertyAction act = new GetPropertyAction("jmx.serial.form");
120+ String form = AccessController.doPrivileged(act);
121+ compat = (form != null && form.equals("1.0"));
122+ } catch (Exception e) {
123+ // OK : Too bad, no compat with 1.0
124+ }
125+ if (compat) {
126+ serialPersistentFields = oldSerialPersistentFields;
127+ serialVersionUID = oldSerialVersionUID;
128+ } else {
129+ serialPersistentFields = newSerialPersistentFields;
130+ serialVersionUID = newSerialVersionUID;
131+ }
132+ }
133+ //
134+ // END Serialization compatibility stuff
135+
136+ //
137+ // Notification types
138+ //
139+
140+ /**
141+ * Type for the creation of an internal relation.
142+ */
143+ public static final String RELATION_BASIC_CREATION = "jmx.relation.creation.basic";
144+ /**
145+ * Type for the relation MBean added into the Relation Service.
146+ */
147+ public static final String RELATION_MBEAN_CREATION = "jmx.relation.creation.mbean";
148+ /**
149+ * Type for an update of an internal relation.
150+ */
151+ public static final String RELATION_BASIC_UPDATE = "jmx.relation.update.basic";
152+ /**
153+ * Type for the update of a relation MBean.
154+ */
155+ public static final String RELATION_MBEAN_UPDATE = "jmx.relation.update.mbean";
156+ /**
157+ * Type for the removal from the Relation Service of an internal relation.
158+ */
159+ public static final String RELATION_BASIC_REMOVAL = "jmx.relation.removal.basic";
160+ /**
161+ * Type for the removal from the Relation Service of a relation MBean.
162+ */
163+ public static final String RELATION_MBEAN_REMOVAL = "jmx.relation.removal.mbean";
164+
165+ //
166+ // Private members
167+ //
168+
169+ /**
170+ * @serial Relation identifier of created/removed/updated relation
171+ */
172+ private String relationId = null;
173+
174+ /**
175+ * @serial Relation type name of created/removed/updated relation
176+ */
177+ private String relationTypeName = null;
178+
179+ /**
180+ * @serial {@link ObjectName} of the relation MBean of created/removed/updated relation
181+ * (only if the relation is represented by an MBean)
182+ */
183+ private ObjectName relationObjName = null;
184+
185+ /**
186+ * @serial List of {@link ObjectName}s of referenced MBeans to be unregistered due to
187+ * relation removal
188+ */
189+ private List<ObjectName> unregisterMBeanList = null;
190+
191+ /**
192+ * @serial Name of updated role (only for role update)
193+ */
194+ private String roleName = null;
195+
196+ /**
197+ * @serial Old role value ({@link ArrayList} of {@link ObjectName}s) (only for role update)
198+ */
199+ private List<ObjectName> oldRoleValue = null;
200+
201+ /**
202+ * @serial New role value ({@link ArrayList} of {@link ObjectName}s) (only for role update)
203+ */
204+ private List<ObjectName> newRoleValue = null;
205+
206+ //
207+ // Constructors
208+ //
209+
210+ /**
211+ * Creates a notification for either a relation creation (RelationSupport
212+ * object created internally in the Relation Service, or an MBean added as a
213+ * relation) or for a relation removal from the Relation Service.
214+ *
215+ * @param notifType type of the notification; either:
216+ * <P>- RELATION_BASIC_CREATION
217+ * <P>- RELATION_MBEAN_CREATION
218+ * <P>- RELATION_BASIC_REMOVAL
219+ * <P>- RELATION_MBEAN_REMOVAL
220+ * @param sourceObj source object, sending the notification. This is either
221+ * an ObjectName or a RelationService object. In the latter case it must be
222+ * the MBean emitting the notification; the MBean Server will rewrite the
223+ * source to be the ObjectName under which that MBean is registered.
224+ * @param sequence sequence number to identify the notification
225+ * @param timeStamp time stamp
226+ * @param message human-readable message describing the notification
227+ * @param id relation id identifying the relation in the Relation
228+ * Service
229+ * @param typeName name of the relation type
230+ * @param objectName ObjectName of the relation object if it is an MBean
231+ * (null for relations internally handled by the Relation Service)
232+ * @param unregMBeanList list of ObjectNames of referenced MBeans
233+ * expected to be unregistered due to relation removal (only for removal,
234+ * due to CIM qualifiers, can be null)
235+ *
236+ * @exception IllegalArgumentException if:
237+ * <P>- no value for the notification type
238+ * <P>- the notification type is not RELATION_BASIC_CREATION,
239+ * RELATION_MBEAN_CREATION, RELATION_BASIC_REMOVAL or
240+ * RELATION_MBEAN_REMOVAL
241+ * <P>- no source object
242+ * <P>- the source object is not a Relation Service
243+ * <P>- no relation id
244+ * <P>- no relation type name
245+ */
246+ public RelationNotification(String notifType,
247+ Object sourceObj,
248+ long sequence,
249+ long timeStamp,
250+ String message,
251+ String id,
252+ String typeName,
253+ ObjectName objectName,
254+ List<ObjectName> unregMBeanList)
255+ throws IllegalArgumentException {
256+
257+ super(notifType, sourceObj, sequence, timeStamp, message);
258+
259+ // Can throw IllegalArgumentException
260+ initMembers(1,
261+ notifType,
262+ sourceObj,
263+ sequence,
264+ timeStamp,
265+ message,
266+ id,
267+ typeName,
268+ objectName,
269+ unregMBeanList,
270+ null,
271+ null,
272+ null);
273+ return;
274+ }
275+
276+ /**
277+ * Creates a notification for a role update in a relation.
278+ *
279+ * @param notifType type of the notification; either:
280+ * <P>- RELATION_BASIC_UPDATE
281+ * <P>- RELATION_MBEAN_UPDATE
282+ * @param sourceObj source object, sending the notification. This is either
283+ * an ObjectName or a RelationService object. In the latter case it must be
284+ * the MBean emitting the notification; the MBean Server will rewrite the
285+ * source to be the ObjectName under which that MBean is registered.
286+ * @param sequence sequence number to identify the notification
287+ * @param timeStamp time stamp
288+ * @param message human-readable message describing the notification
289+ * @param id relation id identifying the relation in the Relation
290+ * Service
291+ * @param typeName name of the relation type
292+ * @param objectName ObjectName of the relation object if it is an MBean
293+ * (null for relations internally handled by the Relation Service)
294+ * @param name name of the updated role
295+ * @param newValue new role value (List of ObjectName objects)
296+ * @param oldValue old role value (List of ObjectName objects)
297+ *
298+ * @exception IllegalArgumentException if null parameter
299+ */
300+ public RelationNotification(String notifType,
301+ Object sourceObj,
302+ long sequence,
303+ long timeStamp,
304+ String message,
305+ String id,
306+ String typeName,
307+ ObjectName objectName,
308+ String name,
309+ List<ObjectName> newValue,
310+ List<ObjectName> oldValue
311+ )
312+ throws IllegalArgumentException {
313+
314+ super(notifType, sourceObj, sequence, timeStamp, message);
315+
316+ // Can throw IllegalArgumentException
317+ initMembers(2,
318+ notifType,
319+ sourceObj,
320+ sequence,
321+ timeStamp,
322+ message,
323+ id,
324+ typeName,
325+ objectName,
326+ null,
327+ name,
328+ newValue,
329+ oldValue);
330+ return;
331+ }
332+
333+ //
334+ // Accessors
335+ //
336+
337+ /**
338+ * Returns the relation identifier of created/removed/updated relation.
339+ *
340+ * @return the relation id.
341+ */
342+ public String getRelationId() {
343+ return relationId;
344+ }
345+
346+ /**
347+ * Returns the relation type name of created/removed/updated relation.
348+ *
349+ * @return the relation type name.
350+ */
351+ public String getRelationTypeName() {
352+ return relationTypeName;
353+ }
354+
355+ /**
356+ * Returns the ObjectName of the
357+ * created/removed/updated relation.
358+ *
359+ * @return the ObjectName if the relation is an MBean, otherwise null.
360+ */
361+ public ObjectName getObjectName() {
362+ return relationObjName;
363+ }
364+
365+ /**
366+ * Returns the list of ObjectNames of MBeans expected to be unregistered
367+ * due to a relation removal (only for relation removal).
368+ *
369+ * @return a {@link List} of {@link ObjectName}.
370+ */
371+ public List<ObjectName> getMBeansToUnregister() {
372+ List<ObjectName> result;
373+ if (unregisterMBeanList != null) {
374+ result = new ArrayList<ObjectName>(unregisterMBeanList);
375+ } else {
376+ result = Collections.emptyList();
377+ }
378+ return result;
379+ }
380+
381+ /**
382+ * Returns name of updated role of updated relation (only for role update).
383+ *
384+ * @return the name of the updated role.
385+ */
386+ public String getRoleName() {
387+ String result = null;
388+ if (roleName != null) {
389+ result = roleName;
390+ }
391+ return result;
392+ }
393+
394+ /**
395+ * Returns old value of updated role (only for role update).
396+ *
397+ * @return the old value of the updated role.
398+ */
399+ public List<ObjectName> getOldRoleValue() {
400+ List<ObjectName> result;
401+ if (oldRoleValue != null) {
402+ result = new ArrayList<ObjectName>(oldRoleValue);
403+ } else {
404+ result = Collections.emptyList();
405+ }
406+ return result;
407+ }
408+
409+ /**
410+ * Returns new value of updated role (only for role update).
411+ *
412+ * @return the new value of the updated role.
413+ */
414+ public List<ObjectName> getNewRoleValue() {
415+ List<ObjectName> result;
416+ if (newRoleValue != null) {
417+ result = new ArrayList<ObjectName>(newRoleValue);
418+ } else {
419+ result = Collections.emptyList();
420+ }
421+ return result;
422+ }
423+
424+ //
425+ // Misc
426+ //
427+
428+ // Initializes members
429+ //
430+ // -param notifKind 1 for creation/removal, 2 for update
431+ // -param notifType type of the notification; either:
432+ // - RELATION_BASIC_UPDATE
433+ // - RELATION_MBEAN_UPDATE
434+ // for an update, or:
435+ // - RELATION_BASIC_CREATION
436+ // - RELATION_MBEAN_CREATION
437+ // - RELATION_BASIC_REMOVAL
438+ // - RELATION_MBEAN_REMOVAL
439+ // for a creation or removal
440+ // -param sourceObj source object, sending the notification. Will always
441+ // be a RelationService object.
442+ // -param sequence sequence number to identify the notification
443+ // -param timeStamp time stamp
444+ // -param message human-readable message describing the notification
445+ // -param id relation id identifying the relation in the Relation
446+ // Service
447+ // -param typeName name of the relation type
448+ // -param objectName ObjectName of the relation object if it is an MBean
449+ // (null for relations internally handled by the Relation Service)
450+ // -param unregMBeanList list of ObjectNames of MBeans expected to be
451+ // removed due to relation removal
452+ // -param name name of the updated role
453+ // -param newValue new value (List of ObjectName objects)
454+ // -param oldValue old value (List of ObjectName objects)
455+ //
456+ // -exception IllegalArgumentException if:
457+ // - no value for the notification type
458+ // - incorrect notification type
459+ // - no source object
460+ // - the source object is not a Relation Service
461+ // - no relation id
462+ // - no relation type name
463+ // - no role name (for role update)
464+ // - no role old value (for role update)
465+ // - no role new value (for role update)
466+ private void initMembers(int notifKind,
467+ String notifType,
468+ Object sourceObj,
469+ long sequence,
470+ long timeStamp,
471+ String message,
472+ String id,
473+ String typeName,
474+ ObjectName objectName,
475+ List<ObjectName> unregMBeanList,
476+ String name,
477+ List<ObjectName> newValue,
478+ List<ObjectName> oldValue)
479+ throws IllegalArgumentException {
480+
481+ boolean badInitFlg = false;
482+
483+ if (notifType == null ||
484+ sourceObj == null ||
485+ (!(sourceObj instanceof RelationService) &&
486+ !(sourceObj instanceof ObjectName)) ||
487+ id == null ||
488+ typeName == null) {
489+
490+ badInitFlg = true;
491+ }
492+
493+ if (notifKind == 1) {
494+
495+ if ((!(notifType.equals(RelationNotification.RELATION_BASIC_CREATION)))
496+ &&
497+ (!(notifType.equals(RelationNotification.RELATION_MBEAN_CREATION)))
498+ &&
499+ (!(notifType.equals(RelationNotification.RELATION_BASIC_REMOVAL)))
500+ &&
501+ (!(notifType.equals(RelationNotification.RELATION_MBEAN_REMOVAL)))
502+ ) {
503+
504+ // Creation/removal
505+ badInitFlg = true;
506+ }
507+
508+ } else if (notifKind == 2) {
509+
510+ if (((!(notifType.equals(RelationNotification.RELATION_BASIC_UPDATE)))
511+ &&
512+ (!(notifType.equals(RelationNotification.RELATION_MBEAN_UPDATE))))
513+ || name == null ||
514+ oldValue == null ||
515+ newValue == null) {
516+
517+ // Role update
518+ badInitFlg = true;
519+ }
520+ }
521+
522+ if (badInitFlg) {
523+ String excMsg = "Invalid parameter.";
524+ throw new IllegalArgumentException(excMsg);
525+ }
526+
527+ relationId = id;
528+ relationTypeName = typeName;
529+ relationObjName = objectName;
530+ if (unregMBeanList != null) {
531+ unregisterMBeanList = new ArrayList<ObjectName>(unregMBeanList);
532+ }
533+ if (name != null) {
534+ roleName = name;
535+ }
536+ if (oldValue != null) {
537+ oldRoleValue = new ArrayList<ObjectName>(oldValue);
538+ }
539+ if (newValue != null) {
540+ newRoleValue = new ArrayList<ObjectName>(newValue);
541+ }
542+ return;
543+ }
544+
545+ /**
546+ * Deserializes a {@link RelationNotification} from an {@link ObjectInputStream}.
547+ */
548+ private void readObject(ObjectInputStream in)
549+ throws IOException, ClassNotFoundException {
550+ if (compat)
551+ {
552+ // Read an object serialized in the old serial form
553+ //
554+ ObjectInputStream.GetField fields = in.readFields();
555+ newRoleValue = cast(fields.get("myNewRoleValue", null));
556+ if (fields.defaulted("myNewRoleValue"))
557+ {
558+ throw new NullPointerException("newRoleValue");
559+ }
560+ oldRoleValue = cast(fields.get("myOldRoleValue", null));
561+ if (fields.defaulted("myOldRoleValue"))
562+ {
563+ throw new NullPointerException("oldRoleValue");
564+ }
565+ relationId = (String) fields.get("myRelId", null);
566+ if (fields.defaulted("myRelId"))
567+ {
568+ throw new NullPointerException("relationId");
569+ }
570+ relationObjName = (ObjectName) fields.get("myRelObjName", null);
571+ if (fields.defaulted("myRelObjName"))
572+ {
573+ throw new NullPointerException("relationObjName");
574+ }
575+ relationTypeName = (String) fields.get("myRelTypeName", null);
576+ if (fields.defaulted("myRelTypeName"))
577+ {
578+ throw new NullPointerException("relationTypeName");
579+ }
580+ roleName = (String) fields.get("myRoleName", null);
581+ if (fields.defaulted("myRoleName"))
582+ {
583+ throw new NullPointerException("roleName");
584+ }
585+ unregisterMBeanList = cast(fields.get("myUnregMBeanList", null));
586+ if (fields.defaulted("myUnregMBeanList"))
587+ {
588+ throw new NullPointerException("unregisterMBeanList");
589+ }
590+ }
591+ else
592+ {
593+ // Read an object serialized in the new serial form
594+ //
595+ in.defaultReadObject();
596+ }
597+ }
598+
599+
600+ /**
601+ * Serializes a {@link RelationNotification} to an {@link ObjectOutputStream}.
602+ */
603+ private void writeObject(ObjectOutputStream out)
604+ throws IOException {
605+ if (compat)
606+ {
607+ // Serializes this instance in the old serial form
608+ //
609+ ObjectOutputStream.PutField fields = out.putFields();
610+ fields.put("myNewRoleValue", newRoleValue);
611+ fields.put("myOldRoleValue", oldRoleValue);
612+ fields.put("myRelId", relationId);
613+ fields.put("myRelObjName", relationObjName);
614+ fields.put("myRelTypeName", relationTypeName);
615+ fields.put("myRoleName",roleName);
616+ fields.put("myUnregMBeanList", unregisterMBeanList);
617+ out.writeFields();
618+ }
619+ else
620+ {
621+ // Serializes this instance in the new serial form
622+ //
623+ out.defaultWriteObject();
624+ }
625+ }
626+}