Notes on JXTA Development

• Brendon Wilson's JXTA book
• JXTA JAVA Programmer's guide
• The JXTA homepage for Mailing lists

Layout

• Platform Configuration
  
• Modules
  
• Pipes
  
• BiDirectional Pipes
  
• New Advertisements
  
• Creating New Service
  
• Sending Queries using the Resolver service
  
• Starting a Module/Application
  
• A template for writing a JXTA Application
  
• Printing Out Messages
  
• JXTA Boot Message
  
• Story of a Message
  
• Miscellaneous (&Object Serialization)
  
• Shared Resources Distributed Index (SRDI)
  
• Discovery Service
  

Platform Configuration

Modules

Pipes

Bidirectional Pipes

• Server creates a BidirectionalPipeService.AcceptPipe from a pipeAdvertisement
• Server advertises its pipeAdvertisement
• Client discovers pipeAdvertisement
• Client creates a BidirectionalPipeService and uses bidirpipe.connect(pipeAdv,time) and obtain a BidirectionalPipeService.Pipe
• Server accepts the connection through acceptPipe.accept(timeout) and therefore obtains a BidirectionalPipeService.Pipe
• from this common BidirectionalPipeService.Pipe both client and server can getInput and getOutput pipes for transferring messages.

Adding a new advertisement in the Jxta-java framework

Creating a new Service

• Endpoint : To transfer messages right on top of the network layer
• RendezVous :
• Resolver
• Pipe
• Peer Information
• Discovery
• Membership

• Interface someService extends Service: adds/removes listener and defines the stubs for the methods offered by the service
• Interface someServiceListener : stubs for methods handled by the listener
• someServiceEvent extends java.util.EventObject : wraps the response object into an event object that is passed to the listener for processing.
• someServiceImpl implements someService and possibly QueryHandler : actual code for the methods defined in someService and also for QueryHandler (processQuery, processResponse)

• add the service to the peergroup list of services

  •         ModuleImplAdvertisement implAdv = 
              netPGroup.getAllPurposePeerGroupImplAdvertisement();
            //Get the services params
            StdPeerGroupParamAdv params = 
              new StdPeerGroupParamAdv(implAdv.getParam());
            //get the mapping from service id's to their implementations
            Hashtable services = params.getServices();
            //Add new services to list of services of group
            services.put(ModuleClassID(), ModImplAdv());
            params.setServices(services);
            implAdv.setParam((StructuredDocument) params.getDocument(
              new MimeMediaType("text", "xml")));
            //Set new ModuleSpecID for this new set of services
            implAdv.setModuleSpecID((ModuleSpecID) IDFactory.fromURL(
              new URL(refPeerGroupSpec)));
            PeerGroupID groupID = (PeerGroupID) IDFactory.fromURL(
              new URL((refPeerGroupID)));
            newGroup = netPGroup.newGroup(groupID, implAdv,name,description);
            PeerGroupAdvertisement groupAdv = 
                newGroup.getPeerGroupAdvertisement();
    

• publish the new peergroupadvertisement

  •         discovery.publish(implAdv, DiscoveryService.ADV);
            discovery.remotePublish(implAdv, DiscoveryService.ADV);
            discovery.remotePublish(groupAdv, DiscoveryService.GROUP);
    		...more publishing...
    

• implement the someService methods handling sending and receiving messages
• registering listeners for this service if the peer has to be offering the service.
• Define a GUI for the application

Sending Queries using the Resolver Service

• Register a Handler Name for the class handling the query [This handler class implements the QueryHandler class that defines two methods:processQuery and processResponse]
• Create a query message object and send it using the resolver service
• When the remote peer receives the query, it matches the handler name for this query and creates a response object before sending it back to the requesting peer.

Starting a Module or an Application component

• write an application object that implements Application (init,startApp,stopApp)
• createModuleClassAdv,createModuleSpecAdv,createModuleImplAdv for this module/application
• add the module/application to the peergroup's set of applications:
  Hashtable apps = new Hashtable();
  apps.put(app.getModClassAdv(),appImplAdv);
  params.setApps(apps);
  implAdvOfGroup.setParams(params);
  group.startApp(null);
  
