Deconstructing the Topic Application Channel

Lets look in detail at one channel - the ffcpl:/forum/topic/[topic-id]/[page] interface. You will recall that in the public web application this serves a paginated view of a topic. The interface expects a [topic-id] and an optional [page].

The following rewrite rule captures all possible topic requests and maps them to an active URI which is the execution in the beanshell runtime of the script ffcpl:/main/forum/topic/topic-viewer.bsh. Note that the original URI is captured and appended as an active URI argument named 'uri'...

The mapping of a URI space to an executable code point is very common and is called the 'mapper pattern'.

The topic-viewer.bsh beanshell script can found in the /main/forum/topic/ directory of the expanded forum-web module. It is shown in full below...

/**********
(C) 2005, 1060 Research Limited. All rights reserved.
Licensed under the 1060 Public License v1.0 - http://www.1060research.com/license
1060 is a registered trademark of 1060 Research Ltd.
***********/

import org.ten60.netkernel.layer1.representation.*;
import com.ten60.netkernel.urii.aspect.*;

//Import URL Parser Library Script
parserLibrary = "url-parser.bsh";
i=new bsh.Interpreter();
i.setNameSpace(this.namespace);
i.eval( context.sourceAspect( parserLibrary, IAspectString.class ).getString() );

//Global - set by parseURL()
page=null;

//Topic viewer
void main()
{
    //Retrieve path-based URI from REST interface request
    //this has the structure: ffcpl:/forum/topic/[topic]/[page]
    uri=context.getThisRequest().getArgument("uri");

    StringAspect nvp=parseURL(uri);
    
    if(!page.equals("last"))
    {   //Asynchronously count the hit
        req=context.createSubRequest();
        req.setURI("ffcpl:/forum-main-logHit");
        req.addArgument("param", nvp);
        context.issueAsyncSubRequest(req);
    }
    
    //Call Inner Topic Viewer
    req=context.createSubRequest();
    req.setURI("active:beanshell");
    req.addArgument("operator","topic-viewer-inner.bsh");
    req.addArgument("uri", uri);
    result=context.issueSubRequest(req);

    //Return Response - this response is not cached - we want to keep counting hits.
    resp=context.createResponseFrom(result);
    context.setResponse(resp);

}

                    

Before we dive into this script let's review where we are. We have shown that the application is composed from a set of linearly independent channels. Each channel is presented as an interface on the forum-web module. Within the module each interface is made concrete by mapping an address space to the execution of a script to fulfill the request.

If you examine the application's other channels you will see they each conform to this uniform design pattern. This pattern is convenient in this instance though it is not unique. The key point to take away is that the layered URI composition approach to developing an application ensures that a single uniform mental model can be brought to bear on a diverse range of applications. Ultimately this makes development, maintenance and refactoring very easy.