MBeanInfo info = null; try { info = mbs.getMBeanInfo(objectName); } catch (Exception e) { log.error("Could not get MBeanInfo object for {}", className, e); return; log.info("CLASSNAME: \t" + info.getClassName()); log.info("DESCRIPTION: \t" + info.getDescription()); log.info("ATTRIBUTES"); MBeanAttributeInfo[] attrInfo = info.getAttributes(); if (attrInfo.length > 0) { for (int i = 0; i < attrInfo.length; i++) { log.info(" ** NAME: \t" + attrInfo[i].getName()); log.info(" DESCR: \t" + attrInfo[i].getDescription()); log.info(" TYPE: \t" + attrInfo[i].getType() + "\tREAD: " + attrInfo[i].isReadable() + "\tWRITE: " + attrInfo[i].isWritable()); MBeanConstructorInfo[] constrInfo = info.getConstructors(); for (int i = 0; i < constrInfo.length; i++) { log.info(" ** NAME: \t" + constrInfo[i].getName()); log.info(" DESCR: \t" + constrInfo[i].getDescription()); log.info(" PARAM: \t" + constrInfo[i].getSignature().length + " parameter(s)"); if (opInfo.length > 0) { for (int i = 0; i < opInfo.length; i++) { log.info(" ** NAME: \t" + opInfo[i].getName()); log.info(" DESCR: \t" + opInfo[i].getDescription()); log.info(" PARAM: \t" + opInfo[i].getSignature().length + " parameter(s)");
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); }
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); sb.append(") : ").append(toPrintableType(oi.getReturnType())); sb.append('\n'); if (!oi.getName().equals(oi.getDescription())) { sb.append(" - " + oi.getDescription()); sb.append('\n');
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()); }
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()); result.append("\n");
/** * 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); }
final ObjectName oname = new ObjectName( "org.apache.hadoop.hive.common.metrics:type=MetricsMBean"); MBeanInfo mBeanInfo = mbs.getMBeanInfo(oname); assertEquals(MetricsMBeanImpl.class.getName(), mBeanInfo.getClassName()); MBeanOperationInfo[] oops = mBeanInfo.getOperations(); boolean resetFound = false; for (MBeanOperationInfo op : oops) { if ("reset".equals(op.getName())) { resetFound = true; break; mbs.setAttribute(oname, attr); mBeanInfo = mbs.getMBeanInfo(oname); MBeanAttributeInfo[] attrinuteInfos = mBeanInfo.getAttributes(); assertEquals(1, attrinuteInfos.length); boolean attrFound = false; for (MBeanAttributeInfo info : attrinuteInfos) { if ("fooMetric".equals(info.getName())) { assertEquals("java.lang.Long", info.getType()); assertTrue(info.isReadable()); assertTrue(info.isWritable()); assertFalse(info.isIs());
@Test @Ignore // re-instate this if Spring decides to look for @ManagedResource on super classes public void testServiceActivatorMBeanHasTrackableComponent() throws Exception { Set<ObjectName> names = server.queryNames(new ObjectName("test.MBeanRegistration:type=ServiceActivatingHandler,name=service,*"), null); Map<String, MBeanOperationInfo> infos = new HashMap<String, MBeanOperationInfo>(); for (MBeanOperationInfo info : server.getMBeanInfo(names.iterator().next()).getOperations()) { infos.put(info.getName(), info); } assertNotNull(infos.get("setShouldTrack")); }
TreeElement root = new TreeElement(info.getClassName()); 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"; new RowElement().add("Type: ", operationInfo.getReturnType()), new RowElement().add("Description: ", operationInfo.getDescription()), new RowElement().add("Impact: ", impact), new RowElement().add(new LabelElement("Signature: "), signature)
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); }
MBeanInfo info = server.getMBeanInfo(this.objectName); MBeanAttributeInfo[] attributeInfo = info.getAttributes(); this.allowedAttributes = new HashMap<>(attributeInfo.length); for (MBeanAttributeInfo infoEle : attributeInfo) { this.allowedAttributes.put(infoEle.getName(), infoEle); MBeanOperationInfo[] operationInfo = info.getOperations(); this.allowedOperations = new HashMap<>(operationInfo.length); for (MBeanOperationInfo infoEle : operationInfo) { Class<?>[] paramTypes = JmxUtils.parameterInfoToTypes(infoEle.getSignature(), this.beanClassLoader); this.allowedOperations.put(new MethodCacheKey(infoEle.getName(), paramTypes), infoEle);
/** Find the operation info for a method * * @param oname * @param opName * @return the operation info for the specified operation */ public MBeanOperationInfo getMethodInfo( ObjectName oname, String opName ) { String type=null; MBeanInfo info; try { info=server.getMBeanInfo(oname); } catch (Exception e) { log.info( "Can't find metadata " + oname ); return null; } MBeanOperationInfo attInfo[]=info.getOperations(); for( int i=0; i<attInfo.length; i++ ) { if( opName.equals(attInfo[i].getName())) { return attInfo[i]; } } return null; }
private OperationRepresentation(MBeanOperationInfo operationInfo) { name = operationInfo.getName(); impact = operationInfo.getImpact(); returnType = operationInfo.getReturnType(); ImmutableList.Builder<ParameterRepresentation> parameters = ImmutableList.builder(); for (MBeanParameterInfo parameterInfo : operationInfo.getSignature()) { parameters.add(new ParameterRepresentation(parameterInfo)); } this.parameters = parameters.build(); descriptor = toMap(operationInfo.getDescriptor()); }
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."));
@Test public void testAttributesAndOperations() throws Exception { MBeanInfo info = mbeanServer.getMBeanInfo( indexBeanObjectName ); MBeanAttributeInfo[] attributes = info.getAttributes(); assertEquals( "Wrong number of attributes", 3, attributes.length ); Set<String> attributeNames = new HashSet<String>(); attributeNames.add( "NumberOfObjectLoadingThreads" ); attributeNames.add( "NumberOfFetchingThreads" ); attributeNames.add( "BatchSize" ); for ( MBeanAttributeInfo attribute : attributes ) { assertTrue( attributeNames.contains( attribute.getName() ) ); } MBeanOperationInfo[] operations = info.getOperations(); assertEquals( "Wrong number of operations", 3, operations.length ); Set<String> operationNames = new HashSet<String>(); operationNames.add( "index" ); operationNames.add( "purge" ); operationNames.add( "optimize" ); for ( MBeanOperationInfo operation : operations ) { assertTrue( operationNames.contains( operation.getName() ) ); } }
public NestedMBeanOperation(String prefix, MBeanOperation delegate) { this.delegate = delegate; MBeanOperationInfo delegateInfo = delegate.getInfo(); this.info = new MBeanOperationInfo(prefix + "." + delegateInfo.getName(), delegateInfo.getDescription(), delegateInfo.getSignature(), delegateInfo.getReturnType(), delegateInfo.getImpact(), delegateInfo.getDescriptor()); signature = new Signature(this.info); }
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() + "\""); }
/** * Names of all the operations available on the MBean. * * @return all the operations on the MBean */ public Collection<String> listOperationNames() { List<String> list = new ArrayList<String>(); try { MBeanOperationInfo[] operations = beanInfo.getOperations(); for (MBeanOperationInfo operation : operations) { list.add(operation.getName()); } } catch (Exception e) { throwException("Could not list operation names. Reason: ", e); } return list; }
for (int i = 0; i < attrs.length; i++) { String name = it.next(); attrs[i] = new MBeanAttributeInfo( name, "java.lang.Double", false); // isIs attrs = ArrayUtils.add(attrs, new MBeanAttributeInfo( "LOG_RESOLUTION", "java.lang.Double", ); MBeanOperationInfo[] opers = { new MBeanOperationInfo( "activate", "Activate statistic logging", new MBeanOperationInfo( "disable", "Disable statistic logging", MBeanOperationInfo.ACTION) }; return new MBeanInfo( "org.broadleafcommerce:name=StatisticsService." + appName, "Runtime Statistics",