In all the previous chapters, we used a special Globus-supplied class called ReflectionResourceProperty to implement our RPs. This class had a number of benefits, described in ReflectionResourceProperty, the main one being that it greatly simplified our implementation since we could use the RPs as if they were normal Java variables.

In this chapter, however, we will use a different Globus-supplied class to represent our RPs: SimpleResourceProperty. Although we could also use ReflectionResourceProperty, this is a good chance to take a look at SimpleResourceProperty. Although this class makes the implementation a little bit more complicated, it shouldn't be too hard to understand now that we know what the resource property document is.

	Now is a good moment to review Section 6.1, “A closer look at resource properties”.

First of all, remember how in all the previous examples, our RPs were implemented simply as two attributes in the resource class:

private int value;
private String lastOp;

Now, this will be replaced by the following:

/* Resource properties */
private ResourceProperty valueRP;
private ResourceProperty lastOpRP;

	ResourceProperty is a Globus-supplied interface that all resource properties must implement. Both ReflectionResourceProperty and SimpleResourceProperty, for example, implement it.

Furthermore, we are not required to implement get/set methods for the RPs, as we did when using ReflectionResourceProperty. However, as will be explained later on, it will nonetheless be convenient to do so, as it will make working with the RPs easier, specially if we split our implementation into a service, a resource, and a resource home.

Next, we need to initialize the resource properties. In our example, this is done in the constructor:

public MathService() throws RemoteException {
	this.propSet = new SimpleResourcePropertySet(
			MathQNames.RESOURCE_PROPERTIES); 

	try {
		valueRP = new SimpleResourceProperty(MathQNames.RP_VALUE); 
		valueRP.add(new Integer(0)); 
				
		
		lastOpRP = new SimpleResourceProperty(MathQNames.RP_LASTOP);
		lastOpRP.add("NONE");
	} catch (Exception e) {
		throw new RuntimeException(e.getMessage());
	}

	
	this.propSet.add(valueRP);
	this.propSet.add(lastOpRP);
}

	First, we create the RP set. This, in effect, creates an empty RP document. In our case, this would be something like this: <MathResourceProperties xmlns:tns="http://www.globus.org/namespaces/examples/core/MathService_instance_notif"> </MathResourceProperties>
	Next, we create a SimpleResourceProperty. If you compare with the previous examples, you'll notice that the constructor for SimpleResourceProperty only requires the QName of the RP (whereas ReflectionResourceProperty required more parameters).
	Now, we set the initial value of the RP. When using ReflectionResourceProperty, we simply had to modify the value attribute. Now, however, we have to use SimpleResourceProperty's add method to do this. By adding new Integer(0), we are creating a new Value RP with value 0: <tns:Value>0</tns:Value> Note that, if the RP were unbounded, we could keep on invoking valueRP.add to create more Value RPs: <tns:Value>0</tns:Value> <tns:Value>0</tns:Value> <tns:Value>0</tns:Value> However, we cannot do this because Value is declared to occur once (and only once) in the RP document.
	We perform the previous two steps again to add a new LastOp RP.
	Finally, we add the RPs to the RP set. Now, our RP document will look something like this: <MathResourceProperties xmlns:tns="http://www.globus.org/namespaces/examples/core/MathService_notif"> <tns:Value>0</tns:Value> <tns:LastOp>NONE</tns:LastOp> </MathResourceProperties>

Now that our resource properties are implemented using the SimpleResourceProperty class, publishing those RPs as topics is very simple. We will use a Globus-supplied class called ResourcePropertyTopic which is both a resource property and a topic (more precisely, it implements both the ResourceProperty and Topic interfaces). As we will see, the only thing we need to to is create new ResourcePropertyTopic objects and "wrap them around" our SimpleResourceProperty objects. Then, the ResourcePropertyTopic objects are added both to the resource's list of RPs (the RP set) and the list of topics.

First of all, our resource class must implement the TopicListAccessor interface, which requires that we implement a getTopicList method returning a TopicList. A TopicList attribute must therefore be added to our resource class to keep track of all the topics published by our resource.

import org.globus.wsrf.TopicListAccessor;

