Creating a JXTA Service

This example illustrates how to create a new JXTA service and its service advertisement, publish and search for advertisements via the Discovery service, create a pipe via the Pipe service, and send messages through the pipe. It consists of two separate applications:

Server The Server application creates the service advertisements (ModuleClassAdvertisement and ModuleSpecAdvertisement) and publishes them in the NetPeerGroup. The ModuleSpecAdvertisement contains a PipeAdvertisement required to connect to the service. The Server application then starts the service by creating an input pipe to receive messages from clients. The service loops forever, waiting for messages to arrive.

Client The Client application discovers the ModuleSpecAdvertisement, extracts the PipeAdvertisement and creates an output pipe to connect to the service, and sends a message to the service.

Figure 7-10 shows example output when the Server application is run, and Figure 7-11 shows example input from the Client application:
Starting Service Peer .... Start the Server daemon Reading in file pipeserver.adv Created service advertisement: jxta:MSA : MSID : urn:jxta:uuid-B6F8546BC21D4A8FB47AA68579C9D89EF3670BB315A C424FA7D1B74079964EA206 Name : JXTASPEC:JXTA-EX1 Crtr : sun.com SURI : http://www.jxta.org/Ex1 Vers : Version 1.0 jxta:PipeAdvertisement : Id : urn:jxta:uuid-9CCCDF5AD8154D3D87A391210404E59BE4B888 209A2241A4A162A10916074A9504 Type : JxtaUnicast Name : JXTA-EX1 Waiting for client messages to arrive Server: received message: Hello my friend! Waiting for client messages to arrive
Figure 7-10

Example output: Server application.

Programming with JXTA

85

Starting Client peer .... Start the Client searching for the JXTASPEC:JXTA-EX1 Service advertisement We found the service advertisement: jxta:MSA : MSID : urn:jxta:uuidFDDF532F4AB543C1A1FCBAEE6BC39EFDFE0336E05D31465CBE9 48722030ECAA306 Name : JXTASPEC:JXTA-EX1 Crtr : sun.com SURI : http://www.jxta.org/Ex1 Vers : Version 1.0 jxta:PipeAdvertisement : Id : urn:jxta:uuid9CCCDF5AD8154D3D87A391210404E59BE4B888209A224 1A4A162A10916074A9504 Type : JxtaUnicast Name : JXTA-EX1 message "Hello my friend!" sent to the Server Good Bye ....
Figure 7-11

Example output: Client application.

Note If you are running both applications on the same system, you will need to run each one from a separate subdirectory so that they can be configured to use separate ports. The Server application must be run first.

86

Project JXTA v2.0: Java Programmers Guide

Server Note This is the server side of the JXTA-EX1 example. The server side application advertises the JXTA-EX1 service, starts the service, and receives messages on a service-defined pipe endpoint. The service associated module spec and class advertisement are published in the NetPeerGroup. Clients can discover the module advertisements and create output pipes to connect to the service. The server application creates an input pipe that waits to receive messages. Each message received is printed to the screen. We run the server as a daemon in an infinite loop, waiting to receive client messages.
This application defines a single class, Server. Four class constants contain information about the service:

String SERVICE the name of the service we create and advertise String TAG the message element name, or tag, which we are expecting in any message we receive; the client application must use this same tag. String NAMESPACE the namespace used by the message element; the client application must use this same space. String FILENAME the name of the file that contains our pipe advertisement. (This file must exist and contain a valid pipe advertisement in order for our application to run correctly.) PeerGroup group our peer group, the default net peer group DiscoveryService discoSvc the discovery service; used to publish our new service PipeService pipeSvc the pipe service; used to create our input pipe and read messages InputPipe myPipe the pipe used to receive messages

We also define several instance fields:

main()
This method [line 34] creates a new Server object, calls startJxta() to instantiate the JXTA platform and create the default net peer group, calls startServer() to create and publish the service, and finally calls readMessages() to read messages received by the service.

startJxta()
This method instantiates the JXTA platform and creates the default net peer group [line 47]:
group = PeerGroupFactory.newNetPeerGroup();

Then it retrieves the discovery and pipe services [line 57]:

discoSvc = group.getDiscoveryService(); pipeSvc = group.getPipeService();

The discovery service is used later when we publish our service advertisements. The pipe service is used later when we create our input pipe and wait for messages on it.

startServer()
This method creates and publishes the service advertisements. It starts by creating a module class advertisement, which is used to simply advertise the existence of the service. The AdvertisementFactory.newAdvertisement() method is used to create a new advertisement [line 74]:
ModuleClassAdvertisement mcadv = (ModuleClassAdvertisement) AdvertisementFactory.newAdvertisement( ModuleClassAdvertisement.getAdvertisementType());
Programming with JXTA 87

