/** * Convert an array of {@code MBeanParameterInfo} into an array of * {@code Class} instances corresponding to the parameters. * @param paramInfo the JMX parameter info * @param classLoader the ClassLoader to use for loading parameter types * @return the parameter types as classes * @throws ClassNotFoundException if a parameter type could not be resolved */ @Nullable public static Class<?>[] parameterInfoToTypes( @Nullable MBeanParameterInfo[] paramInfo, @Nullable ClassLoader classLoader) throws ClassNotFoundException { Class<?>[] types = null; if (paramInfo != null && paramInfo.length > 0) { types = new Class<?>[paramInfo.length]; for (int x = 0; x < paramInfo.length; x++) { types[x] = ClassUtils.forName(paramInfo[x].getType(), classLoader); } } return types; }
/** * Convert an array of {@code MBeanParameterInfo} into an array of * {@code Class} instances corresponding to the parameters. * @param paramInfo the JMX parameter info * @param classLoader the ClassLoader to use for loading parameter types * @return the parameter types as classes * @throws ClassNotFoundException if a parameter type could not be resolved */ @Nullable public static Class<?>[] parameterInfoToTypes( @Nullable MBeanParameterInfo[] paramInfo, @Nullable ClassLoader classLoader) throws ClassNotFoundException { Class<?>[] types = null; if (paramInfo != null && paramInfo.length > 0) { types = new Class<?>[paramInfo.length]; for (int x = 0; x < paramInfo.length; x++) { types[x] = ClassUtils.forName(paramInfo[x].getType(), classLoader); } } return types; }
protected String[] createSignature(MBeanOperationInfo info) { MBeanParameterInfo[] params = info.getSignature(); String[] answer = new String[params.length]; for (int i = 0; i < params.length; i++) { answer[i] = params[i].getType(); } return answer; }
/** * Gets method by operation info. * * @param op MBean operation info. * @return Method. * @throws ClassNotFoundException Thrown if parameter type is unknown. * @throws SecurityException Thrown if method access is not allowed. */ private Method getMethod(MBeanOperationInfo op) throws ClassNotFoundException, SecurityException { String methodName = op.getName(); MBeanParameterInfo[] signature = op.getSignature(); Class<?>[] params = new Class<?>[signature.length]; for (int i = 0; i < signature.length; i++) { // Parameter type is either a primitive type or class. Try both. Class<?> type = primCls.get(signature[i].getType().toLowerCase()); if (type == null) type = Class.forName(signature[i].getType()); params[i] = type; } return findMethod(getMBeanInterface(), methodName, params); }
/** * 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(); }
paramsStrBuffer.append(params[j].getName()); paramsStrBuffer.append(" type="); paramsStrBuffer.append(params[j].getType()); paramsStrBuffer.append(" "); paramsStrBuffer.append(params[j].getDescription());
for (int i = 0; i < paraminfosLength; i++) { MBeanParameterInfo paraminfo = paraminfos[i]; java.lang.reflect.Constructor c = Class.forName(paraminfo.getType()) .getConstructor(new Class[] { String.class }); params[i] = c.newInstance(new Object[] { parse.getArgs()[i] }); signature[i] = paraminfo.getType();
for(MBeanParameterInfo pi: oi.getSignature()) { String name = pi.getName(); String type = toPrintableType(pi.getType()); sb.append(type).append(' ').append(name).append(", ");
public String invoke(ObjectName bean, String operation, String... params) throws InstanceNotFoundException, IntrospectionException, ReflectionException, IOException, MBeanException { MBeanInfo mbinfo = mserver.getMBeanInfo(bean); MBeanOperationInfo op = null; for(MBeanOperationInfo oi: mbinfo.getOperations()) { if (oi.getName().equalsIgnoreCase(operation) && oi.getSignature().length == params.length) { if (op != null) { throw new IllegalArgumentException("Ambiguous " + operation + "/" + params.length + " operatition signature for " + bean); } op = oi; } } if (op == null) { throw new IllegalArgumentException("Operation " + operation + "/" + params.length + " not found for " + bean); } Object[] args = new Object[params.length]; String[] sig = new String[params.length]; for(int i = 0; i != params.length; ++i) { args[i] = convert(params[i], op.getSignature()[i].getType()); sig[i] = op.getSignature()[i].getType(); } return format(mserver.invoke(bean, op.getName(), args, sig), op.getReturnType()); }
/** * Extracts the Method from the MBeanOperationInfo * * @param op * * @return a Method */ private Method getMethod(MBeanOperationInfo op) { final MBeanParameterInfo[] params = op.getSignature(); final String[] paramTypes = new String[params.length]; for (int i = 0; i < params.length; i++) paramTypes[i] = params[i].getType(); return getMethod(getMBeanInterface(), op.getName(), paramTypes); }
@Test public void testOperationParameterMetadata() throws Exception { ModelMBeanInfo info = getMBeanInfoFromAssembler(); ModelMBeanOperationInfo oper = info.getOperation("add"); MBeanParameterInfo[] params = oper.getSignature(); assertEquals("Invalid number of params", 2, params.length); assertEquals("Incorrect name for x param", "x", params[0].getName()); assertEquals("Incorrect type for x param", int.class.getName(), params[0].getType()); assertEquals("Incorrect name for y param", "y", params[1].getName()); assertEquals("Incorrect type for y param", int.class.getName(), params[1].getType()); }
private boolean valueTypeMatchesParameterType(Object value, MBeanParameterInfo paramInfo) { Class<?> 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()); } }
private String signatureToString(List<MBeanParameterInfo[]> pParamInfos) { StringBuffer ret = new StringBuffer(); for (MBeanParameterInfo[] ii : pParamInfos) { ret.append("("); for (MBeanParameterInfo i : ii) { ret.append(i.getType()).append(","); } ret.setLength(ret.length()-1); ret.append("),"); } ret.setLength(ret.length()-1); return ret.toString(); }
private OperationAndParamType(String pOperationName, MBeanParameterInfo[] pParameterInfos) { operationName = pOperationName; paramClasses = new String[pParameterInfos.length]; paramOpenTypes = new OpenType<?>[pParameterInfos.length]; int i=0; for (MBeanParameterInfo info : pParameterInfos) { if (info instanceof OpenMBeanParameterInfo) { OpenMBeanParameterInfo openTypeInfo = (OpenMBeanParameterInfo) info; paramOpenTypes[i] = openTypeInfo.getOpenType(); } paramClasses[i++] = info.getType(); } }
String type = infos[i].getType(); if (!type.equals(pTypes.get(i))) {
private int populateValuesAndSignature(Map<String, Object> paramsFromMessage, MBeanParameterInfo[] paramInfoArray, Object[] values, String[] signature) { int index = 0; 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++; } } return index; }
private MBeanParameterInfo[] getWrappedParameterInfo(MBeanOperationInfo pOInfo, OperationMapInfo pMapInfo) { MBeanParameterInfo origParamInfo[] = pOInfo.getSignature(); MBeanParameterInfo paramInfo[] = new MBeanParameterInfo[origParamInfo.length]; for (int j = 0; j < origParamInfo.length; j++) { MBeanParameterInfo pInfo = origParamInfo[j]; String pType; if (isDirectlySupported(pInfo.getType())) { pType = pInfo.getType(); pMapInfo.pushParamTypes(pType, null, null); } else { pType = STRING_TYPE; if (pInfo instanceof OpenMBeanParameterInfo) { pMapInfo.pushParamTypes(STRING_TYPE, pInfo.getType(), ((OpenMBeanParameterInfo) pInfo).getOpenType()); } else { pMapInfo.pushParamTypes(STRING_TYPE, pInfo.getType(), null); } } paramInfo[j] = new MBeanParameterInfo( pInfo.getName(), pType, pInfo.getDescription(), pInfo.getDescriptor() ); } return paramInfo; }
args.put(DESCRIPTION.getKey(), paramInfo.getDescription()); args.put(NAME.getKey(), paramInfo.getName()); args.put(TYPE.getKey(), paramInfo.getType()); argList.add(args);
MBeanParameterInfo[] parameterInfos = operationInfo.getSignature(); for (MBeanParameterInfo parameterInfo : parameterInfos) { signature.row(parameterInfo.getName(), parameterInfo.getType(), parameterInfo.getDescription());
public ParameterRepresentation(MBeanParameterInfo parameterInfo) { name = parameterInfo.getName(); description = parameterInfo.getDescription(); type = parameterInfo.getType(); descriptor = toMap(parameterInfo.getDescriptor()); }