How lift uses Scala actors

Two of lift's important features are full Comet support and Ask/Answer where components can delegate display and user input to another component until a user has satisfied certain input criteria. lift uses Scala Actors to implement both these features.

You can see an example of Ask/Answer by going to http://liftweb.net/lift. The "group chat" box is an example of Ask/Answer. The chat app asks for the name and when the user has entered their name, the chat app displays the current chat. The chat app (and the clock) are examples of Comet. They are updated immediately when state on the server changes.

Each time a new web session is created, lift creates a "Session" actor. All HTTP requests (except those for static files such as images) are forwarded to the Session Actor and the servlet waits for a response from the Session. The servlet times out the request (10 seconds for normal requests and 120 seconds for AJAX requests) if it does not receive a response from the Session.

The Session uses the URI to determine the template to load. The Session loads the template and resolves the template (by processing the embed, surround, and "snippet" tags.) If the loaded template does not contain a reference to a "controller", the rendered XHTML is sent back to the servlet which returns it to the browser.

If you've got a page with a controller, the Session will retrieve/create a Page Actor and forward the template and request on to the Page. For each controller on the Page (clock and chat in the example), the Page locates the Controller Actor using the Controller factory Actor (one factory for each session).

For non-AJAX requests, the Page sends a message to each Controller containing an XHTML segment for the "view" and awaits a "future". After 600 milliseconds the responses (or a default response) is inserted into the return value and the composed page is returned.

For AJAX requests, if the Page has not been notified of updates, it waits (for up to 110 seconds) for one of the controllers to notify the page of a change. If no changes are sent to the Page, the Page tells the Session "no-op" and the Session returns a "null" JavaScript snippet.

If any of the Controller Actors render updates, the Page packages the update as JavaScript which changes the HTML in the DOM segment that represents the controller and that update is sent back to the browser. An example of this is the Clock which updates every 10 seconds.

The Controller can update asynchronously and sends messages to all the Pages that contain the Controller. Thus, when a 10 second "ping" comes into the Clock controller, it tells the Page to update and when a new Chat message comes in, the Chat app updates the Page.

Here's the code to implement the Clock controller:

class Clock extends ControllerActor {

  ActorPing.schedule(this, Tick, 10000L) // schedule a ping every 10 seconds so we redraw

  def render = bind("time" -> Text(timeNow.toString))

  override def lowPriority : PartialFunction[Any, Unit] = {
    case Tick =>
    reRender // tell the component to redraw itself
    ActorPing.schedule(this, Tick, 10000L) // schedule an update in 10 seconds
  }
}

The "reRender" method renders the Controller and sends the update to all Page Actors that the Controller exists on.