Introduction
Native operating systems such as Linux provide a rich set of tools that perform specific functions.
By using pipelines (created using the symbol "|") these tools can be combined
in computations steps to perform a wide range of processing tasks.
NetKernel inherently supports the pipeline processing model for processing resource types
with services provided by resource models.
NetKernel also allows you to reach out to the hosting native operating system and
leverage its set of native tools.
This tutorial provides a brief introduction to the techniques for using native operating
system tools in a NetKernel application.
While NetKernel applications can run on any operating system that supports Java, if you
use the techniques shown in this tutorial, you will be coupling your application to a
specific operating system.
- Part1 demonstrates a pipeline of native operating system tools
- Part2 demonstrates exposing a native tool as a NetKernel service
Native process pipelines are built using the exec
accessor.
A Native Process Viewer
This example creates a service which shows the currently executing native processes running
on your operating system.
The service executes the native utility top and passes the output to
awk for conversion into XML and then is finally transformed into XHTML using
the active:xslt service.
If you are running Unix or Linux (sorry, this does not work on OS X nor Windows),
try this demo.
The DPML script is shown below
(note: the awk and perl scripts are contained in CDATA sections and so appear
escaped when viewed in a browser - the xml source is available here)
<idoc>
<seq>
<comment>
************************************************************
A DPML script which pipelines top into an awk script to
generate XML which is then styled to an interactive XHTML
process table.
(C) 2004, 1060 Research Limited
************************************************************
</comment>
<comment>
**********
Execute top to get the current process data
**********
</comment>
<instr>
<type>exec</type>
<command>
<args>
<arg>top</arg>
<arg>-b -n 1</arg>
</args>
</command>
<param>
<exec>
<!---->
<ignoreReturnCode />
</exec>
</param>
<target>var:pipeline</target>
</instr>
<comment>
**********
Execute an awk script on the pipeline stream to generate XML
**********
</comment>
<instr>
<type>exec</type>
<stdin>var:pipeline</stdin>
<command>
<args>
<arg>awk</arg>
<arg>
BEGIN { print "<ps>" ; FS = " "; }
{ line++;
if(line>7 && NF > 1)
{ print "<process>";
print "<pid>"; print $1; print "</pid>";
print "<owner>"; print $2; print "</owner>";
print "<cpu>"; print $9; print "</cpu>";
print "<memory>"; print $10; print "</memory>";
print "<time>"; print $11; print "</time>";
print "<name>"; print $12; print "</name>";
print "</process>";
}
}
END { print "</ps>" ; }
</arg>
</args>
</command>
<param>
<mimetype>text/xml</mimetype>
</param>
<target>var:pipeline</target>
</instr>
<comment>
**********
Style the pipeline result. Note: like SAX, this is where all
the action occurs. The value of var:pipeline is needed by the XSLT
accessor and so the pipeline is transparently evaluated in a
single continuous pipelined process execution. The two earlier
steps built the pipe but it is only run just-in-time on demand.
**********
</comment>
<instr>
<type>xslt</type>
<operand>var:pipeline</operand>
<operator>style_ps.xsl</operator>
<param>this:param</param>
<target>this:response</target>
</instr>
</seq>
<comment>
****************************************************************
If you prefer, here's how to do the XML generation with Perl...
****************************************************************
<instr>
<type>exec</type>
<command>
<args>
<arg>perl</arg>
<arg>-W -e</arg>
<arg>
$[ = 1; # set array base to 1
$, = ' '; # set output field separator
$\ = "\n"; # set output record separator
print '<ps>';
while (<>) {
chomp; # strip record separator
@Fld = split(/[ \n]/, $_, 9999);
$line++;
if ($line > 7 && $#Fld > 1) {
print '<process>';
print '<name>';
print $Fld[12];
print '</name>';
print '<pid>';
print $Fld[1];
print '</pid>';
print '<owner>';
print $Fld[2];
print '</owner>';
print '<time>';
print $Fld[11];
print '</time>';
print '</process>';
}
}
print '</ps>';
</arg>
</args>
</command>
<stdin>this:response</stdin>
<param>
<mimetype>text/plain</mimetype>
</param>
<target>this:response</target>
</instr>
****************************************************************
End Comment
****************************************************************
</comment>
</idoc>
Expose a native tool as a NetKernel accessor
This example creates a search and replace service using the native
operating system sed streaming editor.
The accessor script accepts two parameters, operator
and operand.
The argument passed as operand is resource to be searched and the
argument passed as operator is search-replace configuration information.
The service is is exported using the URI address:
active:trailmap_search_replace+operand@[resource to be searched]+operator@[search/replace config]
If you are running NetKernel on Unix, Linux or OS X,
try this demo.
The demo searches the King Lear XML document and replaces all occurrences of "LEAR" with "KONG".
A RESTful interface will allow you to experiment with this service.
Run
the RESTful example and modify the URL query parameters to change the request.
The DPML source for the service is shown below - it uses XSLT to dynamically generate command line arguments for sed from the operator argument.
The exec accessor then streams the file argument as stdin to sed which performs the search and replace.
<idoc>
<seq>
<comment>
************************************************************
A DPML script which searches and replaces the content of
any file (including XML). Takes an "operator" argument
of the form...
<search>
<find>term</find>
<replace>replacement</replace>
</search>
"file" argument is the file to be search/replaced
(C) 2004, 1060 Research Limited
************************************************************
</comment>
<comment>
**********
Dynamically create sed arguments
**********
</comment>
<instr>
<type>xslt</type>
<operand>this:param:operator</operand>
<operator>
<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
<xsl:output method="xml" />
<xsl:template match="/*">
<args>
<arg>sed</arg>
<arg>s/
<xsl:value-of select="find" />/
<xsl:value-of select="replace" />/g
</arg>
</args>
</xsl:template>
</xsl:stylesheet>
</operator>
<target>var:args</target>
</instr>
<comment>
***********
Execute sed and return the result
***********
</comment>
<instr>
<type>exec</type>
<stdin>this:param:file</stdin>
<command>var:args</command>
<param>
<mimetype>content/unknown</mimetype>
</param>
<target>this:response</target>
</instr>
</seq>
</idoc>
Exporting as a Service
To export this service add the following entry to your module export section:
<export>
...
<match>active:trailmap_search_replace.*</match>
...
</export>
If the script is in the resource ffcpl:/resources/search.idoc
add the following entry to associate it with the DPML runtime:
<rewrite>
...
<rule>
<match>active:trailmap_search_replace(.*)</match>
<to>active:dpml+operand@ffcpl:/resources/search.idoc$1</to>
</rule>
...
</rewrite>
Tutorial Introduction
Fundamentals
Practicalites
Pipeline Processing
