wikimedia/mediawiki-extensions-Scribunto
1
0
Fork 0
mirror of https://gerrit.wikimedia.org/r/mediawiki/extensions/Scribunto synced 2024-11-25 08:36:21 +00:00
Code Issues Packages Projects Releases Wiki Activity
mediawiki-extensions-Scribunto/engines/LuaStandalone/protocol.txt

177 lines
4.6 KiB
Plaintext
Raw Normal View History

Introduced standalone interpreter, implemented module isolation * Introduced a Lua implementation based on shelling out to a standard Lua binary. * Bundled several Lua binaries for common platforms. I haven't added a 32-bit Linux binary yet, but that will come. * Refactored the existing Lua class, bringing out functionality common to all Lua implementations into a set of common base classes. * Moved the bulk of the implementation-specific functionality into a set of "interpreter" classes. * Renamed LuaSandboxEngine to Scribunto_LuaSandboxEngine * Don't create an engine object unconditionally when the ParserLimitReport hook is called. * Implemented isolation of module global variable namespaces. This means that separate {{#invoke}} calls can't pass data to each other -- this was a desired feature in planning since it allows more flexibility in wikitext parser design. Isolation for mw.import() means that modules cannot accidentally create global variables which affect other modules -- exports are solely via the return value. Change-Id: I3fa35651fe5b1fbfd85adeadc220b1ea31cd6f0b
2012-04-13 10:38:12 +00:00
The Lua standalone engine has a message-based protocol for communicating between
Add comments and remove trailing whitespace Clean up trailing whitespace from all of our code, and add comments indicating that apparently unused variables are ScopedCallbacks. Change-Id: I8e5997797cc7b1c64c5351ec112a18f30edc8fef
2014-07-07 18:46:59 +00:00
PHP and Lua.
Introduced standalone interpreter, implemented module isolation * Introduced a Lua implementation based on shelling out to a standard Lua binary. * Bundled several Lua binaries for common platforms. I haven't added a 32-bit Linux binary yet, but that will come. * Refactored the existing Lua class, bringing out functionality common to all Lua implementations into a set of common base classes. * Moved the bulk of the implementation-specific functionality into a set of "interpreter" classes. * Renamed LuaSandboxEngine to Scribunto_LuaSandboxEngine * Don't create an engine object unconditionally when the ParserLimitReport hook is called. * Implemented isolation of module global variable namespaces. This means that separate {{#invoke}} calls can't pass data to each other -- this was a desired feature in planning since it allows more flexibility in wikitext parser design. Isolation for mw.import() means that modules cannot accidentally create global variables which affect other modules -- exports are solely via the return value. Change-Id: I3fa35651fe5b1fbfd85adeadc220b1ea31cd6f0b
2012-04-13 10:38:12 +00:00
Messages start with a 16 byte header. The first 8 bytes are the body length in
hexadecimal. The second 8 bytes are (length * 2 - 1) also in hexadecimal.
For messages passed from PHP to Lua, the body is encoded as a Lua expression.
The expression may reference a table in a variable called "chunks", which
contains an array of functions.
(bug 46294) Fix for Windows text-mode file handles On Windows for LuaStandalone, the lua executable's standard output is a text-mode file handle, even if the pipe is opened from PHP with the binary flag. Which means that when Lua returns a "\n", it gets silently rewritten to "\r\n" and the unserialization fails. So, change the protocol for Lua→PHP messages to encode \r and \n (and \ itself, as the escape character) to avoid this issue. Bug: 46294 Change-Id: I73b5f44e8aa0334f5fd03013dc027d1a57318349
2013-03-28 18:29:47 +00:00
Messages passed from Lua to PHP have their body encoded in PHP serialize()
format, and then "\\", "\r", and "\n" are replaced with "\\\\", "\\r", and
"\\n" to avoid issues with text-mode file handles. They may include instances
of function objects which have an "id" member for passing back to Lua as an
index in the chunk table.
Introduced standalone interpreter, implemented module isolation * Introduced a Lua implementation based on shelling out to a standard Lua binary. * Bundled several Lua binaries for common platforms. I haven't added a 32-bit Linux binary yet, but that will come. * Refactored the existing Lua class, bringing out functionality common to all Lua implementations into a set of common base classes. * Moved the bulk of the implementation-specific functionality into a set of "interpreter" classes. * Renamed LuaSandboxEngine to Scribunto_LuaSandboxEngine * Don't create an engine object unconditionally when the ParserLimitReport hook is called. * Implemented isolation of module global variable namespaces. This means that separate {{#invoke}} calls can't pass data to each other -- this was a desired feature in planning since it allows more flexibility in wikitext parser design. Isolation for mw.import() means that modules cannot accidentally create global variables which affect other modules -- exports are solely via the return value. Change-Id: I3fa35651fe5b1fbfd85adeadc220b1ea31cd6f0b
2012-04-13 10:38:12 +00:00
The expressions encoded into the message bodies are associative arrays. The "op"
member of the array gives the operation to be performed by the message.
Add comments and remove trailing whitespace Clean up trailing whitespace from all of our code, and add comments indicating that apparently unused variables are ScopedCallbacks. Change-Id: I8e5997797cc7b1c64c5351ec112a18f30edc8fef
2014-07-07 18:46:59 +00:00
Every request message demands exactly one response message in reply. When a
request message is sent, the responder does not need to send the corresponding
response message as its next message. It may instead send its own request
message. In this way, a stack of pending requests can be accumulated. This
mechanism allows re-entrant and recursive calls.
Introduced standalone interpreter, implemented module isolation * Introduced a Lua implementation based on shelling out to a standard Lua binary. * Bundled several Lua binaries for common platforms. I haven't added a 32-bit Linux binary yet, but that will come. * Refactored the existing Lua class, bringing out functionality common to all Lua implementations into a set of common base classes. * Moved the bulk of the implementation-specific functionality into a set of "interpreter" classes. * Renamed LuaSandboxEngine to Scribunto_LuaSandboxEngine * Don't create an engine object unconditionally when the ParserLimitReport hook is called. * Implemented isolation of module global variable namespaces. This means that separate {{#invoke}} calls can't pass data to each other -- this was a desired feature in planning since it allows more flexibility in wikitext parser design. Isolation for mw.import() means that modules cannot accidentally create global variables which affect other modules -- exports are solely via the return value. Change-Id: I3fa35651fe5b1fbfd85adeadc220b1ea31cd6f0b
2012-04-13 10:38:12 +00:00
All numerically-indexed arrays should start from index 1 unless otherwise
Fix LuaStandalone nil handling In Lua, a table entry with a nil value is the same as a table entry that doesn't exist. So when serializing for transfer to PHP, these keys will be skipped. For a table as an associative array this isn't much of a problem, but for a table as a list it means we have missing indexes. Some of Lua's functions for handling "lists" (i.e. tables with numeric keys) also have a problem when the list contains nils. To work around these issues when passing argument lists and return value lists, pass the number of elements along with the sparse list. On the PHP end we can use this to fill in the missing nulls, and on the Lua end we can pass this count to unpack() to avoid the problems on the Lua side. Change-Id: I858e3905a06e377693301da2b8bc534808f00e3e
2013-01-28 21:05:18 +00:00
specified. Note that the number of values in an array may not match what Lua's
'#' operator returns if the array contains nils.
Introduced standalone interpreter, implemented module isolation * Introduced a Lua implementation based on shelling out to a standard Lua binary. * Bundled several Lua binaries for common platforms. I haven't added a 32-bit Linux binary yet, but that will come. * Refactored the existing Lua class, bringing out functionality common to all Lua implementations into a set of common base classes. * Moved the bulk of the implementation-specific functionality into a set of "interpreter" classes. * Renamed LuaSandboxEngine to Scribunto_LuaSandboxEngine * Don't create an engine object unconditionally when the ParserLimitReport hook is called. * Implemented isolation of module global variable namespaces. This means that separate {{#invoke}} calls can't pass data to each other -- this was a desired feature in planning since it allows more flexibility in wikitext parser design. Isolation for mw.import() means that modules cannot accidentally create global variables which affect other modules -- exports are solely via the return value. Change-Id: I3fa35651fe5b1fbfd85adeadc220b1ea31cd6f0b
2012-04-13 10:38:12 +00:00
== Request messages sent from PHP to Lua ==
=== loadString ===
Load some executable Lua code (a "chunk") and return the resulting function ID.
Message parameters:
* op: "loadString"
* text: The string to load
* chunkName: The name of the string, for use in error messages
On success, the response message is:
* op: "return"
Fix LuaStandalone nil handling In Lua, a table entry with a nil value is the same as a table entry that doesn't exist. So when serializing for transfer to PHP, these keys will be skipped. For a table as an associative array this isn't much of a problem, but for a table as a list it means we have missing indexes. Some of Lua's functions for handling "lists" (i.e. tables with numeric keys) also have a problem when the list contains nils. To work around these issues when passing argument lists and return value lists, pass the number of elements along with the sparse list. On the PHP end we can use this to fill in the missing nulls, and on the Lua end we can pass this count to unpack() to avoid the problems on the Lua side. Change-Id: I858e3905a06e377693301da2b8bc534808f00e3e
2013-01-28 21:05:18 +00:00
* nvalues: 1
Introduced standalone interpreter, implemented module isolation * Introduced a Lua implementation based on shelling out to a standard Lua binary. * Bundled several Lua binaries for common platforms. I haven't added a 32-bit Linux binary yet, but that will come. * Refactored the existing Lua class, bringing out functionality common to all Lua implementations into a set of common base classes. * Moved the bulk of the implementation-specific functionality into a set of "interpreter" classes. * Renamed LuaSandboxEngine to Scribunto_LuaSandboxEngine * Don't create an engine object unconditionally when the ParserLimitReport hook is called. * Implemented isolation of module global variable namespaces. This means that separate {{#invoke}} calls can't pass data to each other -- this was a desired feature in planning since it allows more flexibility in wikitext parser design. Isolation for mw.import() means that modules cannot accidentally create global variables which affect other modules -- exports are solely via the return value. Change-Id: I3fa35651fe5b1fbfd85adeadc220b1ea31cd6f0b
2012-04-13 10:38:12 +00:00
* values: An array with a single element with the ID in it
On failure, the response message is:
* op: "error"
* value: The error message
=== call ===
Call a Lua function.
Message parameters:
* op: "call"
* id: The chunk ID
Fix LuaStandalone nil handling In Lua, a table entry with a nil value is the same as a table entry that doesn't exist. So when serializing for transfer to PHP, these keys will be skipped. For a table as an associative array this isn't much of a problem, but for a table as a list it means we have missing indexes. Some of Lua's functions for handling "lists" (i.e. tables with numeric keys) also have a problem when the list contains nils. To work around these issues when passing argument lists and return value lists, pass the number of elements along with the sparse list. On the PHP end we can use this to fill in the missing nulls, and on the Lua end we can pass this count to unpack() to avoid the problems on the Lua side. Change-Id: I858e3905a06e377693301da2b8bc534808f00e3e
2013-01-28 21:05:18 +00:00
* nargs: Number of arguments, including nils
Introduced standalone interpreter, implemented module isolation * Introduced a Lua implementation based on shelling out to a standard Lua binary. * Bundled several Lua binaries for common platforms. I haven't added a 32-bit Linux binary yet, but that will come. * Refactored the existing Lua class, bringing out functionality common to all Lua implementations into a set of common base classes. * Moved the bulk of the implementation-specific functionality into a set of "interpreter" classes. * Renamed LuaSandboxEngine to Scribunto_LuaSandboxEngine * Don't create an engine object unconditionally when the ParserLimitReport hook is called. * Implemented isolation of module global variable namespaces. This means that separate {{#invoke}} calls can't pass data to each other -- this was a desired feature in planning since it allows more flexibility in wikitext parser design. Isolation for mw.import() means that modules cannot accidentally create global variables which affect other modules -- exports are solely via the return value. Change-Id: I3fa35651fe5b1fbfd85adeadc220b1ea31cd6f0b
2012-04-13 10:38:12 +00:00
* args: The argument array
On success, the response message is:
* op: "return"
Fix LuaStandalone nil handling In Lua, a table entry with a nil value is the same as a table entry that doesn't exist. So when serializing for transfer to PHP, these keys will be skipped. For a table as an associative array this isn't much of a problem, but for a table as a list it means we have missing indexes. Some of Lua's functions for handling "lists" (i.e. tables with numeric keys) also have a problem when the list contains nils. To work around these issues when passing argument lists and return value lists, pass the number of elements along with the sparse list. On the PHP end we can use this to fill in the missing nulls, and on the Lua end we can pass this count to unpack() to avoid the problems on the Lua side. Change-Id: I858e3905a06e377693301da2b8bc534808f00e3e
2013-01-28 21:05:18 +00:00
* nvalues: Number of return values, including nils
Introduced standalone interpreter, implemented module isolation * Introduced a Lua implementation based on shelling out to a standard Lua binary. * Bundled several Lua binaries for common platforms. I haven't added a 32-bit Linux binary yet, but that will come. * Refactored the existing Lua class, bringing out functionality common to all Lua implementations into a set of common base classes. * Moved the bulk of the implementation-specific functionality into a set of "interpreter" classes. * Renamed LuaSandboxEngine to Scribunto_LuaSandboxEngine * Don't create an engine object unconditionally when the ParserLimitReport hook is called. * Implemented isolation of module global variable namespaces. This means that separate {{#invoke}} calls can't pass data to each other -- this was a desired feature in planning since it allows more flexibility in wikitext parser design. Isolation for mw.import() means that modules cannot accidentally create global variables which affect other modules -- exports are solely via the return value. Change-Id: I3fa35651fe5b1fbfd85adeadc220b1ea31cd6f0b
2012-04-13 10:38:12 +00:00
* values: All return values as an array
On failure, the response message is:
* op: "error"
* value: The value given to error(), usually an error message
Add comments and remove trailing whitespace Clean up trailing whitespace from all of our code, and add comments indicating that apparently unused variables are ScopedCallbacks. Change-Id: I8e5997797cc7b1c64c5351ec112a18f30edc8fef
2014-07-07 18:46:59 +00:00
* trace: A table giving a backtrace of the stack as it was when error() was
Nicer errors with backtraces etc. * Added error backtrace collection to MWServer:handleCall() * When there is an error on parse, show a short and simple inline error message to the user, which when clicked, expands to a full error with HTML-formatted backtrace. * When an error is encountered during module validation, have the code editor jump directly to the line. Requires r115011. * Expose the code location of most errors to Scribunto, by parsing the standard error message format. * During module validation, abbreviate the error location if the error is in the same module. * Do not execute the module during validation, just parse it. Execution does not really work without an active parse operation in progress. It already caused a fatal error if you called require() from the main chunk, and problems would have become more visible as more parser-related APIs were added. * LuaSandbox does not yet provide backtraces, but this is planned. Change-Id: Id9f6564a41b310792b3fe3ebb527cbf8f8771bd1
2012-04-23 11:36:13 +00:00
called, in a similar format to the one used by debug.getinfo(). Element 1 of
Add comments and remove trailing whitespace Clean up trailing whitespace from all of our code, and add comments indicating that apparently unused variables are ScopedCallbacks. Change-Id: I8e5997797cc7b1c64c5351ec112a18f30edc8fef
2014-07-07 18:46:59 +00:00
the table is the function that called error(), element 2 is the function that
Nicer errors with backtraces etc. * Added error backtrace collection to MWServer:handleCall() * When there is an error on parse, show a short and simple inline error message to the user, which when clicked, expands to a full error with HTML-formatted backtrace. * When an error is encountered during module validation, have the code editor jump directly to the line. Requires r115011. * Expose the code location of most errors to Scribunto, by parsing the standard error message format. * During module validation, abbreviate the error location if the error is in the same module. * Do not execute the module during validation, just parse it. Execution does not really work without an active parse operation in progress. It already caused a fatal error if you called require() from the main chunk, and problems would have become more visible as more parser-related APIs were added. * LuaSandbox does not yet provide backtraces, but this is planned. Change-Id: Id9f6564a41b310792b3fe3ebb527cbf8f8771bd1
2012-04-23 11:36:13 +00:00
called that, and so on.
Introduced standalone interpreter, implemented module isolation * Introduced a Lua implementation based on shelling out to a standard Lua binary. * Bundled several Lua binaries for common platforms. I haven't added a 32-bit Linux binary yet, but that will come. * Refactored the existing Lua class, bringing out functionality common to all Lua implementations into a set of common base classes. * Moved the bulk of the implementation-specific functionality into a set of "interpreter" classes. * Renamed LuaSandboxEngine to Scribunto_LuaSandboxEngine * Don't create an engine object unconditionally when the ParserLimitReport hook is called. * Implemented isolation of module global variable namespaces. This means that separate {{#invoke}} calls can't pass data to each other -- this was a desired feature in planning since it allows more flexibility in wikitext parser design. Isolation for mw.import() means that modules cannot accidentally create global variables which affect other modules -- exports are solely via the return value. Change-Id: I3fa35651fe5b1fbfd85adeadc220b1ea31cd6f0b
2012-04-13 10:38:12 +00:00
=== registerLibrary ===
Add comments and remove trailing whitespace Clean up trailing whitespace from all of our code, and add comments indicating that apparently unused variables are ScopedCallbacks. Change-Id: I8e5997797cc7b1c64c5351ec112a18f30edc8fef
2014-07-07 18:46:59 +00:00
Register a set of functions in the sandbox environment.
Introduced standalone interpreter, implemented module isolation * Introduced a Lua implementation based on shelling out to a standard Lua binary. * Bundled several Lua binaries for common platforms. I haven't added a 32-bit Linux binary yet, but that will come. * Refactored the existing Lua class, bringing out functionality common to all Lua implementations into a set of common base classes. * Moved the bulk of the implementation-specific functionality into a set of "interpreter" classes. * Renamed LuaSandboxEngine to Scribunto_LuaSandboxEngine * Don't create an engine object unconditionally when the ParserLimitReport hook is called. * Implemented isolation of module global variable namespaces. This means that separate {{#invoke}} calls can't pass data to each other -- this was a desired feature in planning since it allows more flexibility in wikitext parser design. Isolation for mw.import() means that modules cannot accidentally create global variables which affect other modules -- exports are solely via the return value. Change-Id: I3fa35651fe5b1fbfd85adeadc220b1ea31cd6f0b
2012-04-13 10:38:12 +00:00
Message parameters:
* op: "registerLibrary"
* name: The global variable name to register. May contain "." characters to
specify a global variable subtable.
* functions: An associative array mapping function name to ID
On success, the response message is:
* op: "return"
Fix LuaStandalone nil handling In Lua, a table entry with a nil value is the same as a table entry that doesn't exist. So when serializing for transfer to PHP, these keys will be skipped. For a table as an associative array this isn't much of a problem, but for a table as a list it means we have missing indexes. Some of Lua's functions for handling "lists" (i.e. tables with numeric keys) also have a problem when the list contains nils. To work around these issues when passing argument lists and return value lists, pass the number of elements along with the sparse list. On the PHP end we can use this to fill in the missing nulls, and on the Lua end we can pass this count to unpack() to avoid the problems on the Lua side. Change-Id: I858e3905a06e377693301da2b8bc534808f00e3e
2013-01-28 21:05:18 +00:00
* nvalues: 0
Introduced standalone interpreter, implemented module isolation * Introduced a Lua implementation based on shelling out to a standard Lua binary. * Bundled several Lua binaries for common platforms. I haven't added a 32-bit Linux binary yet, but that will come. * Refactored the existing Lua class, bringing out functionality common to all Lua implementations into a set of common base classes. * Moved the bulk of the implementation-specific functionality into a set of "interpreter" classes. * Renamed LuaSandboxEngine to Scribunto_LuaSandboxEngine * Don't create an engine object unconditionally when the ParserLimitReport hook is called. * Implemented isolation of module global variable namespaces. This means that separate {{#invoke}} calls can't pass data to each other -- this was a desired feature in planning since it allows more flexibility in wikitext parser design. Isolation for mw.import() means that modules cannot accidentally create global variables which affect other modules -- exports are solely via the return value. Change-Id: I3fa35651fe5b1fbfd85adeadc220b1ea31cd6f0b
2012-04-13 10:38:12 +00:00
* values: An empty array
On failure the response message is:
* op: "error"
* value: The error message
=== getStatus ===
Get status information about the Lua process.
Message parameters:
* op: "getStatus"
On success, the response message is:
* op: "return"
Fix LuaStandalone nil handling In Lua, a table entry with a nil value is the same as a table entry that doesn't exist. So when serializing for transfer to PHP, these keys will be skipped. For a table as an associative array this isn't much of a problem, but for a table as a list it means we have missing indexes. Some of Lua's functions for handling "lists" (i.e. tables with numeric keys) also have a problem when the list contains nils. To work around these issues when passing argument lists and return value lists, pass the number of elements along with the sparse list. On the PHP end we can use this to fill in the missing nulls, and on the Lua end we can pass this count to unpack() to avoid the problems on the Lua side. Change-Id: I858e3905a06e377693301da2b8bc534808f00e3e
2013-01-28 21:05:18 +00:00
* nvalues: 1
Introduced standalone interpreter, implemented module isolation * Introduced a Lua implementation based on shelling out to a standard Lua binary. * Bundled several Lua binaries for common platforms. I haven't added a 32-bit Linux binary yet, but that will come. * Refactored the existing Lua class, bringing out functionality common to all Lua implementations into a set of common base classes. * Moved the bulk of the implementation-specific functionality into a set of "interpreter" classes. * Renamed LuaSandboxEngine to Scribunto_LuaSandboxEngine * Don't create an engine object unconditionally when the ParserLimitReport hook is called. * Implemented isolation of module global variable namespaces. This means that separate {{#invoke}} calls can't pass data to each other -- this was a desired feature in planning since it allows more flexibility in wikitext parser design. Isolation for mw.import() means that modules cannot accidentally create global variables which affect other modules -- exports are solely via the return value. Change-Id: I3fa35651fe5b1fbfd85adeadc220b1ea31cd6f0b
2012-04-13 10:38:12 +00:00
* values: An array with a single element, which is an associative array mapping
status key to value. The status keys are:
** pid: The process identifier
Add comments and remove trailing whitespace Clean up trailing whitespace from all of our code, and add comments indicating that apparently unused variables are ScopedCallbacks. Change-Id: I8e5997797cc7b1c64c5351ec112a18f30edc8fef
2014-07-07 18:46:59 +00:00
** time: The amount of user and system time spent by the process, measured in clock ticks
Introduced standalone interpreter, implemented module isolation * Introduced a Lua implementation based on shelling out to a standard Lua binary. * Bundled several Lua binaries for common platforms. I haven't added a 32-bit Linux binary yet, but that will come. * Refactored the existing Lua class, bringing out functionality common to all Lua implementations into a set of common base classes. * Moved the bulk of the implementation-specific functionality into a set of "interpreter" classes. * Renamed LuaSandboxEngine to Scribunto_LuaSandboxEngine * Don't create an engine object unconditionally when the ParserLimitReport hook is called. * Implemented isolation of module global variable namespaces. This means that separate {{#invoke}} calls can't pass data to each other -- this was a desired feature in planning since it allows more flexibility in wikitext parser design. Isolation for mw.import() means that modules cannot accidentally create global variables which affect other modules -- exports are solely via the return value. Change-Id: I3fa35651fe5b1fbfd85adeadc220b1ea31cd6f0b
2012-04-13 10:38:12 +00:00
** vsize: The virtual memory size in bytes
** rss: The resident set size in bytes
On failure, the response message is:
* op: "return"
Fix LuaStandalone nil handling In Lua, a table entry with a nil value is the same as a table entry that doesn't exist. So when serializing for transfer to PHP, these keys will be skipped. For a table as an associative array this isn't much of a problem, but for a table as a list it means we have missing indexes. Some of Lua's functions for handling "lists" (i.e. tables with numeric keys) also have a problem when the list contains nils. To work around these issues when passing argument lists and return value lists, pass the number of elements along with the sparse list. On the PHP end we can use this to fill in the missing nulls, and on the Lua end we can pass this count to unpack() to avoid the problems on the Lua side. Change-Id: I858e3905a06e377693301da2b8bc534808f00e3e
2013-01-28 21:05:18 +00:00
* nvalues: 0
Introduced standalone interpreter, implemented module isolation * Introduced a Lua implementation based on shelling out to a standard Lua binary. * Bundled several Lua binaries for common platforms. I haven't added a 32-bit Linux binary yet, but that will come. * Refactored the existing Lua class, bringing out functionality common to all Lua implementations into a set of common base classes. * Moved the bulk of the implementation-specific functionality into a set of "interpreter" classes. * Renamed LuaSandboxEngine to Scribunto_LuaSandboxEngine * Don't create an engine object unconditionally when the ParserLimitReport hook is called. * Implemented isolation of module global variable namespaces. This means that separate {{#invoke}} calls can't pass data to each other -- this was a desired feature in planning since it allows more flexibility in wikitext parser design. Isolation for mw.import() means that modules cannot accidentally create global variables which affect other modules -- exports are solely via the return value. Change-Id: I3fa35651fe5b1fbfd85adeadc220b1ea31cd6f0b
2012-04-13 10:38:12 +00:00
* values: An empty array
LuaStandalone: Release functions when no longer referenced The LuaStandalone interpreter needs to keep a mapping from integers returned to PHP to the corresponding function. But if it never releases these functions when PHP no longer has any reference to them, it can result in Lua running out of memory if a module with a large number of functions is invoked many times in one page. The fix here is to track which function ids are referenced from PHP, and periodically send the list to Lua so it can remove any that are no longer used from its cache. This also takes care of another issue where having multiple interpreter instances and passing function objects from one into another could call the wrong function in Lua. Bug: 51886 Change-Id: I4f15841051f7748d1d6df24080949e5cbd88f217
2013-11-01 00:04:12 +00:00
=== cleanupChunks ===
Tell Lua to release any chunks no longer referenced by PHP.
Message parameters:
* op: "cleanupChunks"
* ids: Table with keys being the chunk IDs still referenced by PHP, and non-falsey values
The response message is:
* op: "return"
* nvalues: 0
* values: An empty array
Added tests and fixed bugs * Added unit tests for the two Lua interpreter classes * Fixed a bug in checkType() * Have Scribunto_LuaSandboxInterpreter throw an exception on construct when the extension doesn't exist, to match the standalone behaviour. * In Scribunto_LuaSandboxInterpreter, removed debugging statements accidentally left in. * Convert LuaSandboxTimeoutError to the appropriate common error message. * Moved the option munging from the sandbox engine to the interpreter, so that the interpreter can be unit tested separately. * Use /bin/sh instead of bash for lua_ulimit.sh, since dash is smaller and still supports ulimit. * Use exec to run the lua binary, so that the vsize of the shell doesn't add to the memory limit. * Added a quit function to the standalone interpreter. Unused at present. * Don't add a comma after the last element of a table in a Lua expression. * Make the SIGXCPU detection work: proc_open() runs the command via a shell, which reports signals in the child via the exit status, so proc_get_status() will never return a valid termsig element. * In MWServer:call(), fixed a bug causing the return values to be wrapped in an array. * Fixed a misunderstanding of what select() does. * In MWServer:getStatus(), fixed indexes so that vsize will be correct. Removed RSS, since it wasn't used anyway and turns out to be measured in multiples of the page size, and I couldn't be bothered trying to fetch that from getconf. Return the PID and vsize as numbers rather than strings. * Added a simple table dump feature to MWServer:debug(). * Fixed brackets in MWServer:tostring(). * Added missing Linux 32-bit binary. Change-Id: Ibf5f4656b1c0a9f81287d363184c3fe9d2abdafd
2012-04-16 04:41:08 +00:00
=== quit ===
Request graceful shutdown.
Message parameters:
* op: "quit"
No return message will be sent.
LuaStandalone: Fix signal handling I252ec046 noticeably broke things by adding a dependency on the pcntl functions, which tend not to be present under Apache. It also subtly broke exit handling by using proc_close()'s return value, which PHP mangles in such a way that we can't tell the difference between an actual XCPU kill and exit( SIGXCPU ). This one wasn't noticed because the pcntl functions interpret everything proc_close() is going to return as a signal kill and we didn't test the 'exited' code path. I'm not sure what was going on in I57cdf8aa since it provides no details about what it was trying to fix, but that would have broken signal handling in the other way: Ibf5f4656 worked because proc_open() on Linux executes the command by passing it to /bin/sh -c, and that shell is going to turn any signal that kills Lua (e.g. the SIGXCPU) into an exit status of 128+signum. To avoid proc_close()'s broken return value while also avoiding the race, we can loop on proc_get_status() until $status['running'] is false. To have signals that kill Lua actually be interpreted as signals, we have two options: add an "exec" in front of the command so proc_open()'s /bin/sh -c is execed away, or detect shell-style signal reporting and convert it. We may as well do both. Bug: T128048 Change-Id: I8a62e1660fe1694e9ba5de77d01960c1ab4580aa
2017-02-06 19:55:24 +00:00
=== testquit ===
Request non-graceful shutdown, for testing.
Message parameters:
* op: "testquit"
No return message will be sent.
Introduced standalone interpreter, implemented module isolation * Introduced a Lua implementation based on shelling out to a standard Lua binary. * Bundled several Lua binaries for common platforms. I haven't added a 32-bit Linux binary yet, but that will come. * Refactored the existing Lua class, bringing out functionality common to all Lua implementations into a set of common base classes. * Moved the bulk of the implementation-specific functionality into a set of "interpreter" classes. * Renamed LuaSandboxEngine to Scribunto_LuaSandboxEngine * Don't create an engine object unconditionally when the ParserLimitReport hook is called. * Implemented isolation of module global variable namespaces. This means that separate {{#invoke}} calls can't pass data to each other -- this was a desired feature in planning since it allows more flexibility in wikitext parser design. Isolation for mw.import() means that modules cannot accidentally create global variables which affect other modules -- exports are solely via the return value. Change-Id: I3fa35651fe5b1fbfd85adeadc220b1ea31cd6f0b
2012-04-13 10:38:12 +00:00
== Request messages sent from Lua to PHP ==
=== call ===
Call a PHP function.
Message parameters:
* op: "call"
* id: The function ID given by registerLibrary
Fix LuaStandalone nil handling In Lua, a table entry with a nil value is the same as a table entry that doesn't exist. So when serializing for transfer to PHP, these keys will be skipped. For a table as an associative array this isn't much of a problem, but for a table as a list it means we have missing indexes. Some of Lua's functions for handling "lists" (i.e. tables with numeric keys) also have a problem when the list contains nils. To work around these issues when passing argument lists and return value lists, pass the number of elements along with the sparse list. On the PHP end we can use this to fill in the missing nulls, and on the Lua end we can pass this count to unpack() to avoid the problems on the Lua side. Change-Id: I858e3905a06e377693301da2b8bc534808f00e3e
2013-01-28 21:05:18 +00:00
* nargs: Number of arguments, including nils
Introduced standalone interpreter, implemented module isolation * Introduced a Lua implementation based on shelling out to a standard Lua binary. * Bundled several Lua binaries for common platforms. I haven't added a 32-bit Linux binary yet, but that will come. * Refactored the existing Lua class, bringing out functionality common to all Lua implementations into a set of common base classes. * Moved the bulk of the implementation-specific functionality into a set of "interpreter" classes. * Renamed LuaSandboxEngine to Scribunto_LuaSandboxEngine * Don't create an engine object unconditionally when the ParserLimitReport hook is called. * Implemented isolation of module global variable namespaces. This means that separate {{#invoke}} calls can't pass data to each other -- this was a desired feature in planning since it allows more flexibility in wikitext parser design. Isolation for mw.import() means that modules cannot accidentally create global variables which affect other modules -- exports are solely via the return value. Change-Id: I3fa35651fe5b1fbfd85adeadc220b1ea31cd6f0b
2012-04-13 10:38:12 +00:00
* args: An array giving the function arguments
On success, the response message is:
* op: "return"
Fix LuaStandalone nil handling In Lua, a table entry with a nil value is the same as a table entry that doesn't exist. So when serializing for transfer to PHP, these keys will be skipped. For a table as an associative array this isn't much of a problem, but for a table as a list it means we have missing indexes. Some of Lua's functions for handling "lists" (i.e. tables with numeric keys) also have a problem when the list contains nils. To work around these issues when passing argument lists and return value lists, pass the number of elements along with the sparse list. On the PHP end we can use this to fill in the missing nulls, and on the Lua end we can pass this count to unpack() to avoid the problems on the Lua side. Change-Id: I858e3905a06e377693301da2b8bc534808f00e3e
2013-01-28 21:05:18 +00:00
* nvalues: Number of return values, including nils
Introduced standalone interpreter, implemented module isolation * Introduced a Lua implementation based on shelling out to a standard Lua binary. * Bundled several Lua binaries for common platforms. I haven't added a 32-bit Linux binary yet, but that will come. * Refactored the existing Lua class, bringing out functionality common to all Lua implementations into a set of common base classes. * Moved the bulk of the implementation-specific functionality into a set of "interpreter" classes. * Renamed LuaSandboxEngine to Scribunto_LuaSandboxEngine * Don't create an engine object unconditionally when the ParserLimitReport hook is called. * Implemented isolation of module global variable namespaces. This means that separate {{#invoke}} calls can't pass data to each other -- this was a desired feature in planning since it allows more flexibility in wikitext parser design. Isolation for mw.import() means that modules cannot accidentally create global variables which affect other modules -- exports are solely via the return value. Change-Id: I3fa35651fe5b1fbfd85adeadc220b1ea31cd6f0b
2012-04-13 10:38:12 +00:00
* values: All return values as an array
On failure the response message is:
* op: "error"
* value: The error message
Reference in a new issue Copy permalink