GWT RPC from non-servlet-container - finally

Finally, I get to this part after the first and second rounds.

GwtRpc

A Scala module(object) GwtRpc, is created for this RPC purpose, which defines three traits of interest:

• GwtRpcSpp
• RpcService
• SppHolder
  

GwtRpcSpp is a simple trait extending GWT's SerializationPolicyProvider, which declares an abstract method getPolicyFileInputStream:

def getPolicyFileInputStream(moduleBaseUrl:String,
strongName:String):Option[InputStream]

moduleBaseUrl and stringName are two parameters carried by client request of GWT RPC. This method is supposed to be implemented to allow users to hook up their own logic about getting serialize policy file generated by GWT RPC.

RpcService is another simple trait which is supposed to be mixed into entities who is going to be the end-implementations of GWT RPC services.

trait RpcService { this:SppHolder with RemoteService =>

 def call(final in: => String)(handler: PartialFunction[CallResult, Unit])={
   ...
 }
 ...
}

Method call is the main entry of a RpcService implementation, which takes two arguments.

• in - a Call-by-name string: the UTF-8 payload of an RPC request;
• handler - a partial function which is provided by user to match the result of a call and write result back to response

SppHolder is a container of SerializationPolicyProvider. RpcService declares it as a part of its self type annotation which sort of declares a dependency to SppHolder, only the dependency needs to be fulfilled by its implementation.

Actually, this GwtRpc module is container-independent. It can be used in any container which provides IO stream as abstraction of HTTP request.

The Restlet implementation

Cause I (in this series) take more interesting in serving GWT RPC via Restlet, I would give a simple implementation for Restlet environment.

Generally, Restlet allows you to serve a HTTP request via a Restlet or a Resource. As a result, two traits implementations for each of them are provided respectively.

For Restlet:

trait RpcRestlet extends Restlet with RpcService with SppHolder{this:RemoteService=>
 override def handle(req:Request, resp:Response){
   req.getMethod match{
     case Method.POST=>
       call(fromStream(req.getEntity.getStream))(writeRpcResult(resp))
     case _ => // do nothing
   }
 }
}

For Resource:

trait RpcResource extends Resource with RpcService with SppHolder{this:RemoteService=>
 override def acceptRepresentation(rep: Representation){
   call(fromStream(rep.getStream))(writeRpcResult(getResponse)) 
 }
}

fromStream is a method to read payload from an InputStream. This payload is simple a UTF-8 string and will be decoded to an instance of RpcRequest by GWT's RPC.decodeRequest(String).

writeRpcResult is a functional variable, which takes a Response as argument and returns a PartialFunction:

val writeRpcResult: Response=>PartialFunction[CallStatus, Unit] = {r=>{
  case CallSuc(msg)=>
    val rep = new StringRepresentation(msg, MediaType.APPLICATION_JSON)
    rep.setCharacterSet(CharacterSet.UTF_8)
    rep.setDownloadable(true)
    rep.setDownloadName("attachment")
    r.setEntity(rep)
    r.setStatus(Status.SUCCESS_OK)
  case CallFail(msg)=>
    r.setEntity(new StringRepresentation(msg, MediaType.TEXT_PLAIN))
    r.setStatus(Status.SERVER_ERROR_INTERNAL)
}
}

To create an implementation of GWT RemoteService, just do almost same thing as in GWT but change the parent class to either one of above. For example:

abstract class PingServiceImpl extends RpcRestlet with PingService with SppHolder{
def ping(msg:String)={
  "Pong-> " + msg + "@" + new Date
}
}

PingServiceImpl is still abstract, because its dependency to SerializationPolicyProvider has not been fulfilled. To make thing simple, I reuse the App created in last installment as the base and make it a SerializationPolicyProvider for the whole Application scope.

The implementation looks like following code, using Directory gwtDir is a lazy way here.

class App extends Application with GwtApp with GwtRpcSpp{self=>
def getPolicyFileInputStream(moduleBaseUrl:String,
                            strongName:String):Option[InputStream]={
  val ref = new Reference(moduleBaseUrl)
  val response = gwtDir.get(ref.getLastSegment+"/"+getPolicyFileName(strongName))
  if(Status.SUCCESS_OK == response.getStatus)
    Some(response.getEntity.getStream)
  else
    None
}
}

Finally attach ping service to the router of this application and specify the SppHolder dependency:

override def createRoot={
//...
r.attach("/ping", new PingServiceImpl{
 def provider = self
})
//...
}

There is no need to change code of GWT client, just let ping service call endpoint http://localhost:8080/ping will done.

For complete source code of this sample, see http://edgebox.googlecode.com/svn/sandbox/gwt-restlet-demo/.