public class MathService implements Resource, ResourceProperties,
		TopicListAccessor {
		
	private TopicList topicList;
	
	// ...
	
	/* Required by interface TopicListAccessor */
	public TopicList getTopicList() {
		return topicList;
	}
}

Next, we initialize the topic list, create the ResourcePropertyTopic objects, and add the to the RP set and the topic list:

public MathService() throws RemoteException {
	/* Create RP set */
	this.propSet = new SimpleResourcePropertySet(
			MathQNames.RESOURCE_PROPERTIES);

	/* Initialize the RP's */
	try {
		valueRP = new SimpleResourceProperty(MathQNames.RP_VALUE);
		valueRP.add(new Integer(0));

		lastOpRP = new SimpleResourceProperty(MathQNames.RP_LASTOP);
		lastOpRP.add("NONE");
	} catch (Exception e) {
		throw new RuntimeException(e.getMessage());
	}

	
	this.topicList = new SimpleTopicList(this);

	
	valueRP = new ResourcePropertyTopic(valueRP);
	((ResourcePropertyTopic) valueRP).setSendOldValue(true);

	lastOpRP = new ResourcePropertyTopic(lastOpRP);
	((ResourcePropertyTopic) lastOpRP).setSendOldValue(true);

	
	this.topicList.addTopic((Topic) valueRP);
	this.topicList.addTopic((Topic) lastOpRP);
	
	this.propSet.add(valueRP);
	this.propSet.add(lastOpRP);
}

	We initialize the topic list using the Globus-supplied SimpleTopicList class.
	We take the previously created SimpleResourceProperty objects and put them "inside" ResourcePropertyTopic objects. Notice how the valueRP and lastOpRP attributes (of type ResourceProperty) are set to the ResourcePropertyTopic objects, not the original SimpleResourceProperty objects. Next, we will activate a nice feature included in ResourcePropertyTopics. We can ask that the notification include not only the new value (whenever an RP is modified), but also the old value.
	Finally, we add the ResourcePropertyTopic objects to the topic list.

	The code shown above is part of $EXAMPLES_DIR/org/globus/examples/services/core/notifications/impl/MathService.java.

This client is composed of two important parts:

First off, let's take a look at the code that sets up the subscription. This code is inside a method called run that expects the notification producer's URI as its only parameter.

public void run(String serviceURI) {
	try {
		
		NotificationConsumerManager consumer;

		
		consumer = NotificationConsumerManager.getInstance();
		consumer.startListening();
		EndpointReferenceType consumerEPR = consumer
				.createNotificationConsumer(this);

			
		Subscribe request = new Subscribe();
		request.setUseNotify(Boolean.TRUE);
		request.setConsumerReference(consumerEPR);

		
		TopicExpressionType topicExpression = new TopicExpressionType();
		topicExpression.setDialect(WSNConstants.SIMPLE_TOPIC_DIALECT);
		topicExpression.setValue(MathQNames.RP_VALUE);
		request.setTopicExpression(topicExpression);

			
		
		WSBaseNotificationServiceAddressingLocator notifLocator = 
			new WSBaseNotificationServiceAddressingLocator();
		EndpointReferenceType endpoint = new EndpointReferenceType();
		endpoint.setAddress(new Address(serviceURI));
		NotificationProducer producerPort = notifLocator
				.getNotificationProducerPort(endpoint);

		
		producerPort.subscribe(request);

		
		System.out.println("Waiting for notification. Ctrl-C to end.");
		while (true) {
			try {
				Thread.sleep(30000);
			} catch (Exception e) {
				System.out.println("Interrupted while sleeping.");
			}
		}
	} catch (Exception e) {
		e.printStackTrace();
	}
}

	Our client is going to act as a notification consumer. This means that our client will have to expose a Notify operation that will be invoked by the notification producer. For this to happen, our client has to act as both a client and a server. Fortunately, thanks to a Globus-supplied class called NotificationConsumerManager, we are shielded from all the potential nastiness involved in doing this is.
	Once we invoke the startListening method in the NotificationConsumerManager, our client becomes a server hosting a service that implements the standard NotificationConsumer portType. As such, this service will have an endpoint reference. We need to keep track of this EPR, since it will be used by the NotificationProducer to deliver the notifications.
	We create the request to the remote Subscribe call. There are two properties we must set: whether the producer must use the standard Notify operation to deliver notifications (in general, we will always want this to be true), and the consumer's EPR.
	Next, we create a TopicExpressionType object representing the topic we want to subscribe to. Notice how we're subscribing to the Value RP.
	A this point, the Subscribe request is ready to be sent to the notification producer. To do this, we need to obtain a reference to the standard NotificationProducer portType in the remote service.
	We are finally ready to send the subscription request.
	Finally, we let out program loop indefinitely. Notice that we instruct the client's thread to sleep during the loop. This doesn't affect the client's ability to receive notifications, as it will be woken up whenever a notification is delivered.

