-
1. Re: PersistPolicy
Actually, I have the following output:
PulsarStandard
startPulse
run
MBeanException: preRegister() failed [ObjectName='DefaultDomain:type=com.peerdirect.rmapplications.master.jmx.PulsarStandard', Class=com.peerdirect.rmapplications.master.jmx.PulsarStandard (com.peerdirect.rmapplications.master.jmx.PulsarStandard@5bdc50)]
Cause: java.lang.NullPointerException
at org.jboss.mx.server.registry.BasicMBeanRegistry.registerMBean(BasicMBeanRegistry.java:187)
at org.jboss.mx.server.MBeanServerImpl.registerMBean(MBeanServerImpl.java:975)
at org.jboss.mx.server.MBeanServerImpl.registerMBean(MBeanServerImpl.java:302)
at com.peerdirect.rmapplications.agent.BaseAgent.(BaseAgent.java:67)
at com.peerdirect.rmapplications.agent.MasterAgent.(MasterAgent.java:5)
at com.peerdirect.rmapplications.agent.MasterAgent.main(MasterAgent.java:15)
Instantiating an HTML protocol adaptor with default port...
Pulsing
Instantiating an RMI connector server with default port...
Pulsing
Pulsing
Pulsing
Pulsing
The code that registers the mbean, is here:
String pulsarName = "com.peerdirect.rmapplications.master.jmx.PulsarStandard" ;
Object pulsar = Class.forName (pulsarName).newInstance();
String name = myMBeanServer.getDefaultDomain() + ":type=" + pulsarName;
myMBeanServer.registerMBean (pulsar, new ObjectName(name));
-------------------------------------------------
The last line is called, and preRegister () is called from inside.
The source code for PulsarStandard is the following:
package com.peerdirect.rmapplications.master.jmx;
import com.peerdirect.rmapplications.master.jms.StatusNotificationClient;
import javax.management.*;
import javax.management.modelmbean.*;
import java.util.Iterator;
import java.lang.Runnable;
import java.io.*;
import org.jboss.mx.modelmbean.*;
import org.jboss.mx.modelmbean.ModelMBeanConstants.*;
/*public class PulsarStandard extends NotificationBroadcasterSupport
implements ModelMBean, Runnable*/
public class PulsarStandard extends ModelBase
implements Runnable
{
final static String OBJECT_REF = "ObjectReference";
//final static String PERSIST_NAME = "persistName";
//final static String PERSIST_LOCATION = "persistLocation";
// notification types
final static String GENERIC_MODELMBEAN_NOTIFICATION =
"jmx.modelmbean.generic";
// support for generic notification listeners
private NotificationBroadcasterSupport notifier = new NotificationBroadcasterSupport();
// sequence numbers for notifications
protected long notifierSequence = 0;
protected long attrNotifierSequence = 0;
// mgmt attribute name constants
final static String PULSE_PERIOD = "PulsePeriodInMills";
final static String IF_STARTED = "Started";
// mgmt operation name constants
final static String START_PULSE = "startPulse";
final static String STOP_PULSE = "stopPulse";
// fields for attribute values
private static final int DEFAULT_PULSE_PERIOD = 1000;
private static final boolean DEFAULT_STARTED= false;
private int mPulsePeriod = 0;
private boolean mStarted = false;
private StatusNotificationClient mSNC = null;
private Thread mThread = null;
protected ModelMBeanInfo metadata = null;
protected Object resource = null;
protected String resourceType = null;
// ModelMbean interface
public void setModelMBeanInfo (ModelMBeanInfo metadata)
throws MBeanException, RuntimeOperationsException {
System.out.println ("setModelMBeanInfo");
if (metadata == null)
throw new IllegalArgumentException ("The Model MBeanInfo cannot be null.");
this.metadata = metadata;
}
public void setManagedResource (Object ref, String resourceType)
throws MBeanException, InstanceNotFoundException, InvalidTargetObjectTypeException
{
System.out.println ("setManagedResource");
if (ref == null)
throw new IllegalArgumentException("Resource reference cannot be null.");
// check that is a supported resource type
if (!isSupportedResourceType(resourceType))
throw new InvalidTargetObjectTypeException("Unsupported resource type: " + resourceType);
this.resource = ref;
this.resourceType = resourceType;
}
public boolean isSupportedResourceType(String resourceType)
{
System.out.println("isSupportedResourceType");
//if (resourceType == null)
// return false;
//if (resourceType.equals(OBJECT_REF))
return true;
//return false;
}
// ModelMBeanNotificationBroadcaster interface
public void addNotificationListener (NotificationListener l, NotificationFilter filter, Object hback)
{
System.out.println ("addNotificationListener");
notifier.addNotificationListener(l, filter, hback);
}
public void removeNotificationListener(NotificationListener l)
throws ListenerNotFoundException
{
System.out.println ("removeNotificationListener");
notifier.removeNotificationListener(l);
}
public void addAttributeChangeNotificationListener (NotificationListener l,
String attributeName,
Object hback) throws MBeanException
{
System.out.println ("addAttributeChangeNotificationListener");
AttributeChangeNotificationFilter filter = new AttributeChangeNotificationFilter();
filter.enableAttribute(attributeName);
notifier.addNotificationListener(l, filter,hback);
}
public void removeAttributeChangeNotificationListener (NotificationListener l, String attributeName)
throws MBeanException, ListenerNotFoundException
{
System.out.println ("removeAttributeChangeNotificationListener");
notifier.removeNotificationListener(l);
}
public void sendNotification(String message)
throws MBeanException {
System.out.println ("sendNotification");
Notification notif = new Notification (
GENERIC_MODELMBEAN_NOTIFICATION, // type
this, // source
++notifierSequence, // sequence number
message // message
);
sendNotification(notif);
}
public void sendNotification (Notification notif)
//throws MBeanException
{
System.out.println ("sendNotification");
notifier.sendNotification(notif);
}
public void sendAttributeChangeNotification(
AttributeChangeNotification notif)
throws MBeanException {
System.out.println ("sendAttributeChangeNotification");
notifier.sendNotification(notif);
}
public void sendAttributeChangeNotification(
Attribute oldValue, Attribute newValue)
throws MBeanException {
System.out.println ("sendAttributeChangeNotification");
String attr = oldValue.getName();
String type = oldValue.getClass().getName();
AttributeChangeNotification notif =
new AttributeChangeNotification(
this, // source
++attrNotifierSequence, // seq. #
System.currentTimeMillis(), // time stamp
"" + attr + " changed from " // message
+ oldValue + " to " + newValue,
attr, type, // name & type
oldValue, newValue // values
);
notifier.sendNotification(notif);
}
public MBeanNotificationInfo[] getNotificationInfo() {
System.out.println ("getNotificationInfo");
int size = metadata.getNotifications().length;
MBeanNotificationInfo[] notifInfo = metadata.getNotifications();
MBeanNotificationInfo[] modelInfo =
new MBeanNotificationInfo[size + 2];
for (int i = 0; i < size ;++i)
modelInfo = notifInfo;
Descriptor descr1 = new DescriptorSupport();
descr1.setField("name", "generic");
descr1.setField("descriptorType", "notification");
descr1.setField("severity", "5");
ModelMBeanNotificationInfo generic = new ModelMBeanNotificationInfo(
new String[] { GENERIC_MODELMBEAN_NOTIFICATION },
"generic",
"A generic Model MBean notification.",
descr1
);
Descriptor descr2 = new DescriptorSupport();
descr2.setField("name", AttributeChangeNotification.class.getName());
descr2.setField("descriptorType", "notification");
ModelMBeanNotificationInfo attrChange = new ModelMBeanNotificationInfo(
new String[] { AttributeChangeNotification.ATTRIBUTE_CHANGE },
AttributeChangeNotification.class.getName(),
"Notifies a change in attribute's value.",
descr2
);
modelInfo[size-2] = generic;
modelInfo[size-1] = attrChange;
return modelInfo;
}
// PersistentMBean interface
public void load() throws MBeanException,
InstanceNotFoundException {
System.out.println ("load");
// throw new UnsupportedOperationException();
if (metadata == null)
return;
Descriptor d = metadata.getMBeanDescriptor();
String dir = (String)d.getFieldValue(PERSIST_LOCATION);
System.out.println (dir);
String file = (String)d.getFieldValue(PERSIST_NAME);
if (file != null) {
try {
File f = new File(dir, file);
FileInputStream fis = new FileInputStream(f);
ObjectInputStream ois = new ObjectInputStream(fis);
metadata = (ModelMBeanInfoSupport)ois.readObject();
}
catch (Exception e) {
System.out.println("Error loading MBean state");
}
}
}
public void store() throws MBeanException,
InstanceNotFoundException {
System.out.println ("store");
try {
Descriptor d = metadata.getMBeanDescriptor();
String dir = (String)d.getFieldValue(PERSIST_LOCATION);
System.out.println (dir);
String file = (String)d.getFieldValue(PERSIST_NAME);
File f = new File(dir, file);
FileOutputStream fos = new FileOutputStream(f);
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(metadata);
}
catch (IOException e) {
throw new MBeanException(e, "Error in persisting MBean.");
}
//throw new UnsupportedOperationException();
}
// getAttribute implementation
public PulsarStandard () throws MBeanException
{
super ();
System.out.println ("PulsarStandard");
mPulsePeriod = DEFAULT_PULSE_PERIOD;
mStarted = DEFAULT_STARTED;
mSNC = new StatusNotificationClient ();
mThread = new Thread (this);
startPulse () ;
}
public Object getAttribute(String attribute) throws AttributeNotFoundException, MBeanException, ReflectionException
{
System.out.println ("getAttribute");
if (attribute == null || attribute.equals(""))
throw new IllegalArgumentException("null or empty attribute name");
// map the named attributes to fields
if (attribute.equals(PULSE_PERIOD))
return new Integer (mPulsePeriod);
else if (attribute.equals(IF_STARTED))
return new Boolean (mStarted);
throw new AttributeNotFoundException("Attribute " + attribute + " not found.");
}
// getAttributes implementation
public AttributeList getAttributes (String[] attributes)
{
System.out.println ("getAttributes");
if (attributes == null)
throw new IllegalArgumentException("null array");
AttributeList list = new AttributeList();
for (int i = 0; i < attributes.length; ++i)
{
try
{
list.add (new Attribute (attributes, getAttribute(attributes)));
}
catch (JMException ignored)
{
// if the attribute could not be retrieved, skip it
}
}
return list;
}
// setAttribute implementation
public void setAttribute (Attribute attribute) throws AttributeNotFoundException, InvalidAttributeValueException,
MBeanException, ReflectionException
{
System.out.println ("setAttribute");
if (attribute == null) throw new
AttributeNotFoundException("null attribute");
// map attributes to fields
try
{
if (attribute.getName().equals(PULSE_PERIOD))
this.mPulsePeriod = ((Integer)attribute.getValue()).intValue();
else if (attribute.getName().equals(IF_STARTED))
this.mStarted = ((Boolean)attribute.getValue()).booleanValue();
else
throw new AttributeNotFoundException("attribute " + attribute.getName() + " not found.");
}
catch (ClassCastException e)
{
throw new InvalidAttributeValueException("Invalid attribute type " + attribute.getValue().getClass().getName());
}
}
// setAttributes implementation
public AttributeList setAttributes (AttributeList list)
{
System.out.println ("setAttributes");
if (list == null)
throw new IllegalArgumentException("null list");
AttributeList results = new AttributeList();
Iterator it = list.iterator();
while (it.hasNext())
{
try
{
Attribute attr = (Attribute)it.next();
setAttribute(attr);
results.add(attr);
}
catch (JMException ignored)
{
// if unable to set the attribute, skip it
}
}
return results;
}
// invoke implementation
public Object invoke(String actionName,
Object[] params,
String[] signature) throws MBeanException, ReflectionException {
System.out.println ("invoke");
if (actionName == null || actionName.equals(""))
throw new IllegalArgumentException("no operation");
// map operation names to methods
if (actionName.equals(START_PULSE))
{
startPulse();
return null;
}
else if (actionName.equals(STOP_PULSE))
{
stopPulse ();
return null;
}
else
throw new UnsupportedOperationException("unknown operation " + actionName);
}
// getMBeanInfo implementation
public MBeanInfo getMBeanInfo()
{
System.out.println ("getMBeanInfo");
final boolean READABLE = true;
final boolean WRITABLE = true;
final boolean IS_GETTER = true;
// MBean class and description
String className = getClass().getName();
String description =
"User resource with model management interface";
// build 'RoomName' read-write attribute
Descriptor descr1 = new DescriptorSupport();
descr1.setField("name", PULSE_PERIOD);
descr1.setField("descriptorType", "attribute");
descr1.setField("displayName", "Room Number");
descr1.setField("default", "D325");
descr1.setField(PERSIST_POLICY, "OnUpdate");
descr1.setField(PERSIST_LOCATION, "c:\\aa");
descr1.setField(PERSIST_NAME, "storage.txt");
System.out.println ("Valid " + descr1.isValid());
// meta data for 'PULSE_PERIOD' attribute.
ModelMBeanAttributeInfo mPulsePeriod = new ModelMBeanAttributeInfo(
PULSE_PERIOD, // name
int.class.getName(), // type
"Pulse Period", // description
IS_READABLE, IS_WRITABLE, !IS_IS, // access
descr1
);
// meta data for 'IF_STARTED' attribute.
ModelMBeanAttributeInfo mStarted = new ModelMBeanAttributeInfo(
IF_STARTED, // name
boolean.class.getName(), // type
"If the Pulser has Started", // description
IS_READABLE, !IS_WRITABLE, !IS_IS // access
);
// meta data for 'startPulse' operation
ModelMBeanOperationInfo startPulse = new ModelMBeanOperationInfo(
START_PULSE, // name
"Start the pulsar", // description
null, // signature
void.class.getName(), // return type
MBeanOperationInfo.ACTION // impact
);
// meta data for 'stopPulse' operation
ModelMBeanOperationInfo stopPulse = new ModelMBeanOperationInfo(
STOP_PULSE, // name
"Stop the pulsar", // description
null, // signature
void.class.getName(), // return type
MBeanOperationInfo.ACTION // impact
);
// mbean constructors
ModelMBeanConstructorInfo defaultConstructor =
new ModelMBeanConstructorInfo(
"Default Constructor",
"Creates a new Pulsar", null
);
// attribute, constructor and operation lists
ModelMBeanAttributeInfo[] attributes = new ModelMBeanAttributeInfo[] {mPulsePeriod, mStarted};
ModelMBeanConstructorInfo[] constructors = new ModelMBeanConstructorInfo[] {defaultConstructor};
ModelMBeanOperationInfo[] operations = new ModelMBeanOperationInfo[] {startPulse, stopPulse};
// return the MBeanInfo
return new ModelMBeanInfoSupport (className, description, attributes, constructors, operations, null);
}
// RW attributes
/*
public int getPulsePeriodInMills ()
{
return mPulsePeriod;
}
public void setPulsePeriodInMills (int pPulsePeriod)
{
mPulsePeriod = pPulsePeriod ;
}
public boolean getStarted ()
{
return mStarted;
}
*/
public void startPulse ()
{
System.out.println ("startPulse");
mThread.start ();
try
{
mSNC.connect();
mStarted = true ;
}
catch (Exception e)
{
mStarted = false ;
}
}
public void stopPulse ()
{
System.out.println ("stopPulse");
mThread.stop ();
mSNC.disconnect();
mStarted = false ;
}
public void run ()
{
System.out.println ("run");
try
{
while (true)
{
mThread.sleep (mPulsePeriod);
if (mStarted)
{
System.out.println("Pulsing");
mSNC.sendPulse();
}
}
}
catch (Exception ex)
{
ex.printStackTrace();
}
}
}
//////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////