Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
Browse files

Improve "make dist" remove generated doc from repo.

  • Loading branch information...
commit bf0d278a4501b03e74d9e02309d667af2182c2a3 1 parent 861f28f
@ry ry authored
View
3  .gitignore
@@ -3,5 +3,8 @@ build
tags
.lock-wscript
*.pyc
+doc/api.xml
+doc/api.html
+doc/node.1
node
node_g
View
26 Makefile
@@ -14,10 +14,10 @@ install:
uninstall:
@tools/waf-light uninstall
-
+
test: all
python tools/test.py --mode=release
-
+
test-all: all
python tools/test.py --mode=debug,release
@@ -40,26 +40,34 @@ doc/api.xml: doc/api.txt
asciidoc -b docbook -d manpage -o doc/api.xml doc/api.txt
doc/node.1: doc/api.xml
- xsltproc --output doc/node.1 \
- --nonet /etc/asciidoc/docbook-xsl/manpage.xsl \
- doc/api.xml
+ xsltproc --output doc/node.1 --nonet doc/manpage.xsl doc/api.xml
website-upload: doc
scp doc/* linode:~/tinyclouds/node/
clean:
+ @-rm doc/node.1 doc/api.xml doc/api.html
@tools/waf-light clean
distclean:
@tools/waf-light distclean
- @-rm -rf _build_
- @-rm -f Makefile
@-rm -f *.pyc
check:
@tools/waf-light check
-dist:
- @tools/waf-light dist
+VERSION=$(shell git-describe)
+TARNAME=node-$(VERSION)
+
+dist: doc/node.1 doc/api.html
+ git-archive --prefix=$(TARNAME)/ HEAD > $(TARNAME).tar
+ mkdir -p $(TARNAME)/doc
+ cp doc/node.1 $(TARNAME)/doc/node.1
+ cp doc/api.html $(TARNAME)/doc/api.html
+ tar rf $(TARNAME).tar \
+ $(TARNAME)/doc/node.1 \
+ $(TARNAME)/doc/api.html
+ rm -r $(TARNAME)
+ gzip -f -9 $(TARNAME).tar
.PHONY: benchmark clean dist distclean check uninstall install all test test-all website-upload
View
2,146 doc/api.html
@@ -1,2146 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
- "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
-<meta name="generator" content="AsciiDoc 8.4.5" />
-<title>NODE(1)</title>
-<link rel="stylesheet" href="./pipe.css" type="text/css" />
-<link rel="stylesheet" href="./pipe-quirks.css" type="text/css" />
-<script type="text/javascript">
-/*<![CDATA[*/
-window.onload = function(){generateToc(2)}
-/*]]>*/
-</script>
-<script type="text/javascript" src="./toc.js"></script>
-</head>
-<body>
-<div id="header">
-<h1>NODE(1)</h1>
-<span id="author">Ryan Dahl</span><br />
-<span id="email"><tt>&lt;<a href="mailto:ry@tinyclouds.org">ry@tinyclouds.org</a>&gt;</tt></span><br />
-<span id="revnumber">version 0.1.13,</span>
-<span id="revdate">2009.09.30</span>
-<div id="toc">
- <div id="toctitle">Table of Contents</div>
- <noscript><p><b>JavaScript must be enabled in your browser to display the table of contents.</b></p></noscript>
-</div>
-</div>
-<h2 id="_name">NAME</h2>
-<div class="sectionbody">
-<div class="paragraph"><p>node - evented I/O for V8 javascript</p></div>
-</div>
-<h2 id="_synopsis">SYNOPSIS</h2>
-<div class="sectionbody">
-<div class="paragraph"><p>An example of a web server written with Node which responds with "Hello
-World":</p></div>
-<div class="listingblock">
-<div class="content">
-<pre><tt>include("/utils.js");
-include("/http.js");
-createServer(function (request, response) {
- response.sendHeader(200, {"Content-Type": "text/plain"});
- response.sendBody("Hello World\n");
- response.finish();
-}).listen(8000);
-puts("Server running at http://127.0.0.1:8000/");</tt></pre>
-</div></div>
-<div class="paragraph"><p>To run the server, put the code into a file called <tt>example.js</tt> and execute
-it with the node program</p></div>
-<div class="listingblock">
-<div class="content">
-<pre><tt>&gt; node example.js
-Server running at http://127.0.0.1:8000/</tt></pre>
-</div></div>
-</div>
-<h2 id="_api">API</h2>
-<div class="sectionbody">
-<div class="paragraph"><p>Node supports 3 string encodings. UTF-8 (<tt>"utf8"</tt>), ASCII (<tt>"ascii"</tt>), and
-Binary (<tt>"binary"</tt>). <tt>"ascii"</tt> and <tt>"binary"</tt> only look at the first 8 bits
-of the 16bit javascript string characters. Both are relatively fast&#8212;use
-them if you can. <tt>"utf8"</tt> is slower and should be avoided when possible.</p></div>
-<div class="paragraph"><p>Unless otherwise noted, functions are all asynchronous and do not block
-execution.</p></div>
-<h3 id="_helpers">Helpers</h3><div style="clear:left"></div>
-<div class="paragraph"><p>These objects are available to all programs.</p></div>
-<div class="dlist"><dl>
-<dt class="hdlist1">
-<tt>node.cwd()</tt>
-</dt>
-<dd>
-<p>
-Returns the current working directory of the process.
-</p>
-</dd>
-<dt class="hdlist1">
-<tt>node.compile(source, scriptOrigin)</tt>
-</dt>
-<dd>
-<p>
-Just like <tt>eval()</tt> except that you can specify a <tt>scriptOrigin</tt> for better
-error reporting.
-</p>
-</dd>
-<dt class="hdlist1">
-<tt>__filename</tt>
-</dt>
-<dd>
-<p>
-The filename of the script being executed.
-</p>
-</dd>
-<dt class="hdlist1">
-<tt>require(path)</tt>
-</dt>
-<dt class="hdlist1">
-<tt>include(path)</tt>
-</dt>
-<dd>
-<p>
-See the modules section.
-</p>
-</dd>
-<dt class="hdlist1">
-<tt>node.libraryPaths</tt>
-</dt>
-<dd>
-<p>
-The search path for absolute path arguments to <tt>require()</tt> and <tt>include()</tt>.
-</p>
-</dd>
-</dl></div>
-<h3 id="_the_tt_process_tt_object">The <tt>process</tt> Object</h3><div style="clear:left"></div>
-<div class="paragraph"><p><tt>process</tt> is the equivalent of <tt>window</tt> in browser-side javascript. It is
-the global scope. <tt>process</tt> is an instance of <tt>node.EventEmitter</tt>.</p></div>
-<div class="tableblock">
-<table rules="all"
-width="100%"
-frame="border"
-cellspacing="0" cellpadding="4">
-<col width="7%" />
-<col width="15%" />
-<col width="76%" />
-<thead>
-<tr>
-<th align="left" valign="top"> Event </th>
-<th align="left" valign="top"> Parameters </th>
-<th align="left" valign="top"> Notes</th>
-</tr>
-</thead>
-<tbody>
-<tr>
-<td align="left" valign="top"><p class="table"><tt>"exit"</tt></p></td>
-<td align="left" valign="top"><p class="table"><tt>code</tt></p></td>
-<td align="left" valign="top"><p class="table">Made when the process exits.
- A listener on this event should not try to perform
- I/O since the process will forcibly exit in less
- than microsecond. However, it is a good hook to
- perform constant time checks of the module&#8217;s
- state (like for unit tests).
- <br />
- The parameter <tt>code</tt> is the integer exit code
- passed to <tt>process.exit()</tt>.</p></td>
-</tr>
-</tbody>
-</table>
-</div>
-<div class="dlist"><dl>
-<dt class="hdlist1">
-<tt>process.exit(code=0)</tt>
-</dt>
-<dd>
-<p>
-Ends the process with the specified code. By default it exits with the
-success code 0.
-</p>
-</dd>
-<dt class="hdlist1">
-<tt>process.ARGV</tt>
-</dt>
-<dd>
-<p>
-An array containing the command line arguments.
-</p>
-</dd>
-<dt class="hdlist1">
-<tt>process.ENV</tt>
-</dt>
-<dd>
-<p>
-An object containing the user environment. See environ(7).
-</p>
-</dd>
-</dl></div>
-<h3 id="_utilities">Utilities</h3><div style="clear:left"></div>
-<div class="paragraph"><p>These function are in <tt>"/utils.js"</tt>. Use <tt>require("/utils.js")</tt> to access them.</p></div>
-<div class="dlist"><dl>
-<dt class="hdlist1">
-<tt>puts(string)</tt>
-</dt>
-<dd>
-<p>
-Outputs the <tt>string</tt> and a trailing new-line to <tt>stdout</tt>.
-</p>
-</dd>
-<dt class="hdlist1">
-<tt>print(string)</tt>
-</dt>
-<dd>
-<p>
-Like <tt>puts()</tt> but without the trailing new-line.
-</p>
-</dd>
-<dt class="hdlist1">
-<tt>debug(string)</tt>
-</dt>
-<dd>
-<p>
-A synchronous output function. Will block the process and
-output the string immediately to stdout.
-</p>
-</dd>
-<dt class="hdlist1">
-<tt>inspect(object)</tt>
-</dt>
-<dd>
-<p>
-Return a string representation of the <tt>object</tt>. (For debugging.)
-</p>
-</dd>
-<dt class="hdlist1">
-<tt>exec(command)</tt>
-</dt>
-<dd>
-<p>
-Executes the command as a child process, buffers the output and returns it
-in a promise callback.
-</p>
-<div class="listingblock">
-<div class="content">
-<pre><tt>include("/utils.js");
-exec("ls /").addCallback(function (stdout, stderr) {
- puts(stdout);
-});</tt></pre>
-</div></div>
-<div class="ulist"><ul>
-<li>
-<p>
-on success: stdout buffer, stderr buffer
-</p>
-</li>
-<li>
-<p>
-on error: exit code, stdout buffer, stderr buffer
-</p>
-</li>
-</ul></div>
-</dd>
-</dl></div>
-<h3 id="_events">Events</h3><div style="clear:left"></div>
-<div class="paragraph"><p>Many objects in Node emit events: a TCP server emits an event each time
-there is a connection, a child process emits an event when it exits. All
-objects which emit events are are instances of <tt>node.EventEmitter</tt>.</p></div>
-<div class="paragraph"><p>Events are represented by a camel-cased string. Here are some examples:
-<tt>"connection"</tt>, <tt>"receive"</tt>, <tt>"messageBegin"</tt>.</p></div>
-<div class="paragraph"><p>Functions can be then be attached to objects, to be executed when an event
-is emitted. These functions are called <em>listeners</em>.</p></div>
-<div class="paragraph"><p>Some asynchronous file operations return an <tt>EventEmitter</tt> called a
-<em>promise</em>. A promise emits just a single event when the operation is
-complete.</p></div>
-<h4 id="_tt_node_eventemitter_tt"><tt>node.EventEmitter</tt></h4>
-<div class="paragraph"><p>All EventEmitters emit the event <tt>"newListener"</tt> when new listeners are
-added.</p></div>
-<div class="tableblock">
-<table rules="all"
-width="100%"
-frame="border"
-cellspacing="0" cellpadding="4">
-<col width="7%" />
-<col width="15%" />
-<col width="76%" />
-<thead>
-<tr>
-<th align="left" valign="top"> Event </th>
-<th align="left" valign="top"> Parameters </th>
-<th align="left" valign="top"> Notes</th>
-</tr>
-</thead>
-<tbody>
-<tr>
-<td align="left" valign="top"><p class="table"><tt>"newListener"</tt></p></td>
-<td align="left" valign="top"><p class="table"><tt>event, listener</tt></p></td>
-<td align="left" valign="top"><p class="table">This event is made
- any time someone adds
- a new listener.</p></td>
-</tr>
-</tbody>
-</table>
-</div>
-<div class="dlist"><dl>
-<dt class="hdlist1">
-<tt>emitter.addListener(event, listener)</tt>
-</dt>
-<dd>
-<p>
-Adds a listener to the end of the listeners array for the specified event.
-</p>
-<div class="listingblock">
-<div class="content">
-<pre><tt>server.addListener("connection", function (socket) {
- puts("someone connected!");
-});</tt></pre>
-</div></div>
-</dd>
-<dt class="hdlist1">
-<tt>emitter.listeners(event)</tt>
-</dt>
-<dd>
-<p>
-Returns an array of listeners for the specified event. This array can be
-manipulated, e.g. to remove listeners.
-</p>
-</dd>
-<dt class="hdlist1">
-<tt>emitter.emit(event, arg1, arg2, &#8230;)</tt>
-</dt>
-<dd>
-<p>
-Execute each of the listeners in order with the supplied arguments.
-</p>
-</dd>
-</dl></div>
-<h4 id="_tt_node_promise_tt"><tt>node.Promise</tt></h4>
-<div class="paragraph"><p><tt>node.Promise</tt> inherits from <tt>node.eventEmitter</tt>. A promise emits one of two
-events: <tt>"success"</tt> or <tt>"error"</tt>. After emitting its event, it will not
-emit anymore events.</p></div>
-<div class="tableblock">
-<table rules="all"
-width="100%"
-frame="border"
-cellspacing="0" cellpadding="4">
-<col width="7%" />
-<col width="15%" />
-<col width="76%" />
-<thead>
-<tr>
-<th align="left" valign="top"> Event </th>
-<th align="left" valign="top"> Parameters </th>
-<th align="left" valign="top"> Notes</th>
-</tr>
-</thead>
-<tbody>
-<tr>
-<td align="left" valign="top"><p class="table"><tt>"success"</tt></p></td>
-<td align="left" valign="top"><p class="table">(depends)</p></td>
-<td align="left" valign="top"><p class="table"></p></td>
-</tr>
-<tr>
-<td align="left" valign="top"><p class="table"><tt>"error"</tt></p></td>
-<td align="left" valign="top"><p class="table">(depends)</p></td>
-<td align="left" valign="top"><p class="table"></p></td>
-</tr>
-</tbody>
-</table>
-</div>
-<div class="dlist"><dl>
-<dt class="hdlist1">
-<tt>promise.addCallback(listener)</tt>
-</dt>
-<dd>
-<p>
-Adds a listener for the <tt>"success"</tt> event. Returns the same promise object.
-</p>
-</dd>
-<dt class="hdlist1">
-<tt>promise.addErrback(listener)</tt>
-</dt>
-<dd>
-<p>
-Adds a listener for the <tt>"error"</tt> event. Returns the same promise object.
-</p>
-</dd>
-<dt class="hdlist1">
-<tt>promise.emitSuccess(arg1, arg2, &#8230;)</tt>
-</dt>
-<dd>
-<p>
-If you created the promise (by doing <tt>new node.Promise()</tt>) then call
-<tt>emitSuccess</tt> to emit the <tt>"success"</tt> event with the given arguments.
-</p>
-<div class="paragraph"><p>(<tt>promise.emit("success", arg1, arg2, &#8230;)</tt> should also work, but doesn&#8217;t at
-the moment due to a bug; use <tt>emitSuccess</tt> instead.)</p></div>
-</dd>
-<dt class="hdlist1">
-<tt>promise.emitError(arg1, arg2, &#8230;)</tt>
-</dt>
-<dd>
-<p>
-Emits the <tt>"error"</tt> event.
-</p>
-</dd>
-<dt class="hdlist1">
-<tt>promise.wait()</tt>
-</dt>
-<dd>
-<p>
-Blocks futher execution until the promise emits a success or error event.
-Events setup before the call to <tt>promise.wait()</tt> was made may still be
-emitted and executed while <tt>promise.wait()</tt> is blocking.
-</p>
-<div class="paragraph"><p>If there was a single argument to the <tt>"success"</tt> event then it is returned.
-If there were multiple arguments to <tt>"success"</tt> then they are returned as an
-array.</p></div>
-<div class="paragraph"><p>If <tt>"error"</tt> was emitted instead, <tt>wait()</tt> throws an error.</p></div>
-<div class="paragraph"><p><strong>IMPORTANT</strong> <tt>promise.wait()</tt> is not a true fiber/coroutine. If any other
-promises are created and made to wait while the first promise waits, the
-first promise&#8217;s wait will not return until all others return. The benefit of
-this is a simple implementation and the event loop does not get blocked.
-Disadvantage is the possibility of situations where the promise stack grows
-infinitely large because promises keep getting created and keep being told
-to wait(). Use <tt>promise.wait()</tt> sparingly&#8212;probably best used only during
-program setup, not during busy server activity.</p></div>
-</dd>
-</dl></div>
-<h3 id="_standard_i_o">Standard I/O</h3><div style="clear:left"></div>
-<div class="paragraph"><p>Standard I/O is handled through a special object <tt>node.stdio</tt>. stdout and
-stdin are fully non-blocking (even when piping to files). stderr is
-synchronous.</p></div>
-<div class="tableblock">
-<table rules="all"
-width="100%"
-frame="border"
-cellspacing="0" cellpadding="4">
-<col width="7%" />
-<col width="15%" />
-<col width="76%" />
-<thead>
-<tr>
-<th align="left" valign="top"> Event </th>
-<th align="left" valign="top"> Parameters </th>
-<th align="left" valign="top"> Notes</th>
-</tr>
-</thead>
-<tbody>
-<tr>
-<td align="left" valign="top"><p class="table"><tt>"data"</tt></p></td>
-<td align="left" valign="top"><p class="table"><tt>data</tt></p></td>
-<td align="left" valign="top"><p class="table">Made when stdin has received a chunk of data.
- Depending on the encoding that stdin was opened
- with, <tt>data</tt> will be a string. This event will
- only be emited after <tt>node.stdio.open()</tt> has
- been called.</p></td>
-</tr>
-<tr>
-<td align="left" valign="top"><p class="table"><tt>"close"</tt></p></td>
-<td align="left" valign="top"><p class="table"></p></td>
-<td align="left" valign="top"><p class="table">Made when stdin has been closed.</p></td>
-</tr>
-</tbody>
-</table>
-</div>
-<div class="dlist"><dl>
-<dt class="hdlist1">
-<tt>node.stdio.open(encoding="utf8")</tt>
-</dt>
-<dd>
-<p>
-Open stdin. The program will not exit until <tt>node.stdio.close()</tt> has been
-called or the <tt>"close"</tt> event has been emitted.
-</p>
-</dd>
-<dt class="hdlist1">
-<tt>node.stdio.write(data)</tt>
-</dt>
-<dd>
-<p>
-Write data to stdout.
-</p>
-</dd>
-<dt class="hdlist1">
-<tt>node.stdio.writeError(data)</tt>
-</dt>
-<dd>
-<p>
-Write data to stderr. Synchronous.
-</p>
-</dd>
-<dt class="hdlist1">
-<tt>node.stdio.close()</tt>
-</dt>
-<dd>
-<p>
-Close stdin.
-</p>
-</dd>
-</dl></div>
-<h3 id="_modules">Modules</h3><div style="clear:left"></div>
-<div class="paragraph"><p>Node has a simple module loading system. In Node, files and modules are in
-one-to-one correspondence. As an example, <tt>foo.js</tt> loads the module
-<tt>circle.js</tt>.</p></div>
-<div class="paragraph"><p>The contents of <tt>foo.js</tt>:</p></div>
-<div class="listingblock">
-<div class="content">
-<pre><tt>var circle = require("circle.js");
-include("/utils.js");
-puts("The area of a circle of radius 4 is " + circle.area(4));</tt></pre>
-</div></div>
-<div class="paragraph"><p>The contents of <tt>circle.js</tt>:</p></div>
-<div class="listingblock">
-<div class="content">
-<pre><tt>var PI = 3.14;
-
-exports.area = function (r) {
- return PI * r * r;
-};
-
-exports.circumference = function (r) {
- return 2 * PI * r;
-};</tt></pre>
-</div></div>
-<div class="paragraph"><p>The module <tt>circle.js</tt> has exported the functions <tt>area()</tt> and
-<tt>circumference()</tt>. To export an object, add to the special <tt>exports</tt>
-object. (Alternatively, one can use <tt>this</tt> instead of <tt>exports</tt>.) Variables
-local to the module will be private. In this example the variable <tt>PI</tt> is
-private to <tt>circle.js</tt>. The function <tt>puts()</tt> comes from the module
-<tt>"/utils.js"</tt>. Because <tt>include("/utils.js")</tt> was called, <tt>puts()</tt> is in the
-global namespace.</p></div>
-<div class="paragraph"><p>The module path is relative to the file calling <tt>require()</tt>. That is,
-<tt>circle.js</tt> must be in the same directory as <tt>foo.js</tt> for <tt>require()</tt> to
-find it.</p></div>
-<div class="paragraph"><p>Like <tt>require()</tt> the function <tt>include()</tt> also loads a module. Instead of
-returning a namespace object, <tt>include()</tt> will add the module&#8217;s exports into
-the global namespace. For example:</p></div>
-<div class="listingblock">
-<div class="content">
-<pre><tt>include("circle.js");
-include("/utils.js");
-puts("The area of a cirlce of radius 4 is " + area(4));</tt></pre>
-</div></div>
-<div class="paragraph"><p>When an absolute path is given to <tt>require()</tt> or <tt>include()</tt>, like
-<tt>require("/mjsunit.js")</tt> the module is searched for in the
-<tt>node.libraryPaths</tt> array. <tt>node.libraryPaths</tt> on my system looks like this:</p></div>
-<div class="listingblock">
-<div class="content">
-<pre><tt>[ "/home/ryan/.node_libraries"
-, "/home/ryan/local/node/lib/node_libraries"
-, "/"
-]</tt></pre>
-</div></div>
-<div class="paragraph"><p>That is, first Node looks for <tt>"/home/ryan/.node_libraries/mjsunit.js"</tt> and
-then for <tt>"/home/ryan/local/node/lib/node_libraries/mjsunit.js"</tt>. If not
-found, it finally looks for <tt>"/mjsunit.js"</tt> (in the root directory).</p></div>
-<div class="paragraph"><p><tt>node.libraryPaths</tt> can be modified at runtime by simply unshifting new
-paths on to it and at startup with the <tt>NODE_LIBRARY_PATHS</tt> environmental
-variable (which should be a list of paths, colon separated).</p></div>
-<div class="paragraph"><p>Node comes with several libraries which are installed when <tt>"make install"</tt>
-is run. These are currently undocumented, but do look them up in your
-system.</p></div>
-<h3 id="_timers">Timers</h3><div style="clear:left"></div>
-<div class="dlist"><dl>
-<dt class="hdlist1">
-<tt>setTimeout(callback, delay)</tt>
-</dt>
-<dd>
-<p>
-To schedule execution of callback after delay milliseconds. Returns a
-<tt>timeoutId</tt> for possible use with <tt>clearTimeout()</tt>.
-</p>
-</dd>
-<dt class="hdlist1">
-<tt>clearTimeout(timeoutId)</tt>
-</dt>
-<dd>
-<p>
-Prevents said timeout from triggering.
-</p>
-</dd>
-<dt class="hdlist1">
-<tt>setInterval(callback, delay)</tt>
-</dt>
-<dd>
-<p>
-To schedule the repeated execution of callback every <tt>delay</tt> milliseconds. Returns
-a <tt>intervalId</tt> for possible use with <tt>clearInterval()</tt>.
-</p>
-</dd>
-<dt class="hdlist1">
-<tt>clearInterval(intervalId)</tt>
-</dt>
-<dd>
-<p>
-Stops a interval from triggering.
-</p>
-</dd>
-</dl></div>
-<h3 id="_child_processes">Child Processes</h3><div style="clear:left"></div>
-<div class="paragraph"><p>Node provides a tridirectional <tt>popen(3)</tt> facility through the class
-<tt>node.ChildProcess</tt>. It is possible to stream data through the child&#8217;s <tt>stdin</tt>,
-<tt>stdout</tt>, and <tt>stderr</tt> in a fully non-blocking way.</p></div>
-<h4 id="_tt_node_childprocess_tt"><tt>node.ChildProcess</tt></h4>
-<div class="tableblock">
-<table rules="all"
-width="100%"
-frame="border"
-cellspacing="0" cellpadding="4">
-<col width="7%" />
-<col width="15%" />
-<col width="76%" />
-<thead>
-<tr>
-<th align="left" valign="top"> Event </th>
-<th align="left" valign="top"> Parameters </th>
-<th align="left" valign="top">Notes</th>
-</tr>
-</thead>
-<tbody>
-<tr>
-<td align="left" valign="top"><p class="table"><tt>"output"</tt></p></td>
-<td align="left" valign="top"><p class="table"><tt>data</tt></p></td>
-<td align="left" valign="top"><p class="table">Each time the child process
- sends data to its <tt>stdout</tt>, this event is
- emitted. <tt>data</tt> is a string. + If the child
- process closes its <tt>stdout</tt> stream (a common
- thing to do on exit), this event will be emitted
- with <tt>data === null</tt>.</p></td>
-</tr>
-<tr>
-<td align="left" valign="top"><p class="table"><tt>"error"</tt></p></td>
-<td align="left" valign="top"><p class="table"><tt>data</tt></p></td>
-<td align="left" valign="top"><p class="table">Identical to the <tt>"output"</tt> event except for
- <tt>stderr</tt> instead of <tt>stdout</tt>.</p></td>
-</tr>
-<tr>
-<td align="left" valign="top"><p class="table"><tt>"exit"</tt></p></td>
-<td align="left" valign="top"><p class="table"><tt>code</tt></p></td>
-<td align="left" valign="top"><p class="table">This event is emitted after the child process
- ends. <tt>code</tt> is the final exit code of the
- process. One can be assured that after this
- event is emitted that the <tt>"output"</tt> and
- <tt>"error"</tt> callbacks will no longer be made.</p></td>
-</tr>
-</tbody>
-</table>
-</div>
-<div class="dlist"><dl>
-<dt class="hdlist1">
-<tt>node.createChildProcess(command)</tt>
-</dt>
-<dd>
-<p>
-Launches a new process with the given <tt>command</tt>. For example:
-</p>
-<div class="listingblock">
-<div class="content">
-<pre><tt>var ls = node.createChildProcess("ls -lh /usr");
-ls.addListener("output", function (data) {
- puts(data);
-});</tt></pre>
-</div></div>
-</dd>
-<dt class="hdlist1">
-<tt>child.pid</tt>
-</dt>
-<dd>
-<p>
-The PID of the child process.
-</p>
-</dd>
-<dt class="hdlist1">
-<tt>child.write(data, encoding="ascii")</tt>
-</dt>
-<dd>
-<p>
-Write data to the child process&#8217;s <tt>stdin</tt>. The second argument is optional and
-specifies the encoding: possible values are <tt>"utf8"</tt>, <tt>"ascii"</tt>, and
-<tt>"binary"</tt>.
-</p>
-</dd>
-<dt class="hdlist1">
-<tt>child.close()</tt>
-</dt>
-<dd>
-<p>
-Closes the process&#8217;s <tt>stdin</tt> stream.
-</p>
-</dd>
-<dt class="hdlist1">
-<tt>child.kill(signal=node.SIGTERM)</tt>
-</dt>
-<dd>
-<p>
-Send a single to the child process. If no argument is given, the process
-will be sent <tt>node.SIGTERM</tt>. The standard POSIX signals are defined under
-the <tt>node</tt> namespace (<tt>node.SIGINT</tt>, <tt>node.SIGUSR1</tt>, &#8230;).
-</p>
-</dd>
-</dl></div>
-<h3 id="_file_i_o">File I/O</h3><div style="clear:left"></div>
-<div class="paragraph"><p>File I/O is provided by simple wrappers around standard POSIX functions.
-All POSIX wrappers have a similar form.
-They return a promise (<tt>node.Promise</tt>). Example:</p></div>
-<div class="listingblock">
-<div class="content">
-<pre><tt>var promise = node.fs.unlink("/tmp/hello");
-promise.addCallback(function () {
- puts("successfully deleted /tmp/hello");
-});</tt></pre>
-</div></div>
-<div class="paragraph"><p>There is no guaranteed ordering to the POSIX wrappers. The
-following is very much prone to error</p></div>
-<div class="listingblock">
-<div class="content">
-<pre><tt>node.fs.rename("/tmp/hello", "/tmp/world");
-node.fs.stat("/tmp/world").addCallback(function (stats) {
- puts("stats: " + JSON.stringify(stats));
-});</tt></pre>
-</div></div>
-<div class="paragraph"><p>It could be that <tt>stat()</tt> is executed before the <tt>rename()</tt>.
-The correct way to do this is to chain the promises.</p></div>
-<div class="listingblock">
-<div class="content">
-<pre><tt>node.fs.rename("/tmp/hello", "/tmp/world").addCallback(function () {
- node.fs.stat("/tmp/world").addCallback(function (stats) {
- puts("stats: " + JSON.stringify(stats));
- });
-});</tt></pre>
-</div></div>
-<div class="paragraph"><p>Or use the <tt>promise.wait()</tt> functionality:</p></div>
-<div class="listingblock">
-<div class="content">
-<pre><tt>node.fs.rename("/tmp/hello", "/tmp/world").wait();
-node.fs.stat("/tmp/world").addCallback(function (stats) {
- puts("stats: " + JSON.stringify(stats));
-});</tt></pre>
-</div></div>
-<div class="dlist"><dl>
-<dt class="hdlist1">
-<tt>node.fs.rename(path1, path2)</tt>
-</dt>
-<dd>
-<p>
- See rename(2).
-</p>
-<div class="ulist"><ul>
-<li>
-<p>
-on success: no parameters.
-</p>
-</li>
-<li>
-<p>
-on error: no parameters.
-</p>
-</li>
-</ul></div>
-</dd>
-<dt class="hdlist1">
-<tt>node.fs.stat(path)</tt>
-</dt>
-<dd>
-<p>
- See stat(2).
-</p>
-<div class="ulist"><ul>
-<li>
-<p>
-on success: Returns <tt>node.fs.Stats</tt> object. It looks like this:
- <tt>{ dev: 2049, ino: 305352, mode: 16877, nlink: 12, uid: 1000, gid: 1000,
- rdev: 0, size: 4096, blksize: 4096, blocks: 8, atime:
- "2009-06-29T11:11:55Z", mtime: "2009-06-29T11:11:40Z", ctime:
- "2009-06-29T11:11:40Z" }</tt>
- See the <tt>node.fs.Stats</tt> section below for more information.
-</p>
-</li>
-<li>
-<p>
-on error: no parameters.
-</p>
-</li>
-</ul></div>
-</dd>
-<dt class="hdlist1">
-<tt>node.fs.unlink(path)</tt>
-</dt>
-<dd>
-<p>
- See unlink(2)
-</p>
-<div class="ulist"><ul>
-<li>
-<p>
-on success: no parameters.
-</p>
-</li>
-<li>
-<p>
-on error: no parameters.
-</p>
-</li>
-</ul></div>
-</dd>
-<dt class="hdlist1">
-<tt>node.fs.rmdir(path)</tt>
-</dt>
-<dd>
-<p>
- See rmdir(2)
-</p>
-<div class="ulist"><ul>
-<li>
-<p>
-on success: no parameters.
-</p>
-</li>
-<li>
-<p>
-on error: no parameters.
-</p>
-</li>
-</ul></div>
-</dd>
-<dt class="hdlist1">
-<tt>node.fs.mkdir(path, mode)</tt>
-</dt>
-<dd>
-<p>
- See mkdir(2)
-</p>
-<div class="ulist"><ul>
-<li>
-<p>
-on success: no parameters.
-</p>
-</li>
-<li>
-<p>
-on error: no parameters.
-</p>
-</li>
-</ul></div>
-</dd>
-<dt class="hdlist1">
-<tt>node.fs.readdir(path)</tt>
-</dt>
-<dd>
-<p>
- Reads the contents of a directory.
-</p>
-<div class="ulist"><ul>
-<li>
-<p>
-on success: One argument, an array containing the names (strings) of the
- files in the directory (excluding "." and "..").
-</p>
-</li>
-<li>
-<p>
-on error: no parameters.
-</p>
-</li>
-</ul></div>
-</dd>
-<dt class="hdlist1">
-<tt>node.fs.close(fd)</tt>
-</dt>
-<dd>
-<p>
- See close(2)
-</p>
-<div class="ulist"><ul>
-<li>
-<p>
-on success: no parameters.
-</p>
-</li>
-<li>
-<p>
-on error: no parameters.
-</p>
-</li>
-</ul></div>
-</dd>
-<dt class="hdlist1">
-<tt>node.fs.open(path, flags, mode)</tt>
-</dt>
-<dd>
-<p>
- See open(2). The constants like <tt>O_CREAT</tt> are defined at <tt>node.O_CREAT</tt>.
-</p>
-<div class="ulist"><ul>
-<li>
-<p>
-on success: <tt>fd</tt> is given as the parameter.
-</p>
-</li>
-<li>
-<p>
-on error: no parameters.
-</p>
-</li>
-</ul></div>
-</dd>
-<dt class="hdlist1">
-<tt>node.fs.write(fd, data, position, encoding)</tt>
-</dt>
-<dd>
-<p>
- Write data to the file specified by <tt>fd</tt>. <tt>position</tt> refers to the offset
- from the beginning of the file where this data should be written. If
- <tt>position</tt> is <tt>null</tt>, the data will be written at the current position.
- See pwrite(2).
-</p>
-<div class="ulist"><ul>
-<li>
-<p>
-on success: returns an integer <tt>written</tt> which specifies how many <em>bytes</em> were written.
-</p>
-</li>
-<li>
-<p>
-on error: no parameters.
-</p>
-</li>
-</ul></div>
-</dd>
-<dt class="hdlist1">
-<tt>node.fs.read(fd, length, position, encoding)</tt>
-</dt>
-<dd>
-<p>
-Read data from the file specified by <tt>fd</tt>.
-</p>
-<div class="paragraph"><p><tt>length</tt> is an integer specifying the number of
-bytes to read.</p></div>
-<div class="paragraph"><p><tt>position</tt> is an integer specifying where to begin
-reading from in the file.</p></div>
-<div class="ulist"><ul>
-<li>
-<p>
-on success: returns <tt>data, bytes_read</tt>, what was read from the file.
-</p>
-</li>
-<li>
-<p>
-on error: no parameters.
-</p>
-</li>
-</ul></div>
-</dd>
-<dt class="hdlist1">
-<tt>node.fs.cat(filename, encoding="utf8")</tt>
-</dt>
-<dd>
-<p>
-Outputs the entire contents of a file. Example:
-</p>
-<div class="listingblock">
-<div class="content">
-<pre><tt>node.fs.cat("/etc/passwd").addCallback(function (content) {
- puts(content);
-});</tt></pre>
-</div></div>
-<div class="ulist"><ul>
-<li>
-<p>
-on success: returns <tt>data</tt>, what was read from the file.
-</p>
-</li>
-<li>
-<p>
-on error: no parameters.
-</p>
-</li>
-</ul></div>
-</dd>
-</dl></div>
-<h4 id="_tt_node_fs_stats_tt"><tt>node.fs.Stats</tt></h4>
-<div class="paragraph"><p>Objects returned from <tt>node.fs.stat()</tt> are of this type.</p></div>
-<div class="dlist"><dl>
-<dt class="hdlist1">
-<tt>stats.isFile()</tt>
-</dt>
-<dt class="hdlist1">
-<tt>stats.isDirectory()</tt>
-</dt>
-<dt class="hdlist1">
-<tt>stats.isBlockDevice()</tt>
-</dt>
-<dt class="hdlist1">
-<tt>stats.isCharacterDevice()</tt>
-</dt>
-<dt class="hdlist1">
-<tt>stats.isSymbolicLink()</tt>
-</dt>
-<dt class="hdlist1">
-<tt>stats.isFIFO()</tt>
-</dt>
-<dt class="hdlist1">
-<tt>stats.isSocket()</tt>
-</dt>
-<dd>
-<p>
-&#8230;
-</p>
-</dd>
-</dl></div>
-<h3 id="_http">HTTP</h3><div style="clear:left"></div>
-<div class="paragraph"><p>To use the HTTP server and client one must <tt>require("/http.js")</tt> or
-<tt>include("/http.js")</tt>.</p></div>
-<div class="paragraph"><p>The HTTP interfaces in Node are designed to support many features
-of the protocol which have been traditionally difficult to use.
-In particular, large, possibly chunk-encoded, messages. The interface is
-careful to never buffer entire requests or responses&#8212;the
-user is able to stream data.</p></div>
-<div class="paragraph"><p>HTTP message headers are represented by an object like this</p></div>
-<div class="listingblock">
-<div class="content">
-<pre><tt>{ "Content-Length": "123"
-, "Content-Type": "text/plain"
-, "Connection": "keep-alive"
-, "Accept": "*/*"
-}</tt></pre>
-</div></div>
-<div class="paragraph"><p>In order to support the full spectrum of possible HTTP applications, Node&#8217;s
-HTTP API is very low-level. It deals with connection handling and message
-parsing only. It parses a message into headers and body but it does not
-parse the actual headers or the body.</p></div>
-<h4 id="_tt_http_server_tt"><tt>http.Server</tt></h4>
-<div class="tableblock">
-<table rules="all"
-width="100%"
-frame="border"
-cellspacing="0" cellpadding="4">
-<col width="7%" />
-<col width="15%" />
-<col width="76%" />
-<thead>
-<tr>
-<th align="left" valign="top">Event </th>
-<th align="left" valign="top"> Parameters </th>
-<th align="left" valign="top"> Notes</th>
-</tr>
-</thead>
-<tbody>
-<tr>
-<td align="left" valign="top"><p class="table"><tt>"request"</tt></p></td>
-<td align="left" valign="top"><p class="table"><tt>request, response</tt></p></td>
-<td align="left" valign="top"><p class="table"><tt>request</tt> is an instance of <tt>http.ServerRequest</tt>
- <br />
- <tt>response</tt> is an instance of <tt>http.ServerResponse</tt></p></td>
-</tr>
-<tr>
-<td align="left" valign="top"><p class="table"><tt>"connection"</tt></p></td>
-<td align="left" valign="top"><p class="table"><tt>connection</tt></p></td>
-<td align="left" valign="top"><p class="table">When a new TCP connection is established.
- <tt>connection</tt> is an object of type
- <tt>http.Connection</tt>. Usually users
- will not want to access this event.
- The <tt>connection</tt> can also be
- accessed at <tt>request.connection</tt>.</p></td>
-</tr>
-<tr>
-<td align="left" valign="top"><p class="table"><tt>"close"</tt></p></td>
-<td align="left" valign="top"><p class="table"><tt>errorno</tt></p></td>
-<td align="left" valign="top"><p class="table">Emitted when the server closes. <tt>errorno</tt>
- is an integer which indicates what, if any,
- error caused the server to close. If no
- error occured <tt>errorno</tt> will be 0.</p></td>
-</tr>
-</tbody>
-</table>
-</div>
-<div class="dlist"><dl>
-<dt class="hdlist1">
-<tt>http.createServer(request_listener, options);</tt>
-</dt>
-<dd>
-<p>
-Returns a new web server object.
-</p>
-<div class="paragraph"><p>The <tt>options</tt> argument is optional. The
-<tt>options</tt> argument accepts the same values as the
-options argument for <tt>tcp.Server</tt> does.</p></div>
-<div class="paragraph"><p>The <tt>request_listener</tt> is a function which is automatically
-added to the <tt>"request"</tt> event.</p></div>
-</dd>
-<dt class="hdlist1">
-<tt>server.listen(port, hostname)</tt>
-</dt>
-<dd>
-<p>
-Begin accepting connections on the specified port and hostname.
-If the hostname is omitted, the server will accept connections
-directed to any address. This function is synchronous.
-</p>
-</dd>
-<dt class="hdlist1">
-<tt>server.close()</tt>
-</dt>
-<dd>
-<p>
-Stops the server from accepting new connections.
-</p>
-</dd>
-</dl></div>
-<h4 id="_tt_http_serverrequest_tt"><tt>http.ServerRequest</tt></h4>
-<div class="paragraph"><p>This object is created internally by a HTTP server&#8212;not by
-the user&#8212;and passed as the first argument to a <tt>"request"</tt> listener.</p></div>
-<div class="tableblock">
-<table rules="all"
-width="100%"
-frame="border"
-cellspacing="0" cellpadding="4">
-<col width="7%" />
-<col width="15%" />
-<col width="76%" />
-<thead>
-<tr>
-<th align="left" valign="top">Event </th>
-<th align="left" valign="top"> Parameters </th>
-<th align="left" valign="top"> Notes</th>
-</tr>
-</thead>
-<tbody>
-<tr>
-<td align="left" valign="top"><p class="table"><tt>"body"</tt></p></td>
-<td align="left" valign="top"><p class="table"><tt>chunk</tt></p></td>
-<td align="left" valign="top"><p class="table">Emitted when a piece of the
- message body is received. Example: A chunk
- of the body is given as the single
- argument. The transfer-encoding has been
- decoded. The body chunk is a String. The
- body encoding is set with
- <tt>request.setBodyEncoding()</tt>.</p></td>
-</tr>
-<tr>
-<td align="left" valign="top"><p class="table"><tt>"complete"</tt></p></td>
-<td align="left" valign="top"><p class="table">(none)</p></td>
-<td align="left" valign="top"><p class="table">Emitted exactly once for each message.
- No arguments. After emitted no other
- events will be emitted on the request.</p></td>
-</tr>
-</tbody>
-</table>
-</div>
-<div class="dlist"><dl>
-<dt class="hdlist1">
-<tt>request.method</tt>
-</dt>
-<dd>
-<p>
-The request method as a string. Read only. Example:
-<tt>"GET"</tt>, <tt>"DELETE"</tt>.
-</p>
-</dd>
-<dt class="hdlist1">
-<tt>request.uri</tt>
-</dt>
-<dd>
-<p>
-Request URI Object. This contains only the parameters that are
-present in the actual HTTP request. That is, if the request is
-</p>
-<div class="listingblock">
-<div class="content">
-<pre><tt>GET /status?name=ryan HTTP/1.1\r\n
-Accept: text/plain\r\n
-\r\n</tt></pre>
-</div></div>
-<div class="paragraph"><p>Then <tt>request.uri</tt> will be</p></div>
-<div class="listingblock">
-<div class="content">
-<pre><tt>{ path: "/status",
- file: "status",
- directory: "/",
- params: { "name" : "ryan" }
-}</tt></pre>
-</div></div>
-<div class="paragraph"><p>In particular, note that <tt>request.uri.protocol</tt> is
-<tt>undefined</tt>. This is because there was no URI protocol given
-in the actual HTTP Request.</p></div>
-<div class="paragraph"><p>Here is what&#8217;s available: <tt>request.uri.anchor</tt>, <tt>request.uri.query</tt>,
-<tt>request.uri.file</tt>, <tt>request.uri.directory</tt>, <tt>request.uri.path</tt>,
-<tt>request.uri.relative</tt>, <tt>request.uri.port</tt>, <tt>request.uri.host</tt>,
-<tt>request.uri.password</tt>, <tt>request.uri.user</tt>, <tt>request.uri.authority</tt>,
-<tt>request.uri.protocol</tt>, <tt>request.uri.params</tt>, <tt>request.uri.toString()</tt>,
-<tt>request.uri.source</tt></p></div>
-</dd>
-<dt class="hdlist1">
-<tt>request.headers</tt>
-</dt>
-<dd>
-<p>
-Read only.
-</p>
-</dd>
-<dt class="hdlist1">
-<tt>request.httpVersion</tt>
-</dt>
-<dd>
-<p>
-The HTTP protocol version as a string. Read only. Examples:
-<tt>"1.1"</tt>, <tt>"1.0"</tt>
-</p>
-</dd>
-<dt class="hdlist1">
-<tt>request.setBodyEncoding(encoding)</tt>
-</dt>
-<dd>
-<p>
-Set the encoding for the request body. Either <tt>"utf8"</tt> or <tt>"binary"</tt>. Defaults
-to <tt>"binary"</tt>.
-</p>
-</dd>
-<dt class="hdlist1">
-<tt>request.pause()</tt>
-</dt>
-<dd>
-<p>
-Pauses request from emitting events. Useful to throttle back an upload.
-</p>
-</dd>
-<dt class="hdlist1">
-<tt>request.resume()</tt>
-</dt>
-<dd>
-<p>
-Resumes a paused request.
-</p>
-</dd>
-<dt class="hdlist1">
-<tt>request.connection</tt>
-</dt>
-<dd>
-<p>
-The <tt>http.Connection</tt> object.
-</p>
-</dd>
-</dl></div>
-<h4 id="_tt_http_serverresponse_tt"><tt>http.ServerResponse</tt></h4>
-<div class="paragraph"><p>This object is created internally by a HTTP server&#8212;not by the user. It is
-passed as the second parameter to the <tt>"request"</tt> event.</p></div>
-<div class="dlist"><dl>
-<dt class="hdlist1">
-<tt>response.sendHeader(statusCode, headers)</tt>
-</dt>
-<dd>
-<p>
-Sends a response header to the request. The status code is a 3-digit HTTP
-status code, like <tt>404</tt>. The second argument, <tt>headers</tt> are the response headers.
-</p>
-<div class="paragraph"><p>Example:</p></div>
-<div class="listingblock">
-<div class="content">
-<pre><tt>var body = "hello world";
-response.sendHeader(200, {
- "Content-Length": body.length,
- "Content-Type": "text/plain"
-});</tt></pre>
-</div></div>
-<div class="paragraph"><p>This method must only be called once on a message and it must
-be called before <tt>response.finish()</tt> is called.</p></div>
-</dd>
-<dt class="hdlist1">
-<tt>response.sendBody(chunk, encoding="ascii")</tt>
-</dt>
-<dd>
-<p>
-This method must be called after <tt>sendHeader</tt> was
-called. It sends a chunk of the response body. This method may
-be called multiple times to provide successive parts of the body.
-</p>
-<div class="paragraph"><p>If <tt>chunk</tt> is a string, the second parameter
-specifies how to encode it into a byte stream. By default the
-<tt>encoding</tt> is <tt>"ascii"</tt>.</p></div>
-<div class="paragraph"><p>Note: This is the raw HTTP body and has nothing to do with
-higher-level multi-part body encodings that may be used.</p></div>
-<div class="paragraph"><p>The first time <tt>sendBody</tt> is called, it will send the buffered header
-information and the first body to the client. The second time
-<tt>sendBody</tt> is called, Node assumes you&#8217;re going to be streaming data, and
-sends that seperately. That is, the response is buffered up to the
-first chunk of body.</p></div>
-</dd>
-<dt class="hdlist1">
-<tt>response.finish()</tt>
-</dt>
-<dd>
-<p>
-This method signals to the server that all of the response headers and body
-has been sent; that server should consider this message complete.
-The method, <tt>response.finish()</tt>, MUST be called on each
-response.
-</p>
-</dd>
-</dl></div>
-<h4 id="_tt_http_client_tt"><tt>http.Client</tt></h4>
-<div class="paragraph"><p>An HTTP client is constructed with a server address as its
-argument, the returned handle is then used to issue one or more
-requests. Depending on the server connected to, the client might
-pipeline the requests or reestablish the connection after each
-connection. <em>Currently the implementation does not pipeline requests.</em></p></div>
-<div class="paragraph"><p>Example of connecting to <tt>google.com</tt></p></div>
-<div class="listingblock">
-<div class="content">
-<pre><tt>var google = http.createClient(80, "google.com");
-var request = google.get("/");
-request.finish(function (response) {
- puts("STATUS: " + response.statusCode);
- puts("HEADERS: " + JSON.stringify(response.headers));
- response.setBodyEncoding("utf8");
- response.addListener("body", function (chunk) {
- puts("BODY: " + chunk);
- });
-});</tt></pre>
-</div></div>
-<div class="dlist"><dl>
-<dt class="hdlist1">
-<tt>http.createClient(port, host)</tt>
-</dt>
-<dd>
-<p>
-Constructs a new HTTP client. <tt>port</tt> and
-<tt>host</tt> refer to the server to be connected to. A
-connection is not established until a request is issued.
-</p>
-</dd>
-<dt class="hdlist1">
-<tt>client.get(path, request_headers)</tt>, <tt>client.head(path, request_headers)</tt>, <tt>client.post(path, request_headers)</tt>, <tt>client.del(path, request_headers)</tt>, <tt>client.put(path, request_headers)</tt>
-</dt>
-<dd>
-<p>
-Issues a request; if necessary establishes connection. Returns a <tt>http.ClientRequest</tt> instance.
-</p>
-<div class="paragraph"><p><tt>request_headers</tt> is optional.
-Additional request headers might be added internally
-by Node. Returns a <tt>ClientRequest</tt> object.</p></div>
-<div class="paragraph"><p>Do remember to include the <tt>Content-Length</tt> header if you
-plan on sending a body. If you plan on streaming the body, perhaps
-set <tt>Transfer-Encoding: chunked</tt>.</p></div>
-<div class="admonitionblock">
-<table><tr>
-<td class="icon">
-<div class="title">Note</div>
-</td>
-<td class="content">the request is not complete. This method only sends
-the header of the request. One needs to call
-<tt>request.finish()</tt> to finalize the request and retrieve
-the response. (This sounds convoluted but it provides a chance
-for the user to stream a body to the server with
-<tt>request.sendBody()</tt>.)</td>
-</tr></table>
-</div>
-</dd>
-</dl></div>
-<h4 id="_tt_http_clientrequest_tt"><tt>http.ClientRequest</tt></h4>
-<div class="paragraph"><p>This object is created internally and returned from the request methods of a
-<tt>http.Client</tt>. It represents an <em>in-progress</em> request whose header has
-already been sent.</p></div>
-<div class="tableblock">
-<table rules="all"
-width="100%"
-frame="border"
-cellspacing="0" cellpadding="4">
-<col width="7%" />
-<col width="15%" />
-<col width="76%" />
-<thead>
-<tr>
-<th align="left" valign="top">Event </th>
-<th align="left" valign="top"> Parameters </th>
-<th align="left" valign="top"> Notes</th>
-</tr>
-</thead>
-<tbody>
-<tr>
-<td align="left" valign="top"><p class="table"><tt>"response"</tt></p></td>
-<td align="left" valign="top"><p class="table"><tt>response</tt></p></td>
-<td align="left" valign="top"><p class="table">Emitted when a response is received to this request. Typically the user will
-set a listener to this via the <tt>request.finish()</tt> method.<br />
-This event is emitted only once.<br />
-The <tt>response</tt> argument will be an instance of <tt>http.ClientResponse</tt>.</p></td>
-</tr>
-</tbody>
-</table>
-</div>
-<div class="dlist"><dl>
-<dt class="hdlist1">
-<tt>request.sendBody(chunk, encoding="ascii")</tt>
-</dt>
-<dd>
-<p>
-Sends a chunk of the body. By calling this method
-many times, the user can stream a request body to a
-server&mdash;in that case it is suggested to use the
-<tt>["Transfer-Encoding", "chunked"]</tt> header line when
-creating the request.
-</p>
-<div class="paragraph"><p>The <tt>chunk</tt> argument should be an array of integers
-or a string.</p></div>
-<div class="paragraph"><p>The <tt>encoding</tt> argument is optional and only
-applies when <tt>chunk</tt> is a string. The encoding
-argument should be either <tt>"utf8"</tt> or
-<tt>"ascii"</tt>. By default the body uses ASCII encoding,
-as it is faster.</p></div>
-</dd>
-<dt class="hdlist1">
-<tt>request.finish(responseListener)</tt>
-</dt>
-<dd>
-<p>
-Finishes sending the request. If any parts of the body are
-unsent, it will flush them to the socket. If the request is
-chunked, this will send the terminating <tt>"0\r\n\r\n"</tt>.
-</p>
-<div class="paragraph"><p>The parameter <tt>responseListener</tt> is a callback which
-will be executed when the response headers have been received.
-The <tt>responseListener</tt> callback is executed with one
-argument which is an instance of <tt>http.ClientResponse</tt>.</p></div>
-<div class="paragraph"><p>In the <tt>responseListener</tt> callback, one can add more listeners to the
-response, in particular listening for the <tt>"body"</tt> event. Note that
-the <tt>responseListener</tt> is called before any part of the body is receieved,
-so there is no need to worry about racing to catch the first part of the
-body. As long as a listener for <tt>"body"</tt> is added during the
-<tt>responseListener</tt> callback, the entire body will be caught.</p></div>
-<div class="listingblock">
-<div class="content">
-<pre><tt>// Good
-request.finish(function (response) {
- response.addListener("body", function (chunk) {
- puts("BODY: " + chunk);
- });
-});
-
-// Bad - misses all or part of the body
-request.finish(function (response) {
- setTimeout(function () {
- response.addListener("body", function (chunk) {
- puts("BODY: " + chunk);
- });
- }, 10);
-});</tt></pre>
-</div></div>
-</dd>
-</dl></div>
-<h4 id="_tt_http_clientresponse_tt"><tt>http.ClientResponse</tt></h4>
-<div class="paragraph"><p>This object is created internally and passed to the <tt>"response"</tt> event.</p></div>
-<div class="tableblock">
-<table rules="all"
-width="100%"
-frame="border"
-cellspacing="0" cellpadding="4">
-<col width="7%" />
-<col width="15%" />
-<col width="76%" />
-<thead>
-<tr>
-<th align="left" valign="top">Event </th>
-<th align="left" valign="top"> Parameters </th>
-<th align="left" valign="top"> Notes</th>
-</tr>
-</thead>
-<tbody>
-<tr>
-<td align="left" valign="top"><p class="table"><tt>"body"</tt></p></td>
-<td align="left" valign="top"><p class="table"><tt>chunk</tt></p></td>
-<td align="left" valign="top"><p class="table">Emitted when a piece of the message body is received. Example: A chunk of
-the body is given as the single argument. The transfer-encoding has been
-decoded. The body chunk a String. The body encoding is set with
-<tt>response.setBodyEncoding()</tt>.</p></td>
-</tr>
-<tr>
-<td align="left" valign="top"><p class="table"><tt>"complete"</tt></p></td>
-<td align="left" valign="top"><p class="table"></p></td>
-<td align="left" valign="top"><p class="table">Emitted exactly once for each message. No arguments.
-After emitted no other events will be emitted on the response.</p></td>
-</tr>
-</tbody>
-</table>
-</div>
-<div class="dlist"><dl>
-<dt class="hdlist1">
-<tt>response.statusCode</tt>
-</dt>
-<dd>
-<p>
- The 3-digit HTTP response status code. E.G. <tt>404</tt>.
-</p>
-</dd>
-<dt class="hdlist1">
-<tt>response.httpVersion</tt>
-</dt>
-<dd>
-<p>
- The HTTP version of the connected-to server. Probably either
- <tt>"1.1"</tt> or <tt>"1.0"</tt>.
-</p>
-</dd>
-<dt class="hdlist1">
-<tt>response.headers</tt>
-</dt>
-<dd>
-<p>
- The response headers.
-</p>
-</dd>
-<dt class="hdlist1">
-<tt>response.setBodyEncoding(encoding)</tt>
-</dt>
-<dd>
-<p>
- Set the encoding for the response body. Either <tt>"utf8"</tt> or <tt>"binary"</tt>.
- Defaults to <tt>"binary"</tt>.
-</p>
-</dd>
-<dt class="hdlist1">
-<tt>response.pause()</tt>
-</dt>
-<dd>
-<p>
- Pauses response from emitting events. Useful to throttle back a download.
-</p>
-</dd>
-<dt class="hdlist1">
-<tt>response.resume()</tt>
-</dt>
-<dd>
-<p>
- Resumes a paused response.
-</p>
-</dd>
-<dt class="hdlist1">
-<tt>response.client</tt>
-</dt>
-<dd>
-<p>
- A reference to the <tt>http.Client</tt> that this response belongs to.
-</p>
-</dd>
-</dl></div>
-<h3 id="_multipart_parsing">Multipart Parsing</h3><div style="clear:left"></div>
-<div class="paragraph"><p>A library to parse HTTP requests with <tt>multipart/form-data</tt> is included with
-Node. To use it, <tt>require("/multipart.js")</tt>.</p></div>
-<div class="dlist"><dl>
-<dt class="hdlist1">
-<tt>multipart.parse(options)</tt>
-</dt>
-<dd>
-<div class="ulist"><ul>
-<li>
-<p>
-on success: Returns an object where each key holds the value of one part of
- the stream. <tt>options</tt> can either be an instance of
- <tt>http.ServerRequest</tt> or an object containing a <em>boundary</em> and a
- <em>data</em> key.
-</p>
-</li>
-<li>
-<p>
-on error: no parameters.
-</p>
-</li>
-</ul></div>
-</dd>
-</dl></div>
-<h4 id="_tt_multipart_stream_tt"><tt>multipart.Stream</tt></h4>
-<div class="paragraph"><p>Here is an example for parsing a <tt>multipart/form-data</tt> request:</p></div>
-<div class="listingblock">
-<div class="content">
-<pre><tt>var multipart = require('/multipart.js');
-var stream = new multipart.Stream(options);
-var parts = {};
-
-stream.addListener('part', function (part) {
- var name = part.headers['Content-Disposition'].name;
- var buffer = '';
-
- part.addListener('body', function(chunk) {
- buffer = buffer + chunk;
- });
-
- part.addListener('complete', function() {
- parts[name] = buffer;
- });
-});
-
-stream.addListener('complete', function() {
- // The parts object now contains all parts and data
-});</tt></pre>
-</div></div>
-<div class="tableblock">
-<table rules="all"
-width="100%"
-frame="border"
-cellspacing="0" cellpadding="4">
-<col width="7%" />
-<col width="15%" />
-<col width="76%" />
-<thead>
-<tr>
-<th align="left" valign="top">Event </th>
-<th align="left" valign="top"> Parameters </th>
-<th align="left" valign="top"> Notes</th>
-</tr>
-</thead>
-<tbody>
-<tr>
-<td align="left" valign="top"><p class="table"><tt>"part"</tt></p></td>
-<td align="left" valign="top"><p class="table"><tt>part</tt></p></td>
-<td align="left" valign="top"><p class="table">Emitted when a new part is found in the stream.
- <tt>part</tt> is an instance of <tt>multipart.Part</tt>.</p></td>
-</tr>
-<tr>
-<td align="left" valign="top"><p class="table"><tt>"complete"</tt></p></td>
-<td align="left" valign="top"><p class="table"></p></td>
-<td align="left" valign="top"><p class="table">Emitted when the end of the stream is reached.</p></td>
-</tr>
-</tbody>
-</table>
-</div>
-<h4 id="_tt_multipart_part_tt"><tt>multipart.Part</tt></h4>
-<div class="tableblock">
-<table rules="all"
-width="100%"
-frame="border"
-cellspacing="0" cellpadding="4">
-<col width="7%" />
-<col width="15%" />
-<col width="76%" />
-<thead>
-<tr>
-<th align="left" valign="top">Event </th>
-<th align="left" valign="top"> Parameters </th>
-<th align="left" valign="top"> Notes</th>
-</tr>
-</thead>
-<tbody>
-<tr>
-<td align="left" valign="top"><p class="table"><tt>"body"</tt></p></td>
-<td align="left" valign="top"><p class="table"><tt>chunk</tt></p></td>
-<td align="left" valign="top"><p class="table">Emitted when a chunk of body is read.</p></td>
-</tr>
-<tr>
-<td align="left" valign="top"><p class="table"><tt>"complete"</tt></p></td>
-<td align="left" valign="top"><p class="table"></p></td>
-<td align="left" valign="top"><p class="table">Emitted when the end of the part is reached.</p></td>
-</tr>
-</tbody>
-</table>
-</div>
-<h3 id="_tcp">TCP</h3><div style="clear:left"></div>
-<div class="paragraph"><p>To use the TCP server and client one must <tt>require("/tcp.js")</tt> or
-<tt>include("/tcp.js")</tt>.</p></div>
-<h4 id="_tt_tcp_server_tt"><tt>tcp.Server</tt></h4>
-<div class="paragraph"><p>Here is an example of a echo server which listens for connections
-on port 7000</p></div>
-<div class="listingblock">
-<div class="content">
-<pre><tt>include("/tcp.js");
-var server = createServer(function (socket) {
- socket.setEncoding("utf8");
- socket.addListener("connect", function () {
- socket.send("hello\r\n");
- });
- socket.addListener("receive", function (data) {
- socket.send(data);
- });
- socket.addListener("eof", function () {
- socket.send("goodbye\r\n");
- socket.close();
- });
-});
-server.listen(7000, "localhost");</tt></pre>
-</div></div>
-<div class="tableblock">
-<table rules="all"
-width="100%"
-frame="border"
-cellspacing="0" cellpadding="4">
-<col width="7%" />
-<col width="15%" />
-<col width="76%" />
-<thead>
-<tr>
-<th align="left" valign="top">Event </th>
-<th align="left" valign="top"> Parameters </th>
-<th align="left" valign="top"> Notes</th>
-</tr>
-</thead>
-<tbody>
-<tr>
-<td align="left" valign="top"><p class="table"><tt>"connection"</tt></p></td>
-<td align="left" valign="top"><p class="table"><tt>connection</tt></p></td>
-<td align="left" valign="top"><p class="table">Emitted when a new connection is made.
- <tt>connection</tt> is an instance of <tt>tcp.Connection</tt>.</p></td>
-</tr>
-<tr>
-<td align="left" valign="top"><p class="table"><tt>"close"</tt></p></td>
-<td align="left" valign="top"><p class="table"><tt>errorno</tt></p></td>
-<td align="left" valign="top"><p class="table">Emitted when the server closes. <tt>errorno</tt>
- is an integer which indicates what, if any,
- error caused the server to close. If no
- error occurred <tt>errorno</tt> will be 0.</p></td>
-</tr>
-</tbody>
-</table>
-</div>
-<div class="dlist"><dl>
-<dt class="hdlist1">
-<tt>tcp.createServer(connection_listener);</tt>
-</dt>
-<dd>
-<p>
-Creates a new TCP server.
-</p>
-<div class="paragraph"><p>The <tt>connection_listener</tt> argument is automatically set as a listener for
-the <tt>"connection"</tt> event.</p></div>
-</dd>
-<dt class="hdlist1">
-<tt>server.listen(port, host=null, backlog=128)</tt>
-</dt>
-<dd>
-<p>
-Tells the server to listen for TCP connections to <tt>port</tt> and <tt>host</tt>.
-</p>
-<div class="paragraph"><p><tt>host</tt> is optional. If <tt>host</tt> is not specified the server will accept client
-connections on any network address.</p></div>
-<div class="paragraph"><p>The third argument, <tt>backlog</tt>, is also optional and defaults to 128. The
-<tt>backlog</tt> argument defines the maximum length to which the queue of pending
-connections for the server may grow.</p></div>
-<div class="paragraph"><p>This function is synchronous.</p></div>
-</dd>
-<dt class="hdlist1">
-<tt>server.close()</tt>
-</dt>
-<dd>
-<p>
-Stops the server from accepting new connections. This function is
-asynchronous, the server is finally closed when the server emits a <tt>"close"</tt>
-event.
-</p>
-</dd>
-</dl></div>
-<h4 id="_tt_tcp_connection_tt"><tt>tcp.Connection</tt></h4>
-<div class="paragraph"><p>This object is used as a TCP client and also as a server-side
-socket for <tt>tcp.Server</tt>.</p></div>
-<div class="tableblock">
-<table rules="all"
-width="100%"
-frame="border"
-cellspacing="0" cellpadding="4">
-<col width="7%" />
-<col width="15%" />
-<col width="76%" />
-<thead>
-<tr>
-<th align="left" valign="top">Event </th>
-<th align="left" valign="top"> Parameters </th>
-<th align="left" valign="top"> Notes</th>
-</tr>
-</thead>
-<tbody>
-<tr>
-<td align="left" valign="top"><p class="table"><tt>"connect"</tt></p></td>
-<td align="left" valign="top"><p class="table"></p></td>
-<td align="left" valign="top"><p class="table">Call once the connection is established
- after a call to <tt>createConnection()</tt> or
- <tt>connect()</tt>.</p></td>
-</tr>
-<tr>
-<td align="left" valign="top"><p class="table"><tt>"receive"</tt></p></td>
-<td align="left" valign="top"><p class="table"><tt>data</tt></p></td>
-<td align="left" valign="top"><p class="table">Called when data is received on the
- connection. <tt>data</tt> will be a string.
- Encoding of data is set by
- <tt>connection.setEncoding()</tt>.</p></td>
-</tr>
-<tr>
-<td align="left" valign="top"><p class="table"><tt>"eof"</tt></p></td>
-<td align="left" valign="top"><p class="table"></p></td>
-<td align="left" valign="top"><p class="table">Called when the other end of the
- connection sends a FIN packet.
- After this is emitted the <tt>readyState</tt>
- will be <tt>"writeOnly"</tt>. One should probably
- just call <tt>connection.close()</tt> when this
- event is emitted.</p></td>
-</tr>
-<tr>
-<td align="left" valign="top"><p class="table"><tt>"timeout"</tt></p></td>
-<td align="left" valign="top"><p class="table"></p></td>
-<td align="left" valign="top"><p class="table">Emitted if the connection times out from
- inactivity. The <tt>"close"</tt> event will be
- emitted immediately following this event.</p></td>
-</tr>
-<tr>
-<td align="left" valign="top"><p class="table"><tt>"close"</tt></p></td>
-<td align="left" valign="top"><p class="table"><tt>had_error</tt></p></td>
-<td align="left" valign="top"><p class="table">Emitted once the connection is fully
- closed. The argument <tt>had_error</tt>
- is a boolean which says if the connection
- was closed due to a transmission error.
- (TODO: access error codes.)</p></td>
-</tr>
-</tbody>
-</table>
-</div>
-<div class="dlist"><dl>
-<dt class="hdlist1">
-<tt>tcp.createConnection(port, host="127.0.0.1")</tt>
-</dt>
-<dd>
-<p>
-Creates a new connection object and opens a connection to the specified
-<tt>port</tt> and <tt>host</tt>. If the second parameter is omitted, localhost is assumed.
-</p>
-<div class="paragraph"><p>When the connection is established the <tt>"connect"</tt> event will be emitted.</p></div>
-</dd>
-<dt class="hdlist1">
-<tt>connection.connect(port, host="127.0.0.1")</tt>
-</dt>
-<dd>
-<p>
-Opens a connection to the specified <tt>port</tt> and <tt>host</tt>. <tt>createConnection()</tt>
-also opens a connection; normally this method is not needed. Use this only
-if a connection is closed and you want to reuse the object to connect to
-another server.
-</p>
-<div class="paragraph"><p>This function is asynchronous. When the <tt>"connect"</tt> event is emitted the
-connection is established. If there is a problem connecting, the <tt>"connect"</tt>
-event will not be emitted, the <tt>"close"</tt> event will be emitted with
-<tt>had_error == true</tt>.</p></div>
-</dd>
-<dt class="hdlist1">
-<tt>connection.remoteAddress</tt>
-</dt>
-<dd>
-<p>
-The string representation of the remote IP address. For example,
-<tt>"74.125.127.100"</tt> or <tt>"2001:4860:a005::68"</tt>.
-</p>
-<div class="paragraph"><p>This member is only present in server-side connections.</p></div>
-</dd>
-<dt class="hdlist1">
-<tt>connection.readyState</tt>
-</dt>
-<dd>
-<p>
-Either <tt>"closed"</tt>, <tt>"open"</tt>, <tt>"opening"</tt>, <tt>"readOnly"</tt>, or <tt>"writeOnly"</tt>.
-</p>
-</dd>
-<dt class="hdlist1">
-<tt>connection.setEncoding(encoding)</tt>
-</dt>
-<dd>
-<p>
-Sets the encoding (either <tt>"ascii"</tt>, <tt>"utf8"</tt>, or <tt>"binary"</tt>) for data that is received.
-</p>
-</dd>
-<dt class="hdlist1">
-<tt>connection.send(data, encoding="ascii")</tt>
-</dt>
-<dd>
-<p>
-Sends data on the connection. The second parameter specifies the encoding
-in the case of a string&#8212;it defaults to ASCII because encoding to UTF8 is
-rather slow.
-</p>
-</dd>
-<dt class="hdlist1">
-<tt>connection.close()</tt>
-</dt>
-<dd>
-<p>
-Half-closes the connection. I.E., it sends a FIN packet. It is
-possible the server will still send some data. After calling
-this <tt>readyState</tt> will be <tt>"readOnly"</tt>.
-</p>
-</dd>
-<dt class="hdlist1">
-<tt>connection.forceClose()</tt>
-</dt>
-<dd>
-<p>
-Ensures that no more I/O activity happens on this socket. Only
-necessary in case of errors (parse error or so).
-</p>
-</dd>
-<dt class="hdlist1">
-<tt>connection.readPause()</tt>
-</dt>
-<dd>
-<p>
-Pauses the reading of data. That is, <tt>"receive"</tt> events will not be emitted.
-Useful to throttle back an upload.
-</p>
-</dd>
-<dt class="hdlist1">
-<tt>connection.readResume()</tt>
-</dt>
-<dd>
-<p>
-Resumes reading if reading was paused by <tt>readPause()</tt>.
-</p>
-</dd>
-<dt class="hdlist1">
-<tt>connection.setTimeout(timeout)</tt>
-</dt>
-<dd>
-<p>
-Sets the connection to timeout after <tt>timeout</tt> milliseconds of inactivity on
-the connection. By default all <tt>tcp.Connection</tt> objects have a timeout
-of 60 seconds (60000 ms).
-</p>
-<div class="paragraph"><p>If <tt>timeout</tt> is 0, then the idle timeout is disabled.</p></div>
-</dd>
-<dt class="hdlist1">
-<tt>connection.setNoDelay(noDelay=true)</tt>
-</dt>
-<dd>
-<p>
-Disables the Nagle algorithm. By default TCP connections use the Nagle
-algorithm, they buffer data before sending it off. Setting <tt>noDelay</tt> will
-immediately fire off data each time <tt>connection.send()</tt> is called.
-</p>
-</dd>
-</dl></div>
-<h3 id="_dns">DNS</h3><div style="clear:left"></div>
-<div class="paragraph"><p>Here is an example of which resolves <tt>"www.google.com"</tt> then reverse
-resolves the IP addresses which are returned.</p></div>
-<div class="listingblock">
-<div class="content">
-<pre><tt>var resolution = node.dns.resolve4("www.google.com");
-
-resolution.addCallback(function (addresses, ttl, cname) {
- puts("addresses: " + JSON.stringify(addresses));
- puts("ttl: " + JSON.stringify(ttl));
- puts("cname: " + JSON.stringify(cname));
-
- for (var i = 0; i &lt; addresses.length; i++) {
- var a = addresses[i];
- var reversing = node.dns.reverse(a);
- reversing.addCallback( function (domains, ttl, cname) {
- puts("reverse for " + a + ": " + JSON.stringify(domains));
- });
- reversing.addErrback( function (code, msg) {
- puts("reverse for " + a + " failed: " + msg);
- });
- }
-});
-
-resolution.addErrback(function (code, msg) {
- puts("error: " + msg);
-});</tt></pre>
-</div></div>
-<div class="dlist"><dl>
-<dt class="hdlist1">
-<tt>node.dns.resolve4(domain)</tt>
-</dt>
-<dd>
-<p>
-Resolves a domain (e.g. <tt>"google.com"</tt>) into an array of IPv4 addresses (e.g.
-<tt>["74.125.79.104", "74.125.79.105", "74.125.79.106"]</tt>).
-This function returns a promise.
-</p>
-<div class="ulist"><ul>
-<li>
-<p>
-on success: returns <tt>addresses, ttl, cname</tt>. <tt>ttl</tt> (time-to-live) is an integer
- specifying the number of seconds this result is valid for. <tt>cname</tt> is the
- canonical name for the query.
-</p>
-</li>
-<li>
-<p>
-on error: returns <tt>code, msg</tt>. <tt>code</tt> is one of the error codes listed
- below and <tt>msg</tt> is a string describing the error in English.
-</p>
-</li>
-</ul></div>
-</dd>
-<dt class="hdlist1">
-<tt>node.dns.resolve6(domain)</tt>
-</dt>
-<dd>
-<p>
-The same as <tt>node.dns.resolve4()</tt> except for IPv6 queries (an <tt>AAAA</tt> query).
-</p>
-</dd>
-<dt class="hdlist1">
-<tt>node.dns.reverse(ip)</tt>
-</dt>
-<dd>
-<p>
-Reverse resolves an ip address to an array of domain names.
-</p>
-<div class="ulist"><ul>
-<li>
-<p>
-on success: returns <tt>domains, ttl, cname</tt>. <tt>ttl</tt> (time-to-live) is an integer
- specifying the number of seconds this result is valid for. <tt>cname</tt> is the
- canonical name for the query. <tt>domains</tt> is an array of domains.
-</p>
-</li>
-<li>
-<p>
-on error: returns <tt>code, msg</tt>. <tt>code</tt> is one of the error codes listed
- below and <tt>msg</tt> is a string describing the error in English.
-</p>
-</li>
-</ul></div>
-</dd>
-</dl></div>
-<div class="paragraph"><p>Each DNS query can return an error code.</p></div>
-<div class="ulist"><ul>
-<li>
-<p>
-<tt>node.dns.TEMPFAIL</tt>: timeout, SERVFAIL or similar.
-</p>
-</li>
-<li>
-<p>
-<tt>node.dns.PROTOCOL</tt>: got garbled reply.
-</p>
-</li>
-<li>
-<p>
-<tt>node.dns.NXDOMAIN</tt>: domain does not exists.
-</p>
-</li>
-<li>
-<p>
-<tt>node.dns.NODATA</tt>: domain exists but no data of reqd type.
-</p>
-</li>
-<li>
-<p>
-<tt>node.dns.NOMEM</tt>: out of memory while processing.
-</p>
-</li>
-<li>
-<p>
-<tt>node.dns.BADQUERY</tt>: the query is malformed.
-</p>
-</li>
-</ul></div>
-</div>
-<h2 id="_repl">REPL</h2>
-<div class="sectionbody">
-<div class="paragraph"><p>A Read-Eval-Print-Loop is available both as a standalone program and easily
-includable in other programs.</p></div>
-<div class="paragraph"><p>The standalone REPL is called <tt>node-repl</tt> and is installed at
-<tt>$PREFIX/bin/node-repl</tt>. It&#8217;s recommended to use it with the program
-<tt>rlwrap</tt> for a better user interface. I set</p></div>
-<div class="listingblock">
-<div class="content">
-<pre><tt>alias node-repl="rlwrap node-repl"</tt></pre>
-</div></div>
-<div class="paragraph"><p>in my zsh configuration.</p></div>
-<div class="paragraph"><p>Inside the REPL, Control+D will exit. The special variable <tt>_</tt> (underscore) contains the
-result of the last expression.</p></div>
-<div class="paragraph"><p>The library is called <tt>/repl.js</tt> and it can be used like this:</p></div>
-<div class="listingblock">
-<div class="content">
-<pre><tt>include("/utils.js");
-include("/tcp.js");
-nconnections = 0;
-createServer(function (c) {
- error("Connection!");
- nconnections += 1;
- c.close();
-}).listen(5000);
-require("/repl.js").start("simple tcp server&gt; ");</tt></pre>
-</div></div>
-</div>
-<h2 id="_extension_api">Extension API</h2>
-<div class="sectionbody">
-<div class="paragraph"><p>External modules can be compiled and dynamically linked into Node.
-Node is more or less glue between several C and C++ libraries:</p></div>
-<div class="ulist"><ul>
-<li>
-<p>
-V8 Javascript, a C++ library. Used for interfacing with Javascript:
- creating objects, calling functions, etc. Documented mostly in the
- <tt>v8.h</tt> header file (<tt>deps/v8/include/v8.h</tt> in the Node source tree).
-</p>
-</li>
-<li>
-<p>
-libev, C event loop library. Anytime one needs to wait for a file
- descriptor to become readable, wait for a timer, or wait for a signal to
- received one will need to interface with libev. That is, if you perform
- any I/O, libev will need to be used. Node uses the <tt>EV_DEFAULT</tt> event
- loop. Documentation can be found <a href="http:/cvs.schmorp.de/libev/ev.html">here</a>.
-</p>
-</li>
-<li>
-<p>
-libeio, C thread pool library. Used to execute blocking POSIX system
- calls asynchronously. Mostly wrappers already exist for such calls, in
- <tt>src/file.cc</tt> so you will probably not need to use it. If you do need it,
- look at the header file <tt>deps/libeio/eio.h</tt>.
-</p>
-</li>
-<li>
-<p>
-Internal Node libraries. Most importantly is the <tt>node::EventEmitter</tt>
- class which you will likely want to derive from.
-</p>
-</li>
-<li>
-<p>
-Others. Look in <tt>deps/</tt> for what else is available.
-</p>
-</li>
-</ul></div>
-<div class="paragraph"><p>Node statically compiles all its dependencies into the executable. When
-compiling your module, you don&#8217;t need to worry about linking to any of these
-libraries.</p></div>
-<div class="paragraph"><p>Here is a sample Makefile taken from
-<a href="http://github.com/ry/node_postgres">node_postgres</a>:</p></div>
-<div class="listingblock">
-<div class="content">
-<pre><tt>binding.node: binding.o Makefile
- gcc -shared -o binding.node binding.o \
- -L`pg_config --libdir` -lpq
-
-binding.o: binding.cc Makefile
- gcc `node --cflags` -I`pg_config --includedir` \
- binding.cc -c -o binding.o
-
-clean:
- rm -f binding.o binding.node
-.PHONY: clean</tt></pre>
-</div></div>
-<div class="paragraph"><p>As you can see, the only thing your module needs to know about Node is the
-CFLAGS that node was compiled with which are gotten from <tt>node --cflags</tt>
-If you want to make a debug build, then use <tt>node_g --cflags</tt>. (<tt>node_g</tt> is
-the debug build of node, which can built with <tt>configure --debug; make; make
-install</tt>.)</p></div>
-<div class="paragraph"><p>Node extension modules are dynamically linked libraries with a <tt>.node</tt>
-extension. Node opens this file and looks for a function called <tt>init()</tt>
-which must be of the form:</p></div>
-<div class="listingblock">
-<div class="content">
-<pre><tt>extern "C" void init (Handle&lt;Object&gt; target)</tt></pre>
-</div></div>
-<div class="paragraph"><p>In this function you can create new javascript objects and attach them to
-<tt>target</tt>. Here is a very simple module:</p></div>
-<div class="listingblock">
-<div class="content">
-<pre><tt>extern "C" void
-init (Handle&lt;Object&gt; target)
-{
- HandleScope scope;
- target-&gt;Set(String::New("hello"), String::New("World"));
-}</tt></pre>
-</div></div>
-<div class="paragraph"><p>Further documentation will come soon. For now see the source code of
-<a href="http://github.com/ry/node_postgres">node_postgres</a>.</p></div>
-</div>
-<div id="footer">
-<div id="footer-text">
-Version 0.1.13<br />
-Last updated 2009-10-03 18:02:36 CEST
-</div>
-</div>
-</body>
-</html>
View
2,260 doc/api.xml
@@ -1,2260 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE refentry PUBLIC "-//OASIS//DTD DocBook XML V4.5//EN" "http://www.oasis-open.org/docbook/xml/4.5/docbookx.dtd">
-<refentry lang="en">
-<refmeta>
-<refentrytitle>node</refentrytitle>
-<manvolnum>1</manvolnum>
-</refmeta>
-<refnamediv>
- <refname>node</refname>
- <refpurpose>evented I/O for V8 javascript</refpurpose>
-</refnamediv>