Now, let's take a look at the code that handles incoming notifications. Remember that the delivery is required by the NotifyCallback interface. If we do not implement it, our client will be unable to receive notifications.

public void deliver(List topicPath, EndpointReferenceType producer, 
		Object message) {
	ResourcePropertyValueChangeNotificationElementType notif_elem;
	ResourcePropertyValueChangeNotificationType notif;

	
	notif_elem = (ResourcePropertyValueChangeNotificationElementType) message;
	notif = notif_elem.getResourcePropertyValueChangeNotification();

	if (notif != null) {
		System.out.println("A notification has been delivered");
			
		
		System.out.print("Old value: ");
		System.out.println(notif.getOldValue().get_any()[0].getValue());
		System.out.print("New value: ");
		System.out.println(notif.getNewValue().get_any()[0].getValue());
	}
}

	The deliver method has three parameters: topicPath: the topic that produced the notification. producer: the EPR of the notification producer. message: the actual notification. Notice how it is of type Object, so we will need to cast it to a more useful type.
	When using ResourcePropertyTopics to notify changes in RPs, the notification message is of type ResourcePropertyValueChangeNotificationElementType. This type, in turn, contains an object of type ResourcePropertyValueChangeNotificationType. This object is the one that contains the new value of the RP. Remember that, in this example, we've also asked that the notification include the old value too.
	Finally, we print out the old and new values of the RP.

	The code shown above is part of $EXAMPLES_DIR/org/globus/examples/clients/MathService_instance_notif/ValueListener.java

The adding client requires no explanation, as it is identical to the ones seen in previous chapters.

	The source code for the adding client is $EXAMPLES_DIR/org/globus/examples/clients/MathService_instance_notif/ClientAdd.java If you're not sure about how the client works, this might be a good time to review Section 5.9.2, “The adding client”.

First of all, let's compile the listener client:

javac \
-classpath $CLASSPATH:build/stubs/classes/ \
org/globus/examples/clients/MathService_instance_notif/ValueListener.java

Since we are going to use two clients, you should run the listener in a separate console.

java \
-DGLOBUS_LOCATION=$GLOBUS_LOCATION \
-classpath $CLASSPATH:build/stubs/classes/ \
org/globus/examples/clients/MathService_instance_notif/ValueListener \
http://127.0.0.1:8080/wsrf/services/examples/core/notifications/MathService

	Notice how we have to define a property called GLOBUS_LOCATION. This should be set to the directory where GT4 is installed. We need to define this property because, as mentioned earlier, our client is also going to act as a server. Therefore, it needs to know where all the Globus files are located (some of which are necessary for it to work as a server).

If all goes well, you should see the following:

Waiting for notification. Ctrl-C to end.

Now, let's compile the adder client:

javac \
-classpath $CLASSPATH:build/stubs/classes/ \
org/globus/examples/clients/MathService_instance_notif/ClientAdd.java

And run it:

java \
-classpath $CLASSPATH:build/stubs/classes/ \
org/globus/examples/clients/MathService_instance_notif/ClientAdd \
http://127.0.0.1:8080/wsrf/services/examples/core/notifications/MathService \
10

If all goes well, you should see the following:

Value RP: 10
LastOp RP: ADDITION

Now, if you check the console where the listener client is running, you should see the following:

A notification has been delivered
Old value:0
New value:10

You can try to run the adder client once more:

Value RP: 20
LastOp RP: ADDITION

And the following will be output by the listener.

A notification has been delivered
Old value:10
New value:20