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);
}
@Test
public void testMBeanBySuffix() throws Exception {
Registry registry = RegistryUtil.getRegistry();
MBeanServer mBeanServer = registry.getService(MBeanServer.class);
ObjectName objectName = new ObjectName(JMXWhiteboardByInterfaceMBean.OBJECT_NAME);
MBeanInfo mBeanInfo = mBeanServer.getMBeanInfo(objectName);
Assert.assertNotNull(mBeanInfo);
MBeanOperationInfo[] operations = mBeanInfo.getOperations();
MBeanOperationInfo mBeanOperationInfo = operations[0];
MBeanParameterInfo[] signatureParameters = mBeanOperationInfo.getSignature();
String[] sinature = new String[signatureParameters.length];
for (int i = 0; i < signatureParameters.length; i++) {
MBeanParameterInfo mBeanParameterInfo = signatureParameters[i];
sinature[i] = mBeanParameterInfo.getType();
}
Object result =
mBeanServer.invoke(
objectName, mBeanOperationInfo.getName(), new Object[] {"Hello!"}, sinature);
Assert.assertEquals("{Hello!}", result);
}
private boolean valueTypeMatchesParameterType(Object value, MBeanParameterInfo paramInfo) {
Class<? extends Object> valueClass = value.getClass();
if (valueClass.getName().equals(paramInfo.getType())) {
return true;
} else {
Class<?> primitiveType = ClassUtils.resolvePrimitiveType(valueClass);
return primitiveType != null && primitiveType.getName().equals(paramInfo.getType());
}
}
/**
* Compare this MBeanParameterInfo to another.
*
* @param o the object to compare to.
* @return true if and only if <code>o</code> is an MBeanParameterInfo such that its {@link
* #getName()}, {@link #getType()}, {@link #getDescriptor()}, and {@link #getDescription()}
* values are equal (not necessarily identical) to those of this MBeanParameterInfo.
*/
public boolean equals(Object o) {
if (o == this) return true;
if (!(o instanceof MBeanParameterInfo)) return false;
MBeanParameterInfo p = (MBeanParameterInfo) o;
return (Objects.equals(p.getName(), getName())
&& Objects.equals(p.getType(), getType())
&& Objects.equals(p.getDescription(), getDescription())
&& Objects.equals(p.getDescriptor(), getDescriptor()));
}
protected static boolean isSupported(MBeanOperationInfo operationInfo) {
MBeanParameterInfo[] signature = operationInfo.getSignature();
for (MBeanParameterInfo parameterInfo : signature) {
if (!isArgumentSupported(parameterInfo.getType())) {
return false;
}
}
return true;
}
public static String prettySignature(MBeanOperationInfo opInfo) {
StringBuffer sig = new StringBuffer(opInfo.getName());
MBeanParameterInfo[] params = opInfo.getSignature();
sig.append('(');
for (int i = 0; i < params.length; i++) {
if (i > 0) {
sig.append(", "); // $NON-NLS-1$
}
MBeanParameterInfo param = params[i];
sig.append(StringUtils.toString(param.getType(), false));
}
sig.append(')');
return sig.toString();
}
/**
* Description of the operation.
*
* @param operation the operation to describe
* @return pretty-printed description
*/
protected String describeOperation(MBeanOperationInfo operation) {
StringBuilder buf = new StringBuilder();
buf.append(operation.getReturnType()).append(" ").append(operation.getName()).append("(");
MBeanParameterInfo[] params = operation.getSignature();
for (int j = 0; j < params.length; j++) {
MBeanParameterInfo param = params[j];
if (j != 0) {
buf.append(", ");
}
buf.append(param.getType()).append(" ").append(param.getName());
}
buf.append(")");
return buf.toString();
}
/**
* 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."));
}
}
}
/**
* {@inheritDoc}
*
* @see
* net.sourceforge.eclipsejetty.starter.console.AbstractCommand#help(net.sourceforge.eclipsejetty.starter.console.Process)
*/
@Override
public int help(Process process) throws Exception {
String name = process.args.consumeString();
if (name == null) {
return super.help(process);
}
boolean hit = false;
List<ObjectName> objectNames = findObjectNames(getLeft(name));
String operationPattern = Utils.ensure(getRight(name), "*");
for (ObjectName objectName : objectNames) {
MBeanInfo info = getMBeanInfo(objectName);
List<MBeanOperationInfo> operationInfos = findMBeanOperationInfos(info, operationPattern, -1);
for (MBeanOperationInfo operationInfo : operationInfos) {
StringBuilder builder = new StringBuilder(getNames()[0]);
builder.append(" ").append(getName(objectName));
builder.append(".").append(operationInfo.getName());
MBeanParameterInfo[] parameterInfos = operationInfo.getSignature();
for (MBeanParameterInfo parameterInfo : parameterInfos) {
builder.append(" ").append(toParameter(toClass(parameterInfo.getType())));
}
process.out.println(builder);
hit = true;
}
}
if (!hit) {
throw new ArgumentException(String.format("No bean operation matches %s", name));
}
return 0;
}
public static final String getOperationName(MBeanOperationInfo info) {
StringBuilder name = new StringBuilder(info.getName());
name.append('(');
MBeanParameterInfo[] parameterInfos = info.getSignature();
if (parameterInfos != null) {
int parameterCount = parameterInfos.length;
for (int i = 0; i < parameterCount; i++) {
MBeanParameterInfo parameterInfo = parameterInfos[i];
String parameterType = getTypeName(parameterInfo.getType(), parameterInfo.getDescriptor());
name.append(parameterType);
if (i < parameterCount - 1) {
name.append(", ");
}
}
}
name.append(')');
return name.toString();
}
@Nullable
public Result invokeOperation(
@Nonnull MBeanServerConnection mBeanServer,
@Nonnull ObjectName on,
@Nonnull String operationName,
@Nonnull String... arguments)
throws JMException, IOException {
logger.debug("invokeOperation({},{}, {}, {})...", on, operationName, Arrays.asList(arguments));
MBeanInfo mbeanInfo = mBeanServer.getMBeanInfo(on);
List<MBeanOperationInfo> candidates = new ArrayList<MBeanOperationInfo>();
for (MBeanOperationInfo mbeanOperationInfo : mbeanInfo.getOperations()) {
if (mbeanOperationInfo.getName().equals(operationName)
&& mbeanOperationInfo.getSignature().length == arguments.length) {
candidates.add(mbeanOperationInfo);
logger.debug("Select matching operation {}", mbeanOperationInfo);
} else {
logger.trace("Ignore non matching operation {}", mbeanOperationInfo);
}
}
if (candidates.isEmpty()) {
throw new IllegalArgumentException(
"Operation '"
+ operationName
+ "("
+ Strings2.join(arguments, ", ")
+ ")' NOT found on "
+ on);
} else if (candidates.size() > 1) {
throw new IllegalArgumentException(
"More than 1 ("
+ candidates.size()
+ ") operation '"
+ operationName
+ "("
+ Strings2.join(arguments, ", ")
+ ")' found on '"
+ on
+ "': "
+ candidates);
}
MBeanOperationInfo beanOperationInfo = candidates.get(0);
MBeanParameterInfo[] mbeanParameterInfos = beanOperationInfo.getSignature();
List<String> signature = new ArrayList<String>();
for (MBeanParameterInfo mbeanParameterInfo : mbeanParameterInfos) {
signature.add(mbeanParameterInfo.getType());
}
Object[] convertedArguments = convertValues(arguments, signature);
logger.debug("Invoke {}:{}({}) ...", on, operationName, Arrays.asList(convertedArguments));
Object result =
mBeanServer.invoke(on, operationName, convertedArguments, signature.toArray(new String[0]));
if ("void".equals(beanOperationInfo.getReturnType()) && result == null) {
result = "void";
}
logger.info(
"Invoke {}:{}({}): {}", on, operationName, Arrays.asList(convertedArguments), result);
String description =
"Invoke operation "
+ on
+ ":"
+ operationName
+ "("
+ Strings2.join(convertedArguments, ", ")
+ "): "
+ Strings2.toString(result);
return new Result(on, result, description);
}
@Override
protected Object handleRequestMessage(Message<?> requestMessage) {
ObjectName objectName = this.resolveObjectName(requestMessage);
String operationName = this.resolveOperationName(requestMessage);
Map<String, Object> paramsFromMessage = this.resolveParameters(requestMessage);
try {
MBeanInfo mbeanInfo = this.server.getMBeanInfo(objectName);
MBeanOperationInfo[] opInfoArray = mbeanInfo.getOperations();
boolean hasNoArgOption = false;
for (MBeanOperationInfo opInfo : opInfoArray) {
if (operationName.equals(opInfo.getName())) {
MBeanParameterInfo[] paramInfoArray = opInfo.getSignature();
if (paramInfoArray.length == 0) {
hasNoArgOption = true;
}
if (paramInfoArray.length == paramsFromMessage.size()) {
int index = 0;
Object values[] = new Object[paramInfoArray.length];
String signature[] = new String[paramInfoArray.length];
for (MBeanParameterInfo paramInfo : paramInfoArray) {
Object value = paramsFromMessage.get(paramInfo.getName());
if (value == null) {
/*
* With Spring 3.2.3 and greater, the parameter names are
* registered instead of the JVM's default p1, p2 etc.
* Fall back to that naming style if not found.
*/
value = paramsFromMessage.get("p" + (index + 1));
}
if (value != null && valueTypeMatchesParameterType(value, paramInfo)) {
values[index] = value;
signature[index] = paramInfo.getType();
index++;
}
}
if (index == paramInfoArray.length) {
return this.server.invoke(objectName, operationName, values, signature);
}
}
}
}
if (hasNoArgOption) {
return this.server.invoke(objectName, operationName, null, null);
}
throw new MessagingException(
requestMessage,
"failed to find JMX operation '"
+ operationName
+ "' on MBean ["
+ objectName
+ "] of type ["
+ mbeanInfo.getClassName()
+ "] with "
+ paramsFromMessage.size()
+ " parameters: "
+ paramsFromMessage);
} catch (JMException e) {
throw new MessageHandlingException(
requestMessage,
"failed to invoke JMX operation '"
+ operationName
+ "' on MBean ["
+ objectName
+ "]"
+ " with "
+ paramsFromMessage.size()
+ " parameters: "
+ paramsFromMessage,
e);
} catch (IOException e) {
throw new MessageHandlingException(requestMessage, "IOException on MBeanServerConnection", e);
}
}
public static Object[] getParameters(String[] textParams, MBeanParameterInfo[] params)
throws ClassNotFoundException {
if (textParams == null || params == null) {
return null;
}
Object[] ret = new Object[textParams.length];
for (int i = 0; i < ret.length && i < params.length; i++) {
MBeanParameterInfo param = params[i];
String texti = textParams[i];
if (texti.length() == 0) {
ret[i] = null;
} else if (param.getType().equals("byte")) { // $NON-NLS-1$
ret[i] = new Byte(texti);
} else if (param.getType().equals("short")) { // $NON-NLS-1$
ret[i] = new Short(texti);
} else if (param.getType().equals("java.lang.Short")) { // $NON-NLS-1$
ret[i] = new Short(texti);
} else if (param.getType().equals("int")) { // $NON-NLS-1$
ret[i] = new Integer(texti);
} else if (param.getType().equals("java.lang.Integer")) { // $NON-NLS-1$
ret[i] = new Integer(texti);
} else if (param.getType().equals("long")) { // $NON-NLS-1$
ret[i] = new Long(texti);
} else if (param.getType().equals("java.lang.Long")) { // $NON-NLS-1$
ret[i] = new Long(texti);
} else if (param.getType().equals("float")) { // $NON-NLS-1$
ret[i] = new Float(texti);
} else if (param.getType().equals("java.lang.Float")) { // $NON-NLS-1$
ret[i] = new Float(texti);
} else if (param.getType().equals("double")) { // $NON-NLS-1$
ret[i] = new Double(texti);
} else if (param.getType().equals("java.lang.Double")) { // $NON-NLS-1$
ret[i] = new Double(texti);
} else if (param.getType().equals("char")) { // $NON-NLS-1$
ret[i] = new Character(texti.charAt(0));
} else if (param.getType().equals("boolean")) { // $NON-NLS-1$
ret[i] = new Boolean(texti);
} else if (MBeanUtils.class
.getClassLoader()
.loadClass("java.lang.Number")
.isAssignableFrom(
MBeanUtils.class.getClassLoader().loadClass(param.getType()))) { // $NON-NLS-1$
ret[i] = createNumber(texti);
} else {
ret[i] = texti;
}
}
return ret;
}