Help needed in ModelMBean descriptors

[Pradeep Kumar]

Hi ranchers,

I am learning JMX and executed a ModelMBean. I have specified a descriptor for the persisting to a file but when i change the value in the attribute through JConsole, it is not getting persisted into the file. Kindly find the below descriptors for persisting that I have mentioned.

   
	descriptors.add("descriptorType=attribute");
		descriptors.add("persistPolicy=Always");

The complete class file is as below

import java.lang.management.ManagementFactory;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import javax.management.Descriptor;
import javax.management.IntrospectionException;
import javax.management.JMException;
import javax.management.ObjectName;
import javax.management.modelmbean.DescriptorSupport;
import javax.management.modelmbean.InvalidTargetObjectTypeException;
import javax.management.modelmbean.ModelMBean;
import javax.management.modelmbean.ModelMBeanAttributeInfo;
import javax.management.modelmbean.ModelMBeanInfo;
import javax.management.modelmbean.ModelMBeanInfoSupport;
import javax.management.modelmbean.ModelMBeanOperationInfo;
import javax.management.modelmbean.RequiredModelMBean;

public class ModelMBeanDemo {
	

	public static ModelMBean makeModelMBean(Object resource)
			throws JMException, InvalidTargetObjectTypeException {

		final Method[] methods = resource.getClass().getMethods();

		final List<Method> operations = new ArrayList<Method>();
		final List<Method> getters = new ArrayList<Method>();
		final Map<String, Method> setters = new LinkedHashMap<String, Method>();

		for (Method method : methods) {
			// don't want to expose getClass(), hashCode(), equals(), etc...
			if (method.getDeclaringClass().equals(Object.class))
				continue;

			if (method.getName().startsWith("get")
					&& !method.getName().equals("get")
					&& !method.getName().equals("getClass")
					&& method.getParameterTypes().length == 0
					&& method.getReturnType() != void.class) {
				getters.add(method);
			}
			if (method.getName().startsWith("set")
					&& !method.getName().equals("set")
					&& method.getParameterTypes().length == 1
					&& method.getReturnType().equals(void.class)) {
				setters.put(method.getName(), method);
			}

			operations.add(method);
		}

		final List<ModelMBeanAttributeInfo> attrinfo = new ArrayList<ModelMBeanAttributeInfo>();

		for (Method getter : getters) {

			final String attrName = getter.getName().substring(3);
			final String setterMethod = "set" + attrName; // construct setter
															// method

			// Check whether there's a setter and if so removes it from the
			// setter's map.
			//
			Method setter = setters.remove(setterMethod);

			if (setter != null) {
				// If there's a setter, it must have the same "type" than
				// the getter
				if (!getter.getReturnType().equals(
						setter.getParameterTypes()[0])) {
					System.err
							.println("Warning: setter "
									+ setter.getName()
									+ " doesn't have the expected type: setter ignored.");
					setter = null;
				}
			}

			attrinfo.add(makeAttribute(getter, setter));
		}

		// check if there are setters for which there was no getter
		//
		for (Method setter : setters.values()) {
			// It would be unusual to have a setter with no getter!
			System.err.println("Warning: setter " + setter.getName()
					+ " has no corresponding getter!");
			attrinfo.add(makeAttribute(null, setter));
		}

		final ModelMBeanAttributeInfo[] attrs = attrinfo
				.toArray(new ModelMBeanAttributeInfo[attrinfo.size()]);

		final int opcount = operations.size();
		final ModelMBeanOperationInfo[] ops = new ModelMBeanOperationInfo[opcount];
		for (int i = 0; i < opcount; i++) {
			final Method m = operations.get(i);
			ops[i] = new ModelMBeanOperationInfo(m.getName(), m);
		}

		ModelMBeanInfo mmbi = new ModelMBeanInfoSupport(resource.getClass()
				.getName(), resource.getClass().getName(), attrs, null, // constructors
				ops, null); // notifications
		ModelMBean mmb = new RequiredModelMBean(mmbi);
		mmb.setManagedResource(resource, "ObjectReference");
		return mmb;
	}

