/** * 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(); }
private void buildDynamicMBeanInfo() { Constructor[] constructors = this.getClass().getConstructors(); dConstructors[0] = new MBeanConstructorInfo( "HierarchyDynamicMBean(): Constructs a HierarchyDynamicMBean instance", constructors[0]); vAttributes.add(new MBeanAttributeInfo(THRESHOLD, "java.lang.String", "The \"threshold\" state of the hiearchy.", true, true, false)); MBeanParameterInfo[] params = new MBeanParameterInfo[1]; params[0] = new MBeanParameterInfo("name", "java.lang.String", "Create a logger MBean" ); dOperations[0] = new MBeanOperationInfo("addLoggerMBean", "addLoggerMBean(): add a loggerMBean", params , "javax.management.ObjectName", MBeanOperationInfo.ACTION); }
MBeanOperationInfo[] operations = info.getOperations(); if (operations.length > 0) { result.append("Operations:"); result.append("\n"); for (int i = 0; i < operations.length; i++) { MBeanParameterInfo[] params = operations[i].getSignature(); StringBuffer paramsStrBuffer = new StringBuffer(); if (params != null) { for (int j = 0; j < params.length; j++) { paramsStrBuffer.append("\n name="); paramsStrBuffer.append(params[j].getName()); paramsStrBuffer.append(" type="); paramsStrBuffer.append(params[j].getType()); paramsStrBuffer.append(" "); paramsStrBuffer.append(params[j].getDescription()); result.append(' ' + operations[i].getName() + ": " + operations[i].getDescription() + "\n Parameters " + params != null ? params.length : 0 + ", return type=" + operations[i].getReturnType() + paramsStrBuffer.toString());
sb.append(bean); sb.append('\n'); sb.append(mbinfo.getClassName()); sb.append('\n'); sb.append(" - " + mbinfo.getDescription()); sb.append('\n'); for(MBeanAttributeInfo ai: mbinfo.getAttributes()) { sb.append(" (A) "); sb.append(ai.getName()).append(" : ").append(toPrintableType(ai.getType())).append(""); if (!ai.isReadable()) { sb.append(" - WRITEONLY"); for (MBeanOperationInfo oi: mbinfo.getOperations()) { sb.append(" (O) "); sb.append(oi.getName()).append("("); for(MBeanParameterInfo pi: oi.getSignature()) { String name = pi.getName(); String type = toPrintableType(pi.getType()); sb.append(type).append(' ').append(name).append(", "); if (oi.getSignature().length > 0) { sb.setLength(sb.length() - 2);
TreeElement root = new TreeElement(info.getClassName()); overflow(Overflow.HIDDEN). rightCellPadding(1); Descriptor descriptorInfo = info.getDescriptor(); if (descriptorInfo != null) { for (String fieldName : descriptorInfo.getFieldNames()) { rightCellPadding(1). add(new RowElement().style(Decoration.bold.fg(Color.black).bg(Color.white)).add("NAME", "TYPE", "DESCRIPTION")); for (MBeanAttributeInfo attributeInfo : info.getAttributes()) { attributes.row(attributeInfo.getName(), attributeInfo.getType(), attributeInfo.getDescription()); overflow(Overflow.HIDDEN). rightCellPadding(1); MBeanParameterInfo[] parameterInfos = operationInfo.getSignature(); for (MBeanParameterInfo parameterInfo : parameterInfos) { signature.row(parameterInfo.getName(), parameterInfo.getType(), parameterInfo.getDescription()); TreeElement operation = new TreeElement(operationInfo.getName()); String impact; switch (operationInfo.getImpact()) { case MBeanOperationInfo.ACTION: impact = "ACTION";
MBeanInfo info = mbeanServer.getMBeanInfo(objectName); for (MBeanOperationInfo operation : info.getOperations()) { List<String> sig = new ArrayList<>(); for (MBeanParameterInfo param : operation.getSignature()) { sig.add(param.getType()); if (canInvoke(context, objectName, operation.getName(), sig.toArray(new String[] {}))) { return true; for (MBeanAttributeInfo attr : info.getAttributes()) { if (attr.isReadable()) { if (canInvoke(context, objectName, attr.isIs() ? "is" : "get" + attr.getName(), new String[] {})) return true;
private MBeanInfo createMBeanInfo() { final List<MBeanAttributeInfo> attrs = new ArrayList<MBeanAttributeInfo>(); attrs.add(new MBeanAttributeInfo(ATT_TAGS, String.class.getName(), "Tags", true, false, false)); attrs.add(new MBeanAttributeInfo(ATT_STATUS, String.class.getName(), "Status", true, false, false)); MBeanParameterInfo[] params = new MBeanParameterInfo[] { new MBeanParameterInfo(ATT_TAGS, "java.lang.String", "Comma separated list of tags") }; final List<MBeanOperationInfo> ops = new ArrayList<MBeanOperationInfo>(); ops.add(new MBeanOperationInfo(OP_RESET, "Resets this testing mechanism and removes the failing HC", new MBeanParameterInfo[0], "java.lang.String", MBeanOperationInfo.ACTION)); ops.add(new MBeanOperationInfo(OP_ADD_CRITICAL_RESULT_FOR_TAGS, "Adds a critical result for the given tags", params, "java.lang.String", MBeanOperationInfo.ACTION)); ops.add(new MBeanOperationInfo(OP_ADD_WARN_RESULT_FOR_TAGS, "Adds a warn result for the given tags", params, "java.lang.String", MBeanOperationInfo.ACTION)); return new MBeanInfo(this.getClass().getName(), "Adjustable Health Check", attrs.toArray(new MBeanAttributeInfo[attrs.size()]), null, ops.toArray(new MBeanOperationInfo[ops.size()]), null); }
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; for (MBeanAttributeInfo attrInfo : info.getAttributes()) { if (attrInfo.isWritable() == false) { assert (attrInfo.getDescription().equals("MBeanReadonlyGetter.") == true || attrInfo.getDescription().equals("MBeanROGetter."));
@Override public MBeanInfo getMBeanInfo() { MBeanAttributeInfo[] attributes = new MBeanAttributeInfo[] { new MBeanAttributeInfo("AgentId", String.class.getName(), "The agent identifier of the MBeanServer to retrieve", true, false, false), }; MBeanParameterInfo[] signString = new MBeanParameterInfo[] { new MBeanParameterInfo("val", String.class.getName(), "Index number or value") }; MBeanOperationInfo[] operations = new MBeanOperationInfo[] {}; return new MBeanInfo(ManagementMBean.class.getName(), "Ss7 Management", attributes, null, operations, null); }
ManagedMBean(final Object managed, final String prefix) { scan(managed, prefix); for (final Member member : attributesMap.values()) { attributes.add(new MBeanAttributeInfo(member.getName(), member.getType().getName(), "", true, false, false)); } for (final Member member : operationsMap.values()) { final MBeanOperationInfo op = new MBeanOperationInfo("", ((MethodMember) member).getter); operations.add(new MBeanOperationInfo(member.getName(), "", op.getSignature(), op.getReturnType(), op.getImpact())); } filterAttributes = true; excludeInfo = new MBeanParameterInfo("excludeRegex", "java.lang.String", "\"" + excludes.pattern() + "\""); includeInfo = new MBeanParameterInfo("includeRegex", "java.lang.String", "\"" + includes.pattern() + "\""); }
/** * 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); }
/** * Constructs a <code>MBeanParameterInfo</code> instance based upon a * <code>javax.management.MBeanParameterInfo</code> instance. * * @param mbeanParameterInfo The JMX <code>MBeanParameterInfo</code> instance to base this instance on. */ public MBeanParameterInfo(javax.management.MBeanParameterInfo mbeanParameterInfo) { name = mbeanParameterInfo.getName(); type = mbeanParameterInfo.getType(); description = mbeanParameterInfo.getDescription(); }
@Test public void test() throws Exception { MBeanInfo info = server.getMBeanInfo(objectName); assertEquals("MBean desc.", info.getDescription()); MBeanAttributeInfo a0 = findAttribute(info, "Getter"); assertEquals("getter", a0.getDescription()); MBeanAttributeInfo a1 = findAttribute(info, "It"); assertEquals("is", a1.getDescription()); MBeanAttributeInfo a2 = findAttribute(info, "Setter"); assertEquals("setter", a2.getDescription()); MBeanOperationInfo op0 = info.getOperations()[0]; assertEquals("run", op0.getDescription()); assertEquals(MBeanOperationInfo.INFO, op0.getImpact()); MBeanParameterInfo p0 = op0.getSignature()[0]; assertEquals("timeout", p0.getName()); assertEquals("how long?", p0.getDescription()); }
public ParameterRepresentation(MBeanParameterInfo parameterInfo) { name = parameterInfo.getName(); description = parameterInfo.getDescription(); type = parameterInfo.getType(); descriptor = toMap(parameterInfo.getDescriptor()); }
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; }
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; }
public HAInvokerWrapper(MBeanServer mbeanServer, ObjectName targetName, HATarget target) { this.mbeanServer = mbeanServer; this.targetName = targetName; this.target = target; MBeanAttributeInfo[] attrInfo = null; MBeanConstructorInfo[] ctorInfo = null; MBeanParameterInfo[] sig = { new MBeanParameterInfo("invocation", Invocation.class.getName(), "The invocation content information") }; MBeanOperationInfo[] opInfo = { new MBeanOperationInfo("invoke", "The detached invoker entry point", sig, "java.lang.Object", MBeanOperationInfo.ACTION) }; MBeanNotificationInfo[] eventInfo = null; this.info = new MBeanInfo(getClass().getName(), "A wrapper inovker that delegates to the target invoker", attrInfo, ctorInfo, opInfo, eventInfo); }
/** * Returns operations defined for this MBean as an array of MBeanOperationInfo objects. * * @return operations defined as an array of MBeanOperationInfo objects. */ @Override protected MBeanOperationInfo[] createMBeanOperationInfo() { MBeanOperationInfo[] operationsInfo = new MBeanOperationInfo[MAX_OPERATIONS_COUNT]; operationsInfo[0] = new MBeanOperationInfo("getMembers", "Returns ids as strings for all the members - Application Peers & Cache Servers.", new MBeanParameterInfo[] {}, String[].class.getName(), MBeanOperationInfo.ACTION_INFO); MBeanParameterInfo[] getMemberDetailsArgs = new MBeanParameterInfo[1]; getMemberDetailsArgs[0] = new MBeanParameterInfo("memberId", String.class.getName(), "Id of the member for all the details are to be retrieved."); operationsInfo[1] = new MBeanOperationInfo("getMemberDetails", "Returns details for a given member", getMemberDetailsArgs, Map.class.getName(), MBeanOperationInfo.ACTION_INFO); /* * For retrieving ObjectNames of existing Region MBeans, MBeanServerConnection.queryMBeans(), * could be called */ MBeanParameterInfo[] getRegionSnapArgs = new MBeanParameterInfo[1]; getRegionSnapArgs[0] = new MBeanParameterInfo("memberId", String.class.getName(), "Id of the member on which we want to discover all the region MBean."); operationsInfo[2] = new MBeanOperationInfo("getRegions", "Returns a java.util.Map of details of regions on a member", getRegionSnapArgs, Map.class.getName(), MBeanOperationInfo.ACTION_INFO); return operationsInfo; }
public static void checkMBeanOperationParameterNaming(ObjectName objectName) throws Exception { MBeanServer mBeanServer = PerThreadMBeanServerLookup.getThreadMBeanServer(); MBeanInfo mBeanInfo = mBeanServer.getMBeanInfo(objectName); for(MBeanOperationInfo op : mBeanInfo.getOperations()) { for(MBeanParameterInfo param : op.getSignature()) { assertFalse(param.getName().matches("p[0-9]+")); } } }
/** * Create parameter info for the given method. * <p>The default implementation returns an empty array of {@code MBeanParameterInfo}. * @param method the {@code Method} to get the parameter information for * @param beanKey the key associated with the MBean in the beans map * of the {@code MBeanExporter} * @return the {@code MBeanParameterInfo} array */ protected MBeanParameterInfo[] getOperationParameters(Method method, String beanKey) { ParameterNameDiscoverer paramNameDiscoverer = getParameterNameDiscoverer(); String[] paramNames = (paramNameDiscoverer != null ? paramNameDiscoverer.getParameterNames(method) : null); if (paramNames == null) { return new MBeanParameterInfo[0]; } MBeanParameterInfo[] info = new MBeanParameterInfo[paramNames.length]; Class<?>[] typeParameters = method.getParameterTypes(); for (int i = 0; i < info.length; i++) { info[i] = new MBeanParameterInfo(paramNames[i], typeParameters[i].getName(), paramNames[i]); } return info; }