@Override public MBeanInfo getMBeanInfo() { MBeanAttributeInfo[] attributes = new MBeanAttributeInfo[] { // new MBeanAttributeInfo("LocalSsn", int.class.getName(), "Local Ssn", true, true, false), // new MBeanAttributeInfo("RemoteSsn", int.class.getName(), "Remote Ssn", true, true, false), new MBeanAttributeInfo("RemoteAddressDigits", String.class.getName(), "Remote address digits. If empty ROUTING_BASED_ON_DPC_AND_SSN is used for CalledPartyAddress (remoteSpc from SCCP), " + "if not empty ROUTING_BASED_ON_GLOBAL_TITLE is used (address and Ssn from CAP)", true, true, false), }; MBeanParameterInfo[] signString = new MBeanParameterInfo[] { new MBeanParameterInfo("val", String.class.getName(), "Index number or value") }; MBeanOperationInfo[] operations = new MBeanOperationInfo[] {}; return new MBeanInfo(CapMan.class.getName(), "Cap Management", attributes, null, operations, null); }
@Override public MBeanInfo getMBeanInfo() { MBeanAttributeInfo[] attributes = new MBeanAttributeInfo[] { new MBeanAttributeInfo("AutoEquipmentStatus", EquipmentStatusType.class.getName(), "EquipmentStatus parameter to be automatically send in CheckImeiResponse", true, true, false), new MBeanAttributeInfo("AutoEquipmentStatus_Value", String.class.getName(), "EquipmentStatus parameter to be automatically send in CheckImeiResponse", true, false, false), new MBeanAttributeInfo("OneNotificationFor100Dialogs", boolean.class.getName(), "If true there will be only one notification per every 100 sent dialogs", true, true, true), new MBeanAttributeInfo("CurrentRequestDef", String.class.getName(), "Definition of the current request Dialog", true, false, false), }; MBeanParameterInfo[] putAutoEquipmentStatusParam = new MBeanParameterInfo[] { new MBeanParameterInfo("val", String.class.getName(), "EquipmentStatus value") }; MBeanOperationInfo[] operations = new MBeanOperationInfo[] { new MBeanOperationInfo( "putAutoEquipmentStatus", "EquipmentStatus parameter to be automatically send in CheckImeiResponse: " + "0:whiteListed,1:blackListed,2:greyListed", putAutoEquipmentStatusParam, Void.TYPE.getName(), MBeanOperationInfo.ACTION), new MBeanOperationInfo("closeCurrentDialog", "Closing the current dialog", null, String.class.getName(), MBeanOperationInfo.ACTION) }; return new MBeanInfo(TestCheckImeiServerMan.class.getName(), "CheckImeiServer test parameters management", attributes, null, operations, null); }
@Test public void testReadAttributes() throws Exception { DynamicMBean proxy = JMX.newMBeanProxy(platformMBeanServer, threadPoolDynamicWrapperON, DynamicMBean.class); assertEquals(threadCount, proxy.getAttribute(THREAD_COUNT)); assertEquals(threadPoolConfigBean.isTriggerNewInstanceCreation(), proxy.getAttribute(TRIGGER_NEW_INSTANCE_CREATION)); AttributeList attributes = proxy.getAttributes(new String[] { THREAD_COUNT, TRIGGER_NEW_INSTANCE_CREATION }); assertEquals(2, attributes.size()); Attribute threadCountAttr = (Attribute) attributes.get(0); assertEquals(THREAD_COUNT, threadCountAttr.getName()); assertEquals(threadCount, threadCountAttr.getValue()); Attribute boolTestAttr = (Attribute) attributes.get(1); assertEquals(TRIGGER_NEW_INSTANCE_CREATION, boolTestAttr.getName()); assertEquals(threadPoolConfigBean.isTriggerNewInstanceCreation(), boolTestAttr.getValue()); MBeanInfo beanInfo = proxy.getMBeanInfo(); assertEquals(2, beanInfo.getAttributes().length); }
private int checkMBeanInfo(MBeanInfo mbi, Descriptor refDescr) { MBeanNotificationInfo[] notifsInfo = mbi.getNotifications(); int res = 0; for (MBeanNotificationInfo mbni : notifsInfo) { if ( mbni.getDescriptor().equals(refDescr) ) { System.out.println("(OK)"); } else { System.out.println("(ERROR) Descriptor of the notification is " + mbni.getDescriptor() + " as we expect " + refDescr); res++; } } return res; }
@Override public MBeanInfo getMBeanInfo() { MBeanAttributeInfo[] attributes = new MBeanAttributeInfo[] { new MBeanAttributeInfo("NetworkNodeNumberAddress", String.class.getName(), "NetworkNodeNumber address parameter for response", true, true, false), }; MBeanParameterInfo[] performSRIResponseParam = new MBeanParameterInfo[] { }; MBeanOperationInfo[] operations = new MBeanOperationInfo[] { new MBeanOperationInfo("performSendRoutingInfoForLCSResponse", "Send Routing Information for LCS response", performSRIResponseParam, String.class.getName(), MBeanOperationInfo.ACTION), }; return new MBeanInfo(TestMapLcsServerMan.class.getName(), "MapLcsServer test parameters management", attributes, null, operations, null); }
@Override public MBeanInfo getMBeanInfo() { // TODO: Put real attributes and operations MBeanAttributeInfo[] attributes = new MBeanAttributeInfo[] { new MBeanAttributeInfo("AddressNature", AddressNatureType.class.getName(), "AddressNature parameter for mlcNumber creating", true, true, false), new MBeanAttributeInfo("NumberingPlanType", NumberingPlanMapType.class.getName(), "NumberingPlanType parameter for mlcNumber creating", true, true, false), new MBeanAttributeInfo("NumberingPlan", String.class.getName(), "NumberingPlan parameter for mlcNumber creating", true, true, false), }; MBeanParameterInfo[] performSRIRequestParam = new MBeanParameterInfo[] { new MBeanParameterInfo("addressIMSI", String.class.getName(), "Address for IMSI") }; MBeanOperationInfo[] operations = new MBeanOperationInfo[] { new MBeanOperationInfo("performSendRoutingInfoForLCSRequest", "Send Routing Information for LCS request", performSRIRequestParam, String.class.getName(), MBeanOperationInfo.ACTION), }; return new MBeanInfo(TestMapLcsClientMan.class.getName(), "MapLcsClient test parameters management", attributes, null, operations, null); }
private static void printAttrs( MBeanServerConnection mbsc1, Class<? extends Exception> expectX) throws Exception { Set<ObjectName> names = mbsc1.queryNames(null, null); for (ObjectName name : names) { System.out.println(name + ":"); MBeanInfo mbi = mbsc1.getMBeanInfo(name); MBeanAttributeInfo[] mbais = mbi.getAttributes(); for (MBeanAttributeInfo mbai : mbais) { String attr = mbai.getName(); Object value; try { value = mbsc1.getAttribute(name, attr); } catch (Exception e) { if (expectX != null && expectX.isInstance(e)) value = "<" + e + ">"; else throw e; } String s = " " + attr + " = " + value; if (s.length() > 80) s = s.substring(0, 77) + "..."; System.out.println(s); } } }
MBeanInfo get() { curRecNo = 0; for (MetricsRecordImpl rec : recs) { for (MetricsTag t : rec.tags()) { attrs.add(newAttrInfo("tag."+ t.name(), t.description(), "java.lang.String")); } for (AbstractMetric m : rec.metrics()) { m.visit(this); } ++curRecNo; } MetricsSystemImpl.LOG.debug(attrs); MBeanAttributeInfo[] attrsArray = new MBeanAttributeInfo[attrs.size()]; return new MBeanInfo(name, description, attrs.toArray(attrsArray), null, null, null); // no ops/ctors/notifications }
public MBeanInfo getMBeanInfo(ObjectName name) throws InstanceNotFoundException, IntrospectionException, ReflectionException, IOException { if (logger.debugOn()) logger.debug("getMBeanInfo", "name=" + name); final ClassLoader old = pushDefaultClassLoader(); try { return connection.getMBeanInfo(name, delegationSubject); } catch (IOException ioe) { communicatorAdmin.gotIOException(ioe); return connection.getMBeanInfo(name, delegationSubject); } finally { popDefaultClassLoader(old); } }
/** Get the type of an attribute of the object, from the metadata. * * @param oname * @param attName * @return null if metadata about the attribute is not found * @since 1.1 */ public String getType( ObjectName oname, String attName ) { String type=null; MBeanInfo info=null; try { info=server.getMBeanInfo(oname); } catch (Exception e) { log.info( "Can't find metadata for object" + oname ); return null; } MBeanAttributeInfo attInfo[]=info.getAttributes(); for( int i=0; i<attInfo.length; i++ ) { if( attName.equals(attInfo[i].getName())) { type=attInfo[i].getType(); return type; } } return null; }
@Test public void test_simple() { MBeanServer mBeanServer = exporter.getServer(); try { ObjectName objectName = new ObjectName("bean:name=otterControllor"); MBeanInfo nodeInfo = mBeanServer.getMBeanInfo(objectName); System.out.println(nodeInfo); Object result = mBeanServer.getAttribute(objectName, "HeapMemoryUsage"); System.out.println(result); JMXServiceURL address = new JMXServiceURL("service:jmx:rmi://127.0.0.1/jndi/rmi://127.0.0.1:1099/mbean"); Map environment = null; JMXConnector cntor = JMXConnectorFactory.connect(address, environment); MBeanServerConnection mbsc = cntor.getMBeanServerConnection(); String domain = mbsc.getDefaultDomain(); System.out.println(domain); result = mbsc.getAttribute(objectName, "HeapMemoryUsage"); System.out.println(result); } catch (Exception e) { want.fail(e.getMessage()); } }
private void printMBeanInfo(MBeanInfo mbInfo) { System.out.println("Description " + mbInfo.getDescription()); for (MBeanConstructorInfo ctor : mbInfo.getConstructors()) { System.out.println("Constructor " + ctor.getName()); } for (MBeanAttributeInfo att : mbInfo.getAttributes()) { System.out.println("Attribute " + att.getName() + " [" + att.getType() + "]"); } for (MBeanOperationInfo oper : mbInfo.getOperations()) { System.out.println("Operation " + oper.getName()); } for (MBeanNotificationInfo notif : mbInfo.getNotifications()) { System.out.println("Notification " + notif.getName()); } }
/** * 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) { MBeanInfo info = null; 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; }
public static void main(String[] args) throws Exception { // Instantiate the MBean server // final MBeanAttributeInfo[] atts = makeAttInfos(attributes); final MBeanConstructorInfo[] ctors = makeCtorInfos(constructors); final MBeanOperationInfo[] ops = makeOpInfos(operations); final MBeanNotificationInfo[] notifs = makeNotifInfos(notificationclasses); for (int i=0; i<mbeanclasses.length;i++) { System.out.println("Create an MBeanInfo: " + mbeanclasses[i][0]); final MBeanInfo mbi = new MBeanInfo(mbeanclasses[i][1],mbeanclasses[i][0], atts, ctors, ops, notifs); } // Test OK! // System.out.println("All MBeanInfo successfuly created!"); System.out.println("Bye! Bye!"); }
final PerInterface<M> getPerInterface(Class<?> mbeanInterface) throws NotCompliantMBeanException { PerInterfaceMap<M> map = getPerInterfaceMap(); synchronized (map) { WeakReference<PerInterface<M>> wr = map.get(mbeanInterface); PerInterface<M> pi = (wr == null) ? null : wr.get(); if (pi == null) { try { MBeanAnalyzer<M> analyzer = getAnalyzer(mbeanInterface); MBeanInfo mbeanInfo = makeInterfaceMBeanInfo(mbeanInterface, analyzer); pi = new PerInterface<M>(mbeanInterface, this, analyzer, mbeanInfo); wr = new WeakReference<PerInterface<M>>(pi); map.put(mbeanInterface, wr); } catch (Exception x) { throw Introspector.throwException(mbeanInterface,x); } } return pi; } }
public void printAllMatchedAttributes(String attrRegExp) throws Exception { err("List of the keys matching " + attrRegExp + " :"); Object val = null; Pattern p = Pattern.compile(attrRegExp); for (ObjectName oname : hadoopObjectNames) { err(">>>>>>>>jmx name: " + oname.getCanonicalKeyPropertyListString()); MBeanInfo mbinfo = mbsc.getMBeanInfo(oname); MBeanAttributeInfo[] mbinfos = mbinfo.getAttributes(); for (MBeanAttributeInfo mb : mbinfos) { if (p.matcher(mb.getName()).lookingAt()) { val = mbsc.getAttribute(oname, mb.getName()); System.out.format(format, mb.getName(), (val == null) ? "" : val.toString()); } } } }
/** * Return the MBeanInfo for the given resource, based on the given * per-interface data. */ final MBeanInfo getMBeanInfo(Object resource, PerInterface<M> perInterface) { MBeanInfo mbi = getClassMBeanInfo(resource.getClass(), perInterface); MBeanNotificationInfo[] notifs = findNotifications(resource); if (notifs == null || notifs.length == 0) return mbi; else { return new MBeanInfo(mbi.getClassName(), mbi.getDescription(), mbi.getAttributes(), mbi.getConstructors(), mbi.getOperations(), notifs, mbi.getDescriptor()); } }
private static boolean test(Object mbean, boolean expectImmutable) throws Exception { MBeanServer mbs = MBeanServerFactory.newMBeanServer(); ObjectName on = new ObjectName("a:b=c"); mbs.registerMBean(mbean, on); MBeanInfo mbi = mbs.getMBeanInfo(on); Descriptor d = mbi.getDescriptor(); String immutableValue = (String) d.getFieldValue("immutableInfo"); boolean immutable = ("true".equals(immutableValue)); if (immutable != expectImmutable) { System.out.println("FAILED: " + mbean.getClass().getName() + " -> " + immutableValue); return false; } else { System.out.println("OK: " + mbean.getClass().getName()); return true; } }
@Override public MBeanInfo getMBeanInfo() { MBeanInfo mbi = super.getMBeanInfo(); Class<?> resourceClass = getResource().getClass(); if (StandardMBeanIntrospector.isDefinitelyImmutableInfo(resourceClass)) return mbi; return new MBeanInfo(mbi.getClassName(), mbi.getDescription(), mbi.getAttributes(), mbi.getConstructors(), mbi.getOperations(), MBeanIntrospector.findNotifications(getResource()), mbi.getDescriptor()); }
/** Make an MBeanInfo based on the attributes and operations * found in the interface. */ MBeanInfo makeMBeanInfo(Class<?> mbeanInterface, String description) { final MBeanAttributeInfo[] attrArray = attrs.toArray(new MBeanAttributeInfo[0]); final MBeanOperationInfo[] opArray = ops.toArray(new MBeanOperationInfo[0]); final String interfaceClassName = "interfaceClassName=" + mbeanInterface.getName(); final Descriptor classNameDescriptor = new ImmutableDescriptor(interfaceClassName); final Descriptor mbeanDescriptor = getBasicMBeanDescriptor(); final Descriptor annotatedDescriptor = Introspector.descriptorForElement(mbeanInterface); final Descriptor descriptor = DescriptorCache.getInstance().union( classNameDescriptor, mbeanDescriptor, annotatedDescriptor); return new MBeanInfo(mbeanInterface.getName(), description, attrArray, null, opArray, null, descriptor); }
private static void check(MBeanServer mbs, ObjectName on) throws Exception { MBeanInfo mbi = mbs.getMBeanInfo(on); // check the MBean itself check(mbi); // check attributes MBeanAttributeInfo[] attrs = mbi.getAttributes(); for (MBeanAttributeInfo attr : attrs) { check(attr); if (attr.getName().equals("ReadOnly")) check("@Full", attr.getDescriptor(), expectedFullDescriptor); } // check operations MBeanOperationInfo[] ops = mbi.getOperations(); for (MBeanOperationInfo op : ops) { check(op); check(op.getSignature()); } MBeanConstructorInfo[] constrs = mbi.getConstructors(); for (MBeanConstructorInfo constr : constrs) { check(constr); check(constr.getSignature()); } }
private final int doOperatingSystemMXBeanTest(MBeanServerConnection mbsc) { int errorCount = 0 ; System.out.println("---- OperatingSystemMXBean") ; try { ObjectName operationName = new ObjectName(ManagementFactory.OPERATING_SYSTEM_MXBEAN_NAME) ; MBeanInfo mbInfo = mbsc.getMBeanInfo(operationName); errorCount += checkNonEmpty(mbInfo); System.out.println("getMBeanInfo\t\t" + mbInfo); OperatingSystemMXBean operation = null ; operation = JMX.newMXBeanProxy(mbsc, operationName, OperatingSystemMXBean.class) ; System.out.println("getArch\t\t" + operation.getArch()); System.out.println("getAvailableProcessors\t\t" + operation.getAvailableProcessors()); System.out.println("getName\t\t" + operation.getName()); System.out.println("getVersion\t\t" + operation.getVersion()); System.out.println("---- OK\n") ; } catch (Exception e) { Utils.printThrowable(e, true) ; errorCount++ ; System.out.println("---- ERROR\n") ; } return errorCount ; }
/** * Make the MBeanInfo skeleton for the given MBean interface using * the given analyzer. This will never be the MBeanInfo of any real * MBean (because the getClassName() must be a concrete class), but * its MBeanAttributeInfo[] and MBeanOperationInfo[] can be inserted * into such an MBeanInfo, and its Descriptor can be the basis for * the MBeanInfo's Descriptor. */ private MBeanInfo makeInterfaceMBeanInfo(Class<?> mbeanInterface, MBeanAnalyzer<M> analyzer) { final MBeanInfoMaker maker = new MBeanInfoMaker(); analyzer.visit(maker); final String description = "Information on the management interface of the MBean"; return maker.makeMBeanInfo(mbeanInterface, description); }
@Override protected Property[] computeProperties(DynamicProxy object) { MBeanInfo nfo = object.getMBeanInfo(); MBeanAttributeInfo[] attrs = nfo.getAttributes(); List<Property> props = new ArrayList<Property>(); for (MBeanAttributeInfo attr : attrs) { props.add(new AttributeToPropertyAdapter(attr, object)); } return props.toArray(new Property[0]); }
@Override public void run() { try { // This will trigger updateJmxCache(). MBeanInfo info = sa.getMBeanInfo(); final String key = src.getKey(); for (MBeanAttributeInfo mBeanAttributeInfo : info.getAttributes()) { // Found the new key, update the metric source and move on. if (mBeanAttributeInfo.getName().equals(key)) { LOG.info("found key/val=" + cnt + "/" + cnt); cnt++; src.setKV("key" + cnt, cnt); return; } } LOG.error("key=" + key + " not found. Stopping now."); hasError.set(true); } catch (Exception e) { // catch other errors hasError.set(true); LOG.error(e.getStackTrace()); } finally { if (hasError.get()) { future.cancel(false); } } }
private static void doExploit ( final Object payloadObject, MBeanServerConnection mbc ) throws IOException, InstanceNotFoundException, IntrospectionException, ReflectionException { Object[] params = new Object[1]; params[ 0 ] = payloadObject; System.err.println("Querying MBeans"); Set<ObjectInstance> testMBeans = mbc.queryMBeans(null, null); System.err.println("Found " + testMBeans.size() + " MBeans"); for ( ObjectInstance oi : testMBeans ) { MBeanInfo mBeanInfo = mbc.getMBeanInfo(oi.getObjectName()); for ( MBeanOperationInfo opInfo : mBeanInfo.getOperations() ) { try { mbc.invoke(oi.getObjectName(), opInfo.getName(), params, new String[] {}); System.err.println(oi.getObjectName() + ":" + opInfo.getName() + " -> SUCCESS"); return; } catch ( Throwable e ) { String msg = e.getMessage(); if ( msg.startsWith("java.lang.ClassNotFoundException:") ) { int start = msg.indexOf('"'); int stop = msg.indexOf('"', start + 1); String module = ( start >= 0 && stop > 0 ) ? msg.substring(start + 1, stop) : "<unknown>"; if ( !"<unknown>".equals(module) && !"org.jboss.as.jmx:main".equals(module) ) { int cstart = msg.indexOf(':'); int cend = msg.indexOf(' ', cstart + 2); String cls = msg.substring(cstart + 2, cend); System.err.println(oi.getObjectName() + ":" + opInfo.getName() + " -> FAIL CNFE " + cls + " (" + module + ")"); } } else { System.err.println(oi.getObjectName() + ":" + opInfo.getName() + " -> SUCCESS|ERROR " + msg); return; } } } } }
/** * TODO: Comment. * * @param objectNamePattern * @param queryExp * @return */ public List<MBean> getMBeans(Set<ObjectName> objectNames) { if (objectNames == null) { return null; } if (!isConnected()) { return Collections.emptyList(); } List<MBean> mbeanList = new ArrayList<MBean>(objectNames.size()); for (ObjectName objectName : objectNames) { MBeanInfo mbeanInfo = null; try { mbeanInfo = _MBeanServerConnection.getMBeanInfo(objectName); } catch (Exception e) { } if (mbeanInfo == null) { continue; } MBean mbean = new MBean(objectName); mbean.setInfo(mbeanInfo); mbeanList.add(mbean); } return mbeanList; }
/** * Sets the info. * * @param info The info to set. */ public void setInfo(MBeanInfo info) { _Info = info; _AttributeNames = null; _AttributeInfoMap = null; }
private static Object findAttributeInfo(String attrName, Object info) { MBeanAttributeInfo printCompilation = null; for (MBeanAttributeInfo attr : ((MBeanInfo) info).getAttributes()) { if (attr.getName().equals(attrName)) { assertTrue("Readable", attr.isReadable()); assertTrue("Writable", attr.isWritable()); printCompilation = attr; break; } } return printCompilation; }
private final int doClassLoadingMXBeanTest(MBeanServerConnection mbsc) { int errorCount = 0 ; System.out.println("---- ClassLoadingMXBean") ; try { ObjectName classLoadingName = new ObjectName(ManagementFactory.CLASS_LOADING_MXBEAN_NAME) ; MBeanInfo mbInfo = mbsc.getMBeanInfo(classLoadingName); errorCount += checkNonEmpty(mbInfo); System.out.println("getMBeanInfo\t\t" + mbInfo); ClassLoadingMXBean classLoading = null; classLoading = JMX.newMXBeanProxy(mbsc, classLoadingName, ClassLoadingMXBean.class) ; System.out.println("getLoadedClassCount\t\t" + classLoading.getLoadedClassCount()); System.out.println("getTotalLoadedClassCount\t\t" + classLoading.getTotalLoadedClassCount()); System.out.println("getUnloadedClassCount\t\t" + classLoading.getUnloadedClassCount()); System.out.println("isVerbose\t\t" + classLoading.isVerbose()); System.out.println("---- OK\n") ; } catch (Exception e) { Utils.printThrowable(e, true) ; errorCount++ ; System.out.println("---- ERROR\n") ; } return errorCount ; }
private final int doMemoryMXBeanTest(MBeanServerConnection mbsc) { int errorCount = 0 ; System.out.println("---- MemoryMXBean") ; try { ObjectName memoryName = new ObjectName(ManagementFactory.MEMORY_MXBEAN_NAME) ; MBeanInfo mbInfo = mbsc.getMBeanInfo(memoryName); errorCount += checkNonEmpty(mbInfo); System.out.println("getMBeanInfo\t\t" + mbInfo); MemoryMXBean memory = null ; memory = JMX.newMXBeanProxy(mbsc, memoryName, MemoryMXBean.class, true) ; System.out.println("getMemoryHeapUsage\t\t" + memory.getHeapMemoryUsage()); System.out.println("getNonHeapMemoryHeapUsage\t\t" + memory.getNonHeapMemoryUsage()); System.out.println("getObjectPendingFinalizationCount\t\t" + memory.getObjectPendingFinalizationCount()); System.out.println("isVerbose\t\t" + memory.isVerbose()); System.out.println("---- OK\n") ; } catch (Exception e) { Utils.printThrowable(e, true) ; errorCount++ ; System.out.println("---- ERROR\n") ; } return errorCount ; }
private void registerJmxMBean() { try { MBeanServer mBeanServer = ManagementFactory.getPlatformMBeanServer(); ObjectName objectName = new ObjectName(settings.getJmxMBeanName()); mBeanServer.registerMBean(new JmxConfigRegistry(this), objectName); MBeanInfo mBeanInfo = mBeanServer.getMBeanInfo(objectName); LOGGER.info("Registered JMX MBean: {}", mBeanInfo); } catch (Exception e) { LOGGER.warn("Failed to register JMX MBean '{}', cause: {}", settings.getJmxMBeanName(), e); } }
@Override public synchronized MBeanInfo getMBeanInfo() { MBeanParameterInfo[] parameter = new MBeanParameterInfo[] { new MBeanParameterInfo("informationId", "java.lang.String", "The information ID which the value will be changed. e.g. AUTH_MODE"), new MBeanParameterInfo("value", "java.lang.String", "The value to be set for the information ID. e.g. INTERNAL, SAML_SP") }; MBeanOperationInfo[] operations = { new MBeanOperationInfo( SET_CONFIGURATION_SETTING, "Set configuration setting", parameter, "java.lang.String", MBeanOperationInfo.ACTION) }; return new MBeanInfo(this.getClass().getName(), "Set Configuration Setting MBean", null, null, operations, null); }
@Override public synchronized MBeanInfo getMBeanInfo() { MBeanParameterInfo[] parameter = new MBeanParameterInfo[] { new MBeanParameterInfo( "currentDate", "java.lang.String", "The current date for the billing run. Format is " + DATE_FORMAT.toUpperCase()) }; MBeanOperationInfo[] operations = { new MBeanOperationInfo( START_BILLING_RUN, "Start billing run", parameter, "java.lang.String", MBeanOperationInfo.ACTION) }; return new MBeanInfo(this.getClass().getName(), "Billing Run MBean", null, null, operations, null); }
/** * Get MBean Attriute from Mbean Server * @param jmxServerConnection * @param name * @param attribute * @return The type * @throws Exception */ protected String getMBeanAttributeType( MBeanServerConnection jmxServerConnection, String name, String attribute) throws Exception { ObjectName oname = new ObjectName(name); String mattrType = null; MBeanInfo minfo = jmxServerConnection.getMBeanInfo(oname); MBeanAttributeInfo attrs[] = minfo.getAttributes(); if (attrs != null) { for (int i = 0; mattrType == null && i < attrs.length; i++) { if (attribute.equals(attrs[i].getName())) mattrType = attrs[i].getType(); } } return mattrType; }