	private static ModelMBeanAttributeInfo makeAttribute(Method getter,
			Method setter) throws IntrospectionException {
		final String attrName;
		if (getter != null)
			attrName = getter.getName().substring(3);
		else
			attrName = setter.getName().substring(3);

		final List<String> descriptors = new ArrayList<String>();
		descriptors.add("name=" + attrName);
		descriptors.add("descriptorType=attribute");
		descriptors.add("persistPolicy=Always");

		descriptors.add("persistLocation=D:/mbean");
		descriptors.add("persistFile=Sample.txt");
		if (getter != null) {
			descriptors.add("getMethod=" + getter.getName());
		}
		if (setter != null) {
			descriptors.add("setMethod=" + setter.getName());
		}

		final Descriptor attrD = new DescriptorSupport(descriptors
				.toArray(new String[descriptors.size()]));

		return new ModelMBeanAttributeInfo(attrName, attrName, getter, setter,
				attrD);
	}

	public static void main(String[] args) throws Exception {

		final Printer obj = new Printer();
		final ModelMBean mbean = makeModelMBean(obj);
		ManagementFactory.getPlatformMBeanServer().registerMBean(mbean,
				new ObjectName("test:type=MyPrinter"));

		System.out.println("Waiting forever...");
		Thread.sleep(Long.MAX_VALUE);
	}
}

After running the above program I opened the jconsole and tried to change the values of the attributes. I wasn not getting the changes in the file mentioned in the descriptor.

Kindly provide me a solution for this.

Thanks and best regards,
Pradeep

[Pradeep Kumar]

