Each PageBox on the ring acts as a station.

More than one token may be active on the ring at the same time. The number of tokens is determined by a refresh time. Because there may be more than one token the ring size is not limited.

The Deploy and RepoQuery Web services are used for networking.

The PageBox API allows Web applications to register on the ring:

• The Web application must implement a Receiver callback interface

• The Web application can insert data to the ring with a send method

A frame contains a token and a set of messages.

A message contains:

• The Web application name

• The origin PageBox

• The target PageBox or a broadcast address

• Data sent by the Web application on the origin PageBox

• In case of broadcast, the return code of the Web application instances that have already processed the message

The message is uniquely identified by the application name, the origin and target PageBox and a frame sequence number.

The message set is represented by a HashMap whose keys are Web application names and values are linked lists of messages. A message is represented by a TokenMsg class defined like this:

Where:

• origin is the URL of the Deploy Web service of the origin PageBox

• target is the URL of the Deploy Web service of the target PageBox or null in case of broadcast

• data is the payload

• codes is a map whose keys are PageBox URLs and values are Web application return codes

A message remains on the frame up to the time it is received by the sending Web application.

When it receives a frame a PageBox enumerates the Web applications in the received HashMap. When the Web application registered a callback class with the PageBox API the PageBox calls the callback class. Then the PageBox adds the return code of the callback method to the codes LinkedList if the code is not null. If the message was a message with a target the PageBox nullifies the payload.

The PageBox API implements the send method in the following way:

• Queues the payload. [If send is called in the callback method queuing is not needed.]

• When the token is received dequeues the payload and inserts a message in the frame

• When the token comes back removes the message from the frame and returns the codes map

The send can be implemented either in asynchronous mode (the send method provides a callback class and returns when the payload is queued) or in synchroneous mode (the send waits up to the time the token comes back).

In a token ring network a station is connected to two stations, the station from where frames are sent and the station to which the considered station sends frames. In a PageBox constellation such hardware connections don't exist.

The Repository that knows the URLs of subscribed PageBoxes orders this list in an adjacency list and acts as the ring controller.

The Repository generates token frames that include an empty message map and this adjacency list. The Repository sends a token frame to the first station in the adjacency list. The first station may fill the message map and sends the updated frame to the second station in the adjacency list and so on. When the last station in the adjacency list receives the frame it sends the updated frame to the Repository.

The frameSend method is defined on a TokenIF interface defined like this:

Where:

• nb is the frame number

• adjacencyList is the adjacency list

• msgMap is the message HashMap

The DeployIF and RepoQueryIF interfaces implement the TokenIF interface.

When a first Web application registers on the ring the PageBox calls a tokenRegister method of the RepoQuery Web service. Then the Repository adds the PageBox to the adjacency list.

To the opposite of a token ring network case a station get notified when it is unable to contact the next station. In that case the station (1) removes the failing station from the adjacency list (2) sends the updated frame to the next station in the adjacency list (3) calls a tokenUnregister method of the RepoQuery web service of the Repository to unregister the failed station.

A station may be able to receive a frame and not be able to send the updated frame to the next station. In that case the next station doesn't receive a token before last_token_reception_time + refresh_time. In this case the next station checks if the Repository is alive. If it is alive it does nothing, the Repository being responsible for generating new tokens. If the Repository is dead there is a problem: more than one station probably detect that they did not receive the token. So stations issue the new token after a random amount of time. The first station to issue the new token wins.

When a station is no longer able to process frames messages where this station is the destination are removed from the message HashMap. This action is performed by a station when the next station returns an error or when the previous station failed to send a frame.

Once a station has received a frame it has an adjacency list, can contact neighbors stations and update adjacency lists.

The Repository is the point where stations can be inserted on the ring. The failure of the Repository doesn't prevent the ring to run but it prevents the ring to accept new stations.

A ring failure can be detected either by the last station on the ring (frameSend failure) or by the first station on the ring (timeout). The station that detects the failure updates the frame status. Each time it receives again the frame the station before the Repository calls the frameSend method of the RepoQuery Web service. When the Repository is up again it rebuilds its adjacency list and manage again frames.

Contact:support@pagebox.net
©2002-2004 Alexis Grandemange. Last modified .