private Object invokeAttribute(PropertyDescriptor pd, MethodInvocation invocation)
throws JMException, IOException {
String attributeName = JmxUtils.getAttributeName(pd, this.useStrictCasing);
MBeanAttributeInfo inf = (MBeanAttributeInfo) this.allowedAttributes.get(attributeName);
// If no attribute is returned, we know that it is not defined in the
// management interface.
if (inf == null) {
throw new InvalidInvocationException(
"Attribute '" + pd.getName() + "' is not exposed on the management interface");
}
if (invocation.getMethod().equals(pd.getReadMethod())) {
if (inf.isReadable()) {
return this.server.getAttribute(this.objectName, attributeName);
} else {
throw new InvalidInvocationException("Attribute '" + attributeName + "' is not readable");
}
} else if (invocation.getMethod().equals(pd.getWriteMethod())) {
if (inf.isWritable()) {
server.setAttribute(
this.objectName, new Attribute(attributeName, invocation.getArguments()[0]));
return null;
} else {
throw new InvalidInvocationException("Attribute '" + attributeName + "' is not writable");
}
} else {
throw new IllegalStateException(
"Method [" + invocation.getMethod() + "] is neither a bean property getter nor a setter");
}
}
protected Result describeMbean(
@Nonnull MBeanServerConnection mbeanServer, @Nonnull ObjectName objectName)
throws IntrospectionException, ReflectionException, InstanceNotFoundException, IOException {
MBeanInfo mbeanInfo = mbeanServer.getMBeanInfo(objectName);
StringWriter sw = new StringWriter();
PrintWriter out = new PrintWriter(sw);
out.println("# MBEAN");
out.println(objectName.toString());
out.println();
out.println("## OPERATIONS");
List<MBeanOperationInfo> operations = Arrays.asList(mbeanInfo.getOperations());
Collections.sort(
operations,
new Comparator<MBeanOperationInfo>() {
@Override
public int compare(MBeanOperationInfo o1, MBeanOperationInfo o2) {
return o1.getName().compareTo(o1.getName());
}
});
for (MBeanOperationInfo opInfo : operations) {
out.print("* " + opInfo.getName() + "(");
MBeanParameterInfo[] signature = opInfo.getSignature();
for (int i = 0; i < signature.length; i++) {
MBeanParameterInfo paramInfo = signature[i];
out.print(paramInfo.getType() + " " + paramInfo.getName());
if (i < signature.length - 1) {
out.print(", ");
}
}
out.print("):" + opInfo.getReturnType() /* + " - " + opInfo.getDescription() */);
out.println();
}
out.println();
out.println("## ATTRIBUTES");
List<MBeanAttributeInfo> attributes = Arrays.asList(mbeanInfo.getAttributes());
Collections.sort(
attributes,
new Comparator<MBeanAttributeInfo>() {
@Override
public int compare(MBeanAttributeInfo o1, MBeanAttributeInfo o2) {
return o1.getName().compareTo(o2.getName());
}
});
for (MBeanAttributeInfo attrInfo : attributes) {
out.println(
"* "
+ attrInfo.getName()
+ ": "
+ attrInfo.getType()
+ " - "
+ (attrInfo.isReadable() ? "r" : "")
+ (attrInfo.isWritable() ? "w" : "") /* + " - " +
attrInfo.getDescription() */);
}
String description = sw.getBuffer().toString();
return new Result(objectName, description, description);
}
/**
* Writes this attribute value to the MBEan server.
*
* @param connectionConfiguration the connection context.
* @param objectName the ObjectName of the specified MBean
* @param attributeInfo the AtributeInfo object.
* @param attributeValue the new Value
*/
public void writeAttributeValue(
IConnectionConfiguration connectionConfiguration,
ObjectName objectName,
MBeanAttributeInfo attributeInfo,
String attributeValue) {
// convert
Object value = convertStringValueToObjectValue(attributeInfo.getType(), attributeValue);
Attribute attribute = new Attribute(attributeInfo.getName(), value);
JMXExplorerEvent event;
try {
mBeanServerConnection.setAttribute(objectName, attribute);
event =
new JMXExplorerEvent(
connectionConfiguration,
JMXExplorerEvent.ATTRIBUTE_VALUE_CHANGED,
objectName,
attribute,
attributeInfo);
} catch (Exception t) {
// we fould exception, no mather what, the attribute value was not
// set
Activator.getDefault().error("writeAttributeValue failed", t);
event =
new JMXExplorerEvent(
connectionConfiguration,
JMXExplorerEvent.CHANGE_ATTRIBUTE_VALUE_ERROR,
objectName,
t,
attributeInfo);
return;
}
jmxExplorerMediator.notifyObserversWithJMXEvent(event);
}
protected MBeanAttributeInfo getAttributeInfo(MBeanInfo info, String attributeName) {
for (MBeanAttributeInfo attributeInfo : info.getAttributes()) {
if (attributeInfo.getName().equals(attributeName)) {
return attributeInfo;
}
}
return null;
}
/* Check that all descriptors have been returned */
private static void checkDescriptors(
ModelMBeanInfo modelMBeanInfo, Descriptor[] descriptors, String string) {
int errCount = 0;
final ArrayList<Descriptor> list = new ArrayList<Descriptor>(descriptors.length);
list.addAll(Arrays.asList(descriptors));
System.out.println("Got " + list.size() + " descriptors for " + string);
// checks that MBean's descriptor is returned.
//
final Descriptor mbd = ((MBeanInfo) modelMBeanInfo).getDescriptor();
if (!mbd.equals(remove(list, mbd))) {
System.err.println("modelMBeanInfo.getDescriptor(): not found");
errCount++;
}
// checks that MBean's attributes descriptors are returned.
//
final MBeanAttributeInfo[] attrs = modelMBeanInfo.getAttributes();
for (MBeanAttributeInfo att : attrs) {
final Descriptor ad = att.getDescriptor();
final String name = att.getName();
if (!ad.equals(remove(list, ad))) {
System.err.println("attInfo.getDescriptor(): not found for " + name);
errCount++;
}
}
// checks that MBean's operations descriptors are returned.
//
final MBeanOperationInfo[] ops = modelMBeanInfo.getOperations();
for (MBeanOperationInfo op : ops) {
final Descriptor od = op.getDescriptor();
final String name = op.getName();
if (!od.equals(remove(list, od))) {
System.err.println("opInfo.getDescriptor(): not found for " + name);
errCount++;
}
}
// checks that MBean's notifications descriptors are returned.
//
final MBeanNotificationInfo[] ntfs = modelMBeanInfo.getNotifications();
for (MBeanNotificationInfo ntf : ntfs) {
final Descriptor nd = ntf.getDescriptor();
final String name = ntf.getName();
if (!nd.equals(remove(list, nd))) {
System.err.println("notifInfo.getDescriptor(): not found for " + name);
errCount++;
}
}
if (errCount > 0) {
throw new RuntimeException(string + ": failed with " + errCount + " errors");
} else if (list.size() != 0) {
// Check that there are no additional descriptors
//
throw new RuntimeException(string + ": Unexpected remaining descriptors: " + list);
} else System.out.println(string + ": PASSED");
}
/**
* List of the names of each of the attributes on the MBean
*
* @return list of attribute names
*/
public Collection<String> listAttributeNames() {
List<String> list = new ArrayList<String>();
try {
MBeanAttributeInfo[] attrs = beanInfo.getAttributes();
for (MBeanAttributeInfo attr : attrs) {
list.add(attr.getName());
}
} catch (Exception e) {
throwException("Could not list attribute names. Reason: ", e);
}
return list;
}
/**
* Description of the specified attribute name.
*
* @param attr - the attribute
* @return String the description
*/
protected String describeAttribute(MBeanAttributeInfo attr) {
StringBuilder buf = new StringBuilder();
buf.append("(");
if (attr.isReadable()) {
buf.append("r");
}
if (attr.isWritable()) {
buf.append("w");
}
buf.append(") ").append(attr.getType()).append(" ").append(attr.getName());
return buf.toString();
}
/**
* @see com.ixora.rms.agents.impl.jmx.JMXAbstractAgent#acceptCounter(javax.management.ObjectName,
* javax.management.MBeanAttributeInfo)
*/
protected boolean acceptCounter(ObjectName oname, MBeanAttributeInfo ainfo) {
if (ainfo.getName().equals("Name")) {
return false;
}
String soname = oname.toString();
if (soname.startsWith("java.lang:type=MemoryPool,name=")) {
if (ainfo.getName().indexOf("Threshold") >= 0) {
return false;
}
}
return true;
}
private String getType(String attName, boolean read, boolean write) {
boolean allowed = true;
if (attributes.containsKey(attName)) {
MBeanAttributeInfo temp = (MBeanAttributeInfo) attributes.get(attName);
if (read) {
if (!temp.isReadable()) allowed = false;
}
if (write) {
if (!temp.isWritable()) allowed = false;
}
if (!allowed) return null;
else return temp.getType();
} else return null;
}
/**
* Description of the specified attribute name.
*
* @param attributeName - stringified name of the attribute
* @return the description
*/
public String describeAttribute(String attributeName) {
String ret = "Attribute not found";
try {
MBeanAttributeInfo[] attributes = beanInfo.getAttributes();
for (MBeanAttributeInfo attribute : attributes) {
if (attribute.getName().equals(attributeName)) {
return describeAttribute(attribute);
}
}
} catch (Exception e) {
throwException("Could not describe attribute '" + attributeName + "'. Reason: ", e);
}
return ret;
}
void addMBean(ObjectName beanName) {
try {
MBeanInfo info = _server.getMBeanInfo(beanName);
MBeanAttributeInfo[] infos = info.getAttributes();
_beanValueMap.put(beanName.toString(), new HashMap<String, Object>());
for (MBeanAttributeInfo infoItem : infos) {
Object val = _server.getAttribute(beanName, infoItem.getName());
// System.out.println(" " + infoItem.getName() + " : " +
// _server.getAttribute(beanName, infoItem.getName()) + " type : " + infoItem.getType());
_beanValueMap.get(beanName.toString()).put(infoItem.getName(), val);
}
} catch (Exception e) {
_logger.error("Error getting bean info, domain=" + _domain, e);
}
}
protected List<MBeanAttributeInfo> findMBeanAttributeInfos(
MBeanInfo info, String attributePattern) {
List<MBeanAttributeInfo> results = new ArrayList<MBeanAttributeInfo>();
if (attributePattern != null) {
for (MBeanAttributeInfo attributeInfo : info.getAttributes()) {
if (WildcardUtils.match(
attributeInfo.getName().toLowerCase(), attributePattern.toLowerCase())) {
results.add(attributeInfo);
}
}
}
return results;
}
private int attr(
Process process, ObjectName objectName, List<MBeanAttributeInfo> attributeInfos) {
for (MBeanAttributeInfo attributeInfo : attributeInfos) {
Object value;
try {
value = server.getAttribute(objectName, attributeInfo.getName());
} catch (Exception e) {
value = String.format("<%s: %s>", e.getClass().getName(), e.getMessage());
}
process.out.println(
String.format(
"%s.%s = %s", getName(objectName), attributeInfo.getName(), toString(value)));
}
return 0;
}
/**
* Refreshes the content provider.
*
* @param jvm The active JVM
*/
public void refresh(IActiveJvm jvm) {
domains = new HashMap<String, MBeanDomain>();
// add or update elements
for (ObjectName objectName : getObjectNames(jvm)) {
MBeanInfo mBeanInfo = getMBeanInfo(jvm, objectName);
if (mBeanInfo == null) {
continue;
}
List<AttributeNode> mBeanAttributes = new ArrayList<AttributeNode>();
for (MBeanAttributeInfo attributeInfo : mBeanInfo.getAttributes()) {
String attributeName = attributeInfo.getName();
Object value = getContents(jvm, objectName, attributeName);
addAttributeRoots(
mBeanAttributes, new AttributeNode(attributeName, null, objectName), value);
}
for (AttributeNode node : mBeanAttributes.toArray(new AttributeNode[0])) {
validateAttributes(node);
if (node.getChildren().size() == 0 && !node.isValidLeaf()) {
mBeanAttributes.remove(node);
}
}
if (mBeanAttributes.size() == 0) {
continue;
}
attributes.put(objectName, mBeanAttributes);
String domainName = objectName.getDomain();
MBeanDomain domain;
if (domains.containsKey(domainName)) {
domain = domains.get(domainName);
} else {
domain = new MBeanDomain(domainName);
}
domain.refresh(objectName, jvm);
domains.put(domainName, domain);
}
}
public Object getValue(ServiceValueContext valueContext) throws Exception {
MBeanAttributeInfo attributeInfo = valueContext.getAttributeInfo();
ClassLoader cl = valueContext.getClassloader();
String typeName = attributeInfo.getType();
if (typeName == null)
throw new DeploymentException(
"AttributeInfo for " + attributeInfo.getName() + " has no type");
// see if it is a primitive type first
Class typeClass = Classes.getPrimitiveTypeForName(typeName);
if (typeClass == null) {
// nope try look up
try {
typeClass = cl.loadClass(typeName);
} catch (ClassNotFoundException e) {
throw new DeploymentException(
"Class not found for attribute: " + attributeInfo.getName(), e);
}
}
PropertyEditor editor = PropertyEditorFinder.getInstance().find(typeClass);
if (editor == null)
throw new DeploymentException(
"No property editor for attribute: "
+ attributeInfo.getName()
+ "; type="
+ typeClass.getName());
// JBAS-1709, temporarily switch the TCL so that property
// editors have access to the actual deployment ClassLoader.
ClassLoader tcl = Thread.currentThread().getContextClassLoader();
Thread.currentThread().setContextClassLoader(cl);
try {
editor.setAsText(text);
return editor.getValue();
} finally {
Thread.currentThread().setContextClassLoader(tcl);
}
}
public static OperationParams getAttributeParams(MBeanInfo info, String method, Object args[])
throws PluginException {
if (method.startsWith("set") || method.startsWith("get")) {
method = method.substring(3);
}
MBeanAttributeInfo[] attrs = info.getAttributes();
for (int i = 0; i < attrs.length; i++) {
MBeanAttributeInfo attr = attrs[i];
if (!attr.getName().equals(method)) {
continue;
}
String sig = attr.getType();
if (!hasConverter(sig)) {
String msg = "Cannot convert String argument to " + sig;
throw new PluginException(msg);
}
OperationParams params = new OperationParams();
Object value = null;
try {
if (args.length > 0) {
value = convert(sig, (String) args[0]);
}
} catch (Exception e) {
String msg = "Exception converting param '" + args[0] + "' to type '" + sig + "'";
throw new PluginException(msg + ": " + e);
}
if (value != null) {
params.arguments = new Object[] {value};
}
params.isAttribute = true;
return params;
}
return null;
}
public void walkTree(MBeanServerConnection connection, Server server) throws Exception {
// key here is null, null returns everything!
Set<ObjectName> mbeans = connection.queryNames(null, null);
Map<String, String> output = newHashMap();
for (ObjectName name : mbeans) {
MBeanInfo info = connection.getMBeanInfo(name);
MBeanAttributeInfo[] attrs = info.getAttributes();
Query.Builder queryBuilder = Query.builder().setObj(name.getCanonicalName());
ResultCapture resultCapture = new ResultCapture();
queryBuilder.addOutputWriter(resultCapture);
for (MBeanAttributeInfo attrInfo : attrs) {
queryBuilder.addAttr(attrInfo.getName());
}
Query query = queryBuilder.build();
try {
Iterable<Result> results = server.execute(query);
query.runOutputWritersForQuery(server, results);
} catch (AttributeNotFoundException anfe) {
log.error("Error", anfe);
}
for (Result result : resultCapture.results) {
output.put(result.getTypeName(), query.getAttr().toString());
}
}
for (Entry<String, String> entry : output.entrySet()) {
log.debug(entry.getKey());
log.debug(entry.getValue());
log.debug("-----------------------------------------");
}
}
/**
* Query the mbean connection and add all metrics that satisfy the filter to the list {@code
* metrics}.
*/
private void getMetrics(
MBeanServerConnection con, MetricFilter filter, List<Metric> metrics, ObjectName name)
throws JMException, IOException {
// Create tags from the object name
TagList tags = createTagList(name);
MBeanInfo info = con.getMBeanInfo(name);
MBeanAttributeInfo[] attrInfos = info.getAttributes();
// Restrict to attributes that match the filter
List<String> matchingNames = Lists.newArrayList();
for (MBeanAttributeInfo attrInfo : attrInfos) {
String attrName = attrInfo.getName();
if (filter.matches(new MonitorConfig.Builder(attrName).withTags(tags).build())) {
matchingNames.add(attrName);
}
}
List<Attribute> attributeList = safelyLoadAttributes(con, name, matchingNames);
for (Attribute attr : attributeList) {
String attrName = attr.getName();
Object obj = attr.getValue();
if (obj instanceof CompositeData) {
Map<String, Object> values = Maps.newHashMap();
extractValues(null, values, (CompositeData) obj);
for (Map.Entry<String, Object> e : values.entrySet()) {
String key = e.getKey();
TagList newTags =
SortedTagList.builder().withTags(tags).withTag(COMPOSITE_PATH_KEY, key).build();
if (filter.matches(MonitorConfig.builder(attrName).withTags(newTags).build())) {
addMetric(metrics, attrName, newTags, e.getValue());
}
}
} else {
addMetric(metrics, attrName, tags, obj);
}
}
}
public Object getPropertyValue(Object id) {
if ("name".equals(id)) { // $NON-NLS-1$
return attrInfo.getName();
}
if ("description".equals(id)) { // $NON-NLS-1$
return attrInfo.getDescription();
}
if ("type".equals(id)) { // $NON-NLS-1$
Object obj = attrInfo.getType();
if (obj instanceof Object[]) {
return Arrays.asList((Object[]) obj).toString();
}
return obj;
}
if ("readable".equals(id)) { // $NON-NLS-1$
return Boolean.valueOf(attrInfo.isReadable());
}
if ("writable".equals(id)) { // $NON-NLS-1$
return Boolean.valueOf(attrInfo.isWritable());
}
if ("value".equals(id)) { // $NON-NLS-1$
try {
if (mbsc != null) {
Object obj = mbsc.getAttribute(on, attrInfo.getName());
if (obj instanceof Object[]) {
return Arrays.asList((Object[]) obj).toString();
}
return obj;
} else {
conn.run(
new IJMXRunnable() {
final Object[] ret = new Object[1];
@Override
public void run(MBeanServerConnection connection) throws Exception {
Object obj = connection.getAttribute(on, attrInfo.getName());
if (obj instanceof Object[]) {
ret[0] = Arrays.asList((Object[]) obj).toString();
}
ret[0] = obj;
}
});
}
} catch (Exception e) {
JMXUIActivator.log(
IStatus.WARNING, NLS.bind(Messages.MBeanAttributeValue_Warning, attrInfo.getName()), e);
return null;
}
}
return null;
}
/**
* Exports all the numeric attributes of beans matching the supplied MXBean name pattern. Also,
* discovers the numeric properties of the attributes of type CompositeData and registers them as
* well.
*
* @param beanNamePattern the bean name pattern used to discover the beans.
* @see javax.management.ObjectName for bean name pattern syntax
* @see java.lang.management for the list of java platform mbeans
* @throws JMException if there are errors querying MBeans or information on them
*/
public void exportNumericAttributes(ObjectName beanNamePattern) throws JMException {
MBeanServer beanServer = ManagementFactory.getPlatformMBeanServer();
Set<ObjectName> beanNames = beanServer.queryNames(beanNamePattern, null);
// Iterate through all beans and register their numeric properties with Stats
for (ObjectName beanName : beanNames) {
MBeanInfo beanInfo = beanServer.getMBeanInfo(beanName);
// Iterate through all bean attributes
for (MBeanAttributeInfo attributeInfo : beanInfo.getAttributes()) {
if (attributeInfo.isReadable()) {
// Figure out the open type for the attribute
OpenType<?> openType = null;
if (attributeInfo instanceof OpenMBeanAttributeInfo) {
openType = ((OpenMBeanAttributeInfo) attributeInfo).getOpenType();
} else {
// Sometimes the open mbean info is available in the descriptor
Object obj = attributeInfo.getDescriptor().getFieldValue("openType");
if (obj != null && obj instanceof OpenType) {
openType = (OpenType) obj;
}
}
// once the open type is found, figure out if it's a numeric or composite type
if (openType != null) {
if (NUMERIC_TYPES.contains(openType)) {
// numeric attribute types are registered with callbacks that simply
// return their value
addStatIfMatches(
getStatName(beanName, attributeInfo.getName()),
new MBeanLongAttributeFetcher(beanServer, beanName, attributeInfo.getName()));
} else if (openType instanceof CompositeType) {
// for composite types, we figure out which properties of the composite type
// are numeric and register callbacks to fetch those composite type attributes
CompositeType compositeType = (CompositeType) openType;
for (String key : compositeType.keySet()) {
if (NUMERIC_TYPES.contains(compositeType.getType(key))) {
addStatIfMatches(
getStatName(beanName, attributeInfo.getName(), key),
new MBeanLongCompositeValueFetcher(
beanServer, beanName, attributeInfo.getName(), key));
}
}
}
}
}
}
}
}
/**
* Tests correct MBean interface.
*
* @throws Exception Thrown if test fails.
*/
public void testCorrectMBeanInfo() throws Exception {
StandardMBean mbean =
new IgniteStandardMXBean(new GridMBeanImplementation(), GridMBeanInterface.class);
MBeanInfo info = mbean.getMBeanInfo();
assert info.getDescription().equals("MBeanDescription.") == true;
assert info.getOperations().length == 2;
for (MBeanOperationInfo opInfo : info.getOperations()) {
if (opInfo.getDescription().equals("MBeanOperation."))
assert opInfo.getSignature().length == 2;
else {
assert opInfo.getDescription().equals("MBeanSuperOperation.") == true;
assert opInfo.getSignature().length == 1;
}
}
for (MBeanParameterInfo paramInfo : info.getOperations()[0].getSignature()) {
if (paramInfo.getName().equals("ignored"))
assert paramInfo.getDescription().equals("MBeanOperationParameter1.") == true;
else {
assert paramInfo.getName().equals("someData") == true;
assert paramInfo.getDescription().equals("MBeanOperationParameter2.") == true;
}
}
assert info.getAttributes().length == 4
: "Expected 4 attributes but got " + info.getAttributes().length;
for (MBeanAttributeInfo attrInfo : info.getAttributes()) {
if (attrInfo.isWritable() == false) {
assert (attrInfo.getDescription().equals("MBeanReadonlyGetter.") == true
|| attrInfo.getDescription().equals("MBeanROGetter."));
} else {
assert (attrInfo.getDescription().equals("MBeanWritableGetter.") == true
|| attrInfo.getDescription().equals("MBeanWritableIsGetter."));
}
}
}
@Test(dataProvider = "fixtures")
public void testGetterAttributeInfo(
String attribute, boolean isIs, Object[] values, Class<?> clazz) throws Exception {
String methodName = "set" + attribute.replace(".", "");
for (T t : objects) {
String attributeName = toFeatureName(attribute, t);
SimpleInterface simpleInterface = toSimpleInterface(t);
Method setter = getMethod(simpleInterface.getClass(), methodName, clazz);
MBeanInfo info = getMBeanInfo(t);
MBeanAttributeInfo attributeInfo = getAttributeInfo(info, attributeName);
assertNotNull(attributeInfo, "AttributeInfo for " + attributeName);
assertEquals(attributeInfo.getName(), attributeName, "Attribute Name for " + attributeName);
assertEquals(
attributeInfo.getType(),
setter.getParameterTypes()[0].getName(),
"Attribute type for " + attributeName);
assertEquals(attributeInfo.isIs(), isIs, "Attribute isIs for " + attributeName);
assertTrue(attributeInfo.isReadable(), "Attribute Readable for " + attributeName);
assertFalse(attributeInfo.isWritable(), "Attribute Writable for " + attributeName);
}
}
/**
* @see
* com.ixora.rms.agents.impl.jmx.JMXAbstractAgent#getCounterNameAndDescription(javax.management.ObjectName,
* javax.management.MBeanAttributeInfo)
*/
protected String[] getCounterNameAndDescription(ObjectName oname, MBeanAttributeInfo ainfo) {
String soname = oname.toString();
if (soname.equals("java.lang:type=Compilation")) {
return new String[] {
"Compilation." + ainfo.getName(), "Compilation." + ainfo.getName() + ".desc"
};
}
if (soname.equals("java.lang:type=MemoryManager,name=CodeCacheManager")) {
return new String[] {
"CodeCacheManager." + ainfo.getName(), "CodeCacheManager." + ainfo.getName() + ".desc"
};
}
if (soname.startsWith("java.lang:type=GarbageCollector,name=")) {
return new String[] {
"GarbageCollector." + ainfo.getName(), "GarbageCollector." + ainfo.getName() + ".desc"
};
}
if (soname.startsWith("java.lang:type=Runtime")) {
return new String[] {"Runtime." + ainfo.getName(), "Runtime." + ainfo.getName() + ".desc"};
}
if (soname.startsWith("java.lang:type=ClassLoading")) {
return new String[] {
"ClassLoading." + ainfo.getName(), "ClassLoading." + ainfo.getName() + ".desc"
};
}
if (soname.startsWith("java.lang:type=Threading")) {
return new String[] {
"Threading." + ainfo.getName(), "Threading." + ainfo.getName() + ".desc"
};
}
if (soname.startsWith("java.lang:type=OperatingSystem")) {
return new String[] {
"OperatingSystem." + ainfo.getName(), "OperatingSystem." + ainfo.getName() + ".desc"
};
}
if (soname.startsWith("java.lang:type=Memory")) {
return new String[] {"Memory." + ainfo.getName(), "Memory." + ainfo.getName() + ".desc"};
}
return super.getCounterNameAndDescription(oname, ainfo);
}
static String getJobsInfo(ObjectName jobObjName) {
Set<ObjectInstance> jobInstances = mBeanServer.queryMBeans(jobObjName, null);
Iterator<ObjectInstance> jobIterator = jobInstances.iterator();
StringBuffer json = new StringBuffer("[");
int counter = 0;
while (jobIterator.hasNext()) {
if (counter > 0) {
json.append(",");
}
ObjectInstance jobInstance = jobIterator.next();
ObjectName jobObjectName = jobInstance.getObjectName();
MBeanInfo mBeanInfo = null;
try {
mBeanInfo = mBeanServer.getMBeanInfo(jobObjectName);
} catch (IntrospectionException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (InstanceNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (ReflectionException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
/*
* Get the names of all the attributes
*/
Set<String> names = new HashSet<String>();
for (MBeanAttributeInfo attributeInfo : mBeanInfo.getAttributes()) {
names.add(attributeInfo.getName());
}
// now construct the job json and add it to the string buffer
StringBuffer s = new StringBuffer();
s.append("{\"");
Iterator<String> it = names.iterator();
while (it.hasNext()) {
String attr = it.next();
s.append(attr);
s.append("\":\"");
try {
s.append((String) mBeanServer.getAttribute(jobObjectName, attr));
} catch (AttributeNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (InstanceNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (MBeanException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (ReflectionException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
s.append("\",\"");
}
// remove the trailing ,\
s.deleteCharAt(s.length() - 1);
s.deleteCharAt(s.length() - 1);
json.append(s.toString() + "}");
counter++;
}
json.append("]");
String jsonString = json.toString();
return jsonString;
}
public void testCacheService() throws Exception {
assertNotNull(service_.getAllCacheInstances());
int size = service_.getAllCacheInstances().size();
// -----nocache info is retrived from test-configuration(nocache 0bject)
ExoCache<String, Object> nocache = service_.getCacheInstance("nocache");
assertTrue("expect find nocache configuaration", nocache instanceof SimpleExoCache);
assertEquals("expect 'maxsize' of nocache is", 5, nocache.getMaxSize());
assertEquals("expect 'liveTime' of nocache' is", 0, nocache.getLiveTime());
nocache.put("key1", "object 1");
assertEquals("expect 'nocache' is not lived(LiveTime=0)", 0, nocache.getCacheSize());
// -----cacheLiveTime2s's info is retrived from test-configuration
// (cacheLiveTime2s object)
ExoCache<String, Object> cacheLiveTime2s = service_.getCacheInstance("cacheLiveTime2s");
assertTrue(
"expect find cacheLiveTime2s configuaration", cacheLiveTime2s instanceof SimpleExoCache);
assertEquals("expect 'maxsize' of this cache is", 5, cacheLiveTime2s.getMaxSize());
assertEquals("expect 'liveTime' of nocache' is", 2, cacheLiveTime2s.getLiveTime());
cacheLiveTime2s.put("key", "object2s");
String obj2s = (String) cacheLiveTime2s.get("key");
assertTrue("expect found 'object' in cache", obj2s != null && obj2s.equals("object2s"));
assertEquals("expect found object in this cache", 1, cacheLiveTime2s.getCacheSize());
Thread.sleep(2500);
assertTrue("expect no found 'object' in this cache", cacheLiveTime2s.get("key") == null);
assertEquals("expect cache size is ", 0, cacheLiveTime2s.getCacheSize());
// -----cacheMaxSize0's info retrived from test-configuration (cacheMaxSize0
// object)
ExoCache<String, Object> cacheMaxSize0 = service_.getCacheInstance("cacheMaxSize0");
assertTrue("expect find cacheMaxSize0 configuaration", cacheMaxSize0 instanceof SimpleExoCache);
assertEquals("expect 'maxsize' of this cache is", 0, cacheMaxSize0.getMaxSize());
assertEquals("expect 'liveTime' of nocache' is", 4, cacheMaxSize0.getLiveTime());
cacheMaxSize0.put("mkey", "maxsize object");
assertTrue("expect can't put any object to cache", cacheMaxSize0.get("mkey") == null);
// -----default cache's info is retrived if no cache's info is found
ExoCache<String, Object> cache = service_.getCacheInstance("exo");
assertTrue("expect find defaul cache configuaration", cache instanceof SimpleExoCache);
assertEquals("expect 'maxsize' of this cache is", 100, cache.getMaxSize());
assertEquals("expect 'liveTime' of this cache' is", 300, cache.getLiveTime());
cache.put("test", "this is a test");
String ret = (String) cache.get("test");
assertTrue("expect object is cached", ret != null);
/* ----------FIFOExoCache--------------- */
ExoCache<String, Object> fifoCache = service_.getCacheInstance("fifocache");
assertTrue("expect find fifo cache configuration", fifoCache instanceof FIFOExoCache);
assertEquals("expect 'maxsize' of this cache is", 3, fifoCache.getMaxSize());
assertEquals("expect 'liveTime' of this cache' is", 4, fifoCache.getLiveTime());
fifoCache.put("key1", "object 1");
fifoCache.put("key2", "object 2");
assertEquals("expect FIFOExoCache size is:", 2, fifoCache.getCacheSize());
String obj1 = (String) fifoCache.get("key1");
String obj2 = (String) fifoCache.get("key2");
assertTrue("expect found 'key1' object", obj1 != null && obj1.equals("object 1"));
assertTrue("expect found 'key2' object", obj2 != null && obj2.equals("object 2"));
fifoCache.put("skey", "serializable object");
assertEquals("expect FIFOExoCache size is:", 3, fifoCache.getCacheSize());
String sobj = (String) fifoCache.get("skey");
assertTrue(
"expect found serializable key and it's value",
sobj != null && sobj.equals("serializable object"));
fifoCache.put("key4", "object 4");
// because maxsize of cache is 3, 'object 1' associated with 'key1' is
// remove form FIFOExoCache
assertEquals("expect cache size is still:", 3, fifoCache.getCacheSize());
String obj4 = (String) fifoCache.get("key4");
assertTrue("expect object has 'key4' is put in cache", obj4 != null && obj4.equals("object 4"));
assertTrue(
"expect object has key is 'key1' is remove automatically", fifoCache.get("key1") == null);
// -------remove a object in cache by key
fifoCache.remove("key2");
assertEquals("now, expect cache size is", 2, fifoCache.getCacheSize());
assertEquals(
"now, expect number of object in cache is:", 2, fifoCache.getCachedObjects().size());
assertTrue("expect object has 'key2' is removed", fifoCache.get("key2") == null);
// -------remove a object in cache by serializable name
fifoCache.remove(new String("skey"));
assertEquals("now, expect cache size is", 1, fifoCache.getCacheSize());
assertEquals(
"now, expect number of object in cache is:", 1, fifoCache.getCachedObjects().size());
assertTrue(
"expect serializable object with name 'skey' is remove",
fifoCache.get(new String("skey")) == null);
// --------------clear cache
fifoCache.clearCache();
assertEquals("now, expect cache is clear", 0, fifoCache.getCacheSize());
assertEquals(
"now, expect number of object in cache is:", 0, fifoCache.getCachedObjects().size());
/* --------------test cache service with add extenal component plugin------ */
ExoCache simpleCachePlugin = service_.getCacheInstance("simpleCachePlugin");
assertTrue(
"expect found simpleCache from extenal plugin",
simpleCachePlugin instanceof SimpleExoCache);
assertEquals("expect 'maxsize' of this cache is", 8, simpleCachePlugin.getMaxSize());
assertEquals("expect 'LiveTime' of this cache is", 5, simpleCachePlugin.getLiveTime());
ExoCache fifoCachePlugin = service_.getCacheInstance("fifoCachePlugin");
assertTrue(
"expect found fifoCache from extenal plugin", fifoCachePlugin instanceof FIFOExoCache);
assertEquals("expect 'maxsize' of this cache is", 6, fifoCachePlugin.getMaxSize());
assertEquals("expect 'LiveTime' of this cache is", 10, fifoCachePlugin.getLiveTime());
// ----all cache instances---
Collection<ExoCache<? extends Serializable, ?>> caches = service_.getAllCacheInstances();
assertEquals("expect number of cache instanse is ", size + 7, caches.size());
hasObjectInCollection(nocache, caches, new ExoCacheComparator());
hasObjectInCollection(cacheLiveTime2s, caches, new ExoCacheComparator());
hasObjectInCollection(cacheMaxSize0, caches, new ExoCacheComparator());
hasObjectInCollection(fifoCache, caches, new ExoCacheComparator());
hasObjectInCollection(cache, caches, new ExoCacheComparator());
hasObjectInCollection(simpleCachePlugin, caches, new ExoCacheComparator());
hasObjectInCollection(fifoCachePlugin, caches, new ExoCacheComparator());
// Managed tests
MBeanServerLocator locator =
(MBeanServerLocator)
PortalContainer.getInstance().getComponentInstanceOfType(MBeanServerLocator.class);
MBeanServer server = locator.server;
assertNotNull(locator.server);
ObjectName name = new ObjectName("exo:service=cache,name=cacheLiveTime2s,portal=portal");
MBeanInfo info = server.getMBeanInfo(name);
assertNotNull(info);
Map<String, MBeanAttributeInfo> infoMap = new HashMap<String, MBeanAttributeInfo>();
for (MBeanAttributeInfo attributeInfo : info.getAttributes()) {
infoMap.put(attributeInfo.getName(), attributeInfo);
}
assertTrue(infoMap.containsKey("Name"));
assertTrue(infoMap.containsKey("Size"));
assertTrue(infoMap.containsKey("Capacity"));
assertTrue(infoMap.containsKey("TimeToLive"));
assertTrue(infoMap.containsKey("HitCount"));
assertTrue(infoMap.containsKey("MissCount"));
assertEquals(6, infoMap.size());
assertEquals(5, server.getAttribute(name, "Capacity"));
assertEquals(size + 7, service_.getAllCacheInstances().size());
}
private void renderJsonDomain(
final PrintWriter pw,
final ObjectName objectName,
final MBeanInfo mBeanInfo,
boolean renderDetails)
throws IOException, AttributeNotFoundException, InstanceNotFoundException {
pw.write("{");
jsonKey(pw, "mbean");
// using toString to make shure that type is set before any other
// property
String canonicalName = objectName.toString();
String[] split = canonicalName.split(":");
jsonValue(pw, split[1]);
if (renderDetails) {
pw.write(',');
jsonKey(pw, "attributes");
pw.write("[{");
final MBeanAttributeInfo[] attrs = mBeanInfo.getAttributes();
for (int i = 0; i < attrs.length; i++) {
final MBeanAttributeInfo attr = attrs[i];
if (!attr.isReadable()) continue; // skip non readable properties
// jsonValue(pw, attr.getName() + ":writable=" +
// attr.isWritable());
jsonKey(pw, attr.getName());
pw.write("[");
jsonValue(pw, "writable=" + attr.isWritable());
Object value = null;
try {
// Descriptor descriptor = attr.getDescriptor();
// descriptor.get
value = (mBeanServer.getAttribute(objectName, attr.getName()));
} catch (ReflectionException e) {
// Munch skip this attribute then
} catch (MBeanException e) {
// Munch skip this attribute then
} catch (RuntimeMBeanException e) {
// Munch skip this attribute then
}
if (value != null) {
pw.write(",");
if (!value.getClass().isArray()) {
jsonValue(pw, "value=" + value.toString());
} else {
jsonValue(pw, "value=" + Arrays.toString((Object[]) value));
}
}
pw.write("]");
if (i < attrs.length) {
pw.write(',');
}
}
pw.write("}]");
pw.write(',');
jsonKey(pw, "operations");
pw.write("[");
final MBeanOperationInfo[] ops = mBeanInfo.getOperations();
for (int i = 0; i < ops.length; i++) {
final MBeanOperationInfo op = ops[i];
// jsonValue(pw, op.getDescription() + ": " + op.getName() +
// " - "
// + op.getReturnType());
jsonValue(pw, op.getName());
if (i < ops.length) {
pw.write(',');
}
}
pw.write("]");
}
pw.write("},");
}
private void assertNickName(MBeanAttributeInfo attr) {
assertNotNull("Nick Name should not be null", attr);
assertTrue("Nick Name should be writable", attr.isWritable());
assertTrue("Nick Name should be readable", attr.isReadable());
}
/**
* @param mbeanServer
* @param objectName
* @param attributeName
* @param attributeValue if <code>null</code>, this is a read access.
* @return if this is a read access, the returned value (may be null); if it is a write access,
* return <code>void.class</code>.
* @throws IOException
* @throws JMException
*/
public Result invokeAttribute(
@Nonnull MBeanServerConnection mbeanServer,
@Nonnull ObjectName objectName,
@Nonnull String attributeName,
@Nullable String attributeValue)
throws IOException, JMException {
MBeanInfo mbeanInfo = mbeanServer.getMBeanInfo(objectName);
MBeanAttributeInfo attributeInfo = null;
for (MBeanAttributeInfo mai : mbeanInfo.getAttributes()) {
if (mai.getName().equals(attributeName)) {
attributeInfo = mai;
break;
}
}
if (attributeInfo == null) {
throw new IllegalArgumentException(
"No attribute '"
+ attributeName
+ "' found on '"
+ objectName
+ "'. Existing attributes: "
+ Arrays.asList(mbeanInfo.getAttributes()));
}
String description;
Object resultValue;
if (attributeValue == null) {
if (attributeInfo.isReadable()) {
Object attribute = mbeanServer.getAttribute(objectName, attributeName);
logger.info("get attribute value {}:{}:{}", objectName, attributeName, attribute);
resultValue = attribute;
description =
"Get attribute value " + objectName + ":" + attributeName + ": " + resultValue;
} else {
throw new IllegalArgumentException(
"Attribute '"
+ attributeName
+ "' is not readable on '"
+ objectName
+ "': "
+ attributeInfo);
}
} else {
if (attributeInfo.isWritable()) {
Object value = convertValue(attributeValue, attributeInfo.getType());
mbeanServer.setAttribute(objectName, new Attribute(attributeName, value));
logger.info("set attribute value {}:{}:{}", objectName, attributeName, value);
description = "Set attribute value " + objectName + ":" + attributeName + ": " + value;
resultValue = void.class;
} else {
throw new IllegalArgumentException(
"Attribute '"
+ attributeName
+ "' is not writable on '"
+ objectName
+ "': "
+ attributeInfo);
}
}
return new Result(objectName, resultValue, description);
}
/**
* Subclasses could provide here a different description for the given counter.
*
* @param oname
* @param ainfo
* @return
*/
protected String[] getCounterNameAndDescription(ObjectName oname, MBeanAttributeInfo ainfo) {
return new String[] {ainfo.getName(), ainfo.getDescription()};
}
private MBeanAttributeInfo[] createMBeanAttributeInfo(
MBeanMetaData metadata, MBeanDescription description) {
Logger logger = getLogger();
HashMap attributes = new HashMap();
HashMap getterNames = new HashMap();
Method[] methods = metadata.management.getMethods();
for (int j = 0; j < methods.length; ++j) {
Method method = methods[j];
if (Utils.isAttributeGetter(method)) {
String name = method.getName();
boolean isIs = name.startsWith("is");
String attribute = null;
if (isIs) attribute = name.substring(2);
else attribute = name.substring(3);
String descr = description == null ? null : description.getAttributeDescription(attribute);
MBeanAttributeInfo info = (MBeanAttributeInfo) attributes.get(attribute);
if (info != null) {
// JMX spec does not allow overloading attributes.
// If an attribute with the same name already exists the MBean is not compliant
if (!info.getType().equals(method.getReturnType().getName())) {
if (logger.isEnabledFor(Logger.DEBUG))
logger.debug("MBean is not compliant: has overloaded attribute " + attribute);
return null;
} else {
// They return the same value,
if (getterNames.get(name) != null) {
// This is the case of an attribute being present in multiple interfaces
// Ignore all but the first, since they resolve to the same method anyways
continue;
}
// there is a chance that one is a get-getter and one is a is-getter
// for a boolean attribute. In this case, the MBean is not compliant.
if (info.isReadable()) {
if (logger.isEnabledFor(Logger.DEBUG))
logger.debug("MBean is not compliant: has overloaded attribute " + attribute);
return null;
}
// MBeanAttributeInfo is already present due to a setter method, just update its
// readability
info =
new MBeanAttributeInfo(
attribute,
info.getType(),
info.getDescription(),
true,
info.isWritable(),
isIs);
}
} else {
info =
new MBeanAttributeInfo(
attribute, method.getReturnType().getName(), descr, true, false, isIs);
}
// Replace if exists
attributes.put(attribute, info);
getterNames.put(name, method);
} else if (Utils.isAttributeSetter(method)) {
String name = method.getName();
String attribute = name.substring(3);
String descr = description == null ? null : description.getAttributeDescription(attribute);
MBeanAttributeInfo info = (MBeanAttributeInfo) attributes.get(attribute);
if (info != null) {
// JMX spec does not allow overloading attributes.
// If an attribute with the same name already exists the MBean is not compliant
if (!info.getType().equals(method.getParameterTypes()[0].getName())) {
if (logger.isEnabledFor(Logger.DEBUG))
logger.debug("MBean is not compliant: has overloaded attribute " + attribute);
return null;
} else {
// MBeanAttributeInfo is already present due to a getter method, just update its
// writability
info =
new MBeanAttributeInfo(
info.getName(),
info.getType(),
info.getDescription(),
info.isReadable(),
true,
info.isIs());
}
} else {
info =
new MBeanAttributeInfo(
attribute, method.getParameterTypes()[0].getName(), descr, false, true, false);
}
// Replace if exists
attributes.put(attribute, info);
}
}
return (MBeanAttributeInfo[])
attributes.values().toArray(new MBeanAttributeInfo[attributes.size()]);
}