Agenda

• Introduce JavaSpaces
• Describe entries
• Walk through the JavaSpace interface
• Discuss uses of JavaSpaces
• Show a distributed array

---

JavaSpace Service

• JavaSpace: a place on the network to exchange and store objects
• A tuple-space inspired by David Gelernter's Linda
• Operates as a Jini service
• Uses Jini programming model: leasing, events, transactions
• For distributed persistence and algorithms

---

The JavaSpace Interface

• Interact with a space via JavaSpace interface
• No wire protocol specified
• Can get the JavaSpace object from a Jini lookup service, RMI registry, ...

---

Four Operations

• Holds entries: typed groups of objects
• write - stores a copy of an entry
• read - returns an entry or indicates no match
• take - reads and removes
• notify - registers interest in match event
• Entries are leased while in the space
• Transactions supported

---

Entries

• An entry is an object
• Each entry is a typed collection of other objects
• Each distinct set of objects gets an entry class
• An entry class follows three rules:
  • Implements net.jini.core.entry.Entry (which extends java.io.Serializable)
  • All fields must be public (except static, final, or transient fields)
  • Must have a public no-arg constructor

---

A ChatMessage Entry

   1 // In file
   2 // JavaSpaces/ex1/com/artima/chat/entry/ChatMessage.java
   3 package com.artima.chat.entry;
   4
   5 import net.jini.entry.AbstractEntry;
   6
   7 public class ChatMessage extends AbstractEntry {
   8
   9     public String chatRoom;
  10     public String author;
  11     public Long position;
  12     public String content;
  13
  14     public ChatMessage() {
  15     }
  16
  17     public ChatMessage(String chatRoom, String author,
  18         Long position, String content) {
  19
  20      this.chatRoom = chatRoom;
  21      this.author = author;
  22      this.position = position;
  23      this.content = content;
  24     }
  25 }

---

Write

    public Lease write(Entry e, Transaction txn, long lease)
        throws TransactionException, SecurityException,
        java.rmi.RemoteException;

• Entries are leased
• Transaction is optional
• Can write duplicate entries into a space

---

Matching

• Look up with template entries
• Entry's class same or subclass of template's
• Fields with values must match exactly
• null fields act as wildcards
• To look for message 19 in chat room "AutumnLeafCafe":

      ChatMessage m = new ChatMessage();
      m.chatRoom = "AutumnLeafCafe";
      m.position = new Long("19");
  

---

Read

  public Entry read(Entry tmpl, Transaction txn, long timeout)
      throws UnusableEntryException, TransactionException,
      SecurityException, InterruptedException,
      java.rmi.RemoteException;

• Timeout 0: wait forever
• Timeout JavaSpace.NO_WAIT: don't wait at all
• Thread blocks while waiting
• If multiple matches, get an arbitrary matching entry

---

ReadIfExists

  public Entry readIfExists(Entry tmpl, Transaction txn,
      long timeout) throws UnusableEntryException,
      TransactionException, SecurityException,
      InterruptedException, java.rmi.RemoteException;

• readIfExists() also reads, but only blocks if waiting for a transactional state to settle

---

Take and TakeIfExists

  public Entry take(Entry tmpl, Transaction txn, long timeout)
      throws UnusableEntryException, TransactionException,
      SecurityException, InterruptedException,
      java.rmi.RemoteException;

  public Entry takeIfExists(Entry tmpl, Transaction txn,
      long timeout) throws UnusableEntryException,
      TransactionException, SecurityException,
      InterruptedException, java.rmi.RemoteException;

• Like corresponding reads, but also removes returned entry

---

Notify

  public EventRegistration notify(Entry tmpl, Transaction txn,
      RemoteEventListener listener, long lease,
      java.rmi.MarshalledObject handback)
      throws TransactionException, SecurityException,
      java.rmi.RemoteException;

• Registers listener as interested in match event

---

How Matching Works

• Each (public, non-static, non-final, non-transient) field is serialized separately
• Two fields one object --> two fields two objects
• To match, compare serialized images (MarshalledObject.equals())
• Semantic equals() not used in matching
• Object images must match exactly; null is wildcard

---

Code Downloading

• Entry is never deserialized by the space
• When a client does a read or take, client deserializes the entry
• If client doesn't have all the class files, can download them
• Semantic equals() not used in matching
• If client Animal matches a Dog, client will actually get a Dog - no type truncation
• Real objects are exchanged - no type truncation

