/*

* Copyright (c) 2008, 2015, 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 com.sun.btrace;

/**

* This class is a simple implementation of DynamicMBean that exposes

* a BTrace class as a MBean. The static fields annotated with @Property

* are exposed as MBean attributes.

*

* @author A. Sundararajan

*/

import com.sun.btrace.annotations.BTrace;

import com.sun.btrace.annotations.Property;

import java.lang.management.ManagementFactory;

import java.lang.reflect.Field;

import java.lang.reflect.Modifier;

import java.lang.reflect.ParameterizedType;

import java.lang.reflect.Type;

import java.math.BigDecimal;

import java.math.BigInteger;

import java.util.Date;

import java.util.HashMap;

import java.util.Iterator;

import java.util.Map;

import java.util.SortedSet;

import java.util.TreeSet;

import java.util.concurrent.atomic.AtomicInteger;

import java.util.concurrent.atomic.AtomicLong;

import javax.management.Attribute;

import javax.management.AttributeList;

import javax.management.AttributeNotFoundException;

import javax.management.Descriptor;

import javax.management.DynamicMBean;

import javax.management.InvalidAttributeValueException;

import javax.management.MBeanAttributeInfo;

import javax.management.MBeanException;

import javax.management.MBeanInfo;

import javax.management.MBeanServer;

import javax.management.ObjectName;

import javax.management.ReflectionException;

import javax.management.modelmbean.DescriptorSupport;

import javax.management.openmbean.ArrayType;

import javax.management.openmbean.CompositeData;

import javax.management.openmbean.CompositeDataSupport;

import javax.management.openmbean.CompositeType;

import javax.management.openmbean.OpenDataException;

import javax.management.openmbean.OpenType;

import javax.management.openmbean.SimpleType;

/**

* This is a simple DynamicMBean implementation that exposes the static

* fields of BTrace class as attributes. The fields exposed should be

* annotated as {@linkplain Property}.

*

* @author A. Sundararajan

*/