It is passed one argument: the type of advertisement we want to construct. After we create our module class advertisement, we initialize it [lines 78 - 82]:
mcadv.setName("JXTAMOD:JXTA-EX1"); mcadv.setDescription("Tutorial example to use JXTA module advertisement Framework"); ModuleClassID mcID = IDFactory.newModuleClassID(); mcadv.setModuleClassID(mcID);

The name and description can be any string. A suggested naming convention is to choose a name that starts with "JXTAMOD" to indicate this is a JXTA module. Each module class has a unique ID, which is generated by calling the IDFactory.newModuleClassID() method. Now that the module class advertisement is created and initialized, it is published in the local cache and propagated to our rendezvous peer [lines 87 - 88]:
discoSvc.publish(mcadv, DiscoveryService.ADV); discoSvc.remotePublish(mcadv, DiscoveryService.ADV);

Next, we create the module spec advertisement associated with the service. This advertisement contains all the information necessary for a client to contact the service. For instance, it contains a pipe advertisement to be used to contact the service. Similar to creating the module class advertisement, AdvertisementFactory.newAdvertisement() is used to create a new module spec advertisement [line 98]:
ModuleSpecAdvertisement mdadv = (ModuleSpecAdvertisement) AdvertisementFactory.newAdvertisement( ModuleSpecAdvertisement.getAdvertisementType());

After the advertisement is created, we initialize the name, version, creator, ID, and URI [lines 107 - 111]:
mdadv.setName(SERVICE); mdadv.setVersion("Version 1.0"); mdadv.setCreator("sun.com"); mdadv.setModuleSpecID(IDFactory.newModuleSpecID(mcID)); mdadv.setSpecURI("http://www.jxta.org/Ex1");

We use IDFactory.newModuleSpecID() to create the ID for our module spec advertisement. This method takes one argument, which is the ID of the associated module class advertisement (created above in line 81).

Note In practice, you should avoid creating a new ModuleSpecID every time you run your application, because it tends to create many different but equivalent and interchangeable advertisements. This, in turn, would clutter the cache space. It is preferred to allocate a new ModuleSpecID only once, and then hard-code it into your application. A simplistic way to do this is to run your application (or any piece of code) that creates the ModuleSpecID once: IDFactory.newModuleSpecID(mcID) Then print out the resulting ID and use it in your application to recreate the same ID every time: (ModuleSpecID) IDFactory.fromURL(new URL("urn", "", "jxta:uuid-<...ID created...>")
We now create a new pipe advertisement for our service. The client must see use the same advertisement to talk to the server. When the client discovers the module spec advertisement, it will extract the pipe advertisement to create its pipe. We read the pipe advertisement from a default configuration file to ensure that the service will always advertise the same pipe [lines 124 - 128]:
88 Project JXTA v2.0: Java Programmers Guide

FileInputStream is = new FileInputStream(FILENAME); pipeadv = (PipeAdvertisement) AdvertisementFactory.newAdvertisement( new MimeMediaType("text/xml"), is); is.close();

After we successfully create our pipe advertisement, we add it to the module spec advertisement [line 136]:
mdadv.setPipeAdvertisement(pipeadv);

Now, we have initialized everything we need in our module spec advertisement. We print the complete module spec advertisement as a plain text document [lines 139 - 146], and then we publish it to our local cache and propagate it to our rendezvous peer [lines 150 - 151]:
discoSvc.publish(mdadv, DiscoveryService.ADV); discoSvc.remotePublish(mdadv, DiscoveryService.ADV);

Were now ready to start the service. We create the input pipe endpoint that clients will use to connect to the service [line 156]:
myPipe = pipeSvc.createInputPipe(pipeadv);

readMessages()
This method loops continuously waiting for client messages to arrive on the services input pipe. It calls PipeService.waitForMessage() [line 176]:
msg = myPipe.waitForMessage();

This will block and wait indefinitely until a message is received. When a message is received, we extract the message element with the expected namespace and tag [line 189]:
el = msg.getMessageElement(NAMESPACE, TAG);

The Message.getMessageElement() method takes two arguments, a string containing the namespace and a string containing the tag we are looking for. The client and server application must agree on the namespace and tag names; this is part of the service protocol defined to access the service. Finally, assuming we find the expected message element, we print out the message element line 194]:
System.out.println("Server: Received message: " + el.toString());

and then continue to wait for the next message.

Programming with JXTA

