Introduction

NetKernel has a fully asynchronous architecture which allows many concurrent processes to execute simultaneously. In general it is only necessary to write synchronous processes which defer to the kernel to optimize and manage scheduling and thread allocation. However occasionally, such as with high-latency requests to remote systems or requests for which your current process doesn't require a response, it can be valuable to explicitly indicate to the kernel that a service should be invoked asynchronously (ie in parallel with a parent process).

Service Specification

We will create a service which asynchronously calls a time-delayed echo service. The calling process will record the time at which the asynchronous request is issued. Whilst the asynchronous request is being processed the parent process will create a result document, it will then join with the asynchronous process to retrieve its result. Finally the duration of the sub-process and it's echoed response will be added to the result document.

We will show two solutions to this specification. The first is a Beanshell scripted solution using the NetKernel Foundation API. The second is a DPML process using the async and join accessors.

The delayed-echo service (shown below) is implemented in DPML and simply returns the parameter argument it receives after a delay of 3-seconds.

You can try the NKF solution here. The DPML solution can be tried here.

NKF Solution

Below is a solution implemented in beanshell and using the NKF API - the Java comments describe in detail each part of the process.

import org.ten60.netkernel.xml.xda.*;
import org.ten60.netkernel.xml.representation.*;
import org.ten60.netkernel.xml.util.*;
import org.ten60.netkernel.layer1.representation.*;
import org.ten60.netkernel.layer1.nkf.*;
import org.ten60.netkernel.layer1.nkf.impl.*;
import java.io.*;

void main()
    {   //Create a simple message XML doc
        message=new StringAspect("<message>Are your receiving? Over.</message>");
                
        //Create a request to invoke the delayed-echo service
        req=context.createSubRequest();
        req.setURI("active:dpml");
        req.addArgument("operand", "delayed-echo.idoc");
        req.addArgument("param", message);
        req.setAspectClass(IXAspect.class);

        //Get current time
        t1=System.currentTimeMillis();
        
        //Issue asynchronous request - non-blocking returns immediately
        handle=context.issueAsyncSubRequest(req);
        
        //In the mean time prepare the partially completed response document
        sr=new StringReader("<results><issued><start>"+ t1+
         "</start>"+message.getString()+ "</issued><returned></returned></results>");
        dxda=new DOMXDA( XMLUtils.getInstance().parse(sr), false );
        
        //Join with the asynch process
        echoresult=handle.join();

        //Get current time
        t2=System.currentTimeMillis();

        //Finally process the results document
        dxda.appendPath("/results/returned", "duration", ""+(t2-t1) );
        erxa=(IXAspect)echoresult.getAspect(IXAspect.class);
        dxda.append(erxa.getXDA(), "/", "/results/returned");

        //Create response
        dxaa=new DOMXDAAspect(dxda);
        resp=context.createResponseFrom(dxaa);
        resp.setMimeType("text/xml");
        resp.setExpired();

        //Issue response
        context.setResponse(resp);
    }

DPML Solution

Below is a solution implemented in DPML using the async and join accessors - the comments describe in detail each part of the process.

Delayed Echo Service

Below is a simple delayed echo service implemented in DPML.

Deployment

You can experiment further with asynchronous processes by copying these examples to a new module created with the wizard (remember to choose DPML and scripting support).