/* * Copyright (c) 2004, 2008, Oracle and/or its affiliates. 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.  Oracle designates this * particular file as subject to the "Classpath" exception as provided * by Oracle in the LICENSE file that accompanied this code. * * 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA * or visit www.oracle.com if you need additional information or have any * questions. */ package sun.management; import java.lang.management.ThreadInfo;import java.lang.management.MonitorInfo;import java.lang.management.LockInfo;import javax.management.openmbean.CompositeType;import javax.management.openmbean.CompositeData;import javax.management.openmbean.CompositeDataSupport;import javax.management.openmbean.OpenDataException;import javax.management.openmbean.OpenType; /** * A CompositeData for ThreadInfo for the local management support. * This class avoids the performance penalty paid to the * construction of a CompositeData use in the local case. */public class ThreadInfoCompositeData extends LazyCompositeData {    private final ThreadInfo threadInfo;    private final CompositeData cdata;    private final boolean currentVersion;     private ThreadInfoCompositeData(ThreadInfo ti) {        this.threadInfo = ti;        this.currentVersion = true;        this.cdata = null;    }     private ThreadInfoCompositeData(CompositeData cd) {        this.threadInfo = null;        this.currentVersion = ThreadInfoCompositeData.isCurrentVersion(cd);        this.cdata = cd;    }     public ThreadInfo getThreadInfo() {        return threadInfo;    }     public boolean isCurrentVersion() {        return currentVersion;    }     public static ThreadInfoCompositeData getInstance(CompositeData cd) {        validateCompositeData(cd);        return new ThreadInfoCompositeData(cd);    }     public static CompositeData toCompositeData(ThreadInfo ti) {        ThreadInfoCompositeData ticd = new ThreadInfoCompositeData(ti);        return ticd.getCompositeData();    }     protected CompositeData getCompositeData() {        // Convert StackTraceElement[] to CompositeData[]        StackTraceElement[] stackTrace = threadInfo.getStackTrace();        CompositeData[] stackTraceData =            new CompositeData[stackTrace.length];        for (int i = 0; i < stackTrace.length; i++) {            StackTraceElement ste = stackTrace[i];            stackTraceData[i] = StackTraceElementCompositeData.toCompositeData(ste);        }         // Convert MonitorInfo[] and LockInfo[] to CompositeData[]        LockDataConverter converter = new LockDataConverter(threadInfo);        CompositeData lockInfoData = converter.toLockInfoCompositeData();        CompositeData[] lockedSyncsData = converter.toLockedSynchronizersCompositeData();         // Convert MonitorInfo[] to CompositeData[]        MonitorInfo[] lockedMonitors = threadInfo.getLockedMonitors();        CompositeData[] lockedMonitorsData =            new CompositeData[lockedMonitors.length];        for (int i = 0; i < lockedMonitors.length; i++) {            MonitorInfo mi = lockedMonitors[i];            lockedMonitorsData[i] = MonitorInfoCompositeData.toCompositeData(mi);        }          // CONTENTS OF THIS ARRAY MUST BE SYNCHRONIZED WITH        // threadInfoItemNames!        final Object[] threadInfoItemValues = {            new Long(threadInfo.getThreadId()),            threadInfo.getThreadName(),            threadInfo.getThreadState().name(),            new Long(threadInfo.getBlockedTime()),            new Long(threadInfo.getBlockedCount()),            new Long(threadInfo.getWaitedTime()),            new Long(threadInfo.getWaitedCount()),            lockInfoData,            threadInfo.getLockName(),            new Long(threadInfo.getLockOwnerId()),            threadInfo.getLockOwnerName(),            stackTraceData,            new Boolean(threadInfo.isSuspended()),            new Boolean(threadInfo.isInNative()),            lockedMonitorsData,            lockedSyncsData,        };         try {            return new CompositeDataSupport(threadInfoCompositeType,                                            threadInfoItemNames,                                            threadInfoItemValues);        } catch (OpenDataException e) {            // Should never reach here            throw new AssertionError(e);        }    }     // Attribute names    private static final String THREAD_ID       = "threadId";    private static final String THREAD_NAME     = "threadName";    private static final String THREAD_STATE    = "threadState";    private static final String BLOCKED_TIME    = "blockedTime";    private static final String BLOCKED_COUNT   = "blockedCount";    private static final String WAITED_TIME     = "waitedTime";    private static final String WAITED_COUNT    = "waitedCount";    private static final String LOCK_INFO       = "lockInfo";    private static final String LOCK_NAME       = "lockName";    private static final String LOCK_OWNER_ID   = "lockOwnerId";    private static final String LOCK_OWNER_NAME = "lockOwnerName";    private static final String STACK_TRACE     = "stackTrace";    private static final String SUSPENDED       = "suspended";    private static final String IN_NATIVE       = "inNative";    private static final String LOCKED_MONITORS = "lockedMonitors";    private static final String LOCKED_SYNCS    = "lockedSynchronizers";     private static final String[] threadInfoItemNames = {        THREAD_ID,        THREAD_NAME,        THREAD_STATE,        BLOCKED_TIME,        BLOCKED_COUNT,        WAITED_TIME,        WAITED_COUNT,        LOCK_INFO,        LOCK_NAME,        LOCK_OWNER_ID,        LOCK_OWNER_NAME,        STACK_TRACE,        SUSPENDED,        IN_NATIVE,        LOCKED_MONITORS,        LOCKED_SYNCS,    };     // New attributes added in 6.0 ThreadInfo    private static final String[] threadInfoV6Attributes = {        LOCK_INFO,        LOCKED_MONITORS,        LOCKED_SYNCS,    };     // Current version of ThreadInfo    private static final CompositeType threadInfoCompositeType;    // Previous version of ThreadInfo    private static final CompositeType threadInfoV5CompositeType;    private static final CompositeType lockInfoCompositeType;    static {        try {            threadInfoCompositeType = (CompositeType)                MappedMXBeanType.toOpenType(ThreadInfo.class);            // Form a CompositeType for JDK 5.0 ThreadInfo version            String[] itemNames =                threadInfoCompositeType.keySet().toArray(new String[0]);            int numV5Attributes = threadInfoItemNames.length -                                      threadInfoV6Attributes.length;            String[] v5ItemNames = new String[numV5Attributes];            String[] v5ItemDescs = new String[numV5Attributes];            OpenType[] v5ItemTypes = new OpenType[numV5Attributes];            int i = 0;            for (String n : itemNames) {                if (isV5Attribute(n)) {                    v5ItemNames[i] = n;                    v5ItemDescs[i] = threadInfoCompositeType.getDescription(n);                    v5ItemTypes[i] = threadInfoCompositeType.getType(n);                    i++;                }            }             threadInfoV5CompositeType =                new CompositeType("java.lang.management.ThreadInfo",                                  "J2SE 5.0 java.lang.management.ThreadInfo",                                  v5ItemNames,                                  v5ItemDescs,                                  v5ItemTypes);        } catch (OpenDataException e) {            // Should never reach here            throw new AssertionError(e);        }         // Each CompositeData object has its CompositeType associated        // with it.  So we can get the CompositeType representing LockInfo        // from a mapped CompositeData for any LockInfo object.        // Thus we construct a random LockInfo object and pass it        // to LockDataConverter to do the conversion.        Object o = new Object();        LockInfo li = new LockInfo(o.getClass().getName(),                                   System.identityHashCode(o));        CompositeData cd = LockDataConverter.toLockInfoCompositeData(li);        lockInfoCompositeType = cd.getCompositeType();    }     private static boolean isV5Attribute(String itemName) {        for (String n : threadInfoV6Attributes) {            if (itemName.equals(n)) {                return false;            }        }        return true;    }     public static boolean isCurrentVersion(CompositeData cd) {        if (cd == null) {            throw new NullPointerException("Null CompositeData");        }         return isTypeMatched(threadInfoCompositeType, cd.getCompositeType());    }     public long threadId() {        return getLong(cdata, THREAD_ID);    }     public String threadName() {        // The ThreadName item cannot be null so we check that        // it is present with a non-null value.        String name = getString(cdata, THREAD_NAME);        if (name == null) {            throw new IllegalArgumentException("Invalid composite data: " +                "Attribute " + THREAD_NAME + " has null value");        }        return name;    }     public Thread.State threadState() {        return Thread.State.valueOf(getString(cdata, THREAD_STATE));    }     public long blockedTime() {        return getLong(cdata, BLOCKED_TIME);    }     public long blockedCount() {        return getLong(cdata, BLOCKED_COUNT);    }     public long waitedTime() {        return getLong(cdata, WAITED_TIME);    }     public long waitedCount() {        return getLong(cdata, WAITED_COUNT);    }     public String lockName() {        // The LockName and LockOwnerName can legitimately be null,        // we don't bother to check the value        return getString(cdata, LOCK_NAME);    }     public long lockOwnerId() {        return getLong(cdata, LOCK_OWNER_ID);    }     public String lockOwnerName() {        return getString(cdata, LOCK_OWNER_NAME);    }     public boolean suspended() {        return getBoolean(cdata, SUSPENDED);    }     public boolean inNative() {        return getBoolean(cdata, IN_NATIVE);    }     public StackTraceElement[] stackTrace() {        CompositeData[] stackTraceData =            (CompositeData[]) cdata.get(STACK_TRACE);         // The StackTrace item cannot be null, but if it is we will get        // a NullPointerException when we ask for its length.        StackTraceElement[] stackTrace =            new StackTraceElement[stackTraceData.length];        for (int i = 0; i < stackTraceData.length; i++) {            CompositeData cdi = stackTraceData[i];            stackTrace[i] = StackTraceElementCompositeData.from(cdi);        }        return stackTrace;    }     // 6.0 new attributes    public LockInfo lockInfo() {        LockDataConverter converter = new LockDataConverter();        CompositeData lockInfoData = (CompositeData) cdata.get(LOCK_INFO);        return converter.toLockInfo(lockInfoData);    }     public MonitorInfo[] lockedMonitors() {        CompositeData[] lockedMonitorsData =            (CompositeData[]) cdata.get(LOCKED_MONITORS);         // The LockedMonitors item cannot be null, but if it is we will get        // a NullPointerException when we ask for its length.        MonitorInfo[] monitors =            new MonitorInfo[lockedMonitorsData.length];        for (int i = 0; i < lockedMonitorsData.length; i++) {            CompositeData cdi = lockedMonitorsData[i];            monitors[i] = MonitorInfo.from(cdi);        }        return monitors;    }     public LockInfo[] lockedSynchronizers() {        LockDataConverter converter = new LockDataConverter();        CompositeData[] lockedSyncsData =            (CompositeData[]) cdata.get(LOCKED_SYNCS);         // The LockedSynchronizers item cannot be null, but if it is we will        // get a NullPointerException when we ask for its length.        return converter.toLockedSynchronizers(lockedSyncsData);    }     /** Validate if the input CompositeData has the expected     * CompositeType (i.e. contain all attributes with expected     * names and types).     */    public static void validateCompositeData(CompositeData cd) {        if (cd == null) {            throw new NullPointerException("Null CompositeData");        }         CompositeType type = cd.getCompositeType();        boolean currentVersion = true;        if (!isTypeMatched(threadInfoCompositeType, type)) {            currentVersion = false;            // check if cd is an older version            if (!isTypeMatched(threadInfoV5CompositeType, type)) {                throw new IllegalArgumentException(                    "Unexpected composite type for ThreadInfo");            }        }         CompositeData[] stackTraceData =            (CompositeData[]) cd.get(STACK_TRACE);        if (stackTraceData == null) {            throw new IllegalArgumentException(                "StackTraceElement[] is missing");        }        if (stackTraceData.length > 0) {            StackTraceElementCompositeData.validateCompositeData(stackTraceData[0]);        }         // validate v6 attributes        if (currentVersion) {            CompositeData li = (CompositeData) cd.get(LOCK_INFO);            if (li != null) {                if (!isTypeMatched(lockInfoCompositeType,                                   li.getCompositeType())) {                    throw new IllegalArgumentException(                        "Unexpected composite type for \"" +                        LOCK_INFO + "\" attribute.");                }            }             CompositeData[] lms = (CompositeData[]) cd.get(LOCKED_MONITORS);            if (lms == null) {                throw new IllegalArgumentException("MonitorInfo[] is null");            }            if (lms.length > 0) {                MonitorInfoCompositeData.validateCompositeData(lms[0]);            }             CompositeData[] lsyncs = (CompositeData[]) cd.get(LOCKED_SYNCS);            if (lsyncs == null) {                throw new IllegalArgumentException("LockInfo[] is null");            }            if (lsyncs.length > 0) {                if (!isTypeMatched(lockInfoCompositeType,                                   lsyncs[0].getCompositeType())) {                    throw new IllegalArgumentException(                        "Unexpected composite type for \"" +                        LOCKED_SYNCS + "\" attribute.");                }            }         }    }     private static final long serialVersionUID = 2464378539119753175L;}