89

Example Service Advertisement: pipeserver.adv file

An example pipe advertisement, stored in the pipeserver.adv file, is listed below:
<?xml version="1.0"?> <!DOCTYPE jxta:PipeAdvertisement> <jxta:PipeAdvertisement xmlns:jxta="http://jxta.org"> <Id> urn:jxta:uuid9CCCDF5AD8154D3D87A391210404E59BE4B888209A2241A4A162A10916074A9504 </Id> <Type> JxtaUnicast </Type> <Name> JXTA-EX1 </Name> </jxta:PipeAdvertisement>

Programming with JXTA

95

Client Note This is the client side of the EX1 example that looks for the JXTA-EX1 service and connects to its advertised pipe. The Service advertisement is published in the NetPeerGroup by the server application. The client discovers the service advertisement and creates an output pipe to connect to the service input pipe. The server application creates an input pipe that waits to receive messages. Each message receive is displayed to the screen. The client sends an hello message.
This application defines a single class, Client. Three class constants contain information about the service:

String SERVICE the name of the service we are looking for (advertised by Server) String TAG the message element name, or tag, which we include in any message we send; the Server application must use this same tag. String NAMESPACE the namespace used by the message element; the client application must use this same space. PeerGroup netPeerGroup our peer group, the default net peer group DiscoveryService discoSvc the discovery service; used to find the service PipeService pipeSvc the pipe service; used to create our output pipe and send messages

We also define several instance fields:

main()
This method [line 30] creates a new Client object, calls startJxta() to instantiate the JXTA platform and create the default net peer group, calls startClient() to find the service and send a messages.

startJxta()
This method instantiates the JXTA platform and creates the default net peer group [line 42]:
group = PeerGroupFactory.newNetPeerGroup();

Then it retrieves the discovery and pipe services [line 51]:

discoSvc = group.getDiscoveryService(); pipeSvc = group.getPipeService();

The discovery service is used later when we look for the service advertisement. The pipe service is used later when we create our output pipe and send a message on it.

startClient()
This method loops until it locates the service advertisement. It first looks in the local cache to see if it can discover an advertisement which has the (Name, JXTASPEC: JXTA-EX1) tag and value pair [line 73]:
enum = discoSvc.getLocalAdvertisements(DiscoveryService.ADV, "Name", SERVICE);

We pass the DiscoveryService.getLocalAdvertisements() method three arguments: the type of advertisement were looking for, the tag ("Name"), and the value for that tag. This method returns an enumeration of all advertisements that exactly match this tag/value pair; if no matching advertisements are found, this method returns null.

96

Project JXTA v2.0: Java Programmers Guide

If we dont find the advertisement in our local cache, we send a remote discovery request searching for the service [line 82]:
discoSvc.getRemoteAdvertisements(null, DiscoveryService.ADV, "Name", SERVICE, 1, null);

We pass the DiscoveryService.getRemoteAdvertisements() method 6 arguments:

java.lang.string peerid id of a peer to connect to; if null, connect to rendezvous peer int type PEER, GROUP, ADV java.lang.string attribute attribute name to narrow discovery to java.lang.string value value of attribute to narrow discovery to int threshold the upper limit of responses from one peer net.jxta.discovery.DiscoveryListener listener discovery listener service to be used

Since discovery is asynchronous, we dont know how long it will take. We sleep as long as we want, and then try again. When a matching advertisement is found, we break from the loop and continue on. We retrieve the module spec advertisement from the enumeration of advertisements that were found [line 104]:
ModuleSpecAdvertisement mdsadv = (ModuleSpecAdvertisement) enum.nextElement();

We print the advertisement as a plain text document [lines 109 - 115] and then extract the pipe advertisement from the module spec advertisement [line 118]:
PipeAdvertisement pipeadv = mdsadv.getPipeAdvertisement();

Now that we have the pipe advertisement, we can create an output pipe and use it to connect to the server. In our example, we try three times to bind the pipe endpoint to the listening endpoint pipe of the service using PipeService.createOutputPipe() [line 133]:
myPipe = pipeSvc.createOutputPipe(pipeadv, 10000);

Next, we create a new (empty) message and a new element. The element contains the agreed-upon element tag, the data (our message to send), and a null signature [line 147]:
Message msg = new Message(); StringMessageElement sme = new StringMessageElement(TAG, data, null);

We add the element to our message in the agreed-upon namespace:

msg.addMessageElement(NAMESPACE, sme);

The only thing left to do is send the message to the service using the PipeService.send() method [line 152]:
myPipe.send(msg);

Programming with JXTA

97