• the application startApp method will be invoked when the peergroup starts.

Writing applications using JXTA's Java Binding: A Template

• Module advertisements are created
• PeerGroup is Created
• PeerGroup is initialized
• Application is Started

public class MainClass
{
createModClassAdv() {}
createModSpecAdv() {}
createModImplAdv() {}
createPeerGroup()
{
   modclassadv = createModClassAdv
   modspecadv = createModSpecAdv
   modimpladv = createModImplAdv
   ...as many services/apps  as needed
   services = peergroup.getServices()

   services.put(modclassadv.getModClassID(),modimpladv);
   ...as many services as needed
   
   applications.put(modclassadv.getModClassID,modimpladv);

   newgroup = peergroup.newGroup(impladv)
   
   newgroup.startApp()
}
initializePG()
{
peergroup = PeerGroupFactory.newNetPeerGroup()
}

public class MainGUI() implements Application
{
initGUI()
{
JFrame...
setVisible(true);
}

public void init(PeerGroup,ID,impladv)
{
}

public int startApp(String[] args)
{
aService = peergroup.lookup(aservice.getClassID());
aService.addListener(aServiceHandler)

initGUI()
}

public void stopApp()
{
aService.removeListener()
}

Printing out messages

net.jxta.endpoint.MessageElementEnumeration enum = message.getElements();
  System.out.println("**************************************************");
  if(enum!=null)
  while(enum.hasMoreMessageElements())
  {
  try{
  java.io.InputStream is = (java.io.InputStream)enum.nextMessageElement().getStream();
  net.jxta.document.StructuredTextDocument document = (net.jxta.document.StructuredTextDocument)
  net.jxta.document.StructuredDocumentFactory.newStructuredDocument(
  new net.jxta.document.MimeMediaType("text/xml"), is);
  java.io.StringWriter out = new java.io.StringWriter();
  document.sendToWriter(out);
  System.out.println(out.toString());
  }catch(Exception e){System.err.println("Error demuxing"+e);}
  }

JXTA Boot Message

ResolverResponse
	DiscoveryResponse
		PeerAdvertisement
	/DiscoveryResponse
/ResolverResponse
RendezVousPropagateMessage
/RendezVousPropagateMessage

Story of a Message

Miscellaneous

platform/binding/java/api/src/net/jxta/platform/Version.java

package net.jxta.platform;

public class Version
{

public static void main(String[] args)
  {
    System.out.println("JXTA Version 2.1");
  }
}

<target name="version" depends="test">

  <java classname="net.jxta.platform.Version" fork="yes"
    classpathref="classpath" >

    <jvmarg value="-Dnet.jxta.tls.principal=somelogin"/>
    <jvmarg value="-Dnet.jxta.tls.password=somepass"/>
  </java>
</target>

byte[] serializedObject = null;

try {
  ByteArrayOutputStream bytes = new ByteArrayOutputStream();
  ObjectOutputStream b = new ObjectOutputStream(bytes);
  b.writeObject(data);
  b.flush();
  b.close();
  serializedObject = bytes.toByteArray();
  bytes.close();
}
catch (IOException e) {
  System.out.println("OBJECT IS NOT SERIALIZABLE - " +
		     data.getClass().getName());
}

.. then to create the message use:

Message msg = peer.getPipeService().createMessage();

MessageElement messageElement = msg.newMessageElement(
						      TAG, new MimeMediaType("text/plain"), serializedObject);
// add the newly element to the message.
msg.addElement(messageElement);

......and to deserialize the object from a jxta Message in 'msg':

Object data = null;

try {
  byte[] serializedObject = msg.getBytes(TAG);
           ByteArrayInputStream bytes = new
	     ByteArrayInputStream(serializedObject);
           ObjectInputStream b = new ObjectInputStream(bytes);
           data = b.readObject();
           b.close();
           bytes.close();
}
catch (Exception e) {
  System.out.println("RECV: OBJECT IS CORRUPTED - ");
}

Shared Resources Distributed Index (SRDI)

• A propagation of messages based on RendezVous peers based on the Rendezvous peerview (not flooding the network)
• A Key replication mechanism to strengthen availability in case of failure

ResolverService.sendSrdi(dest,message)

Discovery Service