IBM TSpacesLab 2

Customizing tuples

and fields

Summary

Blocking commands Tuple Expiration Extending Tuples (The SubclassableTuple) Reading/writing user defined objects in

tuplespace

Blocking commands

When an application issues a WaitToRead or WaitToTake call, and the data is not yet there on the server, the application blocks on the call until an answer is returned. When a tuple arrives on the server that matches the Read or Take query, it is sent to the client and the application resumes.

As an example, assume that in a client running on machine1,

you had the following code: try {

TupleSpace ts = new TupleSpace("Example",host); Tuple answer = ts.waitToTake("3",new

Field(String.class)); ... } catch(TupleSpaceException tse) { System.out.println("TupleSpace Exception: " + tse.getMessage()); }

Blocking commands (2)

And assume that in a client running on machine2, you had the

following code: try {

TupleSpace ts = new TupleSpace("Example",host); ts.write("1","Data1"); Thread.sleep(5000); ts.write("2","Data2"); Thread.sleep(5000); ts.write("3","Data3"); } catch(TupleSpaceException tse) { System.out.println("TupleSpace Exception: " + tse.getMessage()); }

Assuming that the applications started at the same time, the

application on machine1 would issue the waitToTake and then be

blocked. However, about 10 seconds later as soon as the

Blocking commands (3)

matching Tuple arrived at the server, the server would send it to

machine1 which would unblock and process the matching Tuple.

The default for blocking commands is to wait forever. However one can

specify an optional timeout parameter to specify that if the operation has

not be satisfied when the time limit is exceeded, then the waiting

operation should be terminated and the null should be returned. So if we

wanted to only wait for 60 seconds, then the code above would now look

like the following:

Blocking commands (4)

try { TupleSpace ts = new TupleSpace("Example",host); Tuple template = new Tuple( "3",new

Field(String.class)); Tuple answer = ts.waitToTake(template,60*1000)); if (answer == null) {

System.out.println("Operation timed out"); ...

} } catch(TupleSpaceException tse) {

System.out.println("TupleSpace Exception: " + tse.getMessage());

}

Tuple Expiration

Normally when a client writes a tuple to a space it will stay in the space until some client does a take or delete for the Tuple. However one can specify an expiration time value for the Tuple so that after the time expires, the Tuple will be automatically deleted from the space.

Tuple myTuple = new Tuple("Hello","World"); myTuple.setExpire(5*60*1000); // expire in 5 minutes ts.write(myTuple);Tuple result = ts.read(myTuple); //will return myTuple Thread.sleep(6*60*1000); result = ts.read(myTuple); // will return null

Extending Tuples

The Tuple class is declared final and cannot be subclassed. An alternative to Tuple is the SubclassableTuple class which can be subclassed (extended).

Advantages of defining your own tuples:– You can make constructors for easiest creation of templates

template=new MyTuple(key)instead oftemplate= new Tuple(key,new Field(String.class))

– You can create methods for easy retrieval of tuple datadata=mytuple.getData()instead ofdata= (String) tuple.getField(1).getValue

Extending Tuples (2)

Advantages of defining your own tuples (cont):– You can include your own validity checks on the fields of

your tuple so that applications cannot write invalid tuples

i.e. check that the “age” field of your tuple is always a positive number

Disadvantages of defining your own tuples:– The same version of our tuple definition (MyTuple.class)

must be available to both the clients using this kind of tuples and the TSpace Server.

Extending Tuples (3)

class MyTuple extends SubclassableTuple {

public MyTuple(String key,String data) { super(key,data);

}

public MyTuple(String key) { // build a template if only one operand super(key,new Field(String.class));

} public String getData() throws TupleSpaceException {

return (String)this.getField(1).getValue(); }

}

Reading/writing user defined objects

Beside the basic Java types like String and Integer, any Java object can be placed in a Tuple and written to TSpaces.

However, these objects must obey to the following restrictions:

– The object must be Serializable (implement the Serializable intarface).

– An equivalent class file for the object must be available to both the clients and the TSpaces server. (As we will see later, this restriction can be avoided).

Reading/writing user defined objects(2)

UserObj obj = new UserObj("User Object 1"); Field f = new Field(obj);

ts.write("Key1",f);

obj = new UserObj("User Object 2"); f.setValue(obj); ts.write("Key2",f);

Tuple template = new Tuple("Key2",new Field(UserObj.class)); Tuple mytuple = ts.take(template); UserObj objreturned = (UserObj) mytuple.getField(1).getValue();

System.out.println("Object content is:“ + objreturned.getData());

Reading/writing user defined objects(3)

Defining the user object:class UserObj implements Serializable {

String userdata;

public String getData() { return userdata; } public boolean equals( Object other ) { if ( (other == null)|| !(other instanceof UserObj) )

return false; if ( userdata == null )

return ( ((UserObj)other).getData() == null); return userdata.equals(((UserObj)other).getData()); } // end equals()} //end class

Reading/writing user defined objects(4)

The things to note in this definition are: The class is declared to implement Serializable. An equals() method has been added. This is

required if you plan to use the object as a search field in a template. The equals() method will override the Object.equals(Object other) method. This method will be invoked on the server to match a supplied template to the instances of UserObj that are in the TupleSpace. You should be careful to handle all the possible cases such as null values.

Reading/writing user defined objects(5)

Using FieldPS In many cases, it is not feasible to ensure that the class definition for a

client defined object be available in the TSpaces server. The best way to bypass this problem is to serialize the object into a

byte array prior to sending it to the server and just send the server a field that is defined as byte[].

The FieldPS object is designed to do this Field Pre Serialization.

FieldPS is a subclass of Field and acts like a Field object except when

handed an Object, it automatically serializes it into a byte[] object and

stores that. When requested to return the value of the Field, it

automatically returns the deserialized value.

Reading/writing user defined objects(6)

Using FieldPS

UserObj obj = new UserObj("User Object 1"); FieldPS f2 = new FieldPS(obj); // changedts.write("Key1",f2);

obj = new UserObj("User Object 2"); f2.setValue(obj); ts.write("Key2",f2);

Tuple template= new Tuple("Key2", new FieldPS(UserObj.class)); //changed

Tuple mytuple = ts.take(template); UserObj objreturned =

(UserObj) mytuple.getField(1).getValue();

System.out.println("Object content is:“ + objreturned.getData());

Download examples from here