---

JavaSpaces Uses

• Not a file system or object-oriented database
• Persistence: Can store and retrieve objects
• Distributed Algorithms: facilitates "flows of objects"
• Semantic equals() not used in matching
• Good for coordinating processes that want to work together in a loosely coupled way
• By contrast, RPC like making a phone call - need to know phone number, identity, and time

---

JavaRing and Fractal Points

• To calculate colors for each point of a fractal:
• Fill a JavaSpace with Point jobs
• A JavaRing takes one Point
• JavaRing calculates color, writes a PointColor entry to the space
• Server takes PointColors, and records them

---

An Event Mailbox

---

Distributed Arrays

• JavaSpace acts as "shared memory" for distributed processes
• Can create more elaborate "data structures" than just single entries
• Chat messages form a distributed array, where array index stored in position field
• To write a message, first take NextMessageNumber, increment, write back

---

A NextMessageNumber Entry

   1 // In file JavaSpaces/ex1/com/artima/...
   2 //     ...chat/entry/NextMessageNumber.java
   3 package com.artima.chat.entry;
   4
   5 import net.jini.entry.AbstractEntry;
   6
   7 public class NextMessageNumber extends AbstractEntry {
   8
   9     public String chatRoom;
  10     public Long nextMessageNum;
  11
  12     public NextMessageNumber() {
  13     }
  14
  15     public NextMessageNumber(String chatRoom,
  16         Long nextMessageNum) {
  17
  18         this.chatRoom = chatRoom;
  19         this.nextMessageNum = nextMessageNum;
  20     }
  21
  22     public void increment() {
  23         nextMessageNum = new Long(
  24             nextMessageNum.longValue() + 1);
  25     }
  26 }

---

Writing a Chat Message

 1 // Create the template for NextMessageNumber
 2 NextMessageNumber template = new NextMessageNumber(
 3     currentChatRoom, null);
 4
 5 // Create a transaction
 6 Transaction.Created trans = TransactionFactory.create(
 7     transMan, TIME_OUT);
 8
 9 // Renew lease on transaction
10 long expireTime = trans.lease.getExpiration();
11 Date date = new Date();
12 long currentTime = date.getTime();
13 long leaseLen = expireTime - currentTime;
14 if (leaseLen < TIME_OUT) {
15     leaseMan.renewUntil(trans.lease,
16         currentTime + leaseLen, null);
17 }
18
19 // Take the NextMessageNumber entry
20 NextMessageNumber nextMsgNumEntry =
21     (NextMessageNumber) space.take(template,
22     trans.transaction, TIME_OUT);
23
24 // Grab the next message number
25 myMessageNum = nextMsgNumEntry.nextMessageNum;
26
27 // Increment the number in the entry
28 nextMsgNumEntry.increment();
29
30 // Write the incremented number back to the space
31 write(nextMsgNumEntry, trans.transaction, Lease.FOREVER);
32
33 // Create the ChatMessage entry using the message number
34 ChatMessage msgEntry = new ChatMessage(currentChatRoom,
35     userName, myMessageNum, message);
36
37 // Write the chat message to the space
38 space.write(msgEntry, null, MESSAGE_LEASE_LENGTH);
39
40 // Commit the transaction
41 trans.transaction.commit();

---

Project: Designing Entries for a Chat Service

Design Entry classes for a chat service. The chat service should have the following features:

1. The JavaSpace can contain multiple named chat rooms. Each chat room should have a unique name.
2. Each room can contain multiple users. Each user should be in only one room at any one time.
3. Every user's name is unique across the entire JavaSpace.
4. Users can post a message to the current room.
5. Users can change rooms.
6. Clients can get a list of all current chat rooms in existence.
7. Clients can get a list of all users in a particular chat room.
8. Clients should have some way of finding out when a new user arrives in the current room, or a user already in the current room leaves the room.
9. Users that disappear from the network should eventually be automatically removed from their current room.
10. Messages should be automatically removed from the space after a period of time.
11. Rooms that have been empty (no users) for a while should be automatically removed from the space.

What you will be doing here is basically data model design, not object-oriented design. Even though JavaSpace entries are objects, because their fields are public, entries feel more like C structs or XML documents than objects in a typical object-oriented system. What you will be designing is the implementation of a Jini chat service object, not the interface. When a client invokes methods on the interface of chat service object, it will read, write, and take entries from the JavaSpace.