no reply yet :-(

[Pradeep Kumar]

Hello ranchers. I am using ManagementFactory.getPlatformMBeanServer() as my MBeanServer and using JConsole for monitoring. I am not able to set the values for descriptors like persistLocation, persistName etx related to persistance. What is the value that i need to specify for the above descriptors. Please reply.
I am sending the refactored code for reference.

 
import java.lang.management.ManagementFactory;
import java.lang.reflect.Constructor;

import javax.management.Descriptor;
import javax.management.MBeanAttributeInfo;
import javax.management.MBeanConstructorInfo;
import javax.management.MBeanException;
import javax.management.MBeanNotificationInfo;
import javax.management.MBeanOperationInfo;
import javax.management.MBeanParameterInfo;
import javax.management.MBeanServer;
import javax.management.MalformedObjectNameException;
import javax.management.NotificationBroadcaster;
import javax.management.NotificationListener;
import javax.management.ObjectName;
import javax.management.RuntimeOperationsException;
import javax.management.modelmbean.DescriptorSupport;
import javax.management.modelmbean.ModelMBeanAttributeInfo;
import javax.management.modelmbean.ModelMBeanConstructorInfo;
import javax.management.modelmbean.ModelMBeanInfo;
import javax.management.modelmbean.ModelMBeanInfoSupport;
import javax.management.modelmbean.ModelMBeanNotificationInfo;
import javax.management.modelmbean.ModelMBeanOperationInfo;
import javax.management.modelmbean.RequiredModelMBean;

public class MyModelMBean {

	private MBeanServer server = null;
	private String dClassName = "Printer";
	private String dDescription = "Simple implementation of a Printer.";
	private Descriptor mmbDesc = null;
	private ModelMBeanInfo dMBeanInfo = null;
	private ModelMBeanAttributeInfo[] dAttributes = new ModelMBeanAttributeInfo[3];
	private ModelMBeanConstructorInfo[] dConstructors = new ModelMBeanConstructorInfo[1];
	private ModelMBeanOperationInfo[] dOperations = new ModelMBeanOperationInfo[10];
	private ModelMBeanNotificationInfo[] dNotifications = new ModelMBeanNotificationInfo[1];

	private MyModelMBean() {
		server = ManagementFactory.getPlatformMBeanServer();
	}

	public static void main(String[] args) throws MalformedObjectNameException {
		MyModelMBean myBean = new MyModelMBean();

		myBean.execute();
	}

	private void execute() throws MalformedObjectNameException {
		// building an Object name
		String domain = server.getDefaultDomain();
		String mbeanName = "MyModelSample";

		ObjectName mbeanObjectName = new ObjectName(domain + ":type="
				+ mbeanName);

		buildDynamicMBeanInfo(mbeanObjectName, mbeanName);

		try {
			RequiredModelMBean modelmbean = new RequiredModelMBean(dMBeanInfo);
			// Set the managed resource for the ModelMBean instance
			//
			modelmbean.setManagedResource(new Printer(), "objectReference");
			// Register the ModelMBean in the MBean Server
			//
			server.registerMBean(modelmbean, mbeanObjectName);

			printMBeanInfo(mbeanObjectName, mbeanName);

			NotificationListener attrListener = (NotificationListener) new TestBeanAttributeChangeListener();
			createEventListeners(mbeanObjectName, attrListener);
			NotificationBroadcaster attrEmmitter = (NotificationBroadcaster) new TestBeanAttributeChangeBroadCaster();
			// createEventBroadCaster(mbeanObjectName, attrEmmitter);
			System.out.println("Waiting forever...");
			Thread.sleep(Long.MAX_VALUE);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	private void buildDynamicMBeanInfo(ObjectName mbeanObjectName,
			String mbeanName) {
		try {
			Class<?> appBean = Class.forName(dClassName);
			mmbDesc = new DescriptorSupport(new String[] {
					"name=" + mbeanObjectName, "descriptorType=mbean",
					"displayName=" + mbeanName, "log=T", "logfile=jmxmain.log",
					"currencyTimeLimit=5","persistName=BufferSize","persistPolicy=OnUpdate","persistLocation=D:/Welcome" });

			Descriptor bufferSize = new DescriptorSupport();
			bufferSize.setField("name", "BufferSize");
			bufferSize.setField("descriptorType", "attribute");
			bufferSize.setField("displayName", "MyBufferSize");
			bufferSize.setField("getMethod", "getBufferSize");
			bufferSize.setField("setMethod", "setBufferSize");
			bufferSize.setField("persistName", "BufferSize");
			bufferSize.setField("currencyTimeLimit", "10");
			bufferSize.setField("persistLocation", "D:/Welcome");

			dAttributes[0] = new ModelMBeanAttributeInfo("BufferSize", "int",
					"BufferSize: bufferSize integer value.", true, true, false,
					bufferSize);

			Descriptor speed = new DescriptorSupport();
			speed.setField("name", "Speed");
			speed.setField("descriptorType", "attribute");
			speed.setField("value", new Integer("4444"));
			speed.setField("displayName", "HardCodedValue");
			speed.setField("currencyTimeLimit", "10");
			speed.setField("currencyTimeLimit", "10");
			speed.setField("persistLocation","D:/Welcome");
			speed.setField("persistPolicy","OnUpdate");

			dAttributes[1] = new ModelMBeanAttributeInfo("Speed",
					"int",
					"Speed: static value in ModelMBeanInfo and not in Printer",
					true, true, false, speed);

			Descriptor type = new DescriptorSupport();
			type.setField("name", "Type");
			type.setField("descriptorType", "attribute");
			type.setField("displayName", "MyPrinterType");
			type.setField("getMethod", "getType");
			type.setField("setMethod", "setType");
			type.setField("currencyTimeLimit", "10");

			dAttributes[2] = new ModelMBeanAttributeInfo("Type", "java.lang.String",
					"Type: The printer type.", true, true, false, type);

			Constructor[] constructors = appBean.getConstructors();

			Descriptor printerBeanDesc = new DescriptorSupport();
			printerBeanDesc.setField("name", "Printer");
			printerBeanDesc.setField("descriptorType", "operation");
			printerBeanDesc.setField("role", "constructor");

			dConstructors[0] = new ModelMBeanConstructorInfo(
					"Printer(): Constructs a Printer bean", constructors[0],
					printerBeanDesc);

			MBeanParameterInfo[] params = null;

			Descriptor printDesc = new DescriptorSupport();
			printDesc.setField("name", "print");
			printDesc.setField("descriptorType", "operation");
			printDesc.setField("class", "Printer");
			printDesc.setField("role", "operation");

			MBeanParameterInfo[] setPrintParams = new MBeanParameterInfo[] { new MBeanParameterInfo(
					"newPrintChanges", "java.lang.String",
					"new value for the content value") };

			dOperations[0] = new ModelMBeanOperationInfo("print",
					"print(): Prints the state of the Printer", setPrintParams,
					"void", MBeanOperationInfo.ACTION, printDesc);

			Descriptor getTypeDesc = new DescriptorSupport(new String[] {
					"name=getType", "class=Printer",
					"descriptorType=operation", "role=getter" });

			Printer printer = new Printer();
			getTypeDesc.setField("targetObject", printer);
			getTypeDesc.setField("targetType", "objectReference");

			dOperations[1] = new ModelMBeanOperationInfo("getType",
					"getType(): get the type of the Printer", params,
					"java.lang.String", MBeanOperationInfo.INFO, getTypeDesc);

			Descriptor getBufferSizeDesc = new DescriptorSupport(new String[] {
					"name=getBufferSize", "class=Printer",
					"descriptorType=operation", "role=getter" });

			getBufferSizeDesc.setField("targetObject", printer);
			getBufferSizeDesc.setField("targetType", "objectReference");

			dOperations[2] = new ModelMBeanOperationInfo("getBufferSize",
					"getBufferSize(): get the BufferSize of the Printer",
					params, "int", MBeanOperationInfo.INFO,
					getBufferSizeDesc);

			Descriptor getSpeedDesc = new DescriptorSupport(new String[] {
					"name=getSpeed", "class=Printer",
					"descriptorType=operation", "role=getter" });

			getSpeedDesc.setField("targetObject", printer);
			getSpeedDesc.setField("targetType", "objectReference");

			dOperations[3] = new ModelMBeanOperationInfo("getSpeed",
					"getSpeed(): get the speed of the Printer", params,
					"java.lang.Integer", MBeanOperationInfo.INFO, getSpeedDesc);

			Descriptor setBufferSize = new DescriptorSupport(new String[] {
					"name=setBufferSize", "descriptorType=operation",
					"class=Printer", "role=setter" });

			MBeanParameterInfo[] setBufferSizeParams = new MBeanParameterInfo[] { new MBeanParameterInfo(
					"newBufferSizeChanges", "int",
					"new value for the buffer size") };

			dOperations[4] = new ModelMBeanOperationInfo("setBufferSize",
					"set BufferSize attribute", setBufferSizeParams, "void",
					MBeanOperationInfo.ACTION, setBufferSize);

			Descriptor setType = new DescriptorSupport(new String[] {
					"name=setType", "descriptorType=operation",
					"class=Printer", "role=setter" });

			MBeanParameterInfo[] setTypeParams = new MBeanParameterInfo[] { new MBeanParameterInfo(
					"newTypeChanges", "java.lang.String",
					"new value for the printer type") };

			dOperations[5] = new ModelMBeanOperationInfo("setType",
					"set Type attribute", setTypeParams, "void",
					MBeanOperationInfo.ACTION, setType);

			Descriptor setSpeed = new DescriptorSupport(new String[] {
					"name=setSpeed", "descriptorType=operation",
					"class=Printer", "role=setter" });

			MBeanParameterInfo[] setSpeedParams = new MBeanParameterInfo[] { new MBeanParameterInfo(
					"newSpeedChanges", "java.lang.Integer",
					"new value for the printer speed") };

			dOperations[6] = new ModelMBeanOperationInfo("setSpeed",
					"set Speed attribute", setSpeedParams, "void",
					MBeanOperationInfo.ACTION, setSpeed);

			Descriptor getMBeanInfoDesc = new DescriptorSupport(new String[] {
					"name=getMBeanInfo", "descriptorType=operation",
					"class=javax.management.modelmbean.RequiredModelMBean",
					"role=operation" });

			dOperations[7] = new ModelMBeanOperationInfo("getMBeanInfo",
					"get MBean Info", null, "javax.management.MBeanInfo",
					MBeanOperationInfo.ACTION, getMBeanInfoDesc);

			Descriptor addAttributeChangeNotificationListenerDesc = new DescriptorSupport(
					new String[] {
							"name=addAttributeChangeNotificationListener",
							"descriptorType=operation",
							"class=javax.management.modelmbean.RequiredModelMBean",
							"role=operation" });

			MBeanParameterInfo[] addAttributeChangeNotificationListenerParms = new MBeanParameterInfo[] {
					new MBeanParameterInfo("inlistener",
							"javax.management.NotificationListener",
							"A listener"),
					new MBeanParameterInfo("inAttributeName,",
							"java.lang.String", "attribute name"),
					new MBeanParameterInfo("inhandback),", "java.lang.Object",
							"handback") };

			dOperations[8] = new ModelMBeanOperationInfo(
					"addAttributeChangeNotificationListener",
					"add a listener to receive AttributeChangeNotification",
					addAttributeChangeNotificationListenerParms, "void",
					MBeanOperationInfo.ACTION,
					addAttributeChangeNotificationListenerDesc);

			Descriptor sendAttributeChangeNotificationDesc = new DescriptorSupport(
					new String[] {
							"name=sendAttributeChangeNotification",
							"descriptorType=operation",
							"class=javax.management.modelmbean.RequiredModelMBean",
							"role=operation" });

			MBeanParameterInfo[] sendAttributeChangeNotificationParms = new MBeanParameterInfo[] { new MBeanParameterInfo(
					"inNotification",
					"javax.management.AttributeChangeNotification",
					"A notification emmitter") };

			dOperations[9] = new ModelMBeanOperationInfo(
					"sendAttributeChangeNotification",
					"brodcasts the events on AttributeChangeNotification",
					sendAttributeChangeNotificationParms, "void",
					MBeanOperationInfo.ACTION,
					sendAttributeChangeNotificationDesc);

			Descriptor genEventDesc = new DescriptorSupport(new String[] {
					"descriptorType=notification",
					"name=jmx.ModelMBean.General", "severity=4",
					"MessageId=MA001", "log=T", "logfile=jmx.log" });
			String[] genTypes = new String[1];
			genTypes[0] = "jmx.ModelMBean.General";

			Descriptor getNotificationInfoDesc = new DescriptorSupport(
					new String[] {
							"name=getNotificationInfo",
							"descriptorType=operation",
							"class=javax.management.modelmbean.RequiredModelMBean",
							"role=operation" });

			dOperations[9] = new ModelMBeanOperationInfo("getNotificationInfo",
					"get Notification Info", null,
					"[Ljavax.management.MBeanNotificationInfo",
					MBeanOperationInfo.ACTION, getNotificationInfoDesc);

			dNotifications[0] = new ModelMBeanNotificationInfo(genTypes,
					"jmx.ModelMBean.General", // was Generic
					"Generic Event", genEventDesc); // test event

			dMBeanInfo = new ModelMBeanInfoSupport(dClassName, dDescription,
					dAttributes, dConstructors, dOperations, dNotifications);

			try {
				dMBeanInfo.setMBeanDescriptor(mmbDesc);
			} catch (RuntimeOperationsException e) {
				e.printStackTrace();
			} catch (MBeanException e) {
				e.printStackTrace();
			}

		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
	}

	private void printMBeanInfo(ObjectName mbeanObjectName, String mbeanName) {
		echo("\n>>> Getting the management information for the " + mbeanName
				+ ":" + mbeanObjectName + " MBean");
		echo("    using the getMBeanInfo method of the MBeanServer");
		ModelMBeanInfo info = null;
		try {
			info = (ModelMBeanInfo) server.getMBeanInfo(mbeanObjectName);
			if (info == null) {
				echo("\nModelMBeanInfo from JMX Agent is null!");
			}
		} catch (Exception e) {
			echo("\t!!! ModelAgent:printMBeanInfo: Could not get MBeanInfo "
					+ "object for " + mbeanName + " exception type "
					+ e.getClass().toString() + ":" + e.getMessage() + "!!!");
			e.printStackTrace();
			return;
		}
		echo("\nCLASSNAME: \t" + info.getClassName());
		echo("\nDESCRIPTION: \t" + info.getDescription());
		try {
			echo("\nMBEANDESCRIPTOR: \t"
					+ (info.getMBeanDescriptor()).toString());
		} catch (Exception e) {
			echo("\nMBEANDESCRIPTOR: \tNone");
		}

		echo("\nATTRIBUTES");
		MBeanAttributeInfo[] attrInfo = (info.getAttributes());
		if (attrInfo.length > 0) {
			for (int i = 0; i < attrInfo.length; i++) {
				echo("\n ** NAME: \t" + attrInfo[i].getName());
				echo("    DESCR: \t" + attrInfo[i].getDescription());
				echo("    TYPE: \t" + attrInfo[i].getType() + "\tREAD: "
						+ attrInfo[i].isReadable() + "\tWRITE: "
						+ attrInfo[i].isWritable());
				ModelMBeanAttributeInfo mmai = (ModelMBeanAttributeInfo) attrInfo[i];
				echo("    DESCRIPTOR: \t" + mmai.getDescriptor().toString());
			}
		} else
			echo(" ** No attributes **");

		MBeanConstructorInfo[] constrInfo = info.getConstructors();
		echo("\nCONSTRUCTORS");
		if (constrInfo.length > 0) {
			for (int i = 0; i < constrInfo.length; i++) {
				echo("\n ** NAME: \t" + constrInfo[i].getName());
				echo("    DESCR: \t" + constrInfo[i].getDescription());
				echo("    PARAM: \t" + constrInfo[i].getSignature().length
						+ " parameter(s)");
				ModelMBeanConstructorInfo mmci = (ModelMBeanConstructorInfo) constrInfo[i];
				echo("    DESCRIPTOR: \t" + mmci.getDescriptor().toString());
			}
		} else
			echo(" ** No Constructors **");

		echo("\nOPERATIONS");
		MBeanOperationInfo[] opInfo = info.getOperations();
		if (opInfo.length > 0) {
			for (int i = 0; i < opInfo.length; i++) {
				echo("\n ** NAME: \t" + opInfo[i].getName());
				echo("    DESCR: \t" + opInfo[i].getDescription());
				echo("    PARAM: \t" + opInfo[i].getSignature().length
						+ " parameter(s)");
				ModelMBeanOperationInfo mmoi = (ModelMBeanOperationInfo) opInfo[i];
				echo("    DESCRIPTOR: \t" + mmoi.getDescriptor().toString());
			}
		} else
			echo(" ** No operations ** ");

		echo("\nNOTIFICATIONS");
		MBeanNotificationInfo[] notifInfo = info.getNotifications();
		if (notifInfo.length > 0) {
			for (int i = 0; i < notifInfo.length; i++) {
				echo("\n ** NAME: \t" + notifInfo[i].getName());
				echo("    DESCR: \t" + notifInfo[i].getDescription());
				String notifTypes[] = notifInfo[i].getNotifTypes();
				for (int j = 0; j < notifTypes.length; j++) {
					echo("    TYPE: \t" + notifTypes[j]);
				}
				ModelMBeanNotificationInfo mmni = (ModelMBeanNotificationInfo) notifInfo[i];
				echo("    DESCRIPTOR: \t" + mmni.getDescriptor().toString());
			}
		} else
			echo(" ** No notifications **");

		echo("\nEnd of MBeanInfo print");
	}

	private void echo(String string) {
		System.out.println(string);

	}

	private void createEventListeners(ObjectName mbeanObjectName,
			NotificationListener listener) {
		try {
			server.invoke(mbeanObjectName,
					"addAttributeChangeNotificationListener", new Object[] {
							listener, "BufferSize", null }, new String[] {
							"javax.management.NotificationListener",
							"java.lang.String", "java.lang.Object" });
			echo("\n\tEvent listener created successfully\n");
		} catch (Exception e) {
			echo("Error! Creating event listener with invoke failed "
					+ "with message:\n");
			echo(e.getMessage() + "\n");
			echo("\nEXITING...\n");
			e.printStackTrace();
			System.exit(1);
		}
	}
}