moonbridge
view reference.txt @ 314:1b459e9c12c9
Added parameter to waitfunc of asynchronous I/O functions which allows to check whether waitfunc was called for the first time
| author | jbe |
|---|---|
| date | Thu Feb 01 20:26:30 2018 +0100 (2018-02-01) |
| parents | 334ea1f13b0b |
| children | 15132b3c053d |
line source
2 Moonbridge reference
3 ====================
7 Global function listen{...}
8 ---------------------------
10 This function initializes the Moonbridge Network Server. It may be called
11 multiple times. However, it is not allowed to register additional listeners by
12 calling listen{...} from a "prepare", "connect", or "finish" handler.
14 See file "example.lua" for parametrization of the listen{...} function.
16 Warning: Moonbridge will fork the Lua environment to handle parallel requests.
17 Functions provided as "prepare", "connect", and "finish" handlers may access
18 global variables, but for every child process these global variables will not
19 be shared! If you require a global state, a DBMS, cache server, or similar is
20 necessary.
24 Global function timeout(...)
25 ----------------------------
27 Calling this function with a positive number (time in seconds) sets a timer
28 that kills the current process after the selected time runs out. The remaining
29 time can be queried by calling this function without arguments.
31 Calling this function with a single argument that is the number zero will
32 disable the timeout.
34 Another mode of operation is selected by passing two arguments: a time (in
35 seconds) as first argument and a function as second argument. In this case, a
36 sub-timer will be used to limit the execution time of the function. In case of
37 timeout, the process will be killed (and the timeout function does not return).
38 If the time for the sub-timer is longer than a previously set timeout (using
39 the timeout(...) function with one argument), the shorter timeout (of the
40 previous call of timeout(...)) will have precedence.
42 Timers are also automatically reset (disabled) when a handler (prepare handler
43 or connect handler) returns. To shutdown processes after a certain time waiting
44 for a new request, use the idle_time parameter of the listen function.
48 Socket object passed to "connect" handler
49 -----------------------------------------
51 For every incoming connection, the registered "connect" handler is called with
52 a single socket object as argument, which is described below:
55 ### socket:close()
57 Closes the socket connection (input and output stream) by flushing all data and
58 sending a TCP FIN packet.
60 Returns true on success, or nil plus error message in case of an I/O error.
61 Using this method on sockets that have already been closed (or reset) will
62 throw an error.
64 Warning: Pending data on the input stream may cause connection aborts (TCP RST)
65 when network connections are used. All pending input data should have been read
66 (or drained) before calling socket:close(). Use socket:finish() to send a
67 TCP FIN packet to the peer before waiting for EOF from the peer.
69 A socket passed to the "connect" handler will be closed automatically if it was
70 not closed by the "connect" handler and if the "connect" handler returns
71 normally (i.e. without throwing an error). If the "connect" handler throws an
72 error, then the socket will be reset. See socket:reset().
75 ### socket:drain(maxlen, terminator)
77 Same as socket:read(maxlen, terminator), but discards the input and returns the
78 number of discarded bytes (as first return value) and the status code ("term",
79 "maxlen", "eof" as second return value).
81 In case of an I/O error, nil (as first return value) plus an error message (as
82 second return value) are returned.
85 ### socket:drain_call(waitfunc, maxlen, terminator)
87 Same as socket:drain(maxlen, terminator), but calls waitfunc(socket, "r", first
88 moonbridge_io) (in an infinite loop, first=true only on first call) as long as
89 the reading is blocked.
92 ### socket:drain_nb(maxlen, terminator)
94 Same as socket:drain(maxlen, terminator), but non-blocking. The status code
95 (which is returned as second return value) may therefore be "term", "maxlen",
96 "eof", or "block".
98 In case of an I/O error, nil (as first return value) plus an error message (as
99 second return value) are returned.
102 ### socket:drain_yield(maxlen, terminator)
104 Alias for socket:drain_call(coroutine.yield, maxlen, terminator)
107 ### socket:finish()
109 Sends a TCP FIN packet to indicate EOF on write stream. Subsequent reads are
110 still possible. When there is no more input data to be read, the connection
111 should finally be closed with socket:close().
113 In case of local sockets (Unix Domain Sockets), socket:finish() simply closes
114 the underlying socket and emulates EOF on subsequent reads. Also in this case,
115 the connection should be finally closed with socket:close().
118 ### socket:flush(...)
120 Same as socket:write(...) but additionally flushes the socket (i.e. all pending
121 data is passed to the operating system).
123 In case of an I/O error, nil (as first return value) plus an error message (as
124 second return value) are returned. On success, the socket userdata object is
125 returned.
128 ### socket:flush_call(waitfunc, ...)
130 Same as socket:flush(...), but calls waitfunc(socket, "w", first,
131 moonbridge_io) (in an infinite loop, first=true only on first call) as long as
132 the writing is blocked.
135 ### socket:flush_nb(...)
137 Same as socket:write_nb(...) but additionally flushes the socket (i.e. all
138 pending data is passed to the operating system). The total number of bytes that
139 could not be passed yet to the operating system is returned. Zero is returned
140 if all data could be flushed out.
142 In case of an I/O error, nil (as first return value) plus an error message (as
143 second return value) are returned.
146 ### socket:flush_yield(...)
148 Alias for socket:flush_call(coroutine.yield, ...)
151 ### socket.interval
153 Set to the name of an interval timer if the "connect" handler was called due to
154 an elapsed interval timer. Otherwise nil.
157 ### socket.local_ip4
159 Local IPv4 address used for the connection. Encoded as 4 raw bytes in form of a
160 string.
163 ### socket.local_ip6
165 Local IPv6 address used for the connection. Encoded as 16 raw bytes in form of
166 a string.
169 ### socket.local_tcpport
171 Local TCP port used for the connection.
174 ### socket:read(maxlen, terminator)
176 Reads up to maxlen bytes or until an optional termination character is
177 encountered (which is included in the result). The maxlen value may be nil, in
178 which case there is no limit on the number of bytes read.
180 In case of an I/O error, nil (as first return value) plus an error message (as
181 second return value) are returned.
183 In all other cases (including EOF), the following two values are returned:
185 - a string containing the bytes read (first return value, may be empty string)
186 - a status code equal to "term", "maxlen", or "eof" (second return value)
188 If an EOF is encountered before all data could be read, then "eof" is returned
189 as second return value. If maxlen bytes have been read and no termination
190 character has been read, then "maxlen" is returned as second return value. If
191 the termination character is the last character of the read string, the second
192 return value will be "term".
195 ### socket:read_call(waitfunc, maxlen, terminator)
197 Same as socket:read(maxlen, terminator), but calls waitfunc(socket, "r", first,
198 moonbridge_io) (in an infinite loop, first=true only on first call) as long as
199 the reading is blocked.
202 ### socket:read_nb(maxlen, terminator)
204 Same as socket:read(maxlen, terminator), but does not block.
206 In case of an I/O error, nil (as first return value) plus an error message (as
207 second return value) are returned.
209 In all other cases (including EOF), the following two values are returned:
211 - a string containing the bytes read (first return value, may be empty string)
212 - a status code equal to "term", "maxlen", "eof", "block" (second return value)
214 The status code "block" as second return value is used if the function returned
215 prematurely because it would block otherwise. In this case, the first return
216 value is a string that contains the bytes that could be read without blocking.
219 ### socket:read_yield(maxlen, terminator)
221 Alias for socket:read_call(coroutine.yield, maxlen, terminator)
224 ### socket.remote_ip4
226 Remote IPv4 address used for the connection. Encoded as 4 raw bytes in form of
227 a string.
230 ### socket.remote_ip6
232 Remote IPv6 address used for the connection. Encoded as 16 raw bytes in form of
233 a string.
236 ### socket.remote_tcpport
238 Remote TCP port used for the connection.
241 ### socket:reset()
243 Alias for socket:close(). Closes the socket connection by sending a TCP RST
244 packet if possible to indicate error condition. This is the default operation
245 when a socket handle gets garbage collected or the process is terminated
246 abnormally.
248 Returns true on success, or nil (as first return value) plus error message (as
249 second return value) in case of an I/O error. Using this method on sockets that
250 have already been closed (or reset) will throw an error.
252 Warning: Previously sent (and flushed) data may be lost during transmission.
255 ### socket:write(...)
257 Takes a variable number of strings and sends them to the peer. The operation is
258 buffered, so to actually send out the data, it is necessary to eventually call
259 socket:flush(), socket:finish(), or socket:close().
261 In case of an I/O error, nil (as first return value) plus an error message (as
262 second return value) are returned. On success, the socket userdata object is
263 returned.
266 ### socket:write_call(waitfunc, ...)
268 Same as socket:write(...), but calls waitfunc(socket, "w", first,
269 moonbridge_io) (in an infinite loop, first=true only on first call) as long as
270 the writing is blocked.
273 ### socket:write_nb(...)
275 Takes a variable number of strings and sends them to the peer. The operation is
276 buffered, so to actually send out the data, it is necessary to eventually call
277 socket:flush_nb(), socket:flush(), socket:finish(), or socket:close().
279 This function always returns immediately (i.e. it does not block). If all data
280 (but a small buffered portion) could be sent out, then zero is returned.
281 Otherwise, all arguments that could not be sent are stored in a buffer of
282 unlimited size (up to memory capabilities) and an integer is returned that
283 indicates the number of bytes currently in the buffer.
285 In case of an I/O error, nil (as first return value) plus an error message (as
286 second return value) are returned.
289 ### socket:write_yield(...)
291 Alias for socket:write_call(coroutine.yield, ...)
295 I/O library
296 -----------
298 The Moonbridge Network Server for Lua Applications comes with its own I/O
299 library to support blocking as well as nonblocking I/O operations.
301 All methods on an I/O handle (e.g. socket) are described in the previous
302 section regarding the "socket" object. All other functions of the library are
303 listed below.
306 ### moonbridge_io.catch_sigterm()
308 This function installs a signal handler for SIGTERM. Instead of causing
309 immediate process termination, the behavior of moonbridge_io.poll(...) is
310 modified.
312 See moonbridge_io.poll(...) for further information.
315 ### moonbridge_io.exec(command, arg1, arg2, ...)
317 Executes the given command and returns a child handle with three sockets named
318 "stdin", "stdout", and "stderr" as well as the following methods:
320 - :kill(signal)
321 - :wait()
322 - :wait_nb()
323 - :wait_call(waitfunc)
324 - :wait_yield()
326 Use :kill(signal) to terminate the process with the given signal (defaults to 9
327 for SIGKILL).
329 The :wait() method will wait for the process to terminate and return its exit
330 code. If the process was terminated by a signal, a negative integer is returned
331 which corresponds to the respective positive signal number.
333 The method :wait_nb() is the same as :wait(), except that it does not block but
334 returns false (plus a notice as second return value) if the child process has
335 not terminated yet.
337 The method :wait_call() is the same as :wait() but calls waitfunc() (in an
338 infinite loop) as long as the process is still running.
340 The method :wait_yield() is an alias for :wait_call(coroutine.yield).
342 It is possible to wait for process termination by including the child handle
343 in the input_set of the moonbridge_io.poll(...) call.
345 moonbridge_io.exec(...) returns nil (as first return value) plus an error
346 message (as second return value) in case of error.
349 ### moonbridge_io.getpid()
351 Returns the current PID.
354 ### moonbridge_io.localconnect(path)
356 Tries to connect to a local socket (also known as Unix Domain Socket). Returns
357 a socket object on success, or nil (as first return value) plus an error
358 message (as second return value) in case of error.
361 ### moonbridge_io.localconnect_nb(path)
363 Tries to connect to a local socket (also known as Unix Domain Socket). Returns
364 a socket object on success, or nil (as first return value) plus an error
365 message (as second return value) in case of error.
367 Same as moonbridge_io.localconnect(path), except that this function does not
368 block and immediately returns a socket object.
370 In case of an I/O error, nil (as first return value) plus an error message (as
371 second return value) may be returned. However, connection errors may also be
372 reported on first read or write on the socket.
375 ### moonbridge_io.locallisten(path)
377 Attempts to create a local socket (also known as Unix Domain Socket) to accept
378 incoming connections. If the file does already exist and is a socket, then it
379 is deleted automatically before being re-created.
381 In case of an I/O error, nil (as first return value) plus an error message (as
382 second return value) may be returned. On success, a listener object is returned
383 which supports the methods :accept(), :accept_nb(), and :close().
385 The method :accept() blocks until a new incoming connection is available, in
386 which case a socket object is returned.
388 The method :accept_nb() works like :accept(), except that the call is
389 nonblocking and returns false (plus a notice as second return value) in case no
390 incoming connection is available. It is possible to wait for an incoming
391 connection by including the listener object in the input_set of the
392 moonbridge_io.poll(...) call.
394 The method :close() will close the listening socket. In case of local sockets
395 (Unix Domain Sockets), the socket will not be unlinked in the file system.
397 I/O errors by the methods of the listener object are also reported by returning
398 nil (as first return value) plus an error message (as second return value).
401 ### moonbridge_io.poll(input_set, output_set, timeout, wakeup_on_sigterm)
403 This function waits for at least one of the given file descriptors and/or
404 I/O handles to be ready for input or output. The two sets of file descriptors
405 and/or handles must contain the file descriptor or handle as a key, and a value
406 which does evaluate to true, e.g. input_set = {[socketA] = true}. If a set is
407 nil, it is treated as being empty.
409 The input_set may also contain listeners (to wait for incoming connections) and
410 child handles (to wait for process termination).
412 If the 4th parameter (wakeup_on_sigterm) is set to true, then the function
413 returns immediately if the process received at least one SIGTERM signal after
414 moonbridge_io.catch_sigterm() has been called for the first time. Three values
415 are returned if a timeout happened or a SIGTERM has been received: false as
416 first return value, a message string as second return value (that may, for
417 example, be used for assert(...)), and a boolean as third return value which
418 indicates whether the function prematurely returned because of SIGTERM.
420 If the 4th parameter (wakeup_on_sigterm) is omitted or set to false, then the
421 function only returns false as first return value if a timeout happened. In
422 this case, the second return value also will be set to an appropriate message
423 string such that assert(moonbridge_io.poll(...)) can be used to throw an error.
425 In all other cases, the function returns true as a single return value. The
426 function may also return true (for technical reasons) if signals other than
427 SIGTERM have been received during waiting.
429 Note that the function is not thread-safe when the 4th parameter is set to
430 true.
433 ### moonbridge_io.tcpconnect(hostname, port)
435 Tries to open a TCP connection with the given host and TCP port number. Returns
436 a socket object on success, or nil (as first return value) plus an error
437 message (as second return value) in case of error.
440 ### moonbridge_io.tcpconnect_nb(hostname, port)
442 Same as moonbridge_io.tcpconnect(hostname, port), except that this function
443 does not block and immediately returns a socket object.
445 Note: The current implementation still blocks during the DNS lookup. Use a
446 numeric IP address as hostname to be truly nonblocking.
448 In case of an I/O error, nil (as first return value) plus an error message (as
449 second return value) may be returned. However, connection errors may also be
450 reported on first read or write on the socket.
453 ### moonbridge_io.tcplisten(hostname, port)
455 Attempts to open a TCP port for listening. To listen on the loopback interface,
456 use "::1" as hostname if IPv6 shall be used, or use "127.0.0.1" as hostname if
457 IPv4 shall be used. To listen on all available interfaces, use "::" (IPv6) or
458 "0.0.0.0" (IPv4) respectively.
460 In case of an I/O error, nil (as first return value) plus an error message (as
461 second return value) may be returned. On success, a listener object is returned
462 which supports the methods :accept(), :accept_nb(), and :close(). See reference
463 for moonbridge.io_locallisten(...).
466 ### moonbridge_io.timeref(previous)
468 Helper function which returns a time reference (in SI-seconds). If a value is
469 passed as an optional argument to the function, then that value is substracted
470 from the result. A common idiom is:
472 local starttime = moonbridge_io.timeref()
473 [...]
474 while true do
475 [...]
476 if not moonbridge_io.poll(
477 input_set,
478 output_set,
479 timeout - moonbridge_io.timeref(starttime)
480 ) then
481 error("Timeout")
482 end
483 [...]
484 end
488 HTTP module
489 -----------
491 The HTTP module exports the function moonbridge_http.generate_handler(callback)
492 that converts an HTTP handler to a "connect" handler. See file "helloworld.lua"
493 for a simple example or "example_application.lua" for a more complex example of
494 invocation. A table with options may be passed either as a second argument, or
495 as a first argument preceeding the callback function (whichever is more
496 convenient).
498 The following options are supported:
500 - request_body_size_limit: maximum size of payload of HTTP request body
501 (transfer encoding is allowed to add a limited amount of extra data)
502 - chunk_size: optional default value for maximum_input_chunk_size and
503 minimum_output_chunk_size
504 - request_header_size_limit: maximum size of HTTP request headers
505 - maximum_input_chunk_size: maximum chunk size when streaming a request body or
506 certain POST fields (bigger chunks will be fragmented automatically)
507 - minimum_output_chunk_size: minimum size for a chunk when sending a response
508 body (smaller chunks will be buffered and concatenated with future data;
509 ignored when request:flush() is called)
510 - static_headers: a set of headers to be included in every HTTP response
511 (may be a string, a table or strings, or a table of key-value pairs)
513 The callback function receives a single request object as argument, which is
514 described below.
517 ### request.body
519 The request body (without headers) as a string. Accessing this value makes
520 further access to request.post_params and request.post_params_list, or
521 invocation of request:stream_request_body(...) impossible.
524 ### request:close_after_finish()
526 Closes the connection after answering the request.
528 This method can only be called before the HTTP response header section has been
529 finished (i.e. before request:finish_headers(), request:send_data(...), or
530 request:finish() were called), but it may be called before a status code has
531 been sent using request:send_status(...).
533 A corresponding "Connection: close" header is automatically sent.
535 See also request:monologue().
538 ### request:consume_input()
540 Starts processing the request body (if existent) to set the values
541 request.post_params, request.post_params_list, request.post_metadata, and
542 and request.post_metadata_list and/or to call POST field stream handlers that
543 have been previously registered with request:stream_post_param(...) or
544 request:stream_post_params(...), or to call a previously registered request
545 body stream handler that was set with request:set_request_body_streamer().
547 This method gets invoked automatically when the POST param tables
548 (request.post_params, etc.) are accessed or if request.body is accessed.
551 ### request.cookies
553 A table with all cookies sent by the client.
556 ### request.faulty
558 Normally set to false. In case of a write error on the client connection or
559 certain other unexpected errors, this value is set to true before a Lua error
560 is raised.
562 A faulty request handle must not be used, or another Lua error will be raised.
565 ### request:finish()
567 Finishes and flushes a HTTP response. An HTTP status, all headers, and the
568 response body (if applicable) must have been previously sent. May be called
569 multiple times (performs no operation if called on a finished request handle).
570 Gets automatically invoked when the callback handler returns. After calling
571 this method explicitly, no further data may be written.
574 ### request:finish_headers()
576 Finishes and flushes the HTTP response header section. May be called multiple
577 times, as long as the request is not finished completely. This method is
578 automatically invoked if the application is beginning to send a response body.
579 After calling this method, no further headers may be sent.
582 ### request:flush()
584 Flushes any pending output data. Note: In order to mark the end of a response
585 body, it is required to call request:finish().
588 ### request.fresh
590 Set to false whenever the request object has been used (e.g. data has been read
591 or sent out, or a stream handler was installed); true otherwise.
594 ### request.get_params
596 A table that maps field names to their corresponding GET value. If there are
597 several GET values with the given field name, then the first value is used.
599 Note: May be implemented through metamethods, but does support iteration
600 through pairs(...).
603 ### request.get_params_list
605 A table that maps field names to a sequence of their corresponding GET values.
607 Note: May be implemented through metamethods, but does support iteration
608 through pairs(...).
611 ### request.headers
613 A table that maps (case-insensitively) a HTTP header field name to a sequence
614 of values. For each occurrence of the respective header line, a string entry is
615 created in that sequence. Non-existent headers are mapped to an empty table.
618 ### request.headers_csv_string
620 A table that maps (case-insensitively) a HTTP header field name to a comma
621 separated string. Multiple occurrences of the header with the given field name
622 are automatically merged into the comma separated string.
625 ### request.headers_csv_table
627 A table that maps (case-insensitively) a HTTP header field name to a sequence
628 of values. One entry is created in that sequence for every comma separated
629 value of each header with the given field name.
632 ### request.headers_flags
634 A table that maps (case-insensitively) a HTTP header field name to another
635 table which (again case-insensitively) maps a string to a boolean, depending on
636 whether this string occurred in the list of comma separated values of one
637 header line with the given field name that was the key in the first table.
640 ### request.headers_value
642 A table that maps (case-insensitively) a HTTP header field name to a value. If
643 multiple header lines with the given field name have been received, false is
644 used as value.
647 ### request.method
649 The HTTP request method, e.g. "HEAD", "GET", or "POST".
652 ### request:monologue()
654 Same as request:close_after_finish() but additionally discards all input data
655 immediately.
658 ### request.path
660 The requested path without a leading slash and without the query part (e.g.
661 "index.html" if "/index.html?a=b&c=d" has been requested). For the query part,
662 see request.query.
664 This value will be nil if (and only if) the request method is "OPTIONS" with a
665 request target equal to "*" (see also asterisk-form of request-target in
666 section 5.3.4 in RFC 7230).
669 ### request.post_metadata
671 Only set for multipart/form-data POST requests. A table that maps field names
672 to their corresponding POST metadata table which contains two entries:
673 "file_name" and "content_type". If there are several POST values with the given
674 field name, then the first value/file is used.
676 Note: May be implemented through metamethods, but does support iteration
677 through pairs(...).
680 ### request.post_metadata_list
682 Only set for multipart/form-data POST requests. A table that maps field names
683 to a sequence with their corresponding POST metadata tables. Needed if multiple
684 files are uploaded with the same field name.
686 Note: May be implemented through metamethods, but does support iteration
687 through pairs(...).
690 ### request.post_params
692 A table that maps field names to their corresponding POST value. If there are
693 several POST values with the given field name, then the first value is used.
695 Note: May be implemented through metamethods, but does support iteration
696 through pairs(...).
699 ### request.post_params_list
701 A table that maps field names to a sequence of their corresponding POST values.
703 Note: May be implemented through metamethods, but does support iteration
704 through pairs(...).
707 ### request.query
709 Query part of the request target including the leading question mark, e.g.
710 "?a=b&c=d" if the requested target is "/index.html?a=b&c=d". The data is
711 automatically parsed and made available through request.get_params and
712 request.get_params_list.
714 If there is no query part given in the request target, then this string is
715 the empty string. This value will be nil if (and only if) the request method
716 is "OPTIONS" with a request target equal to "*" (see also asterisk-form of
717 request-target in section 5.3.4 in RFC 7230).
720 ### request:send_data(...)
722 Sends data as response body. All arguments are converted via tostring(...) and
723 concatenated. May be called multiple times until the request has been finished
724 by calling request:finish().
726 If the request method (see request.method) is "HEAD", then calls to
727 request:send_data(...) are automatically ignored.
730 ### request:send_header(key, value)
732 Sends a HTTP response header that consists of the given key and the given
733 value. Note: Key and value must be provided as separate arguments. Before any
734 headers can be sent, a HTTP status must have been set with
735 request:send_status(status_string).
738 ### request:send_status(status_string)
740 Sends a HTTP response status that is given as a string consisting of a 3-digit
741 number and an explanatory string, e.g. "200 OK" or "404 Not Found". This
742 function must be called once before any headers or response body data may be
743 sent.
746 ### request.socket
748 The underlaying socket. Can be used to force a TCP RST, etc.
751 ### request:stream_post_param(field_name, callback)
753 Registers a stream handler for the given POST parameter. The callback function
754 will be called in the following manner:
756 - For the initial chunk, the first chunk gets passed as first argument while a
757 table with metadata ("field_name" and "content_type") gets passed as second
758 argument. In case of an immediate EOF (i.e. an empty file), the passed
759 chunk is the empty string. In all other cases the chunk has a length greater
760 than zero.
761 - For any remaining chunks, the respective chunk gets passed as first and only
762 argument (no metadata). Here, the chunk has always a length greater than
763 zero.
764 - To indicate the end of the stream, the callback function is called without
765 arguments. This also happens in case of an immediate EOF (see above).
767 In case of an immediate EOF (i.e. an empty file), the callback function is thus
768 called as follows:
770 - The first time with an empty string as first argument, and with the metadata
771 as second argument.
772 - The second time without any arguments.
774 Note that request:consume_input() needs to be called to enforce streaming to
775 finish.
778 ### request:stream_post_params(pattern, callback)
780 Same as request:stream_post_param(...) but providing a string pattern to match
781 multiple field names (e.g. "^file_[0-9]+$").
784 ### request:stream_request_body(callback)
786 Registeres a stream handler for the whole request body. For each chunk of the
787 request body, the callback function is called with the corresponding chunk. End
788 of data is indicated by passing a nil value to the callback functuion.
790 Note that request:consume_input() needs to be called to enforce streaming to
791 finish.
794 ### request:stream_request_body_now(callback)
796 Start streaming of request body immediately. On EOF the function returns and
797 the callback function is *not* called with nil as argument.