public class BTraceMBean implements DynamicMBean {

private final Class clazz;

private final Map<String, Field> attributes;

private final String beanName;

private MBeanInfo cachedBeanInfo;

public BTraceMBean(Class clazz) {

this.clazz = clazz;

this.attributes = getJMXAttributes(clazz);

this.beanName = getBeanName(clazz);

}

@Override

public synchronized Object getAttribute(String name)

throws AttributeNotFoundException {

Field field = attributes.get(name);

if (field == null) {

throw new AttributeNotFoundException("No such property: " + name);

}

return getFieldValue(field);

}

@Override

public synchronized void setAttribute(Attribute attribute)

throws InvalidAttributeValueException, MBeanException, AttributeNotFoundException {

throw new MBeanException(new RuntimeException("BTrace attributes are read-only"));

}

@Override

public synchronized AttributeList getAttributes(String[] names) {

AttributeList list = new AttributeList();

for (String name : names) {

Field field = attributes.get(name);

Object value = null;

if (field != null) {

value = getFieldValue(field);

}

if (value != null) {

list.add(new Attribute(name, value));

}

}

return list;

}

@Override

public synchronized AttributeList setAttributes(AttributeList list) {

// we don't support attribute sets -- return an empty list.

return new AttributeList();

}

@Override

public Object invoke(String name, Object[] args, String[] sig)

throws MBeanException, ReflectionException {

throw new ReflectionException(new NoSuchMethodException(name));

}

@Override

public synchronized MBeanInfo getMBeanInfo() {

if (cachedBeanInfo != null) {

return cachedBeanInfo;

}

SortedSet<String> names = new TreeSet<>();

for (String name : attributes.keySet()) {

names.add((String) name);

}

MBeanAttributeInfo[] attrs = new MBeanAttributeInfo[names.size()];

Iterator<String> it = names.iterator();

for (int i = 0; i < attrs.length; i++) {

String name = it.next();

Field field = attributes.get(name);

Property attr = field.getAnnotation(Property.class);

String description = attr.description();

if (description.isEmpty()) {

description = name;

}

Descriptor descriptor = new DescriptorSupport();

OpenType ot = OpenTypeUtils.typeToOpenType(field.getGenericType());

if (ot != null) {

descriptor.setField("openType", ot);

}

attrs[i] = new MBeanAttributeInfo(

name,

field.getType().getName(),

description,

true, // isReadable

false, // isWritable

false, // isIs

descriptor);

}

BTrace info = (BTrace) clazz.getAnnotation(BTrace.class);

String description = info.description();

if (description.isEmpty()) {

description = "BTrace MBean : " + beanName;

}

cachedBeanInfo = new MBeanInfo(

beanName,

description,

attrs,

null, // constructors

null,

null); // notifications

return cachedBeanInfo;

}

public static void registerMBean(Class clazz) {

if (isMBean(clazz)) {

MBeanServer server = ManagementFactory.getPlatformMBeanServer();

BTraceMBean bean = new BTraceMBean(clazz);

try {

ObjectName on = new ObjectName("btrace:name=" + bean.beanName);

if (server.isRegistered(on)) {

server.unregisterMBean(on);

}

server.registerMBean(bean, on);

} catch (RuntimeException re) {

throw re;

} catch (Exception exp) {

throw new RuntimeException(exp);

}

}

}

// internals only below this point

private static String getBeanName(Class clazz) {

BTrace info = (BTrace) clazz.getAnnotation(BTrace.class);

String beanName = info.name();

if (beanName.isEmpty()) {

beanName = clazz.getName();

}

return beanName;

}

public static boolean isMBean(Class clazz) {

// if atleast one field is annotated as @Property, we create MBean

for (Field field : clazz.getDeclaredFields()) {

if (field.isAnnotationPresent(Property.class)) {

return true;

}

}

return false;

}

private static Object getFieldValue(Field field) {

try {

Object value = field.get(null);

OpenType ot = OpenTypeUtils.typeToOpenType(field.getGenericType());

if (ot != null) {

return OpenTypeUtils.convertToOpenTypeValue(ot, value);

} else {

// no conversion attempted!

return value;

}

} catch (RuntimeException re) {

throw re;

} catch (Exception exp) {

throw new RuntimeException(exp);

}

}

private static Map<String, Field> getJMXAttributes(Class clazz) {

try {

Map<String, Field> fields = new HashMap<>();

for (Field field : clazz.getDeclaredFields()) {

if (Modifier.isStatic(field.getModifiers()) &&

field.isAnnotationPresent(Property.class)) {

Property attr = field.getAnnotation(Property.class);

if (attr != null) {

field.setAccessible(true);

String attrName = attr.name();

if (attrName.isEmpty()) {

attrName = field.getName();

// remove BTRACE_FIELD_PREFIX ("$") from field name

if (attrName.startsWith("$")) {

attrName = attrName.substring(1);

}

}

fields.put(attrName, field);

}

}

}

return fields;

} catch (RuntimeException re) {

throw re;

} catch (Exception exp) {

throw new RuntimeException(exp);

}

}

private static class OpenTypeUtils {

private static final Map<Class, OpenType> classToOpenTypes = new HashMap<>();

static {

classToOpenTypes.put(Byte.TYPE, SimpleType.BYTE);

classToOpenTypes.put(Byte.class, SimpleType.BYTE);

classToOpenTypes.put(Short.TYPE, SimpleType.SHORT);

classToOpenTypes.put(Short.class, SimpleType.SHORT);

classToOpenTypes.put(Integer.TYPE, SimpleType.INTEGER);

classToOpenTypes.put(Integer.class, SimpleType.INTEGER);

classToOpenTypes.put(Long.TYPE, SimpleType.LONG);

classToOpenTypes.put(Long.class, SimpleType.LONG);

classToOpenTypes.put(Float.TYPE, SimpleType.FLOAT);

classToOpenTypes.put(Float.class, SimpleType.FLOAT);

classToOpenTypes.put(Double.TYPE, SimpleType.DOUBLE);

classToOpenTypes.put(Double.class, SimpleType.DOUBLE);

classToOpenTypes.put(Boolean.TYPE, SimpleType.BOOLEAN);

classToOpenTypes.put(Boolean.class, SimpleType.BOOLEAN);

classToOpenTypes.put(Character.TYPE, SimpleType.CHARACTER);

classToOpenTypes.put(Character.class, SimpleType.CHARACTER);

classToOpenTypes.put(AtomicInteger.class, SimpleType.INTEGER);

classToOpenTypes.put(AtomicLong.class, SimpleType.LONG);

classToOpenTypes.put(BigInteger.class, SimpleType.BIGINTEGER);

classToOpenTypes.put(BigDecimal.class, SimpleType.BIGDECIMAL);

classToOpenTypes.put(String.class, SimpleType.STRING);

classToOpenTypes.put(ObjectName.class, SimpleType.OBJECTNAME);

classToOpenTypes.put(Date.class, SimpleType.DATE);

}

private static OpenType typeToOpenType(Type t) {

try {

// FIXME: This is highly incomplete, revisit...

// just enough to get Maps for now.

if (t instanceof Class) {

Class c = (Class) t;

if (Profiler.class.isAssignableFrom(c)) {

CompositeType record = new CompositeType("Record",

"Profiler record",

new String[]{"block",

"invocations",

"selfTime.total",

"selfTime.percent",

"selfTime.avg",

"selfTime.max",

"selfTime.min",

"wallTime.total",

"wallTime.percent",

"wallTime.avg",

"wallTime.max",

"wallTime.min"

},

new String[]{"block",

"invocations",

"selfTime.total",

"selfTime.percent",

"selfTime.avg",

"selfTime.max",

"selfTime.min",

"wallTime.total",

"wallTime.percent",

"wallTime.avg",

"wallTime.max",

"wallTime.min"

},

new OpenType[]{

typeToOpenType(String.class),

typeToOpenType(Long.class),

typeToOpenType(Long.class),

typeToOpenType(Double.class),

typeToOpenType(Long.class),

typeToOpenType(Long.class),

typeToOpenType(Long.class),

typeToOpenType(Long.class),

typeToOpenType(Double.class),

typeToOpenType(Long.class),

typeToOpenType(Long.class),

typeToOpenType(Long.class)

});

CompositeType recordEntry = new CompositeType("Record Entry",

"Record map entry",

new String[]{"key", "value"},

new String[]{"key", "value"},

new OpenType[]{

typeToOpenType(String.class),

record

}

);

CompositeType snapshot = new CompositeType("Snapshot",

"Profiler snapshot",

new String[]{"startTime", "lastRefresh", "interval", "data"},

new String[]{"startTime", "lastRefresh", "interval", "data"},

new OpenType[]{

typeToOpenType(Long.class),

typeToOpenType(Long.class),

typeToOpenType(Long.class),

new ArrayType(1, recordEntry)

}

);

return snapshot;

} else {

return classToOpenTypes.get(c);

}

} else if (t instanceof ParameterizedType) {

ParameterizedType pt = (ParameterizedType) t;

Type rawType = pt.getRawType();

if (rawType instanceof Class) {

Class rt = (Class) rawType;

Type[] argTypes = pt.getActualTypeArguments();

if (Map.class.isAssignableFrom(rt)) {

OpenType keyType = typeToOpenType(argTypes[0]);

OpenType valueType = typeToOpenType(argTypes[1]);

if (keyType != null && valueType != null) {

CompositeType rowType = new CompositeType("Map",

"Map of data",

new String[]{"key", "value"},

new String[]{"key", "value"},

new OpenType[]{keyType, valueType});

return new ArrayType(1, rowType);

}

}

}

}

} catch (OpenDataException ode) {

ode.printStackTrace();

}

// nothing seems working...

return null;

}

private static Object convertToOpenTypeValue(OpenType ot, Object value) {

if (ot instanceof SimpleType) {

if (value instanceof AtomicInteger) {

return ((AtomicInteger) value).get();

} else if (value instanceof AtomicLong) {

return ((AtomicLong) value).get();

} else {

return value;

}

} else if (ot instanceof CompositeType) {

// System.err.println("!!! converting val of type " + value.getClass().getName());

// System.err.println("!!! is profiler: " + (value instanceof Profiler));

// System.err.println("!!! is mbean value provider: " + (value instanceof Profiler.MBeanValueProvider));

if (value instanceof Profiler && value instanceof Profiler.MBeanValueProvider) {

CompositeType ct = (CompositeType) ot;

Profiler.MBeanValueProvider p = (Profiler.MBeanValueProvider)value;

Profiler.Snapshot snapshot = p.getMBeanValue();

// System.err.println("!!! snapshot == null :: " + (snapshot == null));

if (snapshot == null) {

// System.err.println("!!! NULL snapshot");

try {

return new CompositeDataSupport(ct,

new String[]{"startTime", "lastRefresh", "interval", "data"},

new Object[]{

convertToOpenTypeValue(ct.getType("startTime"), ((Profiler) p).START_TIME),

convertToOpenTypeValue(ct.getType("lastRefresh"), -1L),

convertToOpenTypeValue(ct.getType("interval"), 0L),

new CompositeData[0]

});

} catch (OpenDataException e) {

e.printStackTrace();

return null;

}

}

// System.err.println("!!! Snapshot length: " + snapshot.total.length);

CompositeData[] total = new CompositeData[snapshot.total.length];

long divider = snapshot.timeInterval * 1000000; // converting ms to ns divider

int index = 0;

for (Profiler.Record r : snapshot.total) {

try {

// System.err.println("!!! adding record: " + r);

CompositeType at = (CompositeType)((ArrayType)ct.getType("data")).getElementOpenType();

CompositeType rt = (CompositeType)at.getType("value");

CompositeData recordData = new CompositeDataSupport(rt,

new String[]{"block",

"invocations",

"selfTime.total",

"selfTime.percent",

"selfTime.avg",

"selfTime.max",

"selfTime.min",

"wallTime.total",

"wallTime.percent",

"wallTime.avg",

"wallTime.max",

"wallTime.min"},

new Object[]{r.blockName,

r.invocations,

r.selfTime,

(double)(snapshot.timeInterval > 0 ? ((double)r.selfTime / (double)divider) * 100 : 0),

r.selfTime / r.invocations,

r.selfTimeMax,

r.selfTimeMin == Long.MAX_VALUE ? 0 : r.selfTimeMin,

r.wallTime,

(double)(snapshot.timeInterval > 0 ? ((double)r.wallTime / (double)divider) * 100 : 0),

r.wallTime / r.invocations,

r.wallTimeMax,

r.wallTimeMin});

total[index] = new CompositeDataSupport(at,

new String[]{"key", "value"},

new Object[]{r.blockName, recordData}

);

} catch (OpenDataException ode) {

ode.printStackTrace();

} catch (Exception e) {

e.printStackTrace();

}

index++;

}

CompositeData snapshotData = null;

try {

// System.err.println("!!! creating snapshot data");

snapshotData = new CompositeDataSupport(ct,

new String[]{"startTime", "lastRefresh", "interval", "data"},

new Object[]{

convertToOpenTypeValue(ct.getType("startTime"), ((Profiler)p).START_TIME),

convertToOpenTypeValue(ct.getType("lastRefresh"), snapshot.timeStamp),

convertToOpenTypeValue(ct.getType("interval"), snapshot.timeInterval),

total

});

} catch (OpenDataException e) {

e.printStackTrace();

} catch (Exception e) {

e.printStackTrace();

}

// System.err.println("!!! data: " + snapshot);

return snapshotData;

}

} else if (ot instanceof ArrayType) {

ArrayType at = (ArrayType) ot;

OpenType et = at.getElementOpenType();

if (value instanceof Map && et instanceof CompositeType) {

CompositeType ct = (CompositeType) et;

Map<Object, Object> map = new HashMap((Map<Object, Object>) value);

CompositeData[] array = new CompositeData[map.size()];

OpenType keyType = ct.getType("key");

OpenType valueType = ct.getType("value");

int index = 0;

for (Map.Entry<Object, Object> entry : map.entrySet()) {

Map<String, Object> row = new HashMap<>();

row.put("key", convertToOpenTypeValue(keyType, entry.getKey()));

row.put("value", convertToOpenTypeValue(valueType, entry.getValue()));

try {

array[index] = new CompositeDataSupport(ct, row);

} catch (OpenDataException ode) {

ode.printStackTrace();

}

index++;

}

return array;

}

}

return value;

}

}

}