Upload
muriel-gilbert
View
215
Download
2
Embed Size (px)
Citation preview
IBM TSpacesLab 1
Introduction
Summary
TSpaces Overview Basic Definitions Basic primitive operations Reading/writing tuples in tuplespace HelloWorld program Installing TSpaces Compiling/running programs in TSpaces
TSpaces Overview
TSpaces is a Java implementation of the Linda coordination model. It enables communication between applications and devices in a network of heterogeneous computers and operating systems.
Basic Definitions
Field– Most basic component of Tuplespace data
structure. It contains: Type (i.e. "java.lang.String" or
"com.company.appl.EmployeeObject") Value Field Name (optional): Specifying a field name implies
that this field will be indexed (and searched).
Basic Definitions (2)
Tuple– A Tuple object is an ordered sequence of Fields. – Implemented by SuperTuple class (abstract
class)– Clients should create objects of either Tuple or
SubclassableTuple classes. – A template tuple is a Tuple that is used for
matching. One or more of the Fields in a template may be "wildcards" and consist of only the class type with no value.
Basic Definitions (3)
TupleSpace– A class implementing a space where tuples can be
added/removed– It is stored and administered across a network on one or
more "TSpace Servers“. A TSpace server may contain many Tuplespaces.
– Several threads on the same or different machines can be accessing the space simultaneously.
– For each different TupleSpace a client wishes to access, it requires a separate instance of this class, even if they are managed by the same server.
– In order to obtain an instance of a specific tuplespace you need the name of the space, and the name of a server that manages that space.
Basic primitive operations
write ( tuple ): Adds a tuple to the space. take( template_tuple ): Searches for a tuple that
matches the template. When found, the tuple is removed from the space and returned. If none is found, returns null.
waitToTake(template_tuple ): Searches for a tuple that matches the template. Blocks until match is found. Removes and returns the matched tuple from the space.
read( template_tuple ): Like "take" above, except that the tuple is not removed from the tuple space.
Basic primitive operations (2)
waitToRead( template_tuple ): Like "waitToTake" above, except that the tuple is not removed from the tuple space.
scan( template_tuple ): Like "read" above, except that it returns the entire set of tuples that match.
countN( template_tuple ): Like "scan" above, except that it returns the number of matching tuples rather than the set of tuples itself.
There are also numerous other more specializedcommands and there is an ability to define your own specialized commands.
Reading and writing tuples
Step 1: Create a new tuplespace or get access to an already created tuplespace String host = "tserver1.company.com"; ... TupleSpace ts = new TupleSpace("Example1",host);
The above will contact the TSpaces server that is running on a machine with hostname "tserver1.company.com" and return a handle to the TupleSpace that is named "Example1". If the "Example1" TupleSpace does not exist, it will be created at this time.
Reading and writing tuples (2)
Step 2: Create and write tuples to tuplespace
Tuple t1 = new Tuple("Key1","Data1"); ts.write(t1); Tuple t2 = new Tuple("Key2",new
Integer(999),"Data2"); ts.write(t2); Tuple t3 = new Tuple("Key2","Data3"); ts.write(t3);
The above will create and write 3 Tuples to the TupleSpace allocated previously. Tuples can contain any number and any type of fields.
Reading and writing tuples (3)
Other ways to create and write a tuple are the
following: Field f1 = new Field("Key1"); Field f2 = new Field("Data1"); Tuple t1 = new Tuple(); t1.add(f1); t1.add(f2); ts.write(t1); -or- ts.write("Key1","Data1"); .
Reading and writing tuples (4)
Step 3: Reading tuples from tuplespace
In order to read a tuple you must create a template Tuple. Template Tuple is a Tuple that is used to select matching Tuples. It will contain 0 or more Fields that are either Actual Fields or Formal Fields. Actual fields have a value that must be matched exactly
against the corresponding Fields in the tuples that are in the TupleSpace.
Formal fields have a class but no value and only describe the type of value that is to be returned. Basically they act as wildcards.
Reading and writing tuples (5)
Tuple template = new Tuple("Key2", new Field(String.class)); Tuple tuple = ts.read(template); String data = (String)tuple.getField(1).getValue();
The above code creates a template that matches any tuple having two fields of type String. The first field must contain the value "Key2". The second field can match any field of String type. In order to read the matching Tuples from Tuplespace we use the command read. The command take can also be used but it will remove the matching Tuples from the TupleSpace database and return it to the caller.
HelloWorld Example
import com.ibm.tspaces.*;import java.io.Serializable;public class HelloWorld { public static void main(String[] args) { String myName = "World"; boolean needReply = false; if ( args.length > 0) myName = args[0]; try { TupleSpace space = new TupleSpace(); Tuple template = new Tuple(myName, new Field(String.class),new Field(Serializable.class));
HelloWorld Example (2)
System.out.println("Checking for message in tuplespace...");Tuple msg = space.take(template); if ( msg == null) { System.out.println("No message for me!\n Sending message to World..."); msg = new Tuple("World", myName,"Hello World"); needReply = true; space.write(msg); } else {
System.out.println("Message received is: "+ msg); System.out.println("Sending reply message to : "+ (String)msg.getField(1).getValue());
HelloWorld Example (3)
msg = new Tuple((String)msg.getField(1).getValue(),myName,"Hi");
space.write(msg); } if (needReply) { // Wait for a reply
System.out.println("Waiting for reply ..."); msg = space.waitToTake(template);
System.out.println("Message received is: "+msg); } } catch (Exception e) { System.out.println(e); } }}
Installing Tspaces
Download TSpaces package (tspaces212.zip) from here
Unzip package to a directory tspaces Exit to dos command window and change directory
to tspaces In order to start a TSpaces Server execute
command: bin\tspacesIf server is started successfully the prompt TSServer:> is appeared
In order to stop the TSpaces Server execute command exit
Compiling/running programs
In order to compile and run TSpaces programs you need to include the jar files tspaces_client.jar and tspaces.jar in your CLASSPATH. These files are located in the tspaces_dir\lib (where tspaces_dir is the path to the directory where TSpaces is installed).
Compile: javac -classpath .;tspaces_dir\lib\tspaces_client.jar;
tspaces_dir\lib\tspaces.jar yourfile.java Run: java -cp .;tspaces_dir\lib\tspaces_client.jar;
tspaces_dir\lib\tspaces.jar yourfile
Replace tspaces_dir with the path to the directory where TSpaces is installed.
Compile and run the HelloWorld Example
HTTP Server Interface
The TSpaces Server contains a light built-in HTTP Server. You can use this interface to determine the status of TSpaces or obtain debug information.
In order to obtain this information access HTTP server at http://hostname:8201/debug where hostname is the name of the machine that TSpaces server runs.