1 /*
2 * Copyright (c) 2003, 2012, 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 package sun.management.snmp.jvminstr;
26
27
28 // java imports
29 //
30 import java.io.Serializable;
31 import java.util.List;
32 import java.util.Map;
33 import java.util.TreeMap;
34
35 // jmx imports
36 //
37 import com.sun.jmx.snmp.SnmpOid;
38 import com.sun.jmx.snmp.SnmpStatusException;
39
40 // jdmk imports
41 //
42 import com.sun.jmx.snmp.agent.SnmpMib;
43 import com.sun.jmx.snmp.agent.SnmpStandardObjectServer;
44
45 import java.lang.management.MemoryManagerMXBean;
46 import java.lang.management.GarbageCollectorMXBean;
47 import java.lang.management.ManagementFactory;
48
49 import sun.management.snmp.jvmmib.JvmMemGCTableMeta;
50 import sun.management.snmp.util.SnmpCachedData;
51 import sun.management.snmp.util.SnmpTableCache;
52 import sun.management.snmp.util.SnmpTableHandler;
53 import sun.management.snmp.util.MibLogger;
54 import sun.management.snmp.util.JvmContextFactory;
55
56 /**
57 * The class is used for implementing the "JvmMemGCTable" table.
58 */
59 public class JvmMemGCTableMetaImpl extends JvmMemGCTableMeta {
60
61 static final long serialVersionUID = 8250461197108867607L;
62
63 /**
64 * This class acts as a filter over the SnmpTableHandler
65 * used for the JvmMemoryManagerTable. It filters out
66 * (skip) all MemoryManagerMXBean that are not instances of
67 * GarbageCollectorMXBean so that only Garbage Collectors are
68 * seen. This is a better solution than relying on
69 * ManagementFactory.getGarbageCollectorMXBeans() because it makes it
70 * possible to guarantee the consistency betwen the MemoryManager table
71 * and the GCTable since both will be sharing the same cache.
72 **/
73 protected static class GCTableFilter {
74
75 /**
76 * Returns the index that immediately follows the given
77 * <var>index</var>. The returned index is strictly greater
78 * than the given <var>index</var>, and is contained in the table.
79 * <br>If the given <var>index</var> is null, returns the first
80 * index in the table.
81 * <br>If there are no index after the given <var>index</var>,
82 * returns null.
83 * This method is an optimization for the case where the
84 * SnmpTableHandler is in fact an instance of SnmpCachedData.
85 **/
86 public SnmpOid getNext(SnmpCachedData datas, SnmpOid index) {
87
88 final boolean dbg = log.isDebugOn();
89
90 // We're going to loop until we find an instance of
91 // GarbageCollectorMXBean. First we attempt to find
92 // the next element whose OID follows the given index.
93 // If `index' is null, the insertion point is -1
94 // (the next is 0 = -insertion - 1)
95 //
96 final int insertion = (index==null)?-1:datas.find(index);
97 if (dbg) log.debug("GCTableFilter","oid="+index+
98 " at insertion="+insertion);
99
100 int next;
101 if (insertion > -1) next = insertion+1;
102 else next = -insertion -1;
103
104 // Now `next' points to the element that imediately
105 // follows the given `index'. We're going to loop
106 // through the table, starting at `next' (included),
107 // and return the first element which is an instance
108 // of GarbageCollectorMXBean.
109 //
110 for (;next<datas.indexes.length;next++) {
111 if (dbg) log.debug("GCTableFilter","next="+next);
112 final Object value = datas.datas[next];
113 if (dbg) log.debug("GCTableFilter","value["+next+"]=" +
114 ((MemoryManagerMXBean)value).getName());
115 if (value instanceof GarbageCollectorMXBean) {
116 // That's the next: return it.
117 if (dbg) log.debug("GCTableFilter",
118 ((MemoryManagerMXBean)value).getName() +
119 " is a GarbageCollectorMXBean.");
120 return datas.indexes[next];
121 }
122 if (dbg) log.debug("GCTableFilter",
123 ((MemoryManagerMXBean)value).getName() +
124 " is not a GarbageCollectorMXBean: " +
125 value.getClass().getName());
126 // skip to next index...
127 }
128 return null;
129 }
130
131 /**
132 * Returns the index that immediately follows the given
133 * <var>index</var>. The returned index is strictly greater
134 * than the given <var>index</var>, and is contained in the table.
135 * <br>If the given <var>index</var> is null, returns the first
136 * index in the table.
137 * <br>If there are no index after the given <var>index</var>,
138 * returns null.
139 **/
140 public SnmpOid getNext(SnmpTableHandler handler, SnmpOid index) {
141
142 // try to call the optimized method
143 if (handler instanceof SnmpCachedData)
144 return getNext((SnmpCachedData)handler, index);
145
146 // too bad - revert to non-optimized generic algorithm
147 SnmpOid next = index;
148 do {
149 next = handler.getNext(next);
150 final Object value = handler.getData(next);
151 if (value instanceof GarbageCollectorMXBean)
152 // That's the next! return it
153 return next;
154 // skip to next index...
155 } while (next != null);
156 return null;
157 }
158
159 /**
160 * Returns the data associated with the given index.
161 * If the given index is not found, null is returned.
162 * Note that returning null does not necessarily means that
163 * the index was not found.
164 **/
165 public Object getData(SnmpTableHandler handler, SnmpOid index) {
166 final Object value = handler.getData(index);
167 if (value instanceof GarbageCollectorMXBean) return value;
168 // Behaves as if there was nothing at this index...
169 //
170 return null;
171 }
172
173 /**
174 * Returns true if the given <var>index</var> is present.
175 **/
176 public boolean contains(SnmpTableHandler handler, SnmpOid index) {
177 if (handler.getData(index) instanceof GarbageCollectorMXBean)
178 return true;
179 // Behaves as if there was nothing at this index...
180 //
181 return false;
182 }
183 }
184
185
186 private transient JvmMemManagerTableMetaImpl managers = null;
187 private static GCTableFilter filter = new GCTableFilter();
188
189
190 /**
191 * Constructor for the table. Initialize metadata for "JvmMemGCTableMeta".
192 */
193 public JvmMemGCTableMetaImpl(SnmpMib myMib,
194 SnmpStandardObjectServer objserv) {
195 super(myMib,objserv);
196 }
197
198 // Returns a pointer to the JvmMemManager meta node - we're going
199 // to reuse its SnmpTableHandler by filtering out all that is
200 // not a GarbageCollectorMXBean.
201 private final JvmMemManagerTableMetaImpl getManagers(SnmpMib mib) {
202 if (managers == null) {
203 managers = (JvmMemManagerTableMetaImpl)
204 mib.getRegisteredTableMeta("JvmMemManagerTable");
205 }
206 return managers;
207 }
208
209 /**
210 * Returns the JvmMemManagerTable SnmpTableHandler
211 **/
212 protected SnmpTableHandler getHandler(Object userData) {
213 JvmMemManagerTableMetaImpl managerTable= getManagers(theMib);
214 return managerTable.getHandler(userData);
215 }
216
217 // See com.sun.jmx.snmp.agent.SnmpMibTable
218 protected SnmpOid getNextOid(Object userData)
219 throws SnmpStatusException {
220 // null means get the first OID.
221 return getNextOid(null,userData);
222 }
223
224 // See com.sun.jmx.snmp.agent.SnmpMibTable
225 protected SnmpOid getNextOid(SnmpOid oid, Object userData)
226 throws SnmpStatusException {
227 final boolean dbg = log.isDebugOn();
228 try {
229 if (dbg) log.debug("getNextOid", "previous=" + oid);
230
231 // Get the data handler.
232 //
233 SnmpTableHandler handler = getHandler(userData);
234 if (handler == null) {
235 // This should never happen.
236 // If we get here it's a bug.
237 //
238 if (dbg) log.debug("getNextOid", "handler is null!");
239 throw new
240 SnmpStatusException(SnmpStatusException.noSuchInstance);
241 }
242
243
244 // Get the next oid, using the GC filter.
245 //
246 final SnmpOid next = filter.getNext(handler,oid);
247 if (dbg) log.debug("getNextOid", "next=" + next);
248
249 // if next is null: we reached the end of the table.
250 //
251 if (next == null)
252 throw new
253 SnmpStatusException(SnmpStatusException.noSuchInstance);
254
255 return next;
256 } catch (RuntimeException x) {
257 // debug. This should never happen.
258 //
259 if (dbg) log.debug("getNextOid",x);
260 throw x;
261 }
262 }
263
264
265 // See com.sun.jmx.snmp.agent.SnmpMibTable
266 protected boolean contains(SnmpOid oid, Object userData) {
267 // Get the handler.
268 //
269 SnmpTableHandler handler = getHandler(userData);
270
271 // handler should never be null.
272 //
273 if (handler == null)
274 return false;
275 return filter.contains(handler,oid);
276 }
277
278 // See com.sun.jmx.snmp.agent.SnmpMibTable
279 public Object getEntry(SnmpOid oid)
280 throws SnmpStatusException {
281
282 if (oid == null)
283 throw new SnmpStatusException(SnmpStatusException.noSuchInstance);
284
285 // Get the request contextual cache (userData).
286 //
287 final Map<Object, Object> m = JvmContextFactory.getUserData();
288
289 // First look in the request contextual cache: maybe we've already
290 // created this entry...
291 //
292
293 // We know in the case of this table that the index is an integer,
294 // it is thus the first OID arc of the index OID.
295 //
296 final long index = oid.getOidArc(0);
297
298 // We're going to use this name to store/retrieve the entry in
299 // the request contextual cache.
300 //
301 // Revisit: Probably better programming to put all these strings
302 // in some interface.
303 //
304 final String entryTag = ((m==null)?null:("JvmMemGCTable.entry." +
305 index));
306
307 // If the entry is in the cache, simply return it.
308 //
309 if (m != null) {
310 final Object entry = m.get(entryTag);
311 if (entry != null) return entry;
312 }
313
314 // Entry was not in request cache. Make a new one.
315 //
316 // Get the data hanler.
317 //
318 SnmpTableHandler handler = getHandler(m);
319
320 // handler should never be null.
321 //
322 if (handler == null)
323 throw new SnmpStatusException(SnmpStatusException.noSuchInstance);
324
325 // Use the filter to retrieve only GarabageCollectorMBean data.
326 //
327 final Object data = filter.getData(handler,oid);
328
329 // data may be null if the OID we were given is not valid.
330 // (e.g. it identifies a MemoryManager which is not a
331 // GarbageCollector)
332 //
333 if (data == null)
334 throw new SnmpStatusException(SnmpStatusException.noSuchInstance);
335
336 // Make a new entryy (transient object that will be kept only
337 // for the duration of the request.
338 //
339 final Object entry =
340 new JvmMemGCEntryImpl((GarbageCollectorMXBean)data,(int)index);
341
342 // Put the entry in the request cache in case we need it later
343 // in the processing of the request. Note that we could have
344 // optimized this by making JvmMemGCEntryImpl extend
345 // JvmMemManagerEntryImpl, and then make sure that
346 // JvmMemManagerTableMetaImpl creates an instance of JvmMemGCEntryImpl
347 // instead of JvmMemManagerEntryImpl when the associated data is
348 // an instance of GarbageCollectorMXBean. This would have made it
349 // possible to share the transient entry object.
350 // As it is, we may have two transient objects that points to
351 // the same underlying MemoryManagerMXBean (which is definitely
352 // not a problem - but is only a small dysatisfaction)
353 //
354 if (m != null && entry != null) {
355 m.put(entryTag,entry);
356 }
357
358 return entry;
359 }
360
361 static final MibLogger log = new MibLogger(JvmMemGCTableMetaImpl.class);
362 }