Class CNS

java.lang.Object
org.jcsp.net2.cns.CNS
All Implemented Interfaces:
CSProcess

public class CNS extends Object implements CSProcess

This class is the Channel Name Server's main server process class.

This class should only be instantiated at Nodes wishing to run a server process. Although this class does not need to be used by clients wishing to interact with a server, it does provide some convenient static methods for client code to use. There are static versions of the methods provided in CNSService and there are also static factory methods for constructing CNS registered channel objects.

Server Installation

Channel Name Servers may be run either on a dedicated Node or else on the same Node as one of the user Nodes. The former approach is recommended for most situations but for smaller scale use, the latter approach may suffice.

The following example initialises a Node and installs a Channel Name Server. It then proceeds to install a CNS client service and creates and resolves a channel. The example does not proceed to do anything else but could be used as the framework for an application wishing to host its own Channel Name Server.

import org.jcsp.lang.*;
import org.jcsp.net2.*;
import org.jcsp.net2.cns.*;
import org.jcsp.net2.tcpip.*;
import java.io.IOException;
public class CNSInSameJVM implements CSProcess {
//main method for running example
public static void main(String[] args) {
CNSInSameJVM proc = new CNSInSameJVM();
proc.run();
}
public void run() {
NodeKey key = null;
NodeID localNodeID = null;
try {
//Initialize a Node that does not have a CNS client
key = Node.getInstance().init(new TCPIPNodeAddress(7890));
new ProcessManager(CNS.getInstance()).start();
//Dedicated server code could stop here
//Initialise the CNS client
//use the local NodeID to connect to the CNS
localNodeID = Node.getInstance().getNodeID();
CNS.init(localNodeID);
// creating Channel named "in"
NetChannelInput in = CNS.net2one("in");
//resolve the channel
NetChannelOutput out = CNS.one2net("in");
//could now use these channels for something!!
//but this is only a test so will terminate
} catch (NodeInitFailedException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
Node.log.log(this, "Done."); } }

Channel Factory Methods

In order to construct a ChannelInput object which can be resolved by other users of a channel name server, a client simply needs to to do this:

NetChannelInput in = CNS.net2one("Fred");

Another process using the same channel name server can create a ChannelOutput that will send objects to this channel by do this:

NetChannelOutput out = CNS.one2net("Fred");

When these factory methods are called, various resources are used within the JCSP infrastructure. A channel name will be registered and held in the channel name server. These resources are taken for the duration of the JCSP Node's runtime.

This is an example "Hello World" program which contains two inner classes with main methods, each of which can be run in separate JVMs.

 import org.jcsp.lang.*;
 import org.jcsp.net2.*;
 import org.jcsp.net2.cns.*;
 
 public class TestCNS
 {
     public static class Rx
     {
         public static void main(String[] args)
         {
             try
             {
                 Node.getInstance().init(new TCPIPNodeAddress(7890));
                 NetChannelInput in = CNS.net2one("rx.in");
                 System.out.println(in.read());
             }
             catch (Exception e)
             {
                 e.printStackTrace();
             }
         }
     }
 
     public static class Tx
     {
         public static void main(String[] args)
         {
             try
             {
                 Node.getInstance().init(new TCPIPNodeAddress(7890));
                 NetChannelOutput out = CNS.one2net("rx.in");
                 out.write("Hello World");
             }
             catch (Exception e)
             {
                 e.printStackTrace();
             }
         }
     }
 }
 

This code can be compiled and then the following run at two command prompts:

java TestCNS$Rx

java TestCNS$Tx

The programs will connect to a default channel name server. The Rx program will create a NetChannelInput and wait for a message on the channel. Once it has received the message, it prints it, then terminates. The Tx program creates a NetChannelOutput that will send to the Rx program's input channel. It sends a "Hello World" message. Once this has been accepted by the Rx process, it terminates.

See Also: