diff options
| author | carsakiller <carsakiller@gmail.com> | 2023-10-27 20:42:05 -0400 |
|---|---|---|
| committer | carsakiller <carsakiller@gmail.com> | 2023-10-27 20:42:05 -0400 |
| commit | d2f198493b8d3de1c98c94db17a17e378925792e (patch) | |
| tree | f28e3322d42f1d493c7be8c910b44047c02a08f7 | |
| parent | 178d6258167de8a305284e65c413ce6f4df5b5e8 (diff) | |
| download | lua-language-server-d2f198493b8d3de1c98c94db17a17e378925792e.zip | |
refactor: replace openresty with LuaCATS submodule
77 files changed, 3 insertions, 8378 deletions
diff --git a/.gitmodules b/.gitmodules index ef4d5f5e..074b2def 100644 --- a/.gitmodules +++ b/.gitmodules @@ -19,3 +19,6 @@ [submodule "3rd/json.lua"] path = 3rd/json.lua url = https://github.com/actboy168/json.lua +[submodule "meta/3rd/OpenResty"] + path = meta/3rd/OpenResty + url = https://github.com/LuaCATS/openresty.git diff --git a/meta/3rd/OpenResty b/meta/3rd/OpenResty new file mode 160000 +Subproject 3bec36f0f645bb38b3c8208990d5c36feb66ce3 diff --git a/meta/3rd/OpenResty/config.json b/meta/3rd/OpenResty/config.json deleted file mode 100644 index 39d495fc..00000000 --- a/meta/3rd/OpenResty/config.json +++ /dev/null @@ -1,19 +0,0 @@ -{ - "files" : [ - "resty/redis%.lua", - "lib/resty/.*%.lua", - "src/resty/.*%.lua", - "lib/ngx.*/.*%.lua", - "src/ngx.*/.*%.lua" - ], - "words" : [ - "resty%.%w+", - "ngx%.%w+" - ], - "settings" : { - "Lua.runtime.version" : "LuaJIT", - "Lua.diagnostics.globals" : [ - "ngx" - ] - } -} diff --git a/meta/3rd/OpenResty/library/cjson.lua b/meta/3rd/OpenResty/library/cjson.lua deleted file mode 100644 index aeef436a..00000000 --- a/meta/3rd/OpenResty/library/cjson.lua +++ /dev/null @@ -1,488 +0,0 @@ ----@meta - ---- lua cjson ---- ---- https://kyne.com.au/~mark/software/lua-cjson.php ---- https://kyne.com.au/~mark/software/lua-cjson-manual.html ---- https://openresty.org/en/lua-cjson-library.html ---- ---- **NOTE:** This includes the additions in the OpenResty-maintained cjson fork: https://github.com/openresty/lua-cjson ---- ---- --- ---- ---- The cjson module will throw an error during JSON conversion if any invalid ---- data is encountered. Refer to `cjson.encode` and cjson.decode for details. ---- ---- The cjson.safe module behaves identically to the cjson module, except when ---- errors are encountered during JSON conversion. On error, the cjson_safe.encode ---- and cjson_safe.decode functions will return nil followed by the error message. ---- ---- cjson.new can be used to instantiate an independent copy of the Lua CJSON ---- module. The new module has a separate persistent encoding buffer, and default settings. ---- ---- Lua CJSON can support Lua implementations using multiple preemptive threads ---- within a single Lua state provided the persistent encoding buffer is not ---- shared. This can be achieved by one of the following methods: ---- ---- * Disabling the persistent encoding buffer with cjson.encode_keep_buffer ---- * Ensuring each thread calls cjson.encode separately (ie, treat cjson.encode as non-reentrant). ---- * Using a separate cjson module table per preemptive thread (cjson.new) ---- ---- ## Note ---- ---- Lua CJSON uses `strtod` and `snprintf` to perform numeric conversion as they ---- are usually well supported, fast and bug free. However, these functions ---- require a workaround for JSON encoding/parsing under locales using a comma ---- decimal separator. Lua CJSON detects the current locale during instantiation ---- to determine and automatically implement the workaround if required. Lua ---- CJSON should be reinitialised via cjson.new if the locale of the current ---- process changes. Using a different locale per thread is not supported. ---- ----@class cjson ----@field _NAME string ----@field _VERSION string ----@field null cjson.null ----@field empty_array cjson.empty_array ----@field array_mt cjson.array_mt ----@field empty_array_mt cjson.empty_array_mt ---- -local cjson = {} - - ---- A metatable which can "tag" a table as a JSON Array in case it is empty (that ---- is, if the table has no elements, `cjson.encode()` will encode it as an empty ---- JSON Array). ---- ---- Instead of: ---- ----```lua ---- local function serialize(arr) ---- if #arr < 1 then ---- arr = cjson.empty_array ---- end ---- ---- return cjson.encode({some_array = arr}) ---- end ----``` ---- ---- This is more concise: ---- ----```lua ---- local function serialize(arr) ---- setmetatable(arr, cjson.empty_array_mt) ---- ---- return cjson.encode({some_array = arr}) ---- end ----``` ---- ---- Both will generate: ---- ----```json ---- { ---- "some_array": [] ---- } ----``` ---- ---- **NOTE:** This field is specific to the OpenResty cjson fork. ---- ----@alias cjson.empty_array_mt table - - ---- When lua-cjson encodes a table with this metatable, it will systematically ---- encode it as a JSON Array. The resulting, encoded Array will contain the ---- array part of the table, and will be of the same length as the `#` operator ---- on that table. Holes in the table will be encoded with the null JSON value. ---- ---- ## Example ---- ----```lua ---- local t = { "hello", "world" } ---- setmetatable(t, cjson.array_mt) ---- cjson.encode(t) -- ["hello","world"] ----``` ---- ---- Or: ---- ----```lua ---- local t = {} ---- t[1] = "one" ---- t[2] = "two" ---- t[4] = "three" ---- t.foo = "bar" ---- setmetatable(t, cjson.array_mt) ---- cjson.encode(t) -- ["one","two",null,"three"] ----``` ---- ---- **NOTE:** This field is specific to the OpenResty cjson fork. ---- ---- This value was introduced in the 2.1.0.5 release of this module. ---- ----@alias cjson.array_mt table - - ---- Sentinel type that denotes a JSON `null` value ----@alias cjson.null lightuserdata - - ---- A lightuserdata, similar to `cjson.null`, which will be encoded as an empty ---- JSON Array by `cjson.encode()`. ---- ---- For example, since encode_empty_table_as_object is true by default: ---- ----```lua ---- local cjson = require "cjson" ---- ---- local json = cjson.encode({ ---- foo = "bar", ---- some_object = {}, ---- some_array = cjson.empty_array ---- }) ----``` ---- ---- This will generate: ---- ----```json ---- { ---- "foo": "bar", ---- "some_object": {}, ---- "some_array": [] ---- } ----``` ---- ---- **NOTE:** This field is specific to the OpenResty cjson fork. ---- ----@alias cjson.empty_array lightuserdata - - ---- unserialize a json string to a lua value ---- ---- `cjson.decode` will deserialise any UTF-9 JSON string into a Lua value or table. ---- ---- UTF-16 and UTF-32 JSON strings are not supported. ---- ---- cjson.decode requires that any NULL (ASCII 0) and double quote (ASCII 34) characters are escaped within strings. All escape codes will be decoded and other bytes will be passed transparently. UTF-8 characters are not validated during decoding and should be checked elsewhere if required. ---- ---- JSON null will be converted to a NULL lightuserdata value. This can be compared with `cjson.null` for convenience. ---- ---- By default, numbers incompatible with the JSON specification (infinity, NaN, hexadecimal) can be decoded. This default can be changed with `cjson.decode_invalid_numbers()`. ---- ---- ```lua ---- local json_text '[ true, { "foo": "bar" } ]' ---- cjson.decode(json_text) --> { true, { foo = "bar" } } ---- ``` ---- ----@param json string ----@return any -function cjson.decode(json) end - - ---- decode_invalid_numbers ---- ---- Lua CJSON may generate an error when trying to decode numbers not supported ---- by the JSON specification. Invalid numbers are defined as: ---- ---- * infinity ---- * not-a-number (NaN) ---- * hexadecimal ---- ---- Available settings: ---- ---- * `true`: Accept and decode invalid numbers. This is the default setting. ---- * `false`: Throw an error when invalid numbers are encountered. ---- ---- The current setting is always returned, and is only updated when an argument is provided. ---- ----@param setting? boolean # (default: `true`) ----@return boolean setting # the value of the current setting -function cjson.decode_invalid_numbers(setting) end - - ---- decode_max_depth ---- ---- Lua CJSON will generate an error when parsing deeply nested JSON once the ---- maximum array/object depth has been exceeded. This check prevents ---- unnecessarily complicated JSON from slowing down the application, or crashing ---- the application due to lack of process stack space. ---- ---- An error may be generated before the depth limit is hit if Lua is unable to ---- allocate more objects on the Lua stack. ---- ---- By default, Lua CJSON will reject JSON with arrays and/or objects nested ---- more than 1000 levels deep. ---- ---- The current setting is always returned, and is only updated when an argument is provided. ---- ----@param depth? integer # must be positive (default `1000`) ----@return integer depth -function cjson.decode_max_depth(depth) end - - ---- decode_array_with_array_mt ---- ---- If enabled, JSON Arrays decoded by cjson.decode will result in Lua tables ---- with the array_mt metatable. This can ensure a 1-to-1 relationship between ---- arrays upon multiple encoding/decoding of your JSON data with this module. ---- ---- If disabled, JSON Arrays will be decoded to plain Lua tables, without the ---- `cjson.array_mt` metatable. ---- ---- ## Example ---- ----```lua ---- local cjson = require "cjson" ---- ---- -- default behavior ---- local my_json = [[{"my_array":[]}]] ---- local t = cjson.decode(my_json) ---- cjson.encode(t) -- {"my_array":{}} back to an object ---- ---- -- now, if this behavior is enabled ---- cjson.decode_array_with_array_mt(true) ---- ---- local my_json = [[{"my_array":[]}]] ---- local t = cjson.decode(my_json) ---- cjson.encode(t) -- {"my_array":[]} properly re-encoded as an array ----``` ---- ---- **NOTE:** This function is specific to the OpenResty cjson fork. ---- ----@param enabled boolean # (default: false) -function cjson.decode_array_with_array_mt(enabled) end - - ---- serialize a lua value to a json string ---- ---- cjson.encode will serialise a Lua value into a string containing the JSON representation. ---- ---- cjson.encode supports the following types: ---- ---- * boolean ---- * lightuserdata (NULL value only) ---- * nil ---- * number ---- * string ---- * table ---- ---- The remaining Lua types will generate an error: ---- ---- * function ---- * lightuserdata (non-NULL values) ---- * thread ---- * userdata ---- ---- By default, numbers are encoded with 14 significant digits. Refer to cjson.encode_number_precision for details. ---- ---- Lua CJSON will escape the following characters within each UTF-8 string: ---- ---- * Control characters (ASCII 0 - 31) ---- * Double quote (ASCII 34) ---- * Forward slash (ASCII 47) ---- * Blackslash (ASCII 92) ---- * Delete (ASCII 127) ---- ---- All other bytes are passed transparently. ---- ---- ---- ## Caution ---- ---- Lua CJSON will successfully encode/decode binary strings, but this is technically not supported by JSON and may not be compatible with other JSON libraries. To ensure the output is valid JSON, applications should ensure all Lua strings passed to cjson.encode are UTF-8. ---- ---- --- ---- Base64 is commonly used to encode binary data as the most efficient encoding under UTF-8 can only reduce the encoded size by a further ~8%. Lua Base64 routines can be found in the LuaSocket and lbase64 packages. ---- ---- Lua CJSON uses a heuristic to determine whether to encode a Lua table as a JSON array or an object. A Lua table with only positive integer keys of type number will be encoded as a JSON array. All other tables will be encoded as a JSON object. ---- ---- Lua CJSON does not use metamethods when serialising tables. ---- ---- * `rawget()` is used to iterate over Lua arrays ---- * `next()` is used to iterate over Lua objects ---- ---- Lua arrays with missing entries (sparse arrays) may optionally be encoded in ---- several different ways. Refer to cjson.encode_sparse_array for details. ---- ---- JSON object keys are always strings. Hence cjson.encode only supports table ---- keys which are type number or string. All other types will generate an error. ---- ---- ## Note ---- Standards compliant JSON must be encapsulated in either an object ({}) or an array ([]). If strictly standards compliant JSON is desired, a table must be passed to cjson.encode. ---- ---- --- ---- ---- By default, encoding the following Lua values will generate errors: ---- ---- * Numbers incompatible with the JSON specification (infinity, NaN) ---- * Tables nested more than 1000 levels deep ---- * Excessively sparse Lua arrays ---- ---- These defaults can be changed with: ---- ---- * cjson.encode_invalid_numbers ---- * cjson.encode_max_depth ---- * cjson.encode_sparse_array ---- ----```lua ---- local value = { true, { foo = "bar" } } ---- cjson.encode(value) --> '[true,{"foo":"bar"}]' ----``` ---- ----@param value any ----@return string json -function cjson.encode(value) end - - ---- encode_invalid_numbers ---- ---- Lua CJSON may generate an error when encoding floating point numbers not ---- supported by the JSON specification (invalid numbers): ---- ---- * infinity ---- * not-a-number (NaN) ---- ---- Available settings: ---- ---- * `true`: Allow invalid numbers to be encoded. This will generate non-standard JSON, but this output is supported by some libraries. ---- * `false`: Throw an error when attempting to encode invalid numbers. This is the default setting. ---- * `"null"`: Encode invalid numbers as a JSON null value. This allows infinity and NaN to be encoded into valid JSON. ---- ---- The current setting is always returned, and is only updated when an argument is provided. ---- ----@param setting? boolean|'"null"' ----@return boolean|'"null"' setting -function cjson.encode_invalid_numbers(setting) end - - ---- encode_keep_buffer ---- ---- Lua CJSON can reuse the JSON encoding buffer to improve performance. ---- ---- Available settings: ---- ---- * `true` - The buffer will grow to the largest size required and is not freed until the Lua CJSON module is garbage collected. This is the default setting. ---- * `false` - Free the encode buffer after each call to cjson.encode. ---- ---- The current setting is always returned, and is only updated when an argument is provided. ---- ----@param setting? boolean ----@return boolean setting -function cjson.encode_keep_buffer(setting) end - - ---- encode_max_depth ---- ---- Once the maximum table depth has been exceeded Lua CJSON will generate an ---- error. This prevents a deeply nested or recursive data structure from ---- crashing the application. ---- ---- By default, Lua CJSON will generate an error when trying to encode data ---- structures with more than 1000 nested tables. ---- ---- The current setting is always returned, and is only updated when an argument is provided. ---- ----@param depth? integer # must be positive (default `1000`) ----@return integer depth -function cjson.encode_max_depth(depth) end - - ---- encode_number_precision ---- ---- The amount of significant digits returned by Lua CJSON when encoding numbers ---- can be changed to balance accuracy versus performance. For data structures ---- containing many numbers, setting cjson.encode_number_precision to a smaller ---- integer, for example 3, can improve encoding performance by up to 50%. ---- ---- By default, Lua CJSON will output 14 significant digits when converting a number to text. ---- ---- The current setting is always returned, and is only updated when an argument is provided. ---- ---- **NOTE:** The maximum value of 16 is only supported by the OpenResty cjson ---- fork. The maximum in the upstream mpx/lua-cjson module is 14. ---- ----@param precision? integer # must be between 1 and 16 ----@return integer precision -function cjson.encode_number_precision(precision) end - - ---- encode_sparse_array ---- ---- Lua CJSON classifies a Lua table into one of three kinds when encoding a JSON array. This is determined by the number of values missing from the Lua array as follows: ---- ---- * Normal - All values are available. ---- * Sparse - At least 1 value is missing. ---- * Excessively sparse - The number of values missing exceeds the configured ratio. ---- ---- Lua CJSON encodes sparse Lua arrays as JSON arrays using JSON null for the missing entries. ---- ---- An array is excessively sparse when all the following conditions are met: ---- ---- * ratio > 0 ---- * maximum_index > safe ---- * maximum_index > item_count * ratio ---- ---- Lua CJSON will never consider an array to be excessively sparse when ratio = 0. ---- The safe limit ensures that small Lua arrays are always encoded as sparse arrays. ---- ---- By default, attempting to encode an excessively sparse array will generate ---- an error. If convert is set to true, excessively sparse arrays will be ---- converted to a JSON object. ---- ---- The current settings are always returned. A particular setting is only ---- changed when the argument is provided (non-nil). ---- ---- ## Example: Encoding a sparse array ---- ----```lua ---- cjson.encode({ [3] = "data" }) ---- -- Returns: '[null,null,"data"]' ----``` ---- ---- ## Example: Enabling conversion to a JSON object ---- ----```lua ---- cjson.encode_sparse_array(true) ---- cjson.encode({ [1000] = "excessively sparse" }) ---- -- Returns: '{"1000":"excessively sparse"}' ----``` ---- ----@param convert? boolean # (default: false) ----@param ratio? integer # must be positive (default: 2) ----@param safe? integer # must be positive (default: 10) ----@return boolean convert ----@return integer ratio ----@return integer safe -function cjson.encode_sparse_array(convert, ratio, safe) end - - ---- encode_empty_table_as_object ---- ---- Change the default behavior when encoding an empty Lua table. ---- ---- By default, empty Lua tables are encoded as empty JSON Objects (`{}`). If ---- this is set to false, empty Lua tables will be encoded as empty JSON Arrays ---- instead (`[]`). ---- ---- **NOTE:** This function is specific to the OpenResty cjson fork. ---- ----@param setting boolean|'"on"'|'"off"' -function cjson.encode_empty_table_as_object(setting) end - - ---- encode_escape_forward_slash ---- ---- If enabled, forward slash '/' will be encoded as '\/'. ---- ---- If disabled, forward slash '/' will be encoded as '/' (no escape is applied). ---- ---- **NOTE:** This function is specific to the OpenResty cjson fork. ---- ----@param enabled boolean # (default: true) -function cjson.encode_escape_forward_slash(enabled) end - - ---- instantiate an independent copy of the Lua CJSON module ---- ---- The new module has a separate persistent encoding buffer, and default settings ----@return cjson -function cjson.new() end - - -return cjson diff --git a/meta/3rd/OpenResty/library/cjson/safe.lua b/meta/3rd/OpenResty/library/cjson/safe.lua deleted file mode 100644 index 64244b15..00000000 --- a/meta/3rd/OpenResty/library/cjson/safe.lua +++ /dev/null @@ -1,46 +0,0 @@ ----@meta - ---- The `cjson.safe` module behaves identically to the `cjson` module, except when ---- errors are encountered during JSON conversion. On error, the `cjson.safe.encode` ---- and `cjson.safe.decode` functions will return `nil` followed by the error message. ---- ---- @see cjson ---- ----@class cjson.safe : cjson -local cjson_safe = {} - - ---- unserialize a json string to a lua value ---- ---- Returns `nil` and an error string when the input cannot be decoded. ---- ---- ```lua ---- local value, err = cjson_safe.decode(some_json_string) ---- ``` ----@param json string ----@return any? decoded ----@return string? error -function cjson_safe.decode(json) end - - ---- serialize a lua value to a json string ---- ---- Returns `nil` and an error string when the input cannot be encoded. ---- ---- ```lua ---- local json, err = cjson_safe.encode(some_lua_value) ---- ``` ----@param value any ----@return string? encoded ----@return string? error -function cjson_safe.encode(value) end - - ---- instantiate an independent copy of the Lua CJSON module ---- ---- The new module has a separate persistent encoding buffer, and default settings ----@return cjson.safe -function cjson_safe.new() end - - -return cjson_safe diff --git a/meta/3rd/OpenResty/library/jit.lua b/meta/3rd/OpenResty/library/jit.lua deleted file mode 100644 index 1adb40fa..00000000 --- a/meta/3rd/OpenResty/library/jit.lua +++ /dev/null @@ -1,32 +0,0 @@ ----@meta - - ---- Returns (and optionally sets) the current PRNG state (an array of 8 Lua ---- numbers with 32-bit integer values) currently used by the JIT compiler. ---- ---- When the `state` argument is non-nil, it is expected to be an array of up to 8 ---- unsigned Lua numbers, each with value less than 2\*\*32-1. This will set the ---- current PRNG state and return the state that was overridden. ---- ---- **Note:** For backward compatibility, `state` argument can also be an unsigned ---- Lua number less than 2\*\*32-1. ---- ---- **Note:** When the `state` argument is an array and less than 8 numbers, or the ---- `state` is a number, the remaining positions are filled with zeros. ---- ---- Usage: ---- ---- ```lua ---- local state = jit.prngstate() ---- local oldstate = jit.prngstate{ a, b, c, ... } ---- ---- jit.prngstate(32) -- {32, 0, 0, 0, 0, 0, 0, 0} ---- jit.prngstate{432, 23, 50} -- {432, 23, 50, 0, 0, 0, 0, 0} ---- ``` ---- ---- **Note:** This API has no effect if LuaJIT is compiled with ---- `-DLUAJIT_DISABLE_JIT`, and will return a table with all `0`. ---- ----@param state? integer[] ----@return integer[] state -function jit.prngstate(state) end diff --git a/meta/3rd/OpenResty/library/ndk.lua b/meta/3rd/OpenResty/library/ndk.lua deleted file mode 100644 index 17085c92..00000000 --- a/meta/3rd/OpenResty/library/ndk.lua +++ /dev/null @@ -1,4 +0,0 @@ ----@meta -ndk={} -ndk.set_var={} -return ndk
\ No newline at end of file diff --git a/meta/3rd/OpenResty/library/ngx.lua b/meta/3rd/OpenResty/library/ngx.lua deleted file mode 100644 index a223709d..00000000 --- a/meta/3rd/OpenResty/library/ngx.lua +++ /dev/null @@ -1,4393 +0,0 @@ ----@meta - ----@class ngx : table ---- ---- The `ngx.null` constant is a `NULL` light userdata usually used to represent nil values in Lua tables etc and is similar to the `lua-cjson` library's `cjson.null` constant. ----@field null userdata ---- ---- Read and write the current request's response status. This should be called ---- before sending out the response headers. ---- ---- ```lua ---- -- set ---- ngx.status = ngx.HTTP_CREATED ---- -- get ---- status = ngx.status ---- ``` ---- ---- Setting `ngx.status` after the response header is sent out has no effect but leaving an error message in your NGINX's error log file: ---- attempt to set ngx.status after sending out response headers ----@field status ngx.http.status_code ---- ---- Returns `true` if the response headers have been sent (by ngx_lua), and `false` otherwise. ---- ----@field headers_sent boolean ---- ---- Returns `true` if the current request is an NGINX subrequest, or `false` otherwise. ----@field is_subrequest boolean ---- -ngx = {} - ----@class ngx.OK -ngx.OK = 0 ----@class ngx.ERROR -ngx.ERROR = -1 -ngx.AGAIN = -2 -ngx.DONE = -4 -ngx.DECLINED = -5 - -ngx.HTTP_GET = 2 -ngx.HTTP_HEAD = 4 -ngx.HTTP_POST = 8 -ngx.HTTP_PUT = 16 -ngx.HTTP_DELETE = 32 -ngx.HTTP_MKCOL = 64 -ngx.HTTP_COPY = 128 -ngx.HTTP_MOVE = 256 -ngx.HTTP_OPTIONS = 512 -ngx.HTTP_PROPFIND = 1024 -ngx.HTTP_PROPPATCH = 2048 -ngx.HTTP_LOCK = 4096 -ngx.HTTP_UNLOCK = 8192 -ngx.HTTP_PATCH = 16384 -ngx.HTTP_TRACE = 32768 - ----@alias ngx.http.method ----| `ngx.HTTP_GET` ----| `ngx.HTTP_HEAD` ----| `ngx.HTTP_POST` ----| `ngx.HTTP_PUT` ----| `ngx.HTTP_DELETE` ----| `ngx.HTTP_MKCOL` ----| `ngx.HTTP_COPY` ----| `ngx.HTTP_MOVE` ----| `ngx.HTTP_OPTIONS` ----| `ngx.HTTP_PROPFIND` ----| `ngx.HTTP_PROPPATCH` ----| `ngx.HTTP_LOCK` ----| `ngx.HTTP_UNLOCK` ----| `ngx.HTTP_PATCH` ----| `ngx.HTTP_TRACE` - -ngx.HTTP_CONTINUE = 100 -ngx.HTTP_SWITCHING_PROTOCOLS = 101 -ngx.HTTP_OK = 200 -ngx.HTTP_CREATED = 201 -ngx.HTTP_ACCEPTED = 202 -ngx.HTTP_NO_CONTENT = 204 -ngx.HTTP_PARTIAL_CONTENT = 206 -ngx.HTTP_SPECIAL_RESPONSE = 300 -ngx.HTTP_MOVED_PERMANENTLY = 301 -ngx.HTTP_MOVED_TEMPORARILY = 302 -ngx.HTTP_SEE_OTHER = 303 -ngx.HTTP_NOT_MODIFIED = 304 -ngx.HTTP_TEMPORARY_REDIRECT = 307 -ngx.HTTP_PERMANENT_REDIRECT = 308 -ngx.HTTP_BAD_REQUEST = 400 -ngx.HTTP_UNAUTHORIZED = 401 -ngx.HTTP_PAYMENT_REQUIRED = 402 -ngx.HTTP_FORBIDDEN = 403 -ngx.HTTP_NOT_FOUND = 404 -ngx.HTTP_NOT_ALLOWED = 405 -ngx.HTTP_NOT_ACCEPTABLE = 406 -ngx.HTTP_REQUEST_TIMEOUT = 408 -ngx.HTTP_CONFLICT = 409 -ngx.HTTP_GONE = 410 -ngx.HTTP_UPGRADE_REQUIRED = 426 -ngx.HTTP_TOO_MANY_REQUESTS = 429 -ngx.HTTP_CLOSE = 444 -ngx.HTTP_ILLEGAL = 451 -ngx.HTTP_INTERNAL_SERVER_ERROR = 500 -ngx.HTTP_METHOD_NOT_IMPLEMENTED = 501 -ngx.HTTP_BAD_GATEWAY = 502 -ngx.HTTP_SERVICE_UNAVAILABLE = 503 -ngx.HTTP_GATEWAY_TIMEOUT = 504 -ngx.HTTP_VERSION_NOT_SUPPORTED = 505 -ngx.HTTP_INSUFFICIENT_STORAGE = 507 - ----@alias ngx.http.status_code ----| integer ----| `ngx.HTTP_CONTINUE` ----| `ngx.HTTP_SWITCHING_PROTOCOLS` ----| `ngx.HTTP_OK` ----| `ngx.HTTP_CREATED` ----| `ngx.HTTP_ACCEPTED` ----| `ngx.HTTP_NO_CONTENT` ----| `ngx.HTTP_PARTIAL_CONTENT` ----| `ngx.HTTP_SPECIAL_RESPONSE` ----| `ngx.HTTP_MOVED_PERMANENTLY` ----| `ngx.HTTP_MOVED_TEMPORARILY` ----| `ngx.HTTP_SEE_OTHER` ----| `ngx.HTTP_NOT_MODIFIED` ----| `ngx.HTTP_TEMPORARY_REDIRECT` ----| `ngx.HTTP_PERMANENT_REDIRECT` ----| `ngx.HTTP_BAD_REQUEST` ----| `ngx.HTTP_UNAUTHORIZED` ----| `ngx.HTTP_PAYMENT_REQUIRED` ----| `ngx.HTTP_FORBIDDEN` ----| `ngx.HTTP_NOT_FOUND` ----| `ngx.HTTP_NOT_ALLOWED` ----| `ngx.HTTP_NOT_ACCEPTABLE` ----| `ngx.HTTP_REQUEST_TIMEOUT` ----| `ngx.HTTP_CONFLICT` ----| `ngx.HTTP_GONE` ----| `ngx.HTTP_UPGRADE_REQUIRED` ----| `ngx.HTTP_TOO_MANY_REQUESTS` ----| `ngx.HTTP_CLOSE` ----| `ngx.HTTP_ILLEGAL` ----| `ngx.HTTP_INTERNAL_SERVER_ERROR` ----| `ngx.HTTP_METHOD_NOT_IMPLEMENTED` ----| `ngx.HTTP_BAD_GATEWAY` ----| `ngx.HTTP_SERVICE_UNAVAILABLE` ----| `ngx.HTTP_GATEWAY_TIMEOUT` ----| `ngx.HTTP_VERSION_NOT_SUPPORTED` ----| `ngx.HTTP_INSUFFICIENT_STORAGE` - - -ngx.DEBUG = 8 -ngx.INFO = 7 -ngx.NOTICE = 6 -ngx.WARN = 5 -ngx.ERR = 4 -ngx.CRIT = 3 -ngx.ALERT = 2 -ngx.EMERG = 1 -ngx.STDERR = 0 - ---- NGINX log level constants ---- https://github.com/openresty/lua-nginx-module/#nginx-log-level-constants ----@alias ngx.log.level ----| `ngx.DEBUG` # debug ----| `ngx.INFO` # info ----| `ngx.NOTICE` # notice ----| `ngx.WARN` # warning ----| `ngx.ERR` # error ----| `ngx.ALERT` # alert ----| `ngx.CRIT` # critical ----| `ngx.EMERG` # emergency ----| `ngx.STDERR` # standard error - - ---- ngx.ctx table ---- ---- This table can be used to store per-request Lua context data and has a life time identical to the current request (as with the NGINX variables). ---- ---- Consider the following example, ---- ---- ```nginx ---- location /test { ---- rewrite_by_lua_block { ---- ngx.ctx.foo = 76 ---- } ---- access_by_lua_block { ---- ngx.ctx.foo = ngx.ctx.foo + 3 ---- } ---- content_by_lua_block { ---- ngx.say(ngx.ctx.foo) ---- } ---- } ---- ``` ---- ---- Then `GET /test` will yield the output ---- ---- ```bash ---- 79 ---- ``` ---- ---- That is, the `ngx.ctx.foo` entry persists across the rewrite, access, and content phases of a request. ---- ---- Every request, including subrequests, has its own copy of the table. For example: ---- ---- ```nginx ---- location /sub { ---- content_by_lua_block { ---- ngx.say("sub pre: ", ngx.ctx.blah) ---- ngx.ctx.blah = 32 ---- ngx.say("sub post: ", ngx.ctx.blah) ---- } ---- } ---- ---- location /main { ---- content_by_lua_block { ---- ngx.ctx.blah = 73 ---- ngx.say("main pre: ", ngx.ctx.blah) ---- local res = ngx.location.capture("/sub") ---- ngx.print(res.body) ---- ngx.say("main post: ", ngx.ctx.blah) ---- } ---- } ---- ``` ---- ---- Then `GET /main` will give the output ---- ---- ```bash ---- main pre: 73 ---- sub pre: nil ---- sub post: 32 ---- main post: 73 ---- ``` ---- ---- Here, modification of the `ngx.ctx.blah` entry in the subrequest does not affect the one in the parent request. This is because they have two separate versions of `ngx.ctx.blah`. ---- ---- Internal redirection will destroy the original request `ngx.ctx` data (if any) and the new request will have an empty `ngx.ctx` table. For instance, ---- ---- ```nginx ---- location /new { ---- content_by_lua_block { ---- ngx.say(ngx.ctx.foo) ---- } ---- } ---- ---- location /orig { ---- content_by_lua_block { ---- ngx.ctx.foo = "hello" ---- ngx.exec("/new") ---- } ---- } ---- ``` ---- ---- Then `GET /orig` will give ---- ---- ```bash ---- nil ---- ``` ---- ---- rather than the original `"hello"` value. ---- ---- Arbitrary data values, including Lua closures and nested tables, can be inserted into this "magic" table. It also allows the registration of custom meta methods. ---- ---- Overriding `ngx.ctx` with a new Lua table is also supported, for example, ---- ---- ```lua ---- ngx.ctx = { foo = 32, bar = 54 } ---- ``` ---- ---- When being used in the context of `init_worker_by_lua*`, this table just has the same lifetime of the current Lua handler. ---- ---- The `ngx.ctx` lookup requires relatively expensive metamethod calls and it is much slower than explicitly passing per-request data along by your own function arguments. So do not abuse this API for saving your own function arguments because it usually has quite some performance impact. ---- ---- Because of the metamethod magic, never "local" the `ngx.ctx` table outside your Lua function scope on the Lua module level due to `worker-level data sharing`. For example, the following is bad: ---- ---- ```lua ---- -- mymodule.lua ---- local _M = {} ---- ---- -- the following line is bad since ngx.ctx is a per-request ---- -- data while this <code>ctx</code> variable is on the Lua module level ---- -- and thus is per-nginx-worker. ---- local ctx = ngx.ctx ---- ---- function _M.main() ---- ctx.foo = "bar" ---- end ---- ---- return _M ---- ``` ---- ---- Use the following instead: ---- ---- ```lua ---- -- mymodule.lua ---- local _M = {} ---- ---- function _M.main(ctx) ---- ctx.foo = "bar" ---- end ---- ---- return _M ---- ``` ---- ---- That is, let the caller pass the `ctx` table explicitly via a function argument. -ngx.ctx = {} - ---- NGINX thread methods -ngx.thread = {} - ----@class ngx.thread : thread - ---- Kills a running "light thread" created by `ngx.thread.spawn`. Returns a true value when successful or `nil` and a string describing the error otherwise. ---- ---- According to the current implementation, only the parent coroutine (or "light thread") can kill a thread. Also, a running "light thread" with pending NGINX subrequests (initiated by `ngx.location.capture` for example) cannot be killed due to a limitation in the NGINX core. ---- ----@param thread ngx.thread ----@return boolean ok ----@return string? error -function ngx.thread.kill(thread) end - ---- Waits on one or more child "light threads" and returns the results of the first "light thread" that terminates (either successfully or with an error). ---- ---- The arguments `thread1`, `thread2`, and etc are the Lua thread objects returned by earlier calls of `ngx.thread.spawn`. ---- ---- The return values have exactly the same meaning as `coroutine.resume`, that is, the first value returned is a boolean value indicating whether the "light thread" terminates successfully or not, and subsequent values returned are the return values of the user Lua function that was used to spawn the "light thread" (in case of success) or the error object (in case of failure). ---- ---- Only the direct "parent coroutine" can wait on its child "light thread", otherwise a Lua exception will be raised. ---- ---- The following example demonstrates the use of `ngx.thread.wait` and `ngx.location.capture` to emulate `ngx.location.capture_multi`: ---- ---- ```lua ---- local capture = ngx.location.capture ---- local spawn = ngx.thread.spawn ---- local wait = ngx.thread.wait ---- local say = ngx.say ---- ---- local function fetch(uri) ---- return capture(uri) ---- end ---- ---- local threads = { ---- spawn(fetch, "/foo"), ---- spawn(fetch, "/bar"), ---- spawn(fetch, "/baz") ---- } ---- ---- for i = 1, #threads do ---- local ok, res = wait(threads[i]) ---- if not ok then ---- say(i, ": failed to run: ", res) ---- else ---- say(i, ": status: ", res.status) ---- say(i, ": body: ", res.body) ---- end ---- end ---- ``` ---- ---- Here it essentially implements the "wait all" model. ---- ---- And below is an example demonstrating the "wait any" model: ---- ---- ```lua ---- function f() ---- ngx.sleep(0.2) ---- ngx.say("f: hello") ---- return "f done" ---- end ---- ---- function g() ---- ngx.sleep(0.1) ---- ngx.say("g: hello") ---- return "g done" ---- end ---- ---- local tf, err = ngx.thread.spawn(f) ---- if not tf then ---- ngx.say("failed to spawn thread f: ", err) ---- return ---- end ---- ---- ngx.say("f thread created: ", coroutine.status(tf)) ---- ---- local tg, err = ngx.thread.spawn(g) ---- if not tg then ---- ngx.say("failed to spawn thread g: ", err) ---- return ---- end ---- ---- ngx.say("g thread created: ", coroutine.status(tg)) ---- ---- ok, res = ngx.thread.wait(tf, tg) ---- if not ok then ---- ngx.say("failed to wait: ", res) ---- return ---- end ---- ---- ngx.say("res: ", res) ---- ---- -- stop the "world", aborting other running threads ---- ngx.exit(ngx.OK) ---- ``` ---- ---- And it will generate the following output: ---- ---- f thread created: running ---- g thread created: running ---- g: hello ---- res: g done ---- ----@param ... ngx.thread ----@return boolean ok ----@return any ret_or_error -function ngx.thread.wait(...) end - ---- Spawns a new user "light thread" with the Lua function `func` as well as those optional arguments `arg1`, `arg2`, and etc. Returns a Lua thread (or Lua coroutine) object represents this "light thread". ---- ---- "Light threads" are just a special kind of Lua coroutines that are scheduled by the ngx_lua module. ---- ---- Before `ngx.thread.spawn` returns, the `func` will be called with those optional arguments until it returns, aborts with an error, or gets yielded due to I/O operations via the NGINX APIs for lua (like `tcpsock:receive`). ---- ---- After `ngx.thread.spawn` returns, the newly-created "light thread" will keep running asynchronously usually at various I/O events. ---- ---- All the Lua code chunks running by `rewrite_by_lua`, `access_by_lua`, and `content_by_lua` are in a boilerplate "light thread" created automatically by ngx_lua. Such boilerplate "light thread" are also called "entry threads". ---- ---- By default, the corresponding NGINX handler (e.g., `rewrite_by_lua` handler) will not terminate until ---- ---- 1. both the "entry thread" and all the user "light threads" terminates, ---- 1. a "light thread" (either the "entry thread" or a user "light thread" aborts by calling `ngx.exit`, `ngx.exec`, `ngx.redirect`, or `ngx.req.set_uri(uri, true)`, or ---- 1. the "entry thread" terminates with a Lua error. ---- ---- When the user "light thread" terminates with a Lua error, however, it will not abort other running "light threads" like the "entry thread" does. ---- ---- Due to the limitation in the NGINX subrequest model, it is not allowed to abort a running NGINX subrequest in general. So it is also prohibited to abort a running "light thread" that is pending on one ore more NGINX subrequests. You must call `ngx.thread.wait` to wait for those "light thread" to terminate before quitting the "world". A notable exception here is that you can abort pending subrequests by calling `ngx.exit` with and only with the status code `ngx.ERROR` (-1), `408`, `444`, or `499`. ---- ---- The "light threads" are not scheduled in a pre-emptive way. In other words, no time-slicing is performed automatically. A "light thread" will keep running exclusively on the CPU until ---- ---- 1. a (nonblocking) I/O operation cannot be completed in a single run, ---- 1. it calls `coroutine.yield` to actively give up execution, or ---- 1. it is aborted by a Lua error or an invocation of `ngx.exit`, `ngx.exec`, `ngx.redirect`, or `ngx.req.set_uri(uri, true)`. ---- ---- For the first two cases, the "light thread" will usually be resumed later by the ngx_lua scheduler unless a "stop-the-world" event happens. ---- ---- User "light threads" can create "light threads" themselves. And normal user coroutines created by `coroutine.create` can also create "light threads". The coroutine (be it a normal Lua coroutine or a "light thread") that directly spawns the "light thread" is called the "parent coroutine" for the "light thread" newly spawned. ---- ---- The "parent coroutine" can call `ngx.thread.wait` to wait on the termination of its child "light thread". ---- ---- You can call coroutine.status() and coroutine.yield() on the "light thread" coroutines. ---- ---- The status of the "light thread" coroutine can be "zombie" if ---- ---- 1. the current "light thread" already terminates (either successfully or with an error), ---- 1. its parent coroutine is still alive, and ---- 1. its parent coroutine is not waiting on it with `ngx.thread.wait`. ---- ---- The following example demonstrates the use of coroutine.yield() in the "light thread" coroutines ---- to do manual time-slicing: ---- ---- ```lua ---- local yield = coroutine.yield ---- ---- function f() ---- local self = coroutine.running() ---- ngx.say("f 1") ---- yield(self) ---- ngx.say("f 2") ---- yield(self) ---- ngx.say("f 3") ---- end ---- ---- local self = coroutine.running() ---- ngx.say("0") ---- yield(self) ---- ---- ngx.say("1") ---- ngx.thread.spawn(f) ---- ---- ngx.say("2") ---- yield(self) ---- ---- ngx.say("3") ---- yield(self) ---- ---- ngx.say("4") ---- ``` ---- ---- Then it will generate the output ---- ---- 0 ---- 1 ---- f 1 ---- 2 ---- f 2 ---- 3 ---- f 3 ---- 4 ---- ---- "Light threads" are mostly useful for making concurrent upstream requests in a single NGINX request handler, much like a generalized version of `ngx.location.capture_multi` that can work with all the NGINX APIs for lua. The following example demonstrates parallel requests to MySQL, Memcached, and upstream HTTP services in a single Lua handler, and outputting the results in the order that they actually return (similar to Facebook's BigPipe model): ---- ---- ```lua ---- -- query mysql, memcached, and a remote http service at the same time, ---- -- output the results in the order that they ---- -- actually return the results. ---- ---- local mysql = require "resty.mysql" ---- local memcached = require "resty.memcached" ---- ---- local function query_mysql() ---- local db = mysql:new() ---- db:connect{ ---- host = "127.0.0.1", ---- port = 3306, ---- database = "test", ---- user = "monty", ---- password = "mypass" ---- } ---- local res, err, errno, sqlstate = ---- db:query("select * from cats order by id asc") ---- db:set_keepalive(0, 100) ---- ngx.say("mysql done: ", cjson.encode(res)) ---- end ---- ---- local function query_memcached() ---- local memc = memcached:new() ---- memc:connect("127.0.0.1", 11211) ---- local res, err = memc:get("some_key") ---- ngx.say("memcached done: ", res) ---- end ---- ---- local function query_http() ---- local res = ngx.location.capture("/my-http-proxy") ---- ngx.say("http done: ", res.body) ---- end ---- ---- ngx.thread.spawn(query_mysql) -- create thread 1 ---- ngx.thread.spawn(query_memcached) -- create thread 2 ---- ngx.thread.spawn(query_http) -- create thread 3 ---- ``` ---- ----@param func function ----@param ... any ----@return ngx.thread -function ngx.thread.spawn(func, ...) end - ---- NGINX worker methods -ngx.worker = {} - ---- This function returns a boolean value indicating whether the current NGINX worker process already starts exiting. NGINX worker process exiting happens on NGINX server quit or configuration reload (aka HUP reload). ---- ----@return boolean -function ngx.worker.exiting() end - ---- Returns the ordinal number of the current NGINX worker processes (starting from number 0). ---- ---- So if the total number of workers is `N`, then this method may return a number between 0 ---- and `N - 1` (inclusive). ---- ----@return number -function ngx.worker.id() end - ---- Returns the total number of the NGINX worker processes (i.e., the value configured ---- by the `worker_processes` ---- directive in `nginx.conf`). ---- ----@return number -function ngx.worker.count() end - ---- This function returns a Lua number for the process ID (PID) of the current NGINX worker process. This API is more efficient than `ngx.var.pid` and can be used in contexts where the `ngx.var.VARIABLE` API cannot be used (like `init_worker_by_lua`). ---- ----@return number -function ngx.worker.pid() end - ----@class ngx.config : table ---- ---- This string field indicates the current NGINX subsystem the current Lua environment is based on. For this module, this field always takes the string value `"http"`. ---- For `ngx_stream_lua_module`, however, this field takes the value `"stream"`. ----@field subsystem '"http"'|'"stream"' ---- ---- This field takes an integral value indicating the version number of the current NGINX core being used. For example, the version number `1.4.3` results in the Lua number 1004003. ----@field nginx_version number ---- ---- This field takes an integral value indicating the version number of the current `ngx_lua` module being used. ---- For example, the version number `0.9.3` results in the Lua number 9003. ----@field ngx_lua_version number ---- ---- This boolean field indicates whether the current NGINX is a debug build, i.e., being built by the `./configure` option `--with-debug`. ----@field debug boolean ---- ---- This boolean field indicates whether the current NGINX run by resty. ----@field is_console boolean ---- -ngx.config = {} - - ---- Returns the NGINX server "prefix" path, as determined by the `-p` command-line option when running the NGINX executable, or the path specified by the `--prefix` command-line option when building NGINX with the `./configure` script. ---- ----@return string -function ngx.config.prefix() end - ---- This function returns a string for the NGINX `./configure` command's arguments string. ---- ----@return string -function ngx.config.nginx_configure() end - -ngx.timer = {} - ----@alias ngx.timer.callback fun(premature:boolean, ...:any) - ---- Returns the number of pending timers. ---- ----@return number -function ngx.timer.pending_count() end - ---- Returns the number of timers currently running. ---- ----@return integer -function ngx.timer.running_count() end - ---- Similar to the `ngx.timer.at` API function, but ---- ---- 1. `delay` *cannot* be zero, ---- 2. timer will be created every `delay` seconds until the current NGINX worker process starts exiting. ---- ---- When success, returns a "conditional true" value (but not a `true`). Otherwise, returns a "conditional false" value and a string describing the error. ---- ---- This API also respect the `lua_max_pending_timers` and `lua_max_running_timers`. ---- ----@param delay number the interval to execute the timer on ----@param callback ngx.timer.callback the function to call ----@param ... any extra arguments to pass to `callback` ----@return boolean ok ----@return string? error -function ngx.timer.every(delay, callback, ...) end - ---- Creates an NGINX timer with a user callback function as well as optional user arguments. ---- ---- The first argument, `delay`, specifies the delay for the timer, ---- in seconds. One can specify fractional seconds like `0.001` to mean 1 ---- millisecond here. `0` delay can also be specified, in which case the ---- timer will immediately expire when the current handler yields ---- execution. ---- ---- The second argument, `callback`, can ---- be any Lua function, which will be invoked later in a background ---- "light thread" after the delay specified. The user callback will be ---- called automatically by the NGINX core with the arguments `premature`, ---- `user_arg1`, `user_arg2`, and etc, where the `premature` ---- argument takes a boolean value indicating whether it is a premature timer ---- expiration or not, and `user_arg1`, `user_arg2`, and etc, are ---- those (extra) user arguments specified when calling `ngx.timer.at` ---- as the remaining arguments. ---- ---- Premature timer expiration happens when the NGINX worker process is ---- trying to shut down, as in an NGINX configuration reload triggered by ---- the `HUP` signal or in an NGINX server shutdown. When the NGINX worker ---- is trying to shut down, one can no longer call `ngx.timer.at` to ---- create new timers with nonzero delays and in that case `ngx.timer.at` will return a "conditional false" value and ---- a string describing the error, that is, "process exiting". ---- ---- It is allowed to create zero-delay timers even when the NGINX worker process starts shutting down. ---- ---- When a timer expires, the user Lua code in the timer callback is ---- running in a "light thread" detached completely from the original ---- request creating the timer. So objects with the same lifetime as the ---- request creating them, like `cosockets`, cannot be shared between the ---- original request and the timer user callback function. ---- ---- Here is a simple example: ---- ---- ```nginx ---- location / { ---- ... ---- log_by_lua_block { ---- local function push_data(premature, uri, args, status) ---- -- push the data uri, args, and status to the remote ---- -- via ngx.socket.tcp or ngx.socket.udp ---- -- (one may want to buffer the data in Lua a bit to ---- -- save I/O operations) ---- end ---- local ok, err = ngx.timer.at(0, push_data, ---- ngx.var.uri, ngx.var.args, ngx.header.status) ---- if not ok then ---- ngx.log(ngx.ERR, "failed to create timer: ", err) ---- return ---- end ---- } ---- } ---- ``` ---- ---- One can also create infinite re-occurring timers, for instance, a timer getting triggered every `5` seconds, by calling `ngx.timer.at` recursively in the timer callback function. Here is such an example, ---- ---- ```lua ---- local delay = 5 ---- local handler ---- handler = function (premature) ---- -- do some routine job in Lua just like a cron job ---- if premature then ---- return ---- end ---- local ok, err = ngx.timer.at(delay, handler) ---- if not ok then ---- ngx.log(ngx.ERR, "failed to create the timer: ", err) ---- return ---- end ---- end ---- ---- local ok, err = ngx.timer.at(delay, handler) ---- if not ok then ---- ngx.log(ngx.ERR, "failed to create the timer: ", err) ---- return ---- end ---- ``` ---- ---- It is recommended, however, to use the `ngx.timer.every` API function ---- instead for creating recurring timers since it is more robust. ---- ---- Because timer callbacks run in the background and their running time ---- will not add to any client request's response time, they can easily ---- accumulate in the server and exhaust system resources due to either ---- Lua programming mistakes or just too much client traffic. To prevent ---- extreme consequences like crashing the NGINX server, there are ---- built-in limitations on both the number of "pending timers" and the ---- number of "running timers" in an NGINX worker process. The "pending ---- timers" here mean timers that have not yet been expired and "running ---- timers" are those whose user callbacks are currently running. ---- ---- The maximal number of pending timers allowed in an NGINX ---- worker is controlled by the `lua_max_pending_timers` ---- directive. The maximal number of running timers is controlled by the ---- `lua_max_running_timers` directive. ---- ---- According to the current implementation, each "running timer" will ---- take one (fake) connection record from the global connection record ---- list configured by the standard `worker_connections` directive in ---- `nginx.conf`. So ensure that the ---- `worker_connections` directive is set to ---- a large enough value that takes into account both the real connections ---- and fake connections required by timer callbacks (as limited by the ---- `lua_max_running_timers` directive). ---- ---- A lot of the Lua APIs for NGINX are enabled in the context of the timer ---- callbacks, like stream/datagram cosockets (`ngx.socket.tcp` and `ngx.socket.udp`), shared ---- memory dictionaries (`ngx.shared.DICT`), user coroutines (`coroutine.*`), ---- user "light threads" (`ngx.thread.*`), `ngx.exit`, `ngx.now`/`ngx.time`, ---- `ngx.md5`/`ngx.sha1_bin`, are all allowed. But the subrequest API (like ---- `ngx.location.capture`), the `ngx.req.*` API, the downstream output API ---- (like `ngx.say`, `ngx.print`, and `ngx.flush`) are explicitly disabled in ---- this context. ---- ---- You can pass most of the standard Lua values (nils, booleans, numbers, strings, tables, closures, file handles, and etc) into the timer callback, either explicitly as user arguments or implicitly as upvalues for the callback closure. There are several exceptions, however: you *cannot* pass any thread objects returned by `coroutine.create` and `ngx.thread.spawn` or any cosocket objects returned by `ngx.socket.tcp`, `ngx.socket.udp`, and `ngx.req.socket` because these objects' lifetime is bound to the request context creating them while the timer callback is detached from the creating request's context (by design) and runs in its own (fake) request context. If you try to share the thread or cosocket objects across the boundary of the creating request, then you will get the "no co ctx found" error (for threads) or "bad request" (for cosockets). It is fine, however, to create all these objects inside your timer callback. ---- ----@param delay number ----@param callback ngx.timer.callback ----@param ... any ----@return boolean ok ----@return string? error -function ngx.timer.at(delay, callback, ...) end - - ---- Unescape `str` as an escaped URI component. ---- ---- For example, ---- ---- ```lua ---- ngx.say(ngx.unescape_uri("b%20r56+7")) ---- ``` ---- ---- gives the output ---- ---- b r56 7 ---- ----@param str string ----@return string -function ngx.unescape_uri(str) end - ---- Escape `str` as a URI component. ---- ----@param str string ----@return string -function ngx.escape_uri(str) end - ---- Returns the binary form of the SHA-1 digest of the `str` argument. ---- ---- This function requires SHA-1 support in the NGINX build. (This usually just means OpenSSL should be installed while building NGINX). ---- ----@param str string ----@return any -function ngx.sha1_bin(str) end - ---- Calculates the CRC-32 (Cyclic Redundancy Code) digest for the `str` argument. ---- ---- This method performs better on relatively short `str` inputs (i.e., less than 30 ~ 60 bytes), as compared to `ngx.crc32_long`. The result is exactly the same as `ngx.crc32_long`. ---- ---- Behind the scene, it is just a thin wrapper around the `ngx_crc32_short` function defined in the NGINX core. ---- ----@param str string ----@return number -function ngx.crc32_short(str) end - ---- Calculates the CRC-32 (Cyclic Redundancy Code) digest for the `str` argument. ---- ---- This method performs better on relatively long `str` inputs (i.e., longer than 30 ~ 60 bytes), as compared to `ngx.crc32_short`. The result is exactly the same as `ngx.crc32_short`. ---- ---- Behind the scene, it is just a thin wrapper around the `ngx_crc32_long` function defined in the NGINX core. ---- ----@param str string ----@return number -function ngx.crc32_long(str) end - ---- Returns the binary form of the MD5 digest of the `str` argument. ---- ---- See `ngx.md5` if the hexadecimal form of the MD5 digest is required. ---- ----@param str string ----@return string -function ngx.md5_bin(str) end - ---- Returns the hexadecimal representation of the MD5 digest of the `str` argument. ---- ---- For example, ---- ---- ```nginx ---- location = /md5 { ---- content_by_lua_block { ngx.say(ngx.md5("hello")) } ---- } ---- ``` ---- ---- yields the output ---- ---- 5d41402abc4b2a76b9719d911017c592 ---- ---- See `ngx.md5_bin` if the raw binary MD5 digest is required. ---- ----@param str string ----@return string -function ngx.md5(str) end - ---- Computes the `HMAC-SHA1` digest of the argument `str` and turns the result using the secret key `<secret_key>`. ---- ---- The raw binary form of the `HMAC-SHA1` digest will be generated, use `ngx.encode_base64`, for example, to encode the result to a textual representation if desired. ---- ---- For example, ---- ---- ```lua ---- local key = "thisisverysecretstuff" ---- local src = "some string we want to sign" ---- local digest = ngx.hmac_sha1(key, src) ---- ngx.say(ngx.encode_base64(digest)) ---- ``` ---- ---- yields the output ---- ---- R/pvxzHC4NLtj7S+kXFg/NePTmk= ---- ----@param secret_key string ----@param str string ----@return string -function ngx.hmac_sha1(secret_key, str) end - ---- Returns a quoted SQL string literal according to the MySQL quoting rules. ---- ----@param raw_value string ----@return string -function ngx.quote_sql_str(raw_value) end - -ngx.re = {} - - ---- PCRE regex options string ---- ---- This is a string made up of single-letter PCRE option names, usable in all `ngx.re.*` functions. ---- ---- Options: ---- ---- a - anchored mode (only match from the beginning) ---- d - enable the DFA mode (or the longest token match semantics). ---- D - enable duplicate named pattern support. This allows named subpattern names to be repeated, returning the captures in an array-like Lua table. ---- i - case insensitive mode ---- j - enable PCRE JIT compilation. For optimum performance, this option should always be used together with the 'o' option. ---- J - enable the PCRE Javascript compatible mode ---- m - multi-line mode ---- o - compile-once mode, to enable the worker-process-level compiled-regex cache ---- s - single-line mode ---- u - UTF-8 mode. ---- U - similar to "u" but disables PCRE's UTF-8 validity check on the subject string ---- x - extended mode ---- ---- These options can be combined: ---- ---- ```lua ---- local m, err = ngx.re.match("hello, world", "HEL LO", "ix") ---- -- m[0] == "hello" ---- ``` ---- ---- ```lua ---- local m, err = ngx.re.match("hello, 美好生活", "HELLO, (.{2})", "iu") ---- -- m[0] == "hello, 美好" ---- -- m[1] == "美好" ---- ``` ---- ---- The `o` option is useful for performance tuning, because the regex pattern in question will only be compiled once, cached in the worker-process level, and shared among all requests in the current NGINX worker process. The upper limit of the regex cache can be tuned via the `lua_regex_cache_max_entries` directive. ---- ----@alias ngx.re.options string - - ---- ngx.re.match capture table ---- ---- This table may have both integer and string keys. ---- ---- `captures[0]` is special and contains the whole substring match ---- ---- `captures[1]` through `captures[n]` contain the values of unnamed, parenthesized sub-pattern captures ---- ---- ```lua ---- local m, err = ngx.re.match("hello, 1234", "[0-9]+") ---- if m then ---- -- m[0] == "1234" ---- ---- else ---- if err then ---- ngx.log(ngx.ERR, "error: ", err) ---- return ---- end ---- ---- ngx.say("match not found") ---- end ---- ``` ---- ---- ```lua ---- local m, err = ngx.re.match("hello, 1234", "([0-9])[0-9]+") ---- -- m[0] == "1234" ---- -- m[1] == "1" ---- ``` ---- ---- Named captures are stored with string keys corresponding to the capture name (e.g. `captures["my_capture_name"]`) _in addition to_ their sequential integer key (`captures[n]`): ---- ---- ```lua ---- local m, err = ngx.re.match("hello, 1234", "([0-9])(?<remaining>[0-9]+)") ---- -- m[0] == "1234" ---- -- m[1] == "1" ---- -- m[2] == "234" ---- -- m["remaining"] == "234" ---- ``` ---- ---- Unmatched captures (named or unnamed) take the value `false`. ---- ---- ```lua ---- local m, err = ngx.re.match("hello, world", "(world)|(hello)|(?<named>howdy)") ---- -- m[0] == "hello" ---- -- m[1] == false ---- -- m[2] == "hello" ---- -- m[3] == false ---- -- m["named"] == false ---- ``` ---- ----@alias ngx.re.captures table<integer|string, string|string[]|'false'> - ---- ngx.re.match context table ---- ---- A Lua table holding an optional `pos` field. When the `pos` field in the `ctx` table argument is specified, `ngx.re.match` will start matching from that offset (starting from 1). Regardless of the presence of the `pos` field in the `ctx` table, `ngx.re.match` will always set this `pos` field to the position *after* the substring matched by the whole pattern in case of a successful match. When match fails, the `ctx` table will be left intact. ---- ---- ```lua ---- local ctx = {} ---- local m, err = ngx.re.match("1234, hello", "[0-9]+", "", ctx) ---- -- m[0] = "1234" ---- -- ctx.pos == 5 ---- ``` ---- ---- ```lua ---- local ctx = { pos = 2 } ---- local m, err = ngx.re.match("1234, hello", "[0-9]+", "", ctx) ---- -- m[0] = "234" ---- -- ctx.pos == 5 ---- ``` ---- ----@class ngx.re.ctx : table ----@field pos? integer - - ---- Similar to `ngx.re.match` but only returns the beginning index (`from`) and end index (`to`) of the matched substring. The returned indexes are 1-based and can be fed directly into the `string.sub` API function to obtain the matched substring. ---- ---- In case of errors (like bad regexes or any PCRE runtime errors), this API function returns two `nil` values followed by a string describing the error. ---- ---- If no match is found, this function just returns a `nil` value. ---- ---- Below is an example: ---- ---- ```lua ---- local s = "hello, 1234" ---- local from, to, err = ngx.re.find(s, "([0-9]+)", "jo") ---- if from then ---- ngx.say("from: ", from) ---- ngx.say("to: ", to) ---- ngx.say("matched: ", string.sub(s, from, to)) ---- else ---- if err then ---- ngx.say("error: ", err) ---- return ---- end ---- ngx.say("not matched!") ---- end ---- ``` ---- ---- This example produces the output ---- ---- from: 8 ---- to: 11 ---- matched: 1234 ---- ---- Because this API function does not create new Lua strings nor new Lua tables, it is much faster than `ngx.re.match`. It should be used wherever possible. ---- ---- The optional 5th argument, `nth`, allows the caller to specify which (submatch) capture's indexes to return. When `nth` is 0 (which is the default), the indexes for the whole matched substring is returned; when `nth` is 1, then the 1st submatch capture's indexes are returned; when `nth` is 2, then the 2nd submatch capture is returned, and so on. When the specified submatch does not have a match, then two `nil` values will be returned. Below is an example for this: ---- ---- ```lua ---- local str = "hello, 1234" ---- local from, to = ngx.re.find(str, "([0-9])([0-9]+)", "jo", nil, 2) ---- if from then ---- ngx.say("matched 2nd submatch: ", string.sub(str, from, to)) -- yields "234" ---- end ---- ``` ---- ----@param subject string ----@param regex string ----@param options? ngx.re.options ----@param ctx? ngx.re.ctx ----@param nth? integer ----@return integer? from ----@return integer? to ----@return string? error -function ngx.re.find(subject, regex, options, ctx, nth) end - - ---- Similar to `ngx.re.match`, but returns a Lua iterator instead, so as to let the user programmer iterate all the matches over the `<subject>` string argument with the PCRE `regex`. ---- ---- In case of errors, like seeing an ill-formed regular expression, `nil` and a string describing the error will be returned. ---- ---- Here is a small example to demonstrate its basic usage: ---- ---- ```lua ---- local iterator, err = ngx.re.gmatch("hello, world!", "([a-z]+)", "i") ---- if not iterator then ---- ngx.log(ngx.ERR, "error: ", err) ---- return ---- end ---- ---- local m ---- m, err = iterator() -- m[0] == m[1] == "hello" ---- if err then ---- ngx.log(ngx.ERR, "error: ", err) ---- return ---- end ---- ---- m, err = iterator() -- m[0] == m[1] == "world" ---- if err then ---- ngx.log(ngx.ERR, "error: ", err) ---- return ---- end ---- ---- m, err = iterator() -- m == nil ---- if err then ---- ngx.log(ngx.ERR, "error: ", err) ---- return ---- end ---- ``` ---- ---- More often we just put it into a Lua loop: ---- ---- ```lua ---- local it, err = ngx.re.gmatch("hello, world!", "([a-z]+)", "i") ---- if not it then ---- ngx.log(ngx.ERR, "error: ", err) ---- return ---- end ---- ---- while true do ---- local m, err = it() ---- if err then ---- ngx.log(ngx.ERR, "error: ", err) ---- return ---- end ---- ---- if not m then ---- -- no match found (any more) ---- break ---- end ---- ---- -- found a match ---- ngx.say(m[0]) ---- ngx.say(m[1]) ---- end ---- ``` ---- ---- The current implementation requires that the iterator returned should only be used in a single request. That is, one should *not* assign it to a variable belonging to persistent namespace like a Lua package. ---- ----@alias ngx.re.gmatch.iterator fun():string,string ---- ----@param subject string ----@param regex string ----@param options? ngx.re.options ----@return ngx.re.gmatch.iterator? iterator ----@return string? error -function ngx.re.gmatch(subject, regex, options) end - - ---- Matches the `subject` string using the Perl compatible regular expression `regex` with the optional `options`. ---- ---- Only the first occurrence of the match is returned, or `nil` if no match is found. In case of errors, like seeing a bad regular expression or exceeding the PCRE stack limit, `nil` and a string describing the error will be returned. ---- ---- The optional fourth argument, `ctx`, can be a Lua table holding an optional `pos` field. When the `pos` field in the `ctx` table argument is specified, `ngx.re.match` will start matching from that offset (starting from 1). Regardless of the presence of the `pos` field in the `ctx` table, `ngx.re.match` will always set this `pos` field to the position *after* the substring matched by the whole pattern in case of a successful match. When match fails, the `ctx` table will be left intact. ---- ---- ```lua ---- local ctx = {} ---- local m, err = ngx.re.match("1234, hello", "[0-9]+", "", ctx) ---- -- m[0] = "1234" ---- -- ctx.pos == 5 ---- ``` ---- ---- ```lua ---- local ctx = { pos = 2 } ---- local m, err = ngx.re.match("1234, hello", "[0-9]+", "", ctx) ---- -- m[0] = "234" ---- -- ctx.pos == 5 ---- ``` ---- ---- The `ctx` table argument combined with the `a` regex modifier can be used to construct a lexer atop `ngx.re.match`. ---- ---- Note that, the `options` argument is not optional when the `ctx` argument is specified and that the empty Lua string (`""`) must be used as placeholder for `options` if no meaningful regex options are required. ---- ---- The optional 5th argument, `res_table`, allows the caller to supply the Lua table used to hold all the capturing results. Starting from `0.9.6`, it is the caller's responsibility to ensure this table is empty. This is very useful for recycling Lua tables and saving GC and table allocation overhead. ---- ----@param subject string ----@param regex string ----@param options? ngx.re.options ----@param ctx? ngx.re.ctx ----@param res? ngx.re.captures ----@return ngx.re.captures? captures ----@return string? error -function ngx.re.match(subject, regex, options, ctx, res) end - ---- Just like `ngx.re.sub`, but does global substitution. ---- ---- Here is some examples: ---- ---- ```lua ---- local newstr, n, err = ngx.re.gsub("hello, world", "([a-z])[a-z]+", "[$0,$1]", "i") ---- if newstr then ---- -- newstr == "[hello,h], [world,w]" ---- -- n == 2 ---- else ---- ngx.log(ngx.ERR, "error: ", err) ---- return ---- end ---- ``` ---- ---- ```lua ---- local func = function (m) ---- return "[" .. m[0] .. "," .. m[1] .. "]" ---- end ---- local newstr, n, err = ngx.re.gsub("hello, world", "([a-z])[a-z]+", func, "i") ---- -- newstr == "[hello,h], [world,w]" ---- -- n == 2 ---- ``` ---- ----@param subject string ----@param regex string ----@param replace ngx.re.replace ----@param options? ngx.re.options ----@return string? new ----@return integer? n ----@return string? error -function ngx.re.gsub(subject, regex, replace, options) end - ---- When `replace` is string, then it is treated as a special template for string replacement: ---- ---- ```lua ---- local newstr, n, err = ngx.re.sub("hello, 1234", "([0-9])[0-9]", "[$0][$1]") ---- if newstr then ---- -- newstr == "hello, [12][1]34" ---- -- n == 1 ---- else ---- ngx.log(ngx.ERR, "error: ", err) ---- return ---- end ---- ``` ---- ---- ...where `$0` refers to the whole substring matched by the pattern, and `$1` referring to the first parenthesized capturing substring. ---- ---- Curly braces can also be used to disambiguate variable names from the background string literals: ---- ---- ```lua ---- local newstr, n, err = ngx.re.sub("hello, 1234", "[0-9]", "${0}00") ---- -- newstr == "hello, 100234" ---- -- n == 1 ---- ``` ---- ---- Literal dollar sign characters (`$`) in the `replace` string argument can be escaped by another dollar sign: ---- ---- ```lua ---- local newstr, n, err = ngx.re.sub("hello, 1234", "[0-9]", "$$") ---- -- newstr == "hello, $234" ---- -- n == 1 ---- ``` ---- ---- Do not use backlashes to escape dollar signs; it will not work as expected. ----@alias ngx.re.replace.string string - ---- When `replace` is a function, it will be invoked with the capture table as the argument to generate the replace string literal for substitution. The capture table fed into the `replace` function is exactly the same as the return value of `ngx.re.match`. Here is an example: ---- ---- ```lua ---- local func = function (m) ---- return "[" .. m[0] .. "][" .. m[1] .. "]" ---- end ---- local newstr, n, err = ngx.re.sub("hello, 1234", "( [0-9] ) [0-9]", func, "x") ---- -- newstr == "hello, [12][1]34" ---- -- n == 1 ---- ``` ---- ---- The dollar sign characters in the return value of the `replace` function argument are not special at all. ---- ----@alias ngx.re.replace.fn fun(m:ngx.re.captures):string - ----@alias ngx.re.replace ngx.re.replace.string|ngx.re.replace.fn - ---- Substitutes the first match of the Perl compatible regular expression `regex` on the `subject` argument string with the string or function argument `replace`. ---- ---- This method returns the resulting new string as well as the number of successful substitutions. In case of failures, like syntax errors in the regular expressions or the `<replace>` string argument, it will return `nil` and a string describing the error. ---- ----@param subject string ----@param regex string ----@param replace ngx.re.replace ----@param options? ngx.re.options ----@return string? new ----@return integer? n ----@return string? error -function ngx.re.sub(subject, regex, replace, options) end - - ---- Decodes the `str` argument as a base64 digest to the raw form. Returns `nil` if `str` is not well formed. ---- ----@param str string ----@return string -function ngx.decode_base64(str) end - ---- Encodes `str` to a base64 digest. ---- ---- An optional boolean-typed `no_padding` argument can be specified to control whether the base64 padding should be appended to the resulting digest (default to `false`, i.e., with padding enabled). ---- ----@param str string ----@param no_padding? boolean ----@return string -function ngx.encode_base64(str, no_padding) end - ---- Fetching the shm-based Lua dictionary object for the shared memory zone named `DICT` defined by the `lua_shared_dict` directive. ---- ---- All these methods are *atomic* operations, that is, safe from concurrent accesses from multiple NGINX worker processes for the same `lua_shared_dict` zone. ---- ---- The shared dictionary will retain its contents through a server config reload (either by sending the `HUP` signal to the NGINX process or by using the `-s reload` command-line option). ---- ---- The contents in the dictionary storage will be lost, however, when the NGINX server quits. ---- ----@type table<string,ngx.shared.DICT> -ngx.shared = {} - ----@class ngx.shared.DICT -local DICT = {} - ---- Valid values for ngx.shared.DICT ----@alias ngx.shared.DICT.value ----| string ----| number ----| boolean ----| nil - ---- Retrieve a value. If the key does not exist or has expired, then `nil` will be returned. ---- ---- In case of errors, `nil` and a string describing the error will be returned. ---- ---- The value returned will have the original data type when they were inserted into the dictionary, for example, Lua booleans, numbers, or strings. ---- ---- ```lua ---- local cats = ngx.shared.cats ---- local value, flags = cats:get("Marry") ---- ``` ---- ---- If the user flags is `0` (the default), then no flags value will be returned. ---- ----@param key string ----@return ngx.shared.DICT.value? value ----@return ngx.shared.DICT.flags|string|nil flags_or_error -function DICT:get(key) end - - ---- Similar to the `get` method but returns the value even if the key has already expired. ---- ---- Returns a 3rd value, `stale`, indicating whether the key has expired or not. ---- ---- Note that the value of an expired key is not guaranteed to be available so one should never rely on the availability of expired items. ---- ----@param key string ----@return ngx.shared.DICT.value? value ----@return ngx.shared.DICT.flags|string flags_or_error ----@return boolean stale -function DICT:get_stale(key) end - ----@alias ngx.shared.DICT.error string ----| '"no memory"' # not enough available memory to store a value ----| '"exists"' # called add() on an existing value ----| '"not found"' # called a method (replace/ttl/expire) on an absent value ----| '"not a number"' # called incr() on a non-number value ----| '"value not a list"' # called list methods (lpush/lpop/rpush/rpop/llen) on a non-list value - ---- Optional user flags associated with a shm value. ---- ---- The user flags is stored as an unsigned 32-bit integer internally. Defaults to `0`. ---- ----@alias ngx.shared.DICT.flags integer - ---- Expiration time of an shm value (in seconds) ---- ---- The time resolution is `0.001` seconds. ---- If this value is set to `0` (the default), the shm value will never expire. ---- ----@alias ngx.shared.DICT.exptime number - ---- Unconditionally sets a key-value pair into the shm-based dictionary. ---- ---- When it fails to allocate memory for the current key-value item, then `set` will try removing existing items in the storage according to the Least-Recently Used (LRU) algorithm. Note that, LRU takes priority over expiration time here. If up to tens of existing items have been removed and the storage left is still insufficient (either due to the total capacity limit specified by `lua_shared_dict` or memory segmentation), then the `err` return value will be `no memory` and `success` will be `false`. ---- ---- If this method succeeds in storing the current item by forcibly removing other not-yet-expired items in the dictionary via LRU, the `forcible` return value will be `true`. If it stores the item without forcibly removing other valid items, then the return value `forcible` will be `false`. ---- ---- ```lua ---- local cats = ngx.shared.cats ---- local succ, err, forcible = cats:set("Marry", "it is a nice cat!") ---- ``` ---- ---- Please note that while internally the key-value pair is set atomically, the atomicity does not go across the method call boundary. ---- ----@param key string ----@param value ngx.shared.DICT.value ----@param exptime? ngx.shared.DICT.exptime ----@param flags? ngx.shared.DICT.flags ----@return boolean ok # whether the key-value pair is stored or not ----@return ngx.shared.DICT.error? error ----@return boolean forcible # indicates whether other valid items have been removed forcibly when out of storage in the shared memory zone. -function DICT:set(key, value, exptime, flags) end - ---- Similar to the `set` method, but never overrides the (least recently used) unexpired items in the store when running out of storage in the shared memory zone. In this case, it will immediately return `nil` and the string "no memory". ---- ----@param key string ----@param value ngx.shared.DICT.value ----@param exptime? ngx.shared.DICT.exptime ----@param flags? ngx.shared.DICT.flags ----@return boolean ok # whether the key-value pair is stored or not ----@return ngx.shared.DICT.error? error ----@return boolean forcible # indicates whether other valid items have been removed forcibly when out of storage in the shared memory zone. -function DICT:safe_set(key, value, exptime, flags) end - ---- Just like the `set` method, but only stores the key-value pair if the key does *not* exist. ---- ---- If the `key` argument already exists in the dictionary (and not expired for sure), the `success` return value will be `false` and the `err` return value will be `"exists"`. ---- ----@param key string ----@param value ngx.shared.DICT.value ----@param exptime? ngx.shared.DICT.exptime ----@param flags? ngx.shared.DICT.flags ----@return boolean ok # whether the key-value pair is stored or not ----@return ngx.shared.DICT.error? error ----@return boolean forcible # indicates whether other valid items have been removed forcibly when out of storage in the shared memory zone. -function DICT:add(key, value, exptime, flags) end - ---- Similar to the `add` method, but never overrides the (least recently used) unexpired items in the store when running out of storage in the shared memory zone. In this case, it will immediately return `nil` and the string "no memory". ---- ----@param key string ----@param value ngx.shared.DICT.value ----@param exptime? ngx.shared.DICT.exptime ----@param flags? ngx.shared.DICT.flags ----@return boolean ok # whether the key-value pair is stored or not ----@return ngx.shared.DICT.error? error ----@return boolean forcible # indicates whether other valid items have been removed forcibly when out of storage in the shared memory zone. -function DICT:safe_add(key, value, exptime, flags) end - - ---- Just like the `set` method, but only stores the key-value pair if the key *does* exist. ---- ---- If the `key` argument does *not* exist in the dictionary (or expired already), the `success` return value will be `false` and the `err` return value will be `"not found"`. ---- ----@param key string ----@param value ngx.shared.DICT.value ----@param exptime? ngx.shared.DICT.exptime ----@param flags? ngx.shared.DICT.flags ----@return boolean ok # whether the key-value pair is stored or not ----@return ngx.shared.DICT.error? error ----@return boolean forcible # indicates whether other valid items have been removed forcibly when out of storage in the shared memory zone. -function DICT:replace(key, value, exptime, flags) end - ---- Unconditionally removes the key-value pair. ---- ---- It is equivalent to `ngx.shared.DICT:set(key, nil)`. ---- ----@param key string -function DICT:delete(key) end - - ---- Increments the (numerical) value for `key` by the step value `value`. Returns the new resulting number if the operation is successfully completed or `nil` and an error message otherwise. ---- ---- When the key does not exist or has already expired in the shared dictionary, ---- ---- 1. if the `init` argument is not specified or takes the value `nil`, this method will return `nil` and the error string `"not found"`, or ---- 1. if the `init` argument takes a number value, this method will create a new `key` with the value `init + value`. ---- ---- Like the `add` method, it also overrides the (least recently used) unexpired items in the store when running out of storage in the shared memory zone. ---- ---- The optional `init_ttl` argument specifies expiration time (in seconds) of the value when it is initialized via the `init` argument. This argument cannot be provided without providing the `init` argument as well, and has no effect if the value already exists (e.g., if it was previously inserted via `set` or the likes). ---- ---- ```lua ---- local cats = ngx.shared.cats ---- local newval, err = cats:incr("black_cats", 1, 0, 0.1) ---- ---- print(newval) -- 1 ---- ---- ngx.sleep(0.2) ---- ---- local val, err = cats:get("black_cats") ---- print(val) -- nil ---- ``` ---- ---- The `forcible` return value will always be `nil` when the `init` argument is not specified. ---- ---- If this method succeeds in storing the current item by forcibly removing other not-yet-expired items in the dictionary via LRU, the `forcible` return value will be `true`. If it stores the item without forcibly removing other valid items, then the return value `forcible` will be `false`. ---- ---- If the original value is not a valid Lua number in the dictionary, it will return `nil` and `"not a number"`. ---- ---- The `value` argument and `init` argument can be any valid Lua numbers, like negative numbers or floating-point numbers. ---- ---- ----@param key string ----@param value number ----@param init? number ----@param init_ttl? ngx.shared.DICT.exptime ----@return integer? new ----@return ngx.shared.DICT.error? error ----@return boolean forcible -function DICT:incr(key, value, init, init_ttl) end - ---- Valid ngx.shared.DICT value for lists ----@alias ngx.shared.DICT.list_value ----| string ----| number - ---- Inserts the specified (numerical or string) `value` at the head of the list named `key`. ---- ---- If `key` does not exist, it is created as an empty list before performing the push operation. When the `key` already takes a value that is not a list, it will return `nil` and `"value not a list"`. ---- ---- It never overrides the (least recently used) unexpired items in the store when running out of storage in the shared memory zone. In this case, it will immediately return `nil` and the string "no memory". ---- ----@param key string ----@param value ngx.shared.DICT.list_value ----@return number? len # number of elements in the list after the push operation ----@return ngx.shared.DICT.error? error -function DICT:lpush(key, value) end - - ---- Similar to the `lpush` method, but inserts the specified (numerical or string) `value` at the tail of the list named `key`. ---- ----@param key string ----@param value ngx.shared.DICT.list_value ----@return number? len # number of elements in the list after the push operation ----@return ngx.shared.DICT.error? error -function DICT:rpush(key, value) end - - ---- Removes and returns the first element of the list named `key`. ---- ---- If `key` does not exist, it will return `nil`. When the `key` already takes a value that is not a list, it will return `nil` and `"value not a list"`. ---- ----@param key string ----@return ngx.shared.DICT.list_value? item ----@return ngx.shared.DICT.error? error -function DICT:lpop(key) end - - ---- Removes and returns the last element of the list named `key`. ---- ---- If `key` does not exist, it will return `nil`. When the `key` already takes a value that is not a list, it will return `nil` and `"value not a list"`. ---- ----@param key string ----@return ngx.shared.DICT.list_value? item ----@return ngx.shared.DICT.error? error -function DICT:rpop(key) end - ---- Returns the number of elements in the list named `key`. ---- ---- If key does not exist, it is interpreted as an empty list and 0 is returned. When the `key` already takes a value that is not a list, it will return `nil` and `"value not a list"`. ---- ----@param key string ----@return number? len ----@return ngx.shared.DICT.error? error -function DICT:llen(key) end - - ---- Retrieves the remaining TTL (time-to-live in seconds) of a key-value pair. ---- ---- Returns the TTL as a number if the operation is successfully completed or `nil` and an error message otherwise. ---- ---- If the key does not exist (or has already expired), this method will return `nil` and the error string `"not found"`. ---- ---- The TTL is originally determined by the `exptime` argument of the `set`, `add`, `replace` (and the likes) methods. It has a time resolution of `0.001` seconds. A value of `0` means that the item will never expire. ---- ---- Example: ---- ---- ```lua ---- local cats = ngx.shared.cats ---- local succ, err = cats:set("Marry", "a nice cat", 0.5) ---- ---- ngx.sleep(0.2) ---- ---- local ttl, err = cats:ttl("Marry") ---- ngx.say(ttl) -- 0.3 ---- ``` ----@param key string ----@return number? ttl ----@return ngx.shared.DICT.error? error -function DICT:ttl(key) end - - ---- Updates the `exptime` (in second) of a key-value pair. ---- ---- Returns a boolean indicating success if the operation completes or `nil` and an error message otherwise. ---- ---- If the key does not exist, this method will return `nil` and the error string `"not found"`. ---- ---- ```lua ---- local cats = ngx.shared.cats ---- local succ, err = cats:set("Marry", "a nice cat", 0.1) ---- ---- succ, err = cats:expire("Marry", 0.5) ---- ---- ngx.sleep(0.2) ---- ---- local val, err = cats:get("Marry") ---- ngx.say(val) -- "a nice cat" ---- ``` ---- ----@param key string ----@param exptime ngx.shared.DICT.exptime ----@return boolean ok ----@return ngx.shared.DICT.error? error -function DICT:expire(key, exptime) end - - ---- Flushes out all the items in the dictionary. This method does not actuall free up all the memory blocks in the dictionary but just marks all the existing items as expired. ---- -function DICT:flush_all() end - - ---- Flushes out the expired items in the dictionary, up to the maximal number specified by the optional `max_count` argument. When the `max_count` argument is given `0` or not given at all, then it means unlimited. Returns the number of items that have actually been flushed. ---- ---- Unlike the `flush_all` method, this method actually frees up the memory used by the expired items. ---- ----@param max_count? number ----@return number flushed -function DICT:flush_expired(max_count) end - - ---- Fetch a list of the keys from the dictionary, up to `<max_count>`. ---- ---- By default, only the first 1024 keys (if any) are returned. When the `<max_count>` argument is given the value `0`, then all the keys will be returned even there is more than 1024 keys in the dictionary. ---- ---- **CAUTION** Avoid calling this method on dictionaries with a very large number of keys as it may lock the dictionary for significant amount of time and block NGINX worker processes trying to access the dictionary. ---- ----@param max_count? number ----@return string[] keys -function DICT:get_keys(max_count) end - - ---- Retrieves the capacity in bytes for the shm-based dictionary. ---- ---- ```lua ---- local cats = ngx.shared.cats ---- local capacity_bytes = cats:capacity() ---- ``` ---- ----@return number -function DICT:capacity() end - - ---- Retrieves the free page size in bytes for the shm-based dictionary. ---- ---- **Note:** The memory for ngx.shared.DICT is allocated via the NGINX slab allocator which has each slot for ---- data size ranges like \~8, 9\~16, 17\~32, ..., 1025\~2048, 2048\~ bytes. And pages are assigned to a slot if there is no room in already assigned pages for the slot. ---- ---- So even if the return value of the `free_space` method is zero, there may be room in already assigned pages, so ---- you may successfully set a new key value pair to the shared dict without getting `true` for `forcible` or ---- non nil `err` from the `ngx.shared.DICT.set`. ---- ---- On the other hand, if already assigned pages for a slot are full and a new key value pair is added to the ---- slot and there is no free page, you may get `true` for `forcible` or non nil `err` from the ---- `ngx.shared.DICT.set` method. ---- ---- ```lua ---- local cats = ngx.shared.cats ---- local free_page_bytes = cats:free_space() ---- ``` ---- ----@return number -function DICT:free_space() end - ---- Read and write NGINX variable values. ---- ---- Usage: ---- ----```lua ---- value = ngx.var.some_nginx_variable_name ---- ngx.var.some_nginx_variable_name = value ----``` ---- ---- Note that only already defined NGINX variables can be written to. ---- For example: ---- ---- ```nginx ---- location /foo { ---- set $my_var ''; # this line is required to create $my_var at config time ---- content_by_lua_block { ---- ngx.var.my_var = 123 ---- ... ---- } ---- } ---- ``` ---- ---- That is, NGINX variables cannot be created on-the-fly. ---- ---- Some special NGINX variables like `$args` and `$limit_rate` can be assigned a value, ---- many others are not, like `$query_string`, `$arg_PARAMETER`, and `$http_NAME`. ---- ---- NGINX regex group capturing variables `$1`, `$2`, `$3`, and etc, can be read by this ---- interface as well, by writing `ngx.var[1]`, `ngx.var[2]`, `ngx.var[3]`, and etc. ---- ---- Setting `ngx.var.Foo` to a `nil` value will unset the `$Foo` NGINX variable. ---- ---- ```lua ---- ngx.var.args = nil ---- ``` ---- ---- **CAUTION** When reading from an NGINX variable, NGINX will allocate memory in the per-request memory pool which is freed only at request termination. So when you need to read from an NGINX variable repeatedly in your Lua code, cache the NGINX variable value to your own Lua variable, for example, ---- ---- ```lua ---- local val = ngx.var.some_var ---- --- use the val repeatedly later ---- ``` ---- ---- to prevent (temporary) memory leaking within the current request's lifetime. Another way of caching the result is to use the `ngx.ctx` table. ---- ---- Undefined NGINX variables are evaluated to `nil` while uninitialized (but defined) NGINX variables are evaluated to an empty Lua string. ---- ---- This API requires a relatively expensive metamethod call and it is recommended to avoid using it on hot code paths. ---- ----@type table -ngx.var = {} - ---- Embedded Variables ---- see https://nginx.org/en/docs/http/ngx_http_core_module.html#variables - ---- client address in a binary form, value’s length is always 4 bytes for IPv4 addresses or 16 bytes for IPv6 addresses ----@type string -ngx.var.binary_remote_addr = nil - ---- number of bytes sent to a client, not counting the response header; this variable is compatible with the “%B” parameter of the mod_log_config Apache module ----@type number -ngx.var.body_bytes_sent = nil - ---- number of bytes sent to a client (1.3.8, 1.2.5) ----@type number -ngx.var.bytes_sent = nil - ---- connection serial number (1.3.8, 1.2.5) ----@type string -ngx.var.connection = nil - ---- current number of requests made through a connection (1.3.8, 1.2.5) ----@type string -ngx.var.connection_requests = nil - ---- connection time in seconds with a milliseconds resolution (1.19.10) ----@type string -ngx.var.connection_time = nil - ---- “Content-Length” request header field ----@type string -ngx.var.content_length = nil - ---- “Content-Type” request header field ----@type string -ngx.var.content_type = nil - ---- root or alias directive’s value for the current request ----@type string -ngx.var.document_root = nil - ---- same as ngx.var.uri ----@type string -ngx.var.document_uri = nil - ---- in this order of precedence: host name from the request line, or host name from the “Host” request header field, or the server name matching a request ----@type string -ngx.var.host = nil - ---- host name ----@type string -ngx.var.hostname = nil - ---- “on” if connection operates in SSL mode, or an empty string otherwise ----@type string '"on"'|'""' -ngx.var.https = nil - ---- “?” if a request line has arguments, or an empty string otherwise ----@type string -ngx.var.is_args = nil - ---- setting this variable enables response rate limiting; see limit_rate ----@type string -ngx.var.limit_rate = nil - ---- current time in seconds with the milliseconds resolution (1.3.9, 1.2.6) ----@type string -ngx.var.msec = nil - ---- nginx version ----@type string -ngx.var.nginx_version = nil - ---- PID of the worker process ----@type string -ngx.var.pid = nil - ---- “p” if request was pipelined, “.” otherwise (1.3.12, 1.2.7) ----@type string -ngx.var.pipe = nil - ---- client address from the PROXY protocol header (1.5.12) ---- The PROXY protocol must be previously enabled by setting the proxy_protocol parameter in the listen directive. ----@type string -ngx.var.proxy_protocol_addr = nil - ---- client port from the PROXY protocol header (1.11.0) ---- ---- The PROXY protocol must be previously enabled by setting the proxy_protocol parameter in the listen directive. ----@type string -ngx.var.proxy_protocol_port = nil - ---- server address from the PROXY protocol header (1.17.6) ---- ---- The PROXY protocol must be previously enabled by setting the proxy_protocol parameter in the listen directive. ----@type string -ngx.var.proxy_protocol_server_addr = nil - ---- server port from the PROXY protocol header (1.17.6) ---- ---- The PROXY protocol must be previously enabled by setting the proxy_protocol parameter in the listen directive. ----@type string -ngx.var.proxy_protocol_server_port = nil - ---- same as ngx.var.args ----@type string -ngx.var.query_string = nil - ---- an absolute pathname corresponding to the root or alias directive’s value for the current request, with all symbolic links resolved to real paths ----@type string -ngx.var.realpath_root = nil - ---- client address ----@type string -ngx.var.remote_addr = nil - ---- client port ----@type string -ngx.var.remote_port = nil - ---- user name supplied with the Basic authentication ----@type string -ngx.var.remote_user = nil - ---- full original request line ----@type string -ngx.var.request = nil - ---- request body ---- ---- The variable’s value is made available in locations processed by the proxy_pass, fastcgi_pass, uwsgi_pass, and scgi_pass directives when the request body was read to a memory buffer. ----@type string -ngx.var.request_body = nil - ---- name of a temporary file with the request body ---- ---- At the end of processing, the file needs to be removed. ---- To always write the request body to a file, client_body_in_file_only needs to be enabled. ---- When the name of a temporary file is passed in a proxied request or in a request to a FastCGI/uwsgi/SCGI server, passing the request body should be disabled by the proxy_pass_request_body off, fastcgi_pass_request_body off, uwsgi_pass_request_body off, or scgi_pass_request_body off directives, respectively. ----@type string -ngx.var.request_body_file = nil - ---- “OK” if a request has completed, or an empty string otherwise ----@type string -ngx.var.request_completion = nil - ---- file path for the current request, based on the root or alias directives, and the request URI ----@type string -ngx.var.request_filename = nil - ---- unique request identifier generated from 16 random bytes, in hexadecimal (1.11.0) ----@type string -ngx.var.request_id = nil - ---- request length (including request line, header, and request body) (1.3.12, 1.2.7) ----@type string -ngx.var.request_length = nil - ---- request method, usually “GET” or “POST” ----@type string -ngx.var.request_method = nil - ---- request processing time in seconds with a milliseconds resolution (1.3.9, 1.2.6); time elapsed since the first bytes were read from the client ----@type string -ngx.var.request_time = nil - ---- full original request URI (with arguments) ----@type string -ngx.var.request_uri = nil - ---- request scheme, “http” or “https” ----@type string -ngx.var.scheme = nil - ---- an address of the server which accepted a request ---- ---- Computing a value of this variable usually requires one system call. To avoid a system call, the listen directives must specify addresses and use the bind parameter. ----@type string -ngx.var.server_addr = nil - ---- name of the server which accepted a request ----@type string -ngx.var.server_name = nil - ---- port of the server which accepted a request ----@type string -ngx.var.server_port = nil - ---- request protocol, usually “HTTP/1.0”, “HTTP/1.1”, or “HTTP/2.0” ----@type string -ngx.var.server_protocol = nil - ---- response status (1.3.2, 1.2.2) ----@type string -ngx.var.status = nil - ---- local time in the ISO 8601 standard format (1.3.12, 1.2.7) ----@type string -ngx.var.time_iso8601 = nil - ---- local time in the Common Log Format (1.3.12, 1.2.7) ----@type string -ngx.var.time_local = nil - ---- current URI in request, normalized ---- The value of $uri may change during request processing, e.g. when doing internal redirects, or when using index files. ----@type string -ngx.var.uri = nil - ---- Updating query arguments via the NGINX variable `$args` (or `ngx.var.args` in Lua) at runtime is also supported: ---- ---- ```lua ---- ngx.var.args = "a=3&b=42" ---- local args, err = ngx.req.get_uri_args() ---- ``` ---- ---- Here the `args` table will always look like ---- ---- ```lua ---- {a = 3, b = 42} ---- ``` ---- ---- regardless of the actual request query string. ----@type string -ngx.var.args = nil - ---- embedded upstream variables ---- https://nginx.org/en/docs/http/ngx_http_upstream_module.html#variables - ---- IP address and port, or the path to the UNIX-domain socket of the upstream server. ---- If several servers were contacted during request processing, their addresses are separated by commas, e.g. “192.168.1.1:80, 192.168.1.2:80, unix:/tmp/sock”. ---- If an internal redirect from one server group to another happens, initiated by “X-Accel-Redirect” or error_page, then the server addresses from different groups are separated by colons, e.g. “192.168.1.1:80, 192.168.1.2:80, unix:/tmp/sock : 192.168.10.1:80, 192.168.10.2:80”. ---- If a server cannot be selected, the variable keeps the name of the server group. ----@type string -ngx.var.upstream_addr = nil - ---- number of bytes received from an upstream server (1.11.4). Values from several connections are separated by commas and colons like addresses in the $upstream_addr variable. ----@type string -ngx.var.upstream_bytes_received = nil - ---- number of bytes sent to an upstream server (1.15.8). Values from several connections are separated by commas and colons like addresses in the $upstream_addr variable. ----@type string -ngx.var.upstream_bytes_sent = nil - ---- status of accessing a response cache (0.8.3). The status can be either “MISS”, “BYPASS”, “EXPIRED”, “STALE”, “UPDATING”, “REVALIDATED”, or “HIT”. ----@type string -ngx.var.upstream_cache_status = nil - ---- time spent on establishing a connection with the upstream server (1.9.1) --- ---- the time is kept in seconds with millisecond resolution. ---- In case of SSL, includes time spent on handshake. ---- Times of several connections are separated by commas and colons like addresses in the $upstream_addr variable. ----@type string -ngx.var.upstream_connect_time = nil - ---- time spent on receiving the response header from the upstream server (1.7.10) ---- the time is kept in seconds with millisecond resolution. ---- Times of several responses are separated by commas and colons like addresses in the $upstream_addr variable. ----@type string -ngx.var.upstream_header_time = nil - ---- the time the request spent in the upstream queue (1.13.9). ---- the time is kept in seconds with millisecond resolution. ---- Times of several responses are separated by commas and colons like addresses in the $upstream_addr variable. ----@type string -ngx.var.upstream_queue_time = nil - ---- the length of the response obtained from the upstream server (0.7.27). ---- the length is kept in bytes. ---- Lengths of several responses are separated by commas and colons like addresses in the $upstream_addr variable. ----@type string -ngx.var.upstream_response_length = nil - ---- time spent on receiving the response from the upstream server ---- ---- the time is kept in seconds with millisecond resolution. ---- Times of several responses are separated by commas and colons like addresses in the $upstream_addr variable. ----@type string -ngx.var.upstream_response_time = nil - ---- status code of the response obtained from the upstream server. ---- Status codes of several responses are separated by commas and colons like addresses in the $upstream_addr variable. ---- If a server cannot be selected, the variable keeps the 502 (Bad Gateway) status code. ----@type string -ngx.var.upstream_status = nil - - -ngx.req = {} - ---- Returns a boolean indicating whether the current request is an "internal request", i.e., ---- a request initiated from inside the current NGINX server instead of from the client side. ---- ---- Subrequests are all internal requests and so are requests after internal redirects. ---- ----@return boolean -function ngx.req.is_internal() end - ---- Returns the HTTP version number for the current request as a Lua number. ---- ---- Current possible values are 2.0, 1.0, 1.1, and 0.9. Returns `nil` for unrecognized values. ---- ----@return '2.0'|'1.0'|'1.1'|'0.9'|'nil' -function ngx.req.http_version() end - ---- Set the current request's request body using the in-memory data specified by the `data` argument. ---- ---- If the request body has not been read yet, call `ngx.req.read_body` first (or turn on `lua_need_request_body` to force this module to read the request body. This is not recommended however). Additionally, the request body must not have been previously discarded by `ngx.req.discard_body`. ---- ---- Whether the previous request body has been read into memory or buffered into a disk file, it will be freed or the disk file will be cleaned up immediately, respectively. ---- ----@param data any -function ngx.req.set_body_data(data) end - ---- Returns a Lua table holding all the current request POST query arguments (of the MIME type `application/x-www-form-urlencoded`). Call `ngx.req.read_body` to read the request body first or turn on the `lua_need_request_body` directive to avoid errors. ---- ---- ```nginx ---- location = /test { ---- content_by_lua_block { ---- ngx.req.read_body() ---- local args, err = ngx.req.get_post_args() ---- ---- if err == "truncated" then ---- -- one can choose to ignore or reject the current request here ---- end ---- ---- if not args then ---- ngx.say("failed to get post args: ", err) ---- return ---- end ---- for key, val in pairs(args) do ---- if type(val) == "table" then ---- ngx.say(key, ": ", table.concat(val, ", ")) ---- else ---- ngx.say(key, ": ", val) ---- end ---- end ---- } ---- } ---- ``` ---- ---- Then ---- ---- ```bash ---- # Post request with the body 'foo=bar&bar=baz&bar=blah' ---- $ curl --data 'foo=bar&bar=baz&bar=blah' localhost/test ---- ``` ---- ---- will yield the response body like ---- ---- ```bash ---- foo: bar ---- bar: baz, blah ---- ``` ---- ---- Multiple occurrences of an argument key will result in a table value holding all of the values for that key in order. ---- ---- Keys and values will be unescaped according to URI escaping rules. ---- ---- With the settings above, ---- ---- ```bash ---- # POST request with body 'a%20b=1%61+2' ---- $ curl -d 'a%20b=1%61+2' localhost/test ---- ``` ---- ---- will yield: ---- ---- ```bash ---- a b: 1a 2 ---- ``` ---- ---- Arguments without the `=<value>` parts are treated as boolean arguments. `POST /test` with the request body `foo&bar` will yield: ---- ---- ```bash ---- foo: true ---- bar: true ---- ``` ---- ---- That is, they will take Lua boolean values `true`. However, they are different from arguments taking empty string values. `POST /test` with request body `foo=&bar=` will return something like ---- ---- ```bash ---- foo: ---- bar: ---- ``` ---- ---- Empty key arguments are discarded. `POST /test` with body `=hello&=world` will yield empty outputs for instance. ---- ---- Note that a maximum of 100 request arguments are parsed by default (including those with the same name) and that additional request arguments are silently discarded to guard against potential denial of service attacks. When the limit is exceeded, it will return a second value which is the string `"truncated"`. ---- ---- However, the optional `max_args` function argument can be used to override this limit: ---- ---- ```lua ---- local args, err = ngx.req.get_post_args(10) ---- if err == "truncated" then ---- -- one can choose to ignore or reject the current request here ---- end ---- ``` ---- ---- This argument can be set to zero to remove the limit and to process all request arguments received: ---- ---- ```lua ---- local args, err = ngx.req.get_post_args(0) ---- ``` ---- ---- Removing the `max_args` cap is strongly discouraged. ---- ----@param max_args? number ----@return table args ----@return string|'"truncated"' error -function ngx.req.get_post_args(max_args) end - ---- Returns a Lua table holding all the current request URL query arguments. An optional `tab` argument can be used to reuse the table returned by this method. ---- ---- ```nginx ---- location = /test { ---- content_by_lua_block { ---- local args, err = ngx.req.get_uri_args() ---- ---- if err == "truncated" then ---- -- one can choose to ignore or reject the current request here ---- end ---- ---- for key, val in pairs(args) do ---- if type(val) == "table" then ---- ngx.say(key, ": ", table.concat(val, ", ")) ---- else ---- ngx.say(key, ": ", val) ---- end ---- end ---- } ---- } ---- ``` ---- ---- Then `GET /test?foo=bar&bar=baz&bar=blah` will yield the response body ---- ---- ```bash ---- foo: bar ---- bar: baz, blah ---- ``` ---- ---- Multiple occurrences of an argument key will result in a table value holding all the values for that key in order. ---- ---- Keys and values are unescaped according to URI escaping rules. In the settings above, `GET /test?a%20b=1%61+2` will yield: ---- ---- ```bash ---- a b: 1a 2 ---- ``` ---- ---- Arguments without the `=<value>` parts are treated as boolean arguments. `GET /test?foo&bar` will yield: ---- ---- ```bash ---- foo: true ---- bar: true ---- ``` ---- ---- That is, they will take Lua boolean values `true`. However, they are different from arguments taking empty string values. `GET /test?foo=&bar=` will give something like ---- ---- ```bash ---- foo: ---- bar: ---- ``` ---- ---- Empty key arguments are discarded. `GET /test?=hello&=world` will yield an empty output for instance. ---- ---- Updating query arguments via the NGINX variable `$args` (or `ngx.var.args` in Lua) at runtime is also supported: ---- ---- ```lua ---- ngx.var.args = "a=3&b=42" ---- local args, err = ngx.req.get_uri_args() ---- ``` ---- ---- Here the `args` table will always look like ---- ---- ```lua ---- {a = 3, b = 42} ---- ``` ---- ---- regardless of the actual request query string. ---- ---- Note that a maximum of 100 request arguments are parsed by default (including those with the same name) and that additional request arguments are silently discarded to guard against potential denial of service attacks. When the limit is exceeded, it will return a second value which is the string `"truncated"`. ---- ---- However, the optional `max_args` function argument can be used to override this limit: ---- ---- ```lua ---- local args, err = ngx.req.get_uri_args(10) ---- if err == "truncated" then ---- -- one can choose to ignore or reject the current request here ---- end ---- ``` ---- ---- This argument can be set to zero to remove the limit and to process all request arguments received: ---- ---- ```lua ---- local args, err = ngx.req.get_uri_args(0) ---- ``` ---- ---- Removing the `max_args` cap is strongly discouraged. ---- ----@param max_args? number ----@param tab? table ----@return table args ----@return string|'"truncated"' error -function ngx.req.get_uri_args(max_args, tab) end - ---- Rewrite the current request's (parsed) URI by the `uri` argument. The `uri` argument must be a Lua string and cannot be of zero length, or a Lua exception will be thrown. ---- ---- The optional boolean `jump` argument can trigger location rematch (or location jump) as `ngx_http_rewrite_module`'s `rewrite` directive, that is, when `jump` is `true` (default to `false`), this function will never return and it will tell NGINX to try re-searching locations with the new URI value at the later `post-rewrite` phase and jumping to the new location. ---- ---- Location jump will not be triggered otherwise, and only the current request's URI will be modified, which is also the default behavior. This function will return but with no returned values when the `jump` argument is `false` or absent altogether. ---- ---- For example, the following NGINX config snippet ---- ---- ```nginx ---- rewrite ^ /foo last; ---- ``` ---- ---- can be coded in Lua like this: ---- ---- ```lua ---- ngx.req.set_uri("/foo", true) ---- ``` ---- ---- Similarly, NGINX config ---- ---- ```nginx ---- rewrite ^ /foo break; ---- ``` ---- ---- can be coded in Lua as ---- ---- ```lua ---- ngx.req.set_uri("/foo", false) ---- ``` ---- ---- or equivalently, ---- ---- ```lua ---- ngx.req.set_uri("/foo") ---- ``` ---- ---- The `jump` argument can only be set to `true` in `rewrite_by_lua*`. Use of jump in other contexts is prohibited and will throw out a Lua exception. ---- ---- A more sophisticated example involving regex substitutions is as follows ---- ---- ```nginx ---- location /test { ---- rewrite_by_lua_block { ---- local uri = ngx.re.sub(ngx.var.uri, "^/test/(.*)", "/$1", "o") ---- ngx.req.set_uri(uri) ---- } ---- proxy_pass http://my_backend; ---- } ---- ``` ---- ---- which is functionally equivalent to ---- ---- ```nginx ---- location /test { ---- rewrite ^/test/(.*) /$1 break; ---- proxy_pass http://my_backend; ---- } ---- ``` ---- ---- Note: this function throws a Lua error if the `uri` argument ---- contains unsafe characters (control characters). ---- ---- Note that it is not possible to use this interface to rewrite URI arguments and that `ngx.req.set_uri_args` should be used for this instead. For instance, NGINX config ---- ---- ```nginx ---- rewrite ^ /foo?a=3? last; ---- ``` ---- ---- can be coded as ---- ---- ```nginx ---- ngx.req.set_uri_args("a=3") ---- ngx.req.set_uri("/foo", true) ---- ``` ---- ---- or ---- ---- ```nginx ---- ngx.req.set_uri_args({a = 3}) ---- ngx.req.set_uri("/foo", true) ---- ``` ---- ---- An optional boolean `binary` argument allows arbitrary binary URI data. By default, this `binary` argument is false and this function will throw out a Lua error such as the one below when the `uri` argument contains any control characters (ASCII Code 0 ~ 0x08, 0x0A ~ 0x1F and 0x7F). ---- ---- [error] 23430#23430: *1 lua entry thread aborted: runtime error: ---- content_by_lua(nginx.conf:44):3: ngx.req.set_uri unsafe byte "0x00" ---- in "\x00foo" (maybe you want to set the 'binary' argument?) ---- ----@param uri string ----@param jump? boolean ----@param binary? boolean -function ngx.req.set_uri(uri, jump, binary) end - ---- Append new data chunk specified by the `data_chunk` argument onto the existing request body created by the `ngx.req.init_body` call. ---- ---- When the data can no longer be hold in the memory buffer for the request body, then the data will be flushed onto a temporary file just like the standard request body reader in the NGINX core. ---- ---- It is important to always call the `ngx.req.finish_body` after all the data has been appended onto the current request body. ---- ---- This function can be used with `ngx.req.init_body`, `ngx.req.finish_body`, and `ngx.req.socket` to implement efficient input filters in pure Lua (in the context of `rewrite_by_lua*` or `access_by_lua*`), which can be used with other NGINX content handler or upstream modules like `ngx_http_proxy_module` and `ngx_http_fastcgi_module`. ---- ----@param data_chunk any -function ngx.req.append_body(data_chunk) end - ---- Overrides the current request's request method with the `method_id` argument. Currently only numerical `method constants` are supported, like `ngx.HTTP_POST` and `ngx.HTTP_GET`. ---- ---- If the current request is an NGINX subrequest, then the subrequest's method will be overridden. ---- ----@param method_id ngx.http.method -function ngx.req.set_method(method_id) end - ---- Retrieves the current request's request method name. Strings like `"GET"` and `"POST"` are returned instead of numerical `method constants`. ---- ---- If the current request is an NGINX subrequest, then the subrequest's method name will be returned. ---- ----@return string -function ngx.req.get_method() end - ---- Returns a read-only cosocket object that wraps the downstream connection. Only `receive` and `receiveuntil` methods are supported on this object. ---- ---- In case of error, `nil` will be returned as well as a string describing the error. ---- ---- The socket object returned by this method is usually used to read the current request's body in a streaming fashion. Do not turn on the `lua_need_request_body` directive, and do not mix this call with `ngx.req.read_body` and `ngx.req.discard_body`. ---- ---- If any request body data has been pre-read into the NGINX core request header buffer, the resulting cosocket object will take care of this to avoid potential data loss resulting from such pre-reading. ---- Chunked request bodies are not yet supported in this API. ---- ---- An optional boolean `raw` argument can be provided. When this argument is `true`, this function returns a full-duplex cosocket object wrapping around the raw downstream connection socket, upon which you can call the `receive`, `receiveuntil`, and `send` methods. ---- ---- When the `raw` argument is `true`, it is required that no pending data from any previous `ngx.say`, `ngx.print`, or `ngx.send_headers` calls exists. So if you have these downstream output calls previously, you should call `ngx.flush(true)` before calling `ngx.req.socket(true)` to ensure that there is no pending output data. If the request body has not been read yet, then this "raw socket" can also be used to read the request body. ---- ---- You can use the "raw request socket" returned by `ngx.req.socket(true)` to implement fancy protocols like `WebSocket`, or just emit your own raw HTTP response header or body data. You can refer to the `lua-resty-websocket library` for a real world example. ---- ----@param raw? boolean ----@return tcpsock? socket ----@return string? error -function ngx.req.socket(raw) end - ---- Completes the construction process of the new request body created by the `ngx.req.init_body` and `ngx.req.append_body` calls. ---- ---- This function can be used with `ngx.req.init_body`, `ngx.req.append_body`, and `ngx.req.socket` to implement efficient input filters in pure Lua (in the context of `rewrite_by_lua*` or `access_by_lua*`), which can be used with other NGINX content handler or upstream modules like `ngx_http_proxy_module` and `ngx_http_fastcgi_module`. ---- -function ngx.req.finish_body() end - ---- Returns the original raw HTTP protocol header received by the NGINX server. ---- ---- By default, the request line and trailing `CR LF` terminator will also be included. For example, ---- ---- ```lua ---- ngx.print(ngx.req.raw_header()) ---- ``` ---- ---- gives something like this: ---- ---- GET /t HTTP/1.1 ---- Host: localhost ---- Connection: close ---- Foo: bar ---- ---- You can specify the optional ---- `no_request_line` argument as a `true` value to exclude the request line from the result. For example, ---- ---- ```lua ---- ngx.print(ngx.req.raw_header(true)) ---- ``` ---- ---- outputs something like this: ---- ---- Host: localhost ---- Connection: close ---- Foo: bar ---- ---- This method does not work in HTTP/2 requests yet. ---- ----@param no_request_line? boolean ----@return string -function ngx.req.raw_header(no_request_line) end - ---- Returns a floating-point number representing the timestamp (including milliseconds as the decimal part) when the current request was created. ---- ---- The following example emulates the `$request_time` variable value (provided by `ngx_http_log_module`) in pure Lua: ---- ---- ```lua ---- local request_time = ngx.now() - ngx.req.start_time() ---- ``` ---- ----@return number -function ngx.req.start_time() end - ---- Creates a new blank request body for the current request and inializes the buffer for later request body data writing via the `ngx.req.append_body` and `ngx.req.finish_body` APIs. ---- ---- If the `buffer_size` argument is specified, then its value will be used for the size of the memory buffer for body writing with `ngx.req.append_body`. If the argument is omitted, then the value specified by the standard `client_body_buffer_size` directive will be used instead. ---- ---- When the data can no longer be hold in the memory buffer for the request body, then the data will be flushed onto a temporary file just like the standard request body reader in the NGINX core. ---- ---- It is important to always call the `ngx.req.finish_body` after all the data has been appended onto the current request body. Also, when this function is used together with `ngx.req.socket`, it is required to call `ngx.req.socket` *before* this function, or you will get the "request body already exists" error message. ---- ---- The usage of this function is often like this: ---- ---- ```lua ---- ngx.req.init_body(128 * 1024) -- buffer is 128KB ---- for chunk in next_data_chunk() do ---- ngx.req.append_body(chunk) -- each chunk can be 4KB ---- end ---- ngx.req.finish_body() ---- ``` ---- ---- This function can be used with `ngx.req.append_body`, `ngx.req.finish_body`, and `ngx.req.socket` to implement efficient input filters in pure Lua (in the context of `rewrite_by_lua*` or `access_by_lua*`), which can be used with other NGINX content handler or upstream modules like `ngx_http_proxy_module` and `ngx_http_fastcgi_module`. ---- ----@param buffer_size? number -function ngx.req.init_body(buffer_size) end - ---- Set the current request's request body using the in-file data specified by the `file_name` argument. ---- ---- If the request body has not been read yet, call `ngx.req.read_body` first (or turn on `lua_need_request_body` to force this module to read the request body. This is not recommended however). Additionally, the request body must not have been previously discarded by `ngx.req.discard_body`. ---- ---- If the optional `auto_clean` argument is given a `true` value, then this file will be removed at request completion or the next time this function or `ngx.req.set_body_data` are called in the same request. The `auto_clean` is default to `false`. ---- ---- Please ensure that the file specified by the `file_name` argument exists and is readable by an NGINX worker process by setting its permission properly to avoid Lua exception errors. ---- ---- Whether the previous request body has been read into memory or buffered into a disk file, it will be freed or the disk file will be cleaned up immediately, respectively. ---- ----@param file_name string ----@param auto_clean? boolean -function ngx.req.set_body_file(file_name, auto_clean) end - ---- Clears the current request's request header named `header_name`. None of the current request's existing subrequests will be affected but subsequently initiated subrequests will inherit the change by default. ---- ----@param header_name string -function ngx.req.clear_header(header_name) end - ---- Returns a Lua table holding all the current request headers. ---- ---- ```lua ---- local h, err = ngx.req.get_headers() ---- ---- if err == "truncated" then ---- -- one can choose to ignore or reject the current request here ---- end ---- ---- for k, v in pairs(h) do ---- ... ---- end ---- ``` ---- ---- To read an individual header: ---- ---- ```lua ---- ngx.say("Host: ", ngx.req.get_headers()["Host"]) ---- ``` ---- ---- Note that the `ngx.var.HEADER` API call, which uses core `$http_HEADER` variables, may be more preferable for reading individual request headers. ---- ---- For multiple instances of request headers such as: ---- ---- ```bash ---- Foo: foo ---- Foo: bar ---- Foo: baz ---- ``` ---- ---- the value of `ngx.req.get_headers()["Foo"]` will be a Lua (array) table such as: ---- ---- ```lua ---- {"foo", "bar", "baz"} ---- ``` ---- ---- Note that a maximum of 100 request headers are parsed by default (including those with the same name) and that additional request headers are silently discarded to guard against potential denial of service attacks. When the limit is exceeded, it will return a second value which is the string `"truncated"`. ---- ---- However, the optional `max_headers` function argument can be used to override this limit: ---- ---- ```lua ---- local headers, err = ngx.req.get_headers(10) ---- ---- if err == "truncated" then ---- -- one can choose to ignore or reject the current request here ---- end ---- ``` ---- ---- This argument can be set to zero to remove the limit and to process all request headers received: ---- ---- ```lua ---- local headers, err = ngx.req.get_headers(0) ---- ``` ---- ---- Removing the `max_headers` cap is strongly discouraged. ---- ---- All the header names in the Lua table returned are converted to the pure lower-case form by default, unless the `raw` argument is set to `true` (default to `false`). ---- ---- Also, by default, an `__index` metamethod is added to the resulting Lua table and will normalize the keys to a pure lowercase form with all underscores converted to dashes in case of a lookup miss. For example, if a request header `My-Foo-Header` is present, then the following invocations will all pick up the value of this header correctly: ---- ---- ```lua ---- ngx.say(headers.my_foo_header) ---- ngx.say(headers["My-Foo-Header"]) ---- ngx.say(headers["my-foo-header"]) ---- ``` ---- ---- The `__index` metamethod will not be added when the `raw` argument is set to `true`. ---- ----@param max_headers? number ----@param raw? boolean ----@return table<string, string|string[]> headers ----@return string|'"truncated"' error -function ngx.req.get_headers(max_headers, raw) end - ---- Explicitly discard the request body, i.e., read the data on the connection and throw it away immediately (without using the request body by any means). ---- ---- This function is an asynchronous call and returns immediately. ---- ---- If the request body has already been read, this function does nothing and returns immediately. ---- -function ngx.req.discard_body() end - ---- Set the current request's request header named `header_name` to value `header_value`, overriding any existing ones. ---- ---- By default, all the subrequests subsequently initiated by `ngx.location.capture` and `ngx.location.capture_multi` will inherit the new header. ---- ---- Here is an example of setting the `Content-Type` header: ---- ---- ```lua ---- ngx.req.set_header("Content-Type", "text/css") ---- ``` ---- ---- The `header_value` can take an array list of values, ---- for example, ---- ---- ```lua ---- ngx.req.set_header("Foo", {"a", "abc"}) ---- ``` ---- ---- will produce two new request headers: ---- ---- ```bash ---- Foo: a ---- Foo: abc ---- ``` ---- ---- and old `Foo` headers will be overridden if there is any. ---- ---- When the `header_value` argument is `nil`, the request header will be removed. So ---- ---- ```lua ---- ngx.req.set_header("X-Foo", nil) ---- ``` ---- ---- is equivalent to ---- ---- ```lua ---- ngx.req.clear_header("X-Foo") ---- ``` ---- ----@param header_name string ----@param header_value string|string[]|nil -function ngx.req.set_header(header_name, header_value) end - ---- Retrieves in-memory request body data. It returns a Lua string rather than a Lua table holding all the parsed query arguments. Use the `ngx.req.get_post_args` function instead if a Lua table is required. ---- ---- This function returns `nil` if ---- ---- 1. the request body has not been read, ---- 1. the request body has been read into disk temporary files, ---- 1. or the request body has zero size. ---- ---- If the request body has not been read yet, call `ngx.req.read_body` first (or turn on `lua_need_request_body` to force this module to read the request body. This is not recommended however). ---- ---- If the request body has been read into disk files, try calling the `ngx.req.get_body_file` function instead. ---- ---- To force in-memory request bodies, try setting `client_body_buffer_size` to the same size value in `client_max_body_size`. ---- ---- Note that calling this function instead of using `ngx.var.request_body` or `ngx.var.echo_request_body` is more efficient because it can save one dynamic memory allocation and one data copy. ---- ----@return string? -function ngx.req.get_body_data() end - ---- Reads the client request body synchronously without blocking the NGINX event loop. ---- ---- ```lua ---- ngx.req.read_body() ---- local args = ngx.req.get_post_args() ---- ``` ---- ---- If the request body is already read previously by turning on `lua_need_request_body` or by using other modules, then this function does not run and returns immediately. ---- ---- If the request body has already been explicitly discarded, either by the `ngx.req.discard_body` function or other modules, this function does not run and returns immediately. ---- ---- In case of errors, such as connection errors while reading the data, this method will throw out a Lua exception *or* terminate the current request with a 500 status code immediately. ---- ---- The request body data read using this function can be retrieved later via `ngx.req.get_body_data` or, alternatively, the temporary file name for the body data cached to disk using `ngx.req.get_body_file`. This depends on ---- ---- 1. whether the current request body is already larger than the `client_body_buffer_size`, ---- 1. and whether `client_body_in_file_only` has been switched on. ---- ---- In cases where current request may have a request body and the request body data is not required, The `ngx.req.discard_body` function must be used to explicitly discard the request body to avoid breaking things under HTTP 1.1 keepalive or HTTP 1.1 pipelining. ---- -function ngx.req.read_body() end - ---- Retrieves the file name for the in-file request body data. Returns `nil` if the request body has not been read or has been read into memory. ---- ---- The returned file is read only and is usually cleaned up by NGINX's memory pool. It should not be manually modified, renamed, or removed in Lua code. ---- ---- If the request body has not been read yet, call `ngx.req.read_body` first (or turn on `lua_need_request_body` to force this module to read the request body. This is not recommended however). ---- ---- If the request body has been read into memory, try calling the `ngx.req.get_body_data` function instead. ---- ---- To force in-file request bodies, try turning on `client_body_in_file_only`. ---- ----@return string? filename -function ngx.req.get_body_file() end - ---- Rewrite the current request's URI query arguments by the `args` argument. The `args` argument can be either a Lua string, as in ---- ---- ```lua ---- ngx.req.set_uri_args("a=3&b=hello%20world") ---- ``` ---- ---- or a Lua table holding the query arguments' key-value pairs, as in ---- ---- ```lua ---- ngx.req.set_uri_args({ a = 3, b = "hello world" }) ---- ``` ---- ---- where in the latter case, this method will escape argument keys and values according to the URI escaping rule. ---- ---- Multi-value arguments are also supported: ---- ---- ```lua ---- ngx.req.set_uri_args({ a = 3, b = {5, 6} }) ---- ``` ---- ---- which will result in a query string like `a=3&b=5&b=6`. ---- ----@param args string|table -function ngx.req.set_uri_args(args) end - ---- Encode the Lua table to a query args string according to the URI encoded rules. ---- ---- For example, ---- ---- ```lua ---- ngx.encode_args({foo = 3, ["b r"] = "hello world"}) ---- ``` ---- ---- yields ---- ---- foo=3&b%20r=hello%20world ---- ---- The table keys must be Lua strings. ---- ---- Multi-value query args are also supported. Just use a Lua table for the argument's value, for example: ---- ---- ```lua ---- ngx.encode_args({baz = {32, "hello"}}) ---- ``` ---- ---- gives ---- ---- baz=32&baz=hello ---- ---- If the value table is empty and the effect is equivalent to the `nil` value. ---- ---- Boolean argument values are also supported, for instance, ---- ---- ```lua ---- ngx.encode_args({a = true, b = 1}) ---- ``` ---- ---- yields ---- ---- a&b=1 ---- ---- If the argument value is `false`, then the effect is equivalent to the `nil` value. ---- ----@param args table ----@return string encoded -function ngx.encode_args(args) end - ---- Decodes a URI encoded query-string into a Lua table. This is the inverse function of `ngx.encode_args`. ---- ---- The optional `max_args` argument can be used to specify the maximum number of arguments parsed from the `str` argument. By default, a maximum of 100 request arguments are parsed (including those with the same name) and that additional URI arguments are silently discarded to guard against potential denial of service attacks. When the limit is exceeded, it will return a second value which is the string `"truncated"`. ---- ---- This argument can be set to zero to remove the limit and to process all request arguments received: ---- ---- ```lua ---- local args = ngx.decode_args(str, 0) ---- ``` ---- ---- Removing the `max_args` cap is strongly discouraged. ---- ----@param str string ----@param max_args? number ----@return table args ----@return string|'"truncated"' error -function ngx.decode_args(str, max_args) end - -ngx.socket = {} - ----@class udpsock -local udpsock = {} - ---- Attempts to connect a UDP socket object to a remote server or to a datagram unix domain socket file. Because the datagram protocol is actually connection-less, this method does not really establish a "connection", but only just set the name of the remote peer for subsequent read/write operations. ---- ---- Both IP addresses and domain names can be specified as the `host` argument. In case of domain names, this method will use NGINX core's dynamic resolver to parse the domain name without blocking and it is required to configure the `resolver` directive in the `nginx.conf` file like this: ---- ---- ```nginx ---- resolver 8.8.8.8; # use Google's public DNS nameserver ---- ``` ---- ---- If the nameserver returns multiple IP addresses for the host name, this method will pick up one randomly. ---- ---- In case of error, the method returns `nil` followed by a string describing the error. In case of success, the method returns `1`. ---- ---- Here is an example for connecting to a UDP (memcached) server: ---- ---- ```nginx ---- location /test { ---- resolver 8.8.8.8; ---- ---- content_by_lua_block { ---- local sock = ngx.socket.udp() ---- local ok, err = sock:setpeername("my.memcached.server.domain", 11211) ---- if not ok then ---- ngx.say("failed to connect to memcached: ", err) ---- return ---- end ---- ngx.say("successfully connected to memcached!") ---- sock:close() ---- } ---- } ---- ``` ---- ---- Connecting to a datagram unix domain socket file is also possible on Linux: ---- ---- ```lua ---- local sock = ngx.socket.udp() ---- local ok, err = sock:setpeername("unix:/tmp/some-datagram-service.sock") ---- if not ok then ---- ngx.say("failed to connect to the datagram unix domain socket: ", err) ---- return ---- end ---- ``` ---- ---- assuming the datagram service is listening on the unix domain socket file `/tmp/some-datagram-service.sock` and the client socket will use the "autobind" feature on Linux. ---- ---- Calling this method on an already connected socket object will cause the original connection to be closed first. ---- ----@param host string ----@param port number ----@return boolean ok ----@return string? error ----@overload fun(self:udpsock, unix_socket:string):boolean, string? -function udpsock:setpeername(host, port) end - ---- Sends data on the current UDP or datagram unix domain socket object. ---- ---- In case of success, it returns `1`. Otherwise, it returns `nil` and a string describing the error. ---- ---- The input argument `data` can either be a Lua string or a (nested) Lua table holding string fragments. In case of table arguments, this method will copy all the string elements piece by piece to the underlying NGINX socket send buffers, which is usually optimal than doing string concatenation operations on the Lua land. ---- ----@param data string | string[] ----@return boolean ok ----@return string? error -function udpsock:send(data) end - ---- Receives data from the UDP or datagram unix domain socket object with an optional receive buffer size argument, `size`. ---- ---- This method is a synchronous operation and is 100% nonblocking. ---- ---- In case of success, it returns the data received; in case of error, it returns `nil` with a string describing the error. ---- ---- If the `size` argument is specified, then this method will use this size as the receive buffer size. But when this size is greater than `8192`, then `8192` will be used instead. ---- ---- If no argument is specified, then the maximal buffer size, `8192` is assumed. ---- ---- Timeout for the reading operation is controlled by the `lua_socket_read_timeout` config directive and the `settimeout` method. And the latter takes priority. For example: ---- ---- ```lua ---- sock:settimeout(1000) -- one second timeout ---- local data, err = sock:receive() ---- if not data then ---- ngx.say("failed to read a packet: ", err) ---- return ---- end ---- ngx.say("successfully read a packet: ", data) ---- ``` ---- ---- It is important here to call the `settimeout` method *before* calling this method. ---- ----@param size? number ----@return string? data ----@return string? error -function udpsock:receive(size) end - - ---- Closes the current UDP or datagram unix domain socket. It returns the `1` in case of success and returns `nil` with a string describing the error otherwise. ---- ---- Socket objects that have not invoked this method (and associated connections) will be closed when the socket object is released by the Lua GC (Garbage Collector) or the current client HTTP request finishes processing. ---- ----@return boolean ok ----@return string? error -function udpsock:close() end - ---- Set the timeout value in milliseconds for subsequent socket operations (like `receive`). ---- ---- Settings done by this method takes priority over those config directives, like `lua_socket_read_timeout`. ---- ----@param time number -function udpsock:settimeout(time) end - ---- Creates and returns a TCP or stream-oriented unix domain socket object (also known as one type of the "cosocket" objects). The following methods are supported on this object: ---- ---- * `connect` ---- * `sslhandshake` ---- * `send` ---- * `receive` ---- * `close` ---- * `settimeout` ---- * `settimeouts` ---- * `setoption` ---- * `receiveany` ---- * `receiveuntil` ---- * `setkeepalive` ---- * `getreusedtimes` ---- ---- It is intended to be compatible with the TCP API of the `LuaSocket` library but is 100% nonblocking out of the box. ---- ---- The cosocket object created by this API function has exactly the same lifetime as the Lua handler creating it. So never pass the cosocket object to any other Lua handler (including ngx.timer callback functions) and never share the cosocket object between different NGINX requests. ---- ---- For every cosocket object's underlying connection, if you do not ---- explicitly close it (via `close`) or put it back to the connection ---- pool (via `setkeepalive`), then it is automatically closed when one of ---- the following two events happens: ---- ---- * the current request handler completes, or ---- * the Lua cosocket object value gets collected by the Lua GC. ---- ---- Fatal errors in cosocket operations always automatically close the current ---- connection (note that, read timeout error is the only error that is ---- not fatal), and if you call `close` on a closed connection, you will get ---- the "closed" error. ---- ---- The cosocket object here is full-duplex, that is, a reader "light thread" and a writer "light thread" can operate on a single cosocket object simultaneously (both "light threads" must belong to the same Lua handler though, see reasons above). But you cannot have two "light threads" both reading (or writing or connecting) the same cosocket, otherwise you might get an error like "socket busy reading" when calling the methods of the cosocket object. ---- ----@return tcpsock -function ngx.socket.tcp() end - ----@class tcpsock -local tcpsock = {} - ---- Attempts to connect a TCP socket object to a remote server or to a stream unix domain socket file without blocking. ---- ---- Before actually resolving the host name and connecting to the remote backend, this method will always look up the connection pool for matched idle connections created by previous calls of this method (or the `ngx.socket.connect` function). ---- ---- Both IP addresses and domain names can be specified as the `host` argument. In case of domain names, this method will use NGINX core's dynamic resolver to parse the domain name without blocking and it is required to configure the `resolver` directive in the `nginx.conf` file like this: ---- ---- ```nginx ---- resolver 8.8.8.8; # use Google's public DNS nameserver ---- ``` ---- ---- If the nameserver returns multiple IP addresses for the host name, this method will pick up one randomly. ---- ---- In case of error, the method returns `nil` followed by a string describing the error. In case of success, the method returns `1`. ---- ---- Here is an example for connecting to a TCP server: ---- ---- ```nginx ---- location /test { ---- resolver 8.8.8.8; ---- ---- content_by_lua_block { ---- local sock = ngx.socket.tcp() ---- local ok, err = sock:connect("www.google.com", 80) ---- if not ok then ---- ngx.say("failed to connect to google: ", err) ---- return ---- end ---- ngx.say("successfully connected to google!") ---- sock:close() ---- } ---- } ---- ``` ---- ---- Connecting to a Unix Domain Socket file is also possible: ---- ---- ```lua ---- local sock = ngx.socket.tcp() ---- local ok, err = sock:connect("unix:/tmp/memcached.sock") ---- if not ok then ---- ngx.say("failed to connect to the memcached unix domain socket: ", err) ---- return ---- end ---- ``` ---- ---- assuming memcached (or something else) is listening on the unix domain socket file `/tmp/memcached.sock`. ---- ---- Timeout for the connecting operation is controlled by the `lua_socket_connect_timeout` config directive and the `settimeout` method. And the latter takes priority. For example: ---- ---- ```lua ---- local sock = ngx.socket.tcp() ---- sock:settimeout(1000) -- one second timeout ---- local ok, err = sock:connect(host, port) ---- ``` ---- ---- It is important here to call the `settimeout` method *before* calling this method. ---- ---- Calling this method on an already connected socket object will cause the original connection to be closed first. ---- ----@param host string ----@param port number ----@param opts? tcpsock.connect.opts ----@return boolean ok ----@return string? error ----@overload fun(self:tcpsock, unix_socket:string, opts?:tcpsock.connect.opts):boolean, string? -function tcpsock:connect(host, port, opts) end - ---- An optional Lua table can be specified as the last argument to `tcpsock:connect()` ---- ----@class tcpsock.connect.opts : table ---- ---- A custom name for the connection pool being used. If omitted, then the connection pool name will be generated from the string template `"<host>:<port>"` or `"<unix-socket-path>"`. ----@field pool string ---- ---- The size of the connection pool. If omitted and no `backlog` option was provided, no pool will be created. If omitted but `backlog` was provided, the pool will be created with a default size equal to the value of the `lua_socket_pool_size` directive. The connection pool holds up to `pool_size` alive connections ready to be reused by subsequent calls to `connect`, but note that there is no upper limit to the total number of opened connections outside of the pool. If you need to restrict the total number of opened connections, specify the `backlog` option. When the connection pool would exceed its size limit, the least recently used (kept-alive) connection already in the pool will be closed to make room for the current connection. Note that the cosocket connection pool is per NGINX worker process rather than per NGINX server instance, so the size limit specified here also applies to every single NGINX worker process. Also note that the size of the connection pool cannot be changed once it has been created. ----@field pool_size number ---- ---- Limits the total number of opened connections for this pool. No more connections than `pool_size` can be opened for this pool at any time. If the connection pool is full, subsequent connect operations will be queued into a queue equal to this option's value (the "backlog" queue). If the number of queued connect operations is equal to `backlog`, subsequent connect operations will fail and return `nil` plus the error string `"too many waiting connect operations"`. The queued connect operations will be resumed once the number of connections in the pool is less than `pool_size`. The queued connect operation will abort once they have been queued for more than `connect_timeout`, controlled by `settimeouts`, and will return `nil` plus the error string `"timeout"`. ----@field backlog number - - ---- Does SSL/TLS handshake on the currently established connection. ---- ---- The optional `reused_session` argument can take a former SSL ---- session userdata returned by a previous `sslhandshake` ---- call for exactly the same target. For short-lived connections, reusing SSL ---- sessions can usually speed up the handshake by one order by magnitude but it ---- is not so useful if the connection pool is enabled. This argument defaults to ---- `nil`. If this argument takes the boolean `false` value, no SSL session ---- userdata would return by this call and only a Lua boolean will be returned as ---- the first return value; otherwise the current SSL session will ---- always be returned as the first argument in case of successes. ---- ---- The optional `server_name` argument is used to specify the server ---- name for the new TLS extension Server Name Indication (SNI). Use of SNI can ---- make different servers share the same IP address on the server side. Also, ---- when SSL verification is enabled, this `server_name` argument is ---- also used to validate the server name specified in the server certificate sent from ---- the remote. ---- ---- The optional `ssl_verify` argument takes a Lua boolean value to ---- control whether to perform SSL verification. When set to `true`, the server ---- certificate will be verified according to the CA certificates specified by ---- the `lua_ssl_trusted_certificate` directive. ---- You may also need to adjust the `lua_ssl_verify_depth` ---- directive to control how deep we should follow along the certificate chain. ---- Also, when the `ssl_verify` argument is true and the ---- `server_name` argument is also specified, the latter will be used ---- to validate the server name in the server certificate. ---- ---- The optional `send_status_req` argument takes a boolean that controls whether to send ---- the OCSP status request in the SSL handshake request (which is for requesting OCSP stapling). ---- ---- For connections that have already done SSL/TLS handshake, this method returns ---- immediately. ---- ----@param reused_session? userdata|boolean ----@param server_name? string ----@param ssl_verify? boolean ----@param send_status_req? boolean ----@return userdata|boolean session_or_ok ----@return string? error -function tcpsock:sslhandshake(reused_session, server_name, ssl_verify, send_status_req) end - ---- Set client certificate chain and corresponding private key to the TCP socket object. ---- ---- The certificate chain and private key provided will be used later by the `tcpsock:sslhandshake` method. ---- ---- If both of `cert` and `pkey` are `nil`, this method will clear any existing client certificate and private key that was previously set on the cosocket object ---- ----@param cert ffi.cdata*|nil # a client certificate chain cdata object that will be used while handshaking with remote server. These objects can be created using ngx.ssl.parse_pem_cert function provided by lua-resty-core. Note that specifying the cert option requires corresponding pkey be provided too. ----@param key ffi.cdata*|nil # a private key corresponds to the cert option above. These objects can be created using ngx.ssl.parse_pem_priv_key function provided by lua-resty-core. ----@return boolean ok ----@return string? error -function tcpsock:setclientcert(cert, key) end - - ---- Sends data without blocking on the current TCP or Unix Domain Socket connection. ---- ---- This method is a synchronous operation that will not return until *all* the data has been flushed into the system socket send buffer or an error occurs. ---- ---- In case of success, it returns the total number of bytes that have been sent. Otherwise, it returns `nil` and a string describing the error. ---- ---- The input argument `data` can either be a Lua string or a (nested) Lua table holding string fragments. In case of table arguments, this method will copy all the string elements piece by piece to the underlying NGINX socket send buffers, which is usually optimal than doing string concatenation operations on the Lua land. ---- ---- Timeout for the sending operation is controlled by the `lua_socket_send_timeout` config directive and the `settimeout` method. And the latter takes priority. For example: ---- ---- ```lua ---- sock:settimeout(1000) -- one second timeout ---- local bytes, err = sock:send(request) ---- ``` ---- ---- It is important here to call the `settimeout` method *before* calling this method. ---- ---- In case of any connection errors, this method always automatically closes the current connection. ---- ----@param data string|string[] ----@return number? bytes ----@return string? error -function tcpsock:send(data) end - - ---- Receives data from the connected socket according to the reading pattern or size. ---- ---- This method is a synchronous operation just like the `send` method and is 100% nonblocking. ---- ---- In case of success, it returns the data received; in case of error, it returns `nil` with a string describing the error and the partial data received so far. ---- ---- If a non-number-like string argument is specified, then it is interpreted as a "pattern". The following patterns are supported: ---- ---- * `'*a'`: reads from the socket until the connection is closed. No end-of-line translation is performed; ---- * `'*l'`: reads a line of text from the socket. The line is terminated by a `Line Feed` (LF) character (ASCII 10), optionally preceded by a `Carriage Return` (CR) character (ASCII 13). The CR and LF characters are not included in the returned line. In fact, all CR characters are ignored by the pattern. ---- ---- If no argument is specified, then it is assumed to be the pattern `'*l'`, that is, the line reading pattern. ---- ---- If a number-like argument is specified (including strings that look like numbers), then it is interpreted as a size. This method will not return until it reads exactly this size of data or an error occurs. ---- ---- ---- Timeout for the reading operation is controlled by the `lua_socket_read_timeout` config directive and the `settimeout` method. And the latter takes priority. For example: ---- ---- ```lua ---- sock:settimeout(1000) -- one second timeout ---- local line, err, partial = sock:receive() ---- if not line then ---- ngx.say("failed to read a line: ", err) ---- return ---- end ---- ngx.say("successfully read a line: ", line) ---- ``` ---- ---- It is important here to call the `settimeout` method *before* calling this method. ---- ---- This method does not automatically closes the current connection when the read timeout error happens. For other connection errors, this method always automatically closes the connection. ---- ----@overload fun(self:tcpsock, size:number):string,string,string ---- ----@param pattern? '"*a"'|'"*l"' ----@return string? data ----@return string? error ----@return string? partial -function tcpsock:receive(pattern) end - ---- Returns any data received by the connected socket, at most `max` bytes. ---- ---- This method is a synchronous operation just like the `send` method and is 100% nonblocking. ---- ---- In case of success, it returns the data received; in case of error, it returns `nil` with a string describing the error. ---- ---- If the received data is more than this size, this method will return with exactly this size of data. ---- The remaining data in the underlying receive buffer could be returned in the next reading operation. ---- ---- Timeout for the reading operation is controlled by the `lua_socket_read_timeout` config directive and the `settimeouts` method. And the latter takes priority. For example: ---- ---- ```lua ---- sock:settimeouts(1000, 1000, 1000) -- one second timeout for connect/read/write ---- local data, err = sock:receiveany(10 * 1024) -- read any data, at most 10K ---- if not data then ---- ngx.say("failed to read any data: ", err) ---- return ---- end ---- ngx.say("successfully read: ", data) ---- ``` ---- ---- This method doesn't automatically close the current connection when the read timeout error occurs. For other connection errors, this method always automatically closes the connection. ---- ----@param max integer ----@return string? data ----@return string? error -function tcpsock:receiveany(max) end - - ---- This method returns an iterator Lua function that can be called to read the data stream until it sees the specified pattern or an error occurs. ---- ---- Here is an example for using this method to read a data stream with the boundary sequence `--abcedhb`: ---- ---- ```lua ---- local reader = sock:receiveuntil("\r\n--abcedhb") ---- local data, err, partial = reader() ---- if not data then ---- ngx.say("failed to read the data stream: ", err) ---- end ---- ngx.say("read the data stream: ", data) ---- ``` ---- ---- When called without any argument, the iterator function returns the received data right *before* the specified pattern string in the incoming data stream. So for the example above, if the incoming data stream is `'hello, world! -agentzh\r\n--abcedhb blah blah'`, then the string `'hello, world! -agentzh'` will be returned. ---- ---- In case of error, the iterator function will return `nil` along with a string describing the error and the partial data bytes that have been read so far. ---- ---- The iterator function can be called multiple times and can be mixed safely with other cosocket method calls or other iterator function calls. ---- ---- The iterator function behaves differently (i.e., like a real iterator) when it is called with a `size` argument. That is, it will read that `size` of data on each invocation and will return `nil` at the last invocation (either sees the boundary pattern or meets an error). For the last successful invocation of the iterator function, the `err` return value will be `nil` too. The iterator function will be reset after the last successful invocation that returns `nil` data and `nil` error. Consider the following example: ---- ---- ```lua ---- local reader = sock:receiveuntil("\r\n--abcedhb") ---- ---- while true do ---- local data, err, partial = reader(4) ---- if not data then ---- if err then ---- ngx.say("failed to read the data stream: ", err) ---- break ---- end ---- ---- ngx.say("read done") ---- break ---- end ---- ngx.say("read chunk: [", data, "]") ---- end ---- ``` ---- ---- Then for the incoming data stream `'hello, world! -agentzh\r\n--abcedhb blah blah'`, we shall get the following output from the sample code above: ---- ---- read chunk: [hell] ---- read chunk: [o, w] ---- read chunk: [orld] ---- read chunk: [! -a] ---- read chunk: [gent] ---- read chunk: [zh] ---- read done ---- ---- Note that, the actual data returned *might* be a little longer than the size limit specified by the `size` argument when the boundary pattern has ambiguity for streaming parsing. Near the boundary of the data stream, the data string actually returned could also be shorter than the size limit. ---- ---- Timeout for the iterator function's reading operation is controlled by the `lua_socket_read_timeout` config directive and the `settimeout` method. And the latter takes priority. For example: ---- ---- ```lua ---- local readline = sock:receiveuntil("\r\n") ---- ---- sock:settimeout(1000) -- one second timeout ---- line, err, partial = readline() ---- if not line then ---- ngx.say("failed to read a line: ", err) ---- return ---- end ---- ngx.say("successfully read a line: ", line) ---- ``` ---- ---- It is important here to call the `settimeout` method *before* calling the iterator function (note that the `receiveuntil` call is irrelevant here). ---- ---- This method also takes an optional `options` table argument to control the behavior. The following options are supported: ---- ---- * `inclusive` ---- ---- The `inclusive` takes a boolean value to control whether to include the pattern string in the returned data string. Default to `false`. For example, ---- ---- ```lua ---- local reader = tcpsock:receiveuntil("_END_", { inclusive = true }) ---- local data = reader() ---- ngx.say(data) ---- ``` ---- ---- Then for the input data stream `"hello world _END_ blah blah blah"`, then the example above will output `hello world _END_`, including the pattern string `_END_` itself. ---- ---- This method does not automatically closes the current connection when the read timeout error happens. For other connection errors, this method always automatically closes the connection. ---- ----@alias ngx.socket.tcpsock.iterator fun(size:number|nil):string,string,any ---- ----@overload fun(self:tcpsock, size:number, options:table):ngx.socket.tcpsock.iterator ---- ----@param pattern string ----@param options? table ----@return ngx.socket.tcpsock.iterator -function tcpsock:receiveuntil(pattern, options) end - - ---- Closes the current TCP or stream unix domain socket. It returns the `1` in case of success and returns `nil` with a string describing the error otherwise. ---- ---- Note that there is no need to call this method on socket objects that have invoked the `setkeepalive` method because the socket object is already closed (and the current connection is saved into the built-in connection pool). ---- ---- Socket objects that have not invoked this method (and associated connections) will be closed when the socket object is released by the Lua GC (Garbage Collector) or the current client HTTP request finishes processing. ---- ----@return boolean ok ----@return string? error -function tcpsock:close() end - - ---- Set the timeout value in milliseconds for subsequent socket operations (`connect`, `receive`, and iterators returned from `receiveuntil`). ---- ---- Settings done by this method take priority over those specified via config directives (i.e. `lua_socket_connect_timeout`, `lua_socket_send_timeout`, and `lua_socket_read_timeout`). ---- ---- Note that this method does *not* affect the `lua_socket_keepalive_timeout` setting; the `timeout` argument to the `setkeepalive` method should be used for this purpose instead. ---- ----@param time number -function tcpsock:settimeout(time) end - - ---- Respectively sets the connect, send, and read timeout thresholds (in milliseconds) for subsequent socket ---- operations (`connect`, `send`, `receive`, and iterators returned from `receiveuntil`). ---- ---- Settings done by this method take priority over those specified via config directives (i.e. `lua_socket_connect_timeout`, `lua_socket_send_timeout`, and `lua_socket_read_timeout`). ---- ---- It is recommended to use `settimeouts` instead of `settimeout`. ---- ---- Note that this method does *not* affect the `lua_socket_keepalive_timeout` setting; the `timeout` argument to the `setkeepalive` method should be used for this purpose instead. ---- ----@param connect_timeout number|nil ----@param send_timeout number|nil ----@param read_timeout number|nil -function tcpsock:settimeouts(connect_timeout, send_timeout, read_timeout) end - - ---- This function is added for `LuaSocket` API compatibility and does nothing for now. ---- ---- In case of success, it returns `true`. Otherwise, it returns nil and a string describing the error. ---- ---- The `option` is a string with the option name, and the value depends on the option being set: ---- ---- * `keepalive` ---- ---- Setting this option to true enables sending of keep-alive messages on ---- connection-oriented sockets. Make sure the `connect` function ---- had been called before, for example, ---- ---- ```lua ---- local ok, err = tcpsock:setoption("keepalive", true) ---- if not ok then ---- ngx.say("setoption keepalive failed: ", err) ---- end ---- ``` ---- * `reuseaddr` ---- ---- Enabling this option indicates that the rules used in validating addresses ---- supplied in a call to bind should allow reuse of local addresses. Make sure ---- the `connect` function had been called before, for example, ---- ---- ```lua ---- local ok, err = tcpsock:setoption("reuseaddr", 0) ---- if not ok then ---- ngx.say("setoption reuseaddr failed: ", err) ---- end ---- ``` ---- * `tcp-nodelay` ---- ---- Setting this option to true disables the Nagle's algorithm for the connection. ---- Make sure the `connect` function had been called before, for example, ---- ---- ```lua ---- local ok, err = tcpsock:setoption("tcp-nodelay", true) ---- if not ok then ---- ngx.say("setoption tcp-nodelay failed: ", err) ---- end ---- ``` ---- * `sndbuf` ---- ---- Sets the maximum socket send buffer in bytes. The kernel doubles this value ---- (to allow space for bookkeeping overhead) when it is set using setsockopt(). ---- Make sure the `connect` function had been called before, for example, ---- ---- ```lua ---- local ok, err = tcpsock:setoption("sndbuf", 1024 * 10) ---- if not ok then ---- ngx.say("setoption sndbuf failed: ", err) ---- end ---- ``` ---- * `rcvbuf` ---- ---- Sets the maximum socket receive buffer in bytes. The kernel doubles this value ---- (to allow space for bookkeeping overhead) when it is set using setsockopt. Make ---- sure the `connect` function had been called before, for example, ---- ---- ```lua ---- local ok, err = tcpsock:setoption("rcvbuf", 1024 * 10) ---- if not ok then ---- ngx.say("setoption rcvbuf failed: ", err) ---- end ---- ``` ---- ---- NOTE: Once the option is set, it will become effective until the connection is closed. If you know the connection is from the connection pool and all the in-pool connections already have called the setoption() method with the desired socket option state, then you can just skip calling setoption() again to avoid the overhead of repeated calls, for example, ---- ---- ```lua ---- local count, err = tcpsock:getreusedtimes() ---- if not count then ---- ngx.say("getreusedtimes failed: ", err) ---- return ---- end ---- ---- if count == 0 then ---- local ok, err = tcpsock:setoption("rcvbuf", 1024 * 10) ---- if not ok then ---- ngx.say("setoption rcvbuf failed: ", err) ---- return ---- end ---- end ---- ``` ---- ----@param option tcpsock.setoption.option ----@param value number|boolean ----@return boolean ok ----@return string? error -function tcpsock:setoption(option, value) end - ----@alias tcpsock.setoption.option ----| '"keepalive"' # enable or disable keepalive ----| '"reuseaddr"' # reuse addr options ----| '"tcp-nodelay"' # disables the Nagle's algorithm for the connection. ----| '"sndbuf"' # max send buffer size (in bytes) ----| '"rcvbuf"' # max receive bufer size (in bytes) - - - ---- Puts the current socket's connection immediately into the cosocket built-in connection pool and keep it alive until other `connect` method calls request it or the associated maximal idle timeout is expired. ---- ---- The first optional argument, `timeout`, can be used to specify the maximal idle timeout (in milliseconds) for the current connection. If omitted, the default setting in the `lua_socket_keepalive_timeout` config directive will be used. If the `0` value is given, then the timeout interval is unlimited. ---- ---- The second optional argument `size` is considered deprecated since the `v0.10.14` release of this module, in favor of the `pool_size` option of the `connect` method. ---- Since the `v0.10.14` release, this option will only take effect if the call to `connect` did not already create a connection pool. ---- When this option takes effect (no connection pool was previously created by `connect`), it will specify the size of the connection pool, and create it. ---- If omitted (and no pool was previously created), the default size is the value of the `lua_socket_pool_size` directive. ---- The connection pool holds up to `size` alive connections ready to be reused by subsequent calls to `connect`, but note that there is no upper limit to the total number of opened connections outside of the pool. ---- When the connection pool would exceed its size limit, the least recently used (kept-alive) connection already in the pool will be closed to make room for the current connection. ---- Note that the cosocket connection pool is per NGINX worker process rather than per NGINX server instance, so the size limit specified here also applies to every single NGINX worker process. Also note that the size of the connection pool cannot be changed once it has been created. ---- If you need to restrict the total number of opened connections, specify both the `pool_size` and `backlog` option in the call to `connect`. ---- ---- In case of success, this method returns `1`; otherwise, it returns `nil` and a string describing the error. ---- ---- When the system receive buffer for the current connection has unread data, then this method will return the "connection in dubious state" error message (as the second return value) because the previous session has unread data left behind for the next session and the connection is not safe to be reused. ---- ---- This method also makes the current cosocket object enter the "closed" state, so there is no need to manually call the `close` method on it afterwards. ---- ----@param timeout? number ----@param size? number ----@return boolean ok ----@return string? error -function tcpsock:setkeepalive(timeout, size) end - - ---- This method returns the (successfully) reused times for the current connection. In case of error, it returns `nil` and a string describing the error. ---- ---- If the current connection does not come from the built-in connection pool, then this method always returns `0`, that is, the connection has never been reused (yet). If the connection comes from the connection pool, then the return value is always non-zero. So this method can also be used to determine if the current connection comes from the pool. ---- ----@return number? count ----@return string? error -function tcpsock:getreusedtimes() end - ---- This function is a shortcut for combining `ngx.socket.tcp()` and the `connect()` method call in a single operation. It is actually implemented like this: ---- ---- ```lua ---- local sock = ngx.socket.tcp() ---- local ok, err = sock:connect(...) ---- if not ok then ---- return nil, err ---- end ---- return sock ---- ``` ---- ---- There is no way to use the `settimeout` method to specify connecting timeout for this method and the `lua_socket_connect_timeout` directive must be set at configure time instead. ---- ----@param host string ----@param port? number ----@return tcpsock? socket ----@return string? error -function ngx.socket.connect(host, port) end - ---- Creates and returns a UDP or datagram-oriented unix domain socket object (also known as one type of the "cosocket" objects). The following methods are supported on this object: ---- ---- * `setpeername` ---- * `send` ---- * `receive` ---- * `close` ---- * `settimeout` ---- ---- It is intended to be compatible with the UDP API of the `LuaSocket` library but is 100% nonblocking out of the box. ---- ----@return udpsock -function ngx.socket.udp() end - ---- Just an alias to `ngx.socket.tcp`. If the stream-typed cosocket may also connect to a unix domain ---- socket, then this API name is preferred. ---- -function ngx.socket.stream() end - ---- When this is used in the context of the `set_by_lua*` directives, this table is read-only and holds the input arguments to the config directives: ---- ---- ```lua ---- value = ngx.arg[n] ---- ``` ---- ---- Here is an example ---- ---- ```nginx ---- location /foo { ---- set $a 32; ---- set $b 56; ---- ---- set_by_lua $sum ---- 'return tonumber(ngx.arg[1]) + tonumber(ngx.arg[2])' ---- $a $b; ---- ---- echo $sum; ---- } ---- ``` ---- ---- that writes out `88`, the sum of `32` and `56`. ---- ---- When this table is used in the context of `body_filter_by_lua*`, the first element holds the input data chunk to the output filter code and the second element holds the boolean flag for the "eof" flag indicating the end of the whole output data stream. ---- ---- The data chunk and "eof" flag passed to the downstream NGINX output filters can also be overridden by assigning values directly to the corresponding table elements. When setting `nil` or an empty Lua string value to `ngx.arg[1]`, no data chunk will be passed to the downstream NGINX output filters at all. -ngx.arg = {} - ----@alias ngx.phase.name ----| '"init"' ----| '"init_worker"' ----| '"ssl_cert"' ----| '"ssl_session_fetch"' ----| '"ssl_session_store"' ----| '"set"' ----| '"rewrite"' ----| '"balancer"' ----| '"access"' ----| '"content"' ----| '"header_filter"' ----| '"body_filter"' ----| '"log"' ----| '"timer"' - ---- Retrieves the current running phase name. ---- ----@return ngx.phase.name -function ngx.get_phase() end - - ---- When `status >= 200` (i.e., `ngx.HTTP_OK` and above), it will interrupt the execution of the current request and return status code to NGINX. ---- ---- When `status == 0` (i.e., `ngx.OK`), it will only quit the current phase handler (or the content handler if the `content_by_lua*` directive is used) and continue to run later phases (if any) for the current request. ---- ---- The `status` argument can be `ngx.OK`, `ngx.ERROR`, `ngx.HTTP_NOT_FOUND`, ---- `ngx.HTTP_MOVED_TEMPORARILY`, or other `ngx.HTTP_*` status constants. ---- ---- To return an error page with custom contents, use code snippets like this: ---- ---- ```lua ---- ngx.status = ngx.HTTP_GONE ---- ngx.say("This is our own content") ---- -- to cause quit the whole request rather than the current phase handler ---- ngx.exit(ngx.HTTP_OK) ---- ``` ---- ---- The effect in action: ---- ---- ```bash ---- $ curl -i http://localhost/test ---- HTTP/1.1 410 Gone ---- Server: nginx/1.0.6 ---- Date: Thu, 15 Sep 2011 00:51:48 GMT ---- Content-Type: text/plain ---- Transfer-Encoding: chunked ---- Connection: keep-alive ---- ---- This is our own content ---- ``` ---- ---- Number literals can be used directly as the argument, for instance, ---- ---- ```lua ---- ngx.exit(501) ---- ``` ---- ---- Note that while this method accepts all `ngx.HTTP_*` status constants as input, it only accepts `ngx.OK` and `ngx.ERROR` of the `core constants`. ---- ---- Also note that this method call terminates the processing of the current request and that it is recommended that a coding style that combines this method call with the `return` statement, i.e., `return ngx.exit(...)` be used to reinforce the fact that the request processing is being terminated. ---- ---- When being used in the contexts of `header_filter_by_lua*`, `balancer_by_lua*`, and ---- `ssl_session_store_by_lua*`, `ngx.exit()` is ---- an asynchronous operation and will return immediately. This behavior may change in future and it is recommended that users always use `return` in combination as suggested above. ---- ----@param status ngx.OK|ngx.ERROR|ngx.http.status_code -function ngx.exit(status) end - ---- Issue an `HTTP 301` or `302` redirection to `uri`. ---- ---- Notice: the `uri` should not contains `\r` or `\n`, otherwise, the characters after `\r` or `\n` will be truncated, including the `\r` or `\n` bytes themself. ---- ---- The `uri` argument will be truncated if it contains the ---- `\r` or `\n` characters. The truncated value will contain ---- all characters up to (and excluding) the first occurrence of `\r` or ---- `\n`. ---- ---- The optional `status` parameter specifies the HTTP status code to be used. The following status codes are supported right now: ---- ---- * `301` ---- * `302` (default) ---- * `303` ---- * `307` ---- * `308` ---- ---- It is `302` (`ngx.HTTP_MOVED_TEMPORARILY`) by default. ---- ---- Here is an example assuming the current server name is `localhost` and that it is listening on port 1984: ---- ---- ```lua ---- return ngx.redirect("/foo") ---- ``` ---- ---- which is equivalent to ---- ---- ```lua ---- return ngx.redirect("/foo", ngx.HTTP_MOVED_TEMPORARILY) ---- ``` ---- ---- Redirecting arbitrary external URLs is also supported, for example: ---- ---- ```lua ---- return ngx.redirect("http://www.google.com") ---- ``` ---- ---- We can also use the numerical code directly as the second `status` argument: ---- ---- ```lua ---- return ngx.redirect("/foo", 301) ---- ``` ---- ---- This method is similar to the `rewrite` directive with the `redirect` modifier in the standard ---- `ngx_http_rewrite_module`, for example, this `nginx.conf` snippet ---- ---- ```nginx ---- rewrite ^ /foo? redirect; # nginx config ---- ``` ---- ---- is equivalent to the following Lua code ---- ---- ```lua ---- return ngx.redirect('/foo'); -- Lua code ---- ``` ---- ---- while ---- ---- ```nginx ---- rewrite ^ /foo? permanent; # nginx config ---- ``` ---- ---- is equivalent to ---- ---- ```lua ---- return ngx.redirect('/foo', ngx.HTTP_MOVED_PERMANENTLY) -- Lua code ---- ``` ---- ---- URI arguments can be specified as well, for example: ---- ---- ```lua ---- return ngx.redirect('/foo?a=3&b=4') ---- ``` ---- ---- Note that this method call terminates the processing of the current request and that it *must* be called before `ngx.send_headers` or explicit response body ---- outputs by either `ngx.print` or `ngx.say`. ---- ---- It is recommended that a coding style that combines this method call with the `return` statement, i.e., `return ngx.redirect(...)` be adopted when this method call is used in contexts other than `header_filter_by_lua*` to reinforce the fact that the request processing is being terminated. ---- ----@param uri string ----@param status? 301|302|303|307|308 -function ngx.redirect(uri, status) end - - ---- Registers a user Lua function as the callback which gets called automatically when the client closes the (downstream) connection prematurely. ---- ---- Returns `1` if the callback is registered successfully or returns `nil` and a string describing the error otherwise. ---- ---- All the NGINX APIs for lua can be used in the callback function because the function is run in a special "light thread", just as those "light threads" created by `ngx.thread.spawn`. ---- ---- The callback function can decide what to do with the client abortion event all by itself. For example, it can simply ignore the event by doing nothing and the current Lua request handler will continue executing without interruptions. And the callback function can also decide to terminate everything by calling `ngx.exit`, for example, ---- ---- ```lua ---- local function my_cleanup() ---- -- custom cleanup work goes here, like cancelling a pending DB transaction ---- ---- -- now abort all the "light threads" running in the current request handler ---- ngx.exit(499) ---- end ---- ---- local ok, err = ngx.on_abort(my_cleanup) ---- if not ok then ---- ngx.log(ngx.ERR, "failed to register the on_abort callback: ", err) ---- ngx.exit(500) ---- end ---- ``` ---- ---- When `lua_check_client_abort` is set to `off` (which is the default), then this function call will always return the error message "lua_check_client_abort is off". ---- ---- According to the current implementation, this function can only be called once in a single request handler; subsequent calls will return the error message "duplicate call". ---- ----@param callback fun() ----@return boolean ok ----@return string|'"lua_check_client_abort is off"'|'"duplicate call"' error -function ngx.on_abort(callback) end - - ---- Does an internal redirect to `uri` with `args` and is similar to the `echo_exec` directive of the `echo-nginx-module`. ---- ---- ```lua ---- ngx.exec('/some-location'); ---- ngx.exec('/some-location', 'a=3&b=5&c=6'); ---- ngx.exec('/some-location?a=3&b=5', 'c=6'); ---- ``` ---- ---- The optional second `args` can be used to specify extra URI query arguments, for example: ---- ---- ```lua ---- ngx.exec("/foo", "a=3&b=hello%20world") ---- ``` ---- ---- Alternatively, a Lua table can be passed for the `args` argument for ngx_lua to carry out URI escaping and string concatenation. ---- ---- ```lua ---- ngx.exec("/foo", { a = 3, b = "hello world" }) ---- ``` ---- ---- The result is exactly the same as the previous example. ---- ---- The format for the Lua table passed as the `args` argument is identical to the format used in the `ngx.encode_args` method. ---- ---- Named locations are also supported but the second `args` argument will be ignored if present and the querystring for the new target is inherited from the referring location (if any). ---- ---- `GET /foo/file.php?a=hello` will return "hello" and not "goodbye" in the example below ---- ---- ```nginx ---- location /foo { ---- content_by_lua_block { ---- ngx.exec("@bar", "a=goodbye"); ---- } ---- } ---- ---- location @bar { ---- content_by_lua_block { ---- local args = ngx.req.get_uri_args() ---- for key, val in pairs(args) do ---- if key == "a" then ---- ngx.say(val) ---- end ---- end ---- } ---- } ---- ``` ---- ---- Note that the `ngx.exec` method is different from `ngx.redirect` in that ---- it is purely an internal redirect and that no new external HTTP traffic is involved. ---- ---- Also note that this method call terminates the processing of the current request and that it *must* be called before `ngx.send_headers` or explicit response body ---- outputs by either `ngx.print` or `ngx.say`. ---- ---- It is recommended that a coding style that combines this method call with the `return` statement, i.e., `return ngx.exec(...)` be adopted when this method call is used in contexts other than `header_filter_by_lua*` to reinforce the fact that the request processing is being terminated. ---- ----@param uri string ----@param args? string|table<string,any> -function ngx.exec(uri, args) end - -ngx.location = {} - ----@class ngx.location.capture.response : table ----@field status integer # response status code ----@field header table<string, string|string[]> # response headers ----@field body string # response body ----@field truncated boolean # truth-y if the response body is truncated. You always need to check the `res.truncated` boolean flag to see if `res.body` contains truncated data. The data truncation here can only be caused by those unrecoverable errors in your subrequests like the cases that the remote end aborts the connection prematurely in the middle of the response body data stream or a read timeout happens when your subrequest is receiving the response body data from the remote. - ---- An optional option table can be fed as the second argument, which supports the options: ---- ----@class ngx.location.capture.options ---- ----@field method ngx.http.method # the subrequest's request method, which only accepts constants like `ngx.HTTP_POST`. ---- ----@field body string # the subrequest's request body (string value only). ---- ----@field args string|table # the subrequest's URI query arguments (both string value and Lua tables are accepted) ----@field ctx table # a Lua table to be the `ngx.ctx` table for the subrequest. It can be the current request's `ngx.ctx` table, which effectively makes the parent and its subrequest to share exactly the same context table. ---- ----@field vars table # a Lua table which holds the values to set the specified NGINX variables in the subrequest as this option's value. ---- ----@field copy_all_vars boolean # whether to copy over all the NGINX variable values of the current request to the subrequest in question. modifications of the NGINX variables in the subrequest will not affect the current (parent) request. ---- ----@field share_all_vars boolean # whether to share all the NGINX variables of the subrequest with the current (parent) request. modifications of the NGINX variables in the subrequest will affect the current (parent) request. Enabling this option may lead to hard-to-debug issues due to bad side-effects and is considered bad and harmful. Only enable this option when you completely know what you are doing. ---- ----@field always_forward_body boolean # when set to true, the current (parent) request's request body will always be forwarded to the subrequest being created if the `body` option is not specified. The request body read by either `ngx.req.read_body()` or `lua_need_request_body on` will be directly forwarded to the subrequest without copying the whole request body data when creating the subrequest (no matter the request body data is buffered in memory buffers or temporary files). By default, this option is `false` and when the `body` option is not specified, the request body of the current (parent) request is only forwarded when the subrequest takes the `PUT` or `POST` request method. - - ----@alias ngx.location.capture.uri string - ----@class ngx.location.capture.arg : table ----@field [1] ngx.location.capture.uri request uri ----@field [2] ngx.location.capture.options? request options - - ---- Issues a synchronous but still non-blocking *NGINX Subrequest* using `uri`. ---- ---- NGINX's subrequests provide a powerful way to make non-blocking internal requests to other locations configured with disk file directory or *any* other NGINX C modules like `ngx_proxy`, `ngx_fastcgi`, `ngx_memc`, ---- `ngx_postgres`, `ngx_drizzle`, and even ngx_lua itself and etc etc etc. ---- ---- Also note that subrequests just mimic the HTTP interface but there is *no* extra HTTP/TCP traffic *nor* IPC involved. Everything works internally, efficiently, on the C level. ---- ---- Subrequests are completely different from HTTP 301/302 redirection (via `ngx.redirect`) and internal redirection (via `ngx.exec`). ---- ---- You should always read the request body (by either calling `ngx.req.read_body` or configuring `lua_need_request_body` on) before initiating a subrequest. ---- ---- This API function (as well as `ngx.location.capture_multi`) always buffers the whole response body of the subrequest in memory. Thus, you should use `cosockets` ---- and streaming processing instead if you have to handle large subrequest responses. ---- ---- Here is a basic example: ---- ---- ```lua ---- res = ngx.location.capture(uri) ---- ``` ---- ---- Returns a Lua table with 4 slots: `res.status`, `res.header`, `res.body`, and `res.truncated`. ---- ---- URI query strings can be concatenated to URI itself, for instance, ---- ---- ```lua ---- res = ngx.location.capture('/foo/bar?a=3&b=4') ---- ``` ---- ---- Named locations like `@foo` are not allowed due to a limitation in ---- the NGINX core. Use normal locations combined with the `internal` directive to ---- prepare internal-only locations. ---- ---- An optional option table can be fed as the second argument. ---- ---- Issuing a POST subrequest, for example, can be done as follows ---- ---- ```lua ---- res = ngx.location.capture( ---- '/foo/bar', ---- { method = ngx.HTTP_POST, body = 'hello, world' } ---- ) ---- ``` ---- ---- See HTTP method constants methods other than POST. ---- The `method` option is `ngx.HTTP_GET` by default. ---- ---- The `args` option can specify extra URI arguments, for instance, ---- ---- ```lua ---- ngx.location.capture('/foo?a=1', ---- { args = { b = 3, c = ':' } } ---- ) ---- ``` ---- ---- is equivalent to ---- ---- ```lua ---- ngx.location.capture('/foo?a=1&b=3&c=%3a') ---- ``` ---- ---- that is, this method will escape argument keys and values according to URI rules and ---- concatenate them together into a complete query string. The format for the Lua table passed as the `args` argument is identical to the format used in the `ngx.encode_args` method. ---- ---- The `args` option can also take plain query strings: ---- ---- ```lua ---- ngx.location.capture('/foo?a=1', ---- { args = 'b=3&c=%3a' } ---- ) ---- ``` ---- ---- This is functionally identical to the previous examples. ---- ---- The `share_all_vars` option controls whether to share NGINX variables among the current request and its subrequests. ---- If this option is set to `true`, then the current request and associated subrequests will share the same NGINX variable scope. Hence, changes to NGINX variables made by a subrequest will affect the current request. ---- ---- Care should be taken in using this option as variable scope sharing can have unexpected side effects. The `args`, `vars`, or `copy_all_vars` options are generally preferable instead. ---- ---- This option is set to `false` by default ---- ---- ```nginx ---- location /other { ---- set $dog "$dog world"; ---- echo "$uri dog: $dog"; ---- } ---- ---- location /lua { ---- set $dog 'hello'; ---- content_by_lua_block { ---- res = ngx.location.capture("/other", ---- { share_all_vars = true }); ---- ---- ngx.print(res.body) ---- ngx.say(ngx.var.uri, ": ", ngx.var.dog) ---- } ---- } ---- ``` ---- ---- Accessing location `/lua` gives ---- ---- /other dog: hello world ---- /lua: hello world ---- ---- The `copy_all_vars` option provides a copy of the parent request's NGINX variables to subrequests when such subrequests are issued. Changes made to these variables by such subrequests will not affect the parent request or any other subrequests sharing the parent request's variables. ---- ---- ```nginx ---- location /other { ---- set $dog "$dog world"; ---- echo "$uri dog: $dog"; ---- } ---- ---- location /lua { ---- set $dog 'hello'; ---- content_by_lua_block { ---- res = ngx.location.capture("/other", ---- { copy_all_vars = true }); ---- ---- ngx.print(res.body) ---- ngx.say(ngx.var.uri, ": ", ngx.var.dog) ---- } ---- } ---- ``` ---- ---- Request `GET /lua` will give the output ---- ---- /other dog: hello world ---- /lua: hello ---- ---- Note that if both `share_all_vars` and `copy_all_vars` are set to true, then `share_all_vars` takes precedence. ---- ---- In addition to the two settings above, it is possible to specify ---- values for variables in the subrequest using the `vars` option. These ---- variables are set after the sharing or copying of variables has been ---- evaluated, and provides a more efficient method of passing specific ---- values to a subrequest over encoding them as URL arguments and ---- unescaping them in the NGINX config file. ---- ---- ```nginx ---- location /other { ---- content_by_lua_block { ---- ngx.say("dog = ", ngx.var.dog) ---- ngx.say("cat = ", ngx.var.cat) ---- } ---- } ---- ---- location /lua { ---- set $dog ''; ---- set $cat ''; ---- content_by_lua_block { ---- res = ngx.location.capture("/other", ---- { vars = { dog = "hello", cat = 32 }}); ---- ---- ngx.print(res.body) ---- } ---- } ---- ``` ---- ---- Accessing `/lua` will yield the output ---- ---- dog = hello ---- cat = 32 ---- ---- The `ctx` option can be used to specify a custom Lua table to serve as the `ngx.ctx` table for the subrequest. ---- ---- ```nginx ---- location /sub { ---- content_by_lua_block { ---- ngx.ctx.foo = "bar"; ---- } ---- } ---- location /lua { ---- content_by_lua_block { ---- local ctx = {} ---- res = ngx.location.capture("/sub", { ctx = ctx }) ---- ---- ngx.say(ctx.foo); ---- ngx.say(ngx.ctx.foo); ---- } ---- } ---- ``` ---- ---- Then request `GET /lua` gives ---- ---- bar ---- nil ---- ---- It is also possible to use this `ctx` option to share the same `ngx.ctx` table between the current (parent) request and the subrequest: ---- ---- ```nginx ---- location /sub { ---- content_by_lua_block { ---- ngx.ctx.foo = "bar"; ---- } ---- } ---- location /lua { ---- content_by_lua_block { ---- res = ngx.location.capture("/sub", { ctx = ngx.ctx }) ---- ngx.say(ngx.ctx.foo); ---- } ---- } ---- ``` ---- ---- Request `GET /lua` yields the output ---- ---- bar ---- ---- Note that subrequests issued by `ngx.location.capture` inherit all the ---- request headers of the current request by default and that this may have unexpected side effects on the ---- subrequest responses. For example, when using the standard `ngx_proxy` module to serve ---- subrequests, an "Accept-Encoding: gzip" header in the main request may result ---- in gzipped responses that cannot be handled properly in Lua code. Original request headers should be ignored by setting ---- `proxy_pass_request_headers` to `off` in subrequest locations. ---- ---- When the `body` option is not specified and the `always_forward_body` option is false (the default value), the `POST` and `PUT` subrequests will inherit the request bodies of the parent request (if any). ---- ---- There is a hard-coded upper limit on the number of concurrent subrequests possible for every main request. In older versions of NGINX, the limit was `50` concurrent subrequests and in more recent versions, NGINX `1.1.x` onwards, this was increased to `200` concurrent subrequests. When this limit is exceeded, the following error message is added to the `error.log` file: ---- ---- [error] 13983#0: *1 subrequests cycle while processing "/uri" ---- ---- The limit can be manually modified if required by editing the definition of the `NGX_HTTP_MAX_SUBREQUESTS` macro in the `nginx/src/http/ngx_http_request.h` file in the NGINX source tree. ---- ---- Please also refer to restrictions on capturing locations configured by subrequest directives of other modules. ---- ----@param uri ngx.location.capture.uri ----@param options? ngx.location.capture.options ----@return ngx.location.capture.response -function ngx.location.capture(uri, options) end - - ---- Just like `ngx.location.capture`, but supports multiple subrequests running in parallel. ---- ---- This function issues several parallel subrequests specified by the input table and returns their results in the same order. For example, ---- ---- ```lua ---- local res1, res2, res3 = ngx.location.capture_multi{ ---- { "/foo", { args = "a=3&b=4" } }, ---- { "/bar" }, ---- { "/baz", { method = ngx.HTTP_POST, body = "hello" } }, ---- } ---- ---- if res1.status == ngx.HTTP_OK then ---- ... ---- end ---- ---- if res2.body == "BLAH" then ---- ... ---- end ---- ``` ---- ---- This function will not return until all the subrequests terminate. ---- The total latency is the longest latency of the individual subrequests rather than the sum. ---- ---- Lua tables can be used for both requests and responses when the number of subrequests to be issued is not known in advance: ---- ---- ```lua ---- -- construct the requests table ---- local reqs = {} ---- table.insert(reqs, { "/mysql" }) ---- table.insert(reqs, { "/postgres" }) ---- table.insert(reqs, { "/redis" }) ---- table.insert(reqs, { "/memcached" }) ---- ---- -- issue all the requests at once and wait until they all return ---- local resps = { ngx.location.capture_multi(reqs) } ---- ---- -- loop over the responses table ---- for i, resp in ipairs(resps) do ---- -- process the response table "resp" ---- end ---- ``` ---- ---- The `ngx.location.capture` function is just a special form ---- of this function. Logically speaking, the `ngx.location.capture` can be implemented like this ---- ---- ```lua ---- ngx.location.capture = function (uri, args) ---- return ngx.location.capture_multi({ {uri, args} }) ---- end ---- ``` ---- ---- Please also refer to restrictions on capturing locations configured by subrequest directives of other modules. ---- ----@param args ngx.location.capture.arg[] ----@return ngx.location.capture.response ... -function ngx.location.capture_multi(args) end - - ---- Set, add to, or clear the current request's `HEADER` response header that is to be sent. ---- ---- Underscores (`_`) in the header names will be replaced by hyphens (`-`) by default. This transformation can be turned off via the `lua_transform_underscores_in_response_headers` directive. ---- ---- The header names are matched case-insensitively. ---- ---- ```lua ---- -- equivalent to ngx.header["Content-Type"] = 'text/plain' ---- ngx.header.content_type = 'text/plain'; ---- ---- ngx.header["X-My-Header"] = 'blah blah'; ---- ``` ---- ---- Multi-value headers can be set this way: ---- ---- ```lua ---- ngx.header['Set-Cookie'] = {'a=32; path=/', 'b=4; path=/'} ---- ``` ---- ---- will yield ---- ---- ```bash ---- Set-Cookie: a=32; path=/ ---- Set-Cookie: b=4; path=/ ---- ``` ---- ---- in the response headers. ---- ---- Only Lua tables are accepted (Only the last element in the table will take effect for standard headers such as `Content-Type` that only accept a single value). ---- ---- ```lua ---- ngx.header.content_type = {'a', 'b'} ---- ``` ---- ---- is equivalent to ---- ---- ```lua ---- ngx.header.content_type = 'b' ---- ``` ---- ---- Setting a slot to `nil` effectively removes it from the response headers: ---- ---- ```lua ---- ngx.header["X-My-Header"] = nil; ---- ``` ---- ---- The same applies to assigning an empty table: ---- ---- ```lua ---- ngx.header["X-My-Header"] = {}; ---- ``` ---- ---- Setting `ngx.header.HEADER` after sending out response headers (either explicitly with `ngx.send_headers` or implicitly with `ngx.print` and similar) will log an error message. ---- ---- Reading `ngx.header.HEADER` will return the value of the response header named `HEADER`. ---- ---- Underscores (`_`) in the header names will also be replaced by dashes (`-`) and the header names will be matched case-insensitively. If the response header is not present at all, `nil` will be returned. ---- ---- This is particularly useful in the context of `header_filter_by_lua*`, for example: ---- ---- ```nginx ---- location /test { ---- set $footer ''; ---- ---- proxy_pass http://some-backend; ---- ---- header_filter_by_lua_block { ---- if ngx.header["X-My-Header"] == "blah" then ---- ngx.var.footer = "some value" ---- end ---- } ---- ---- echo_after_body $footer; ---- } ---- ``` ---- ---- For multi-value headers, all of the values of header will be collected in order and returned as a Lua table. For example, response headers ---- ---- Foo: bar ---- Foo: baz ---- ---- will result in ---- ---- ```lua ---- {"bar", "baz"} ---- ``` ---- ---- to be returned when reading `ngx.header.Foo`. ---- ---- Note that `ngx.header` is not a normal Lua table and as such, it is not possible to iterate through it using the Lua `ipairs` function. ---- ---- Note: `HEADER` and `VALUE` will be truncated if they ---- contain the `\r` or `\n` characters. The truncated values ---- will contain all characters up to (and excluding) the first occurrence of ---- `\r` or `\n`. ---- ---- For reading *request* headers, use the `ngx.req.get_headers` function instead. ---- ----@type table<string, string|string[]|nil> -ngx.header = {} - - ---- Parse the http time string (as returned by `ngx.http_time`) into seconds. Returns the seconds or `nil` if the input string is in bad forms. ---- ---- ```lua ---- local time = ngx.parse_http_time("Thu, 18 Nov 2010 11:27:35 GMT") ---- if time == nil then ---- ... ---- end ---- ``` ---- ----@param str string ----@return number? -function ngx.parse_http_time(str) end - - ---- Returns a formated string can be used as the http header time (for example, being used in `Last-Modified` header). The parameter `sec` is the time stamp in seconds (like those returned from `ngx.time`). ---- ---- ```lua ---- ngx.say(ngx.http_time(1290079655)) ---- -- yields "Thu, 18 Nov 2010 11:27:35 GMT" ---- ``` ---- ----@param sec number ----@return string -function ngx.http_time(sec) end - - ---- Sleeps for the specified seconds without blocking. One can specify time resolution up to 0.001 seconds (i.e., one milliseconds). ---- ---- Behind the scene, this method makes use of the NGINX timers. ---- ---- The `0` time argument can also be specified. ---- ----@param seconds number -function ngx.sleep(seconds) end - ---- Forcibly updates the NGINX current time cache. This call involves a syscall and thus has some overhead, so do not abuse it. ---- -function ngx.update_time() end - ---- Returns a floating-point number for the elapsed time in seconds (including milliseconds as the decimal part) from the epoch for the current time stamp from the NGINX cached time (no syscall involved unlike Lua's date library). ---- ---- You can forcibly update the NGINX time cache by calling `ngx.update_time` first. ---- ----@return number -function ngx.now() end - ---- Returns the current time stamp (in the format `yyyy-mm-dd hh:mm:ss`) of the NGINX cached time (no syscall involved unlike Lua's `os.date` function). ---- ----@return string -function ngx.localtime() end - ---- Returns the current time stamp (in the format `yyyy-mm-dd hh:mm:ss`) of the NGINX cached time (no syscall involved unlike Lua's `os.date` function). ---- ----@return string -function ngx.utctime() end - ---- Returns a formatted string can be used as the cookie expiration time. The parameter `sec` is the time stamp in seconds (like those returned from `ngx.time`). ---- ---- ```lua ---- ngx.say(ngx.cookie_time(1290079655)) ---- -- yields "Thu, 18-Nov-10 11:27:35 GMT" ---- ``` ---- ----@param sec number ----@return string -function ngx.cookie_time(sec) end - ---- Returns current date (in the format `yyyy-mm-dd`) from the NGINX cached time (no syscall involved unlike Lua's date library). ---- ---- This uses the local timezone. ---- ----@return string -function ngx.today() end - ---- Returns the elapsed seconds from the epoch for the current time stamp from the NGINX cached time (no syscall involved unlike Lua's date library). ---- ---- Updates of the NGINX time cache can be forced by calling `ngx.update_time` first. ---- ----@return integer -function ngx.time() end - ---- Log arguments concatenated to error.log with the given logging level. ---- ---- Lua `nil` arguments are accepted and result in literal `"nil"` string while Lua booleans result in literal `"true"` or `"false"` string outputs. And the `ngx.null` constant will yield the `"null"` string output. ---- ---- The `level` argument can take constants like `ngx.ERR` and `ngx.WARN`. ---- ---- There is a hard coded `2048` byte limitation on error message lengths in the NGINX core. This limit includes trailing newlines and leading time stamps. If the message size exceeds this limit, NGINX will truncate the message text accordingly. This limit can be manually modified by editing the `NGX_MAX_ERROR_STR` macro definition in the `src/core/ngx_log.h` file in the NGINX source tree. ---- ----@param level ngx.log.level ----@param ... any -function ngx.log(level, ...) end - - ---- Explicitly specify the end of the response output stream. In the case of HTTP 1.1 chunked encoded output, it will just trigger the NGINX core to send out the "last chunk". ---- ---- When you disable the HTTP 1.1 keep-alive feature for your downstream connections, you can rely on well written HTTP clients to close the connection actively for you when you call this method. This trick can be used do back-ground jobs without letting the HTTP clients to wait on the connection, as in the following example: ---- ---- ```nginx ---- location = /async { ---- keepalive_timeout 0; ---- content_by_lua_block { ---- ngx.say("got the task!") ---- ngx.eof() -- well written HTTP clients will close the connection at this point ---- -- access MySQL, PostgreSQL, Redis, Memcached, and etc here... ---- } ---- } ---- ``` ---- ---- But if you create subrequests to access other locations configured by NGINX upstream modules, then you should configure those upstream modules to ignore client connection abortions if they are not by default. For example, by default the standard `ngx_http_proxy_module` will terminate both the subrequest and the main request as soon as the client closes the connection, so it is important to turn on the `proxy_ignore_client_abort` directive in your location block configured by `ngx_http_proxy_module`://nginx.org/en/docs/http/ngx_http_proxy_module.html): ---- ---- ```nginx ---- proxy_ignore_client_abort on; ---- ``` ---- ---- A better way to do background jobs is to use the `ngx.timer.at` API. ---- ---- Returns `1` on success, or returns `nil` and a string describing the error otherwise. ---- ----@return boolean ok ----@return string? error -function ngx.eof() end - ---- Emits arguments concatenated to the HTTP client (as response body). If response headers have not been sent, this function will send headers out first and then output body data. ---- ---- Returns `1` on success, or returns `nil` and a string describing the error otherwise. ---- ---- Lua `nil` values will output `"nil"` strings and Lua boolean values will output `"true"` and `"false"` literal strings respectively. ---- ---- Nested arrays of strings are permitted and the elements in the arrays will be sent one by one: ---- ---- ```lua ---- local table = { ---- "hello, ", ---- {"world: ", true, " or ", false, ---- {": ", nil}} ---- } ---- ngx.print(table) ---- ``` ---- ---- will yield the output ---- ---- ```bash ---- hello, world: true or false: nil ---- ``` ---- ---- Non-array table arguments will cause a Lua exception to be thrown. ---- ---- The `ngx.null` constant will yield the `"null"` string output. ---- ---- This is an asynchronous call and will return immediately without waiting for all the data to be written into the system send buffer. To run in synchronous mode, call `ngx.flush(true)` after calling `ngx.print`. This can be particularly useful for streaming output. See `ngx.flush` for more details. ---- ---- Please note that both `ngx.print` and `ngx.say` will always invoke the whole NGINX output body filter chain, which is an expensive operation. So be careful when calling either of these two in a tight loop; buffer the data yourself in Lua and save the calls. ---- ----@param ... string|string[] ----@return boolean ok ----@return string? error -function ngx.print(...) end - ---- Just as `ngx.print` but also emit a trailing newline. ---- ----@param ... string|string[] ----@return boolean ok ----@return string? error -function ngx.say(...) end - ---- Explicitly send out the response headers. ---- ---- Returns `1` on success, or returns `nil` and a string describing the error otherwise. ---- ---- Note that there is normally no need to manually send out response headers as ngx_lua will automatically send headers out before content is output with `ngx.say` or `ngx.print` or when `content_by_lua*` exits normally. ---- ----@return boolean ok ----@return string? error -function ngx.send_headers() end - ---- Flushes response output to the client. ---- ---- `ngx.flush` accepts an optional boolean `wait` argument (Default: `false`). When called with the default argument, it issues an asynchronous call (Returns immediately without waiting for output data to be written into the system send buffer). Calling the function with the `wait` argument set to `true` switches to synchronous mode. ---- ---- In synchronous mode, the function will not return until all output data has been written into the system send buffer or until the `send_timeout` setting has expired. Note that using the Lua coroutine mechanism means that this function does not block the NGINX event loop even in the synchronous mode. ---- ---- When `ngx.flush(true)` is called immediately after `ngx.print` or `ngx.say`, it causes the latter functions to run in synchronous mode. This can be particularly useful for streaming output. ---- ---- Note that `ngx.flush` is not functional when in the HTTP 1.0 output buffering mode. See `HTTP 1.0 support`. ---- ---- Returns `1` on success, or returns `nil` and a string describing the error otherwise. ---- ----@param wait? boolean ----@return boolean ok ----@return string? error -function ngx.flush(wait) end - ---- NGINX response methods -ngx.resp = {} - ---- Returns a Lua table holding all the current response headers for the current request. ---- ---- ```lua ---- local h, err = ngx.resp.get_headers() ---- ---- if err == "truncated" then ---- -- one can choose to ignore or reject the current response here ---- end ---- ---- for k, v in pairs(h) do ---- ... ---- end ---- ``` ---- ---- This function has the same signature as `ngx.req.get_headers` except getting response headers instead of request headers. ---- ---- Note that a maximum of 100 response headers are parsed by default (including those with the same name) and that additional response headers are silently discarded to guard against potential denial of service attacks. When the limit is exceeded, it will return a second value which is the string `"truncated"`. ---- ----@param max_headers? number ----@param raw? boolean ----@return table<string, string|string[]> ----@return string|'"truncated"' error -function ngx.resp.get_headers(max_headers, raw) end - ----@alias ngx.thread.arg boolean|number|integer|string|lightuserdata|table - ----**syntax:** *ok, res1, res2, ... = ngx.run_worker_thread(threadpool, module_name, func_name, arg1, arg2, ...)* ---- ----**context:** *rewrite_by_lua*, access_by_lua*, content_by_lua** ---- ----**This API is still experimental and may change in the future without notice.** ---- ----**This API is available only for Linux.** ---- ----Wrap the [nginx worker thread](http://nginx.org/en/docs/dev/development_guide.html#threads) to execute lua function. The caller coroutine would yield until the function returns. ---- ----Only the following ngx_lua APIs could be used in `function_name` function of the `module` module: ---- ----* `ngx.encode_base64` ----* `ngx.decode_base64` ---- ----* `ngx.hmac_sha1` ----* `ngx.encode_args` ----* `ngx.decode_args` ----* `ngx.quote_sql_str` ---- ----* `ngx.re.match` ----* `ngx.re.find` ----* `ngx.re.gmatch` ----* `ngx.re.sub` ----* `ngx.re.gsub` ---- ----* `ngx.crc32_short` ----* `ngx.crc32_long` ----* `ngx.hmac_sha1` ----* `ngx.md5_bin` ----* `ngx.md5` ---- ----* `ngx.config.subsystem` ----* `ngx.config.debug` ----* `ngx.config.prefix` ----* `ngx.config.nginx_version` ----* `ngx.config.nginx_configure` ----* `ngx.config.ngx_lua_version` ---- ---- ----The first argument `threadpool` specifies the Nginx thread pool name defined by [thread_pool](https://nginx.org/en/docs/ngx_core_module.html#thread_pool). ---- ----The second argument `module_name` specifies the lua module name to execute in the worker thread, which would return a lua table. The module must be inside the package path, e.g. ---- ----```nginx ---- ----lua_package_path '/opt/openresty/?.lua;;'; ----``` ---- ----The third argument `func_name` specifies the function field in the module table as the second argument. ---- ----The type of `arg`s must be one of type below: ---- ----* boolean ----* number ----* string ----* nil ----* table (the table may be recursive, and contains members of types above.) ---- ----The `ok` is in boolean type, which indicate the C land error (failed to get thread from thread pool, pcall the module function failed, .etc). If `ok` is `false`, the `res1` is the error string. ---- ----The return values (res1, ...) are returned by invocation of the module function. Normally, the `res1` should be in boolean type, so that the caller could inspect the error. ---- ----This API is useful when you need to execute the below types of tasks: ---- ----* CPU bound task, e.g. do md5 calculation ----* File I/O task ----* Call `os.execute()` or blocking C API via `ffi` ----* Call external Lua library not based on cosocket or nginx ---- ----Example1: do md5 calculation. ---- ----```nginx ---- ----location /calc_md5 { ---- default_type 'text/plain'; ---- ---- content_by_lua_block { ---- local ok, md5_or_err = ngx.run_worker_thread("testpool", "md5", "md5") ---- ngx.say(ok, " : ", md5_or_err) ---- } ---- } ----``` ---- ----`md5.lua` ---- ----```lua ----local function md5() ---- return ngx.md5("hello") ----end ----``` ---- ----Example2: write logs into the log file. ---- ----```nginx ---- ----location /write_log_file { ---- default_type 'text/plain'; ---- ---- content_by_lua_block { ---- local ok, err = ngx.run_worker_thread("testpool", "write_log_file", "log", ngx.var.arg_str) ---- if not ok then ---- ngx.say(ok, " : ", err) ---- return ---- end ---- ngx.say(ok) ---- } ---- } ----``` ---- ----`write_log_file.lua` ---- ----```lua ---- ---- local function log(str) ---- local file, err = io.open("/tmp/tmp.log", "a") ---- if not file then ---- return false, err ---- end ---- file:write(str) ---- file:flush() ---- file:close() ---- return true ---- end ---- return {log=log} ----``` ---- ----@param threadpool string ----@param module_name string ----@param func_name string ----@param arg1? ngx.thread.arg ----@param arg2? ngx.thread.arg ----@param ... ngx.thread.arg ----@return boolean ok ----@return ngx.thread.arg? result_or_error ----@return any ... -function ngx.run_worker_thread(threadpool, module_name, func_name, arg1, arg2, ...) -end - -return ngx diff --git a/meta/3rd/OpenResty/library/ngx/balancer.lua b/meta/3rd/OpenResty/library/ngx/balancer.lua deleted file mode 100644 index 6a103a26..00000000 --- a/meta/3rd/OpenResty/library/ngx/balancer.lua +++ /dev/null @@ -1,118 +0,0 @@ ----@meta -local balancer = { - version = require("resty.core.base").version, -} - ---- Sets the peer address (host and port) for the current backend query (which ---- may be a retry). ---- ---- Domain names in host do not make sense. You need to use OpenResty libraries ---- like lua-resty-dns to obtain IP address(es) from all the domain names before ---- entering the `balancer_by_lua*` handler (for example, you can perform DNS ---- lookups in an earlier phase like `access_by_lua*` and pass the results to the ---- `balancer_by_lua*` handler via `ngx.ctx`. ---- ----@param addr string ----@param port integer ----@return boolean ok ----@return string? error -function balancer.set_current_peer(addr, port) end - - ---- Sets the upstream timeout (connect, send and read) in seconds for the ---- current and any subsequent backend requests (which might be a retry). ---- ---- If you want to inherit the timeout value of the global nginx.conf ---- configuration (like `proxy_connect_timeout`), then just specify the nil value ---- for the corresponding argument (like the `connect_timeout` argument). ---- ---- Zero and negative timeout values are not allowed. ---- ---- You can specify millisecond precision in the timeout values by using floating ---- point numbers like 0.001 (which means 1ms). ---- ---- Note: `send_timeout` and `read_timeout` are controlled by the same config ---- `proxy_timeout` for `ngx_stream_proxy_module`. To keep API compatibility, this ---- function will use `max(send_timeout, read_timeout)` as the value for setting ---- proxy_timeout. ---- ---- Returns `true` when the operation is successful; returns `nil` and a string ---- describing the error otherwise. ---- ---- This only affects the current downstream request. It is not a global change. ---- ---- For the best performance, you should use the OpenResty bundle. ---- ----@param connect_timeout? number ----@param send_timeout? number ----@param read_timeout? number ----@return boolean ok ----@return string? error -function balancer.set_timeouts(connect_timeout, send_timeout, read_timeout) end - ----@alias ngx.balancer.failure ----| '"next"' # Failures due to bad status codes sent from the backend server. The origin's response is same though, which means the backend connection can still be reused for future requests. ----| '"failed"' Fatal errors while communicating to the backend server (like connection timeouts, connection resets, and etc). In this case, the backend connection must be aborted and cannot get reused. - ---- Retrieves the failure details about the previous failed attempt (if any) when ---- the next_upstream retrying mechanism is in action. When there was indeed a ---- failed previous attempt, it returned a string describing that attempt's state ---- name, as well as an integer describing the status code of that attempt. ---- ---- Possible status codes are those HTTP error status codes like 502 and 504. ---- ---- For stream module, `status_code` will always be 0 (`ngx.OK`) and is provided ---- for compatibility reasons. ---- ---- When the current attempt is the first attempt for the current downstream ---- request (which means there is no previous attempts at all), this method ---- always returns a single `nil` value. ---- ----@return ngx.balancer.failure? state_name ----@return integer? status_code -function balancer.get_last_failure() end - ---- Sets the tries performed when the current attempt (which may be a retry) ---- fails (as determined by directives like proxy_next_upstream, depending on ---- what particular nginx uptream module you are currently using). --- ---- Note that the current attempt is excluded in the count number set here. ---- ---- Please note that, the total number of tries in a single downstream request ---- cannot exceed the hard limit configured by directives like ---- `proxy_next_upstream_tries`, depending on what concrete NGINX upstream ---- module you are using. When exceeding this limit, the count value will get ---- reduced to meet the limit and the second return value will be the string ---- "reduced tries due to limit", which is a warning, while the first return ---- value is still a `true` value. ---- ----@param count integer ----@return boolean ok ----@return string? error -function balancer.set_more_tries(count) end - ---- Recreates the request buffer for sending to the upstream server. ---- ---- This is useful, for example if you want to change a request header field ---- to the new upstream server on balancer retries. ---- ---- Normally this does not work because the request buffer is created once ---- during upstream module initialization and won't be regenerated for subsequent ---- retries. However you can use `proxy_set_header My-Header $my_header` and ---- set the `ngx.var.my_header` variable inside the balancer phase. Calling ---- `recreate_request()` after updating a header field will cause the request ---- buffer to be re-generated and the `My-Header` header will thus contain the ---- new value. ---- ---- Warning: because the request buffer has to be recreated and such allocation ---- occurs on the request memory pool, the old buffer has to be thrown away and ---- will only be freed after the request finishes. Do not call this function too ---- often or memory leaks may be noticeable. Even so, a call to this function ---- should be made only if you know the request buffer must be regenerated, ---- instead of unconditionally in each balancer retries. ---- ----@return boolean ok ----@return string? error -function balancer.recreate_request() end - -return balancer
\ No newline at end of file diff --git a/meta/3rd/OpenResty/library/ngx/base64.lua b/meta/3rd/OpenResty/library/ngx/base64.lua deleted file mode 100644 index 5f8184d5..00000000 --- a/meta/3rd/OpenResty/library/ngx/base64.lua +++ /dev/null @@ -1,21 +0,0 @@ ----@meta -local base64 = { - version = require("resty.core.base").version, -} - ----Encode input using base64url rules. Returns the encoded string. ----@param s string ----@return string -function base64.encode_base64url(s) end - ----Decode input using base64url rules. Returns the decoded string. ---- ----If the input is not a valid base64url encoded string, decoded will be `nil` ----and err will be a string describing the error. ---- ----@param s string ----@return string? decoded ----@return string? err -function base64.decode_base64url(s) end - -return base64
\ No newline at end of file diff --git a/meta/3rd/OpenResty/library/ngx/errlog.lua b/meta/3rd/OpenResty/library/ngx/errlog.lua deleted file mode 100644 index ace384a0..00000000 --- a/meta/3rd/OpenResty/library/ngx/errlog.lua +++ /dev/null @@ -1,122 +0,0 @@ ----@meta -local errlog = { - version = require("resty.core.base").version, -} - ---- Return the nginx core's error log filter level (defined via the `error_log` configuration directive in nginx.conf) as an integer value. ----@return ngx.log.level -function errlog.get_sys_filter_level() end - - ---- Specifies the filter log level, only to capture and buffer the error logs with a log level no lower than the specified level. ---- ---- If we don't call this API, all of the error logs will be captured by default. ---- ---- In case of error, `nil` will be returned as well as a string describing the error. ---- ---- This API should always work with directive `lua_capture_error_log`. ---- ----@param level ngx.log.level ----@return boolean ok ----@return string? err -function errlog.set_filter_level(level) end - - ---- Fetches the captured nginx error log messages if any in the global data buffer specified by ngx_lua's `lua_capture_error_log` directive. Upon return, this Lua function also removes those messages from that global capturing buffer to make room for future new error log data. ---- ---- In case of error, nil will be returned as well as a string describing the error. ---- ---- The optional max argument is a number that when specified, will prevent `get_logs()` from adding more than max messages to the res array. ---- ----```lua ---- for i = 1, 20 do ---- ngx.log(ngx.ERR, "test") ---- end ---- ---- local errlog = require "ngx.errlog" ---- local res = errlog.get_logs(10) ---- -- the number of messages in the `res` table is 10 and the `res` table ---- -- has 30 elements. ----``` ---- ---- The resulting table has the following structure: ---- ----``` ---- { level1, time1, msg1, level2, time2, msg2, ... } ----``` ---- ---- The levelX values are constants defined below: ---- ---- https://github.com/openresty/lua-nginx-module/#nginx-log-level-constants ---- ---- The timeX values are UNIX timestamps in seconds with millisecond precision. The sub-second part is presented as the decimal part. The time format is exactly the same as the value returned by ngx.now. It is also subject to NGINX core's time caching. ---- ---- The msgX values are the error log message texts. ---- ---- So to traverse this array, the user can use a loop like this: ---- ----```lua ---- ---- for i = 1, #res, 3 do ---- local level = res[i] ---- if not level then ---- break ---- end ---- ---- local time = res[i + 1] ---- local msg = res[i + 2] ---- ---- -- handle the current message with log level in `level`, ---- -- log time in `time`, and log message body in `msg`. ---- end ----``` ---- ---- Specifying max <= 0 disables this behavior, meaning that the number of results won't be limited. ---- ---- The optional 2th argument res can be a user-supplied Lua table to hold the result instead of creating a brand new table. This can avoid unnecessary table dynamic allocations on hot Lua code paths. It is used like this: ---- ----```lua ---- local errlog = require "ngx.errlog" ---- local new_tab = require "table.new" ---- ---- local buffer = new_tab(100 * 3, 0) -- for 100 messages ---- ---- local errlog = require "ngx.errlog" ---- local res, err = errlog.get_logs(0, buffer) ---- if res then ---- -- res is the same table as `buffer` ---- for i = 1, #res, 3 do ---- local level = res[i] ---- if not level then ---- break ---- end ---- local time = res[i + 1] ---- local msg = res[i + 2] ---- ... ---- end ---- end ----``` ---- ---- When provided with a res table, `get_logs()` won't clear the table for performance reasons, but will rather insert a trailing nil value after the last table element. ---- ---- When the trailing nil is not enough for your purpose, you should clear the table yourself before feeding it into the `get_logs()` function. ---- ----@param max number ----@param res? table ----@return table? res ----@return string? err -function errlog.get_logs(max, res) end - ---- Log msg to the error logs with the given logging level. ---- ---- Just like the ngx.log API, the log_level argument can take constants like ngx.ERR and ngx.WARN. Check out Nginx log level constants for details. ---- ---- However, unlike the ngx.log API which accepts variadic arguments, this function only accepts a single string as its second argument msg. ---- ---- This function differs from ngx.log in the way that it will not prefix the written logs with any sort of debug information (such as the caller's file and line number). ----@param level ngx.log.level ----@param msg string -function errlog.raw_log(level, msg) end - - -return errlog
\ No newline at end of file diff --git a/meta/3rd/OpenResty/library/ngx/ocsp.lua b/meta/3rd/OpenResty/library/ngx/ocsp.lua deleted file mode 100644 index 79e001f1..00000000 --- a/meta/3rd/OpenResty/library/ngx/ocsp.lua +++ /dev/null @@ -1,61 +0,0 @@ ----@meta -local ocsp = { - version = require("resty.core.base").version, -} - ---- Extracts the OCSP responder URL (like "http://test.com/ocsp/") from the SSL server certificate chain in the DER format. ---- ---- Usually the SSL server certificate chain is originally formatted in PEM. You can use the Lua API provided by the ngx.ssl module to do the PEM to DER conversion. ---- ---- The optional max_len argument specifies the maximum length of OCSP URL allowed. This determines the buffer size; so do not specify an unnecessarily large value here. It defaults to the internal string buffer size used throughout this lua-resty-core library (usually default to 4KB). ---- ---- In case of failures, returns `nil` and a string describing the error. ---- ----@param der_cert_chain string ----@param max_len? number ----@return string? ocsp_url ----@return string? error -function ocsp.get_ocsp_responder_from_der_chain(der_cert_chain, max_len) end - ---- Validates the raw OCSP response data specified by the `ocsp_resp` argument using the SSL server certificate chain in DER format as specified in the `der_cert_chain` argument. ---- ---- Returns true when the validation is successful. ---- ---- In case of failures, returns `nil` and a string describing the failure. The maximum length of the error string is controlled by the optional `max_err_msg` argument (which defaults to the default internal string buffer size used throughout this lua-resty-core library, usually being 4KB). ---- ----@param ocsp_resp string ----@param der_cert_chain string ----@param max_err_msg_len? number ----@return boolean ok ----@return string? error -function ocsp.validate_ocsp_response(ocsp_resp, der_cert_chain, max_err_msg_len) end - ---- Builds an OCSP request from the SSL server certificate chain in the DER format, which can be used to send to the OCSP server for validation. ---- ---- The optional `max_len` argument specifies the maximum length of the OCSP request allowed. This value determines the size of the internal buffer allocated, so do not specify an unnecessarily large value here. It defaults to the internal string buffer size used throughout this lua-resty-core library (usually defaults to 4KB). ---- ---- In case of failures, returns `nil` and a string describing the error. ---- ---- The raw OCSP response data can be used as the request body directly if the POST method is used for the OCSP request. But for GET requests, you need to do base64 encoding and then URL encoding on the data yourself before appending it to the OCSP URL obtained by the `get_ocsp_responder_from_der_chain()` function. ---- ----@param der_cert_chain string ----@param max_len? number ----@return string? ocsp_req ----@return string? error -function ocsp.create_ocsp_request(der_cert_chain, max_len) end - - ---- Sets the OCSP response as the OCSP stapling for the current SSL connection. ---- ---- Returns `true` in case of successes. If the SSL client does not send a "status request" at all, then this method still returns true but also with a string as the warning "no status req". ---- ---- In case of failures, returns `nil` and a string describing the error. ---- ---- The OCSP response is returned from CA's OCSP server. See the `create_ocsp_request()` function for how to create an OCSP request and also validate_ocsp_response for how to validate the OCSP response. ---- ----@param ocsp_resp string ----@return boolean ok ----@return string? error -function ocsp.set_ocsp_status_resp(ocsp_resp) end - -return ocsp
\ No newline at end of file diff --git a/meta/3rd/OpenResty/library/ngx/pipe.lua b/meta/3rd/OpenResty/library/ngx/pipe.lua deleted file mode 100644 index c0190e3a..00000000 --- a/meta/3rd/OpenResty/library/ngx/pipe.lua +++ /dev/null @@ -1,312 +0,0 @@ ----@meta -local pipe={} -pipe._gc_ref_c_opt="-c" - -pipe.version = require("resty.core.base").version - ---- Creates and returns a new sub-process instance we can communicate with later. ---- ---- For example: ---- ----```lua ---- local ngx_pipe = require "ngx.pipe" ---- local proc, err = ngx_pipe.spawn({"sh", "-c", "sleep 0.1 && exit 2"}) ---- if not proc then ---- ngx.say(err) ---- return ---- end ----``` ---- ---- In case of failure, this function returns nil and a string describing the error. ---- ---- The sub-process will be killed via SIGKILL if it is still alive when the instance is collected by the garbage collector. ---- ---- Note that args should either be a single level array-like Lua table with string values, or just a single string. ---- ---- Some more examples: ---- ----```lua ---- local proc, err = ngx_pipe.spawn({"ls", "-l"}) ---- ---- local proc, err = ngx_pipe.spawn({"perl", "-e", "print 'hello, wolrd'"}) ---- ----``` ---- ---- If args is specified as a string, it will be executed by the operating system shell, just like os.execute. The above example could thus be rewritten as: ---- ----```lua ---- local ngx_pipe = require "ngx.pipe" ---- local proc, err = ngx_pipe.spawn("sleep 0.1 && exit 2") ---- if not proc then ---- ngx.say(err) ---- return ---- end ----``` ---- ---- In the shell mode, you should be very careful about shell injection attacks when interpolating variables into command string, especially variables from untrusted sources. Please make sure that you escape those variables while assembling the command string. For this reason, it is highly recommended to use the multi-arguments form (args as a table) to specify each command-line argument explicitly. ---- ---- Since by default, Nginx does not pass along the PATH system environment variable, you will need to configure the env PATH directive if you wish for it to be respected during the searching of sub-processes: ---- ----```nginx ---- env PATH; ---- ... ---- content_by_lua_block { ---- local ngx_pipe = require "ngx.pipe" ---- ---- local proc = ngx_pipe.spawn({'ls'}) ---- } ----``` ---- ---- The optional table argument opts can be used to control the behavior of spawned processes. For instance: ---- ----```lua ---- local opts = { ---- merge_stderr = true, ---- buffer_size = 256, ---- environ = {"PATH=/tmp/bin", "CWD=/tmp/work"} ---- } ---- local proc, err = ngx_pipe.spawn({"sh", "-c", ">&2 echo data"}, opts) ---- if not proc then ---- ngx.say(err) ---- return ---- end ----``` ---- ---- ----@param args string[]|string ----@param opts? ngx.pipe.spawn.opts ----@return ngx.pipe.proc? proc ----@return string? error -function pipe.spawn(args, opts) end - - ---- Options for ngx.pipe.spawn() ---- ----@class ngx.pipe.spawn.opts : table ---- ---- when set to true, the output to stderr will be redirected to stdout in the spawned process. This is similar to doing 2>&1 in a shell. ----@field merge_stderr boolean ---- ---- specifies the buffer size used by reading operations, in bytes. The default buffer size is 4096. ----@field buffer_size number ---- ---- specifies environment variables for the spawned process. The value must be a single-level, array-like Lua table with string values. ----@field environ string[] ---- ---- specifies the write timeout threshold, in milliseconds. The default threshold is 10000. If the threshold is 0, the write operation will never time out. ----@field write_timeout number ---- ---- specifies the stdout read timeout threshold, in milliseconds. The default threshold is 10000. If the threshold is 0, the stdout read operation will never time out. ----@field stdout_read_timeout number ---- ---- specifies the stderr read timeout threshold, in milliseconds. The default threshold is 10000. If the threshold is 0, the stderr read operation will never time out. ----@field stderr_read_timeout number ---- ---- specifies the wait timeout threshold, in milliseconds. The default threshold is 10000. If the threshold is 0, the wait operation will never time out. ----@field wait_timeout number - - ----@class ngx.pipe.proc : table -local proc = {} - ---- Respectively sets: the write timeout threshold, stdout read timeout threshold, stderr read timeout threshold, and wait timeout threshold. All timeouts are in milliseconds. ---- ---- The default threshold for each timeout is 10 seconds. ---- ---- If the specified timeout argument is `nil`, the corresponding timeout threshold will not be changed. For example: ---- ----```lua ---- local proc, err = ngx_pipe.spawn({"sleep", "10s"}) ---- ---- -- only change the wait_timeout to 0.1 second. ---- proc:set_timeouts(nil, nil, nil, 100) ---- ---- -- only change the send_timeout to 0.1 second. ---- proc:set_timeouts(100) ----``` ---- ---- If the specified timeout argument is 0, the corresponding operation will never time out. ---- ----@param write_timeout? number ----@param stdout_read_timeout? number ----@param stderr_read_timeout? number ----@param wait_timeout? number -function proc:set_timeouts(write_timeout, stdout_read_timeout, stderr_read_timeout, wait_timeout) end - ---- Waits until the current sub-process exits. ---- ---- It is possible to control how long to wait via set_timeouts. The default timeout is 10 seconds. ---- ---- If process exited with status code zero, the ok return value will be true. ---- ---- If process exited abnormally, the ok return value will be false. ---- ---- The second return value, reason, will be a string. Its values may be: ---- ---- exit: the process exited by calling exit(3), _exit(2), or by returning from main(). In this case, status will be the exit code. ---- signal: the process was terminated by a signal. In this case, status will be the signal number. ---- ---- Note that only one light thread can wait on a process at a time. If another light thread tries to wait on a process, the return values will be `nil` and the error string "pipe busy waiting". ---- ---- If a thread tries to wait an exited process, the return values will be `nil` and the error string "exited". ---- ----@return boolean ok ----@return '"exit"'|'"signal"' reason ----@return number status -function proc:wait() end - - ---- Returns the pid number of the sub-process. ----@return number pid -function proc:pid() end - - ---- Sends a signal to the sub-process. ---- ---- Note that the signum argument should be signal's numerical value. If the specified signum is not a number, an error will be thrown. ---- ---- You should use lua-resty-signal's `signum()` function to convert signal names to signal numbers in order to ensure portability of your application. ---- ---- In case of success, this method returns true. Otherwise, it returns `nil` and a string describing the error. ---- ---- Killing an exited sub-process will return `nil` and the error string "exited". ---- ---- Sending an invalid signal to the process will return `nil` and the error string "invalid signal". ---- ----@param signum integer ----@return boolean ok ----@return string? error -function proc:kill(signum) end - ----Closes the specified direction of the current sub-process. ---- ----The direction argument should be one of these three values: stdin, stdout and stderr. ---- ----In case of success, this method returns true. Otherwise, it returns `nil` and a string describing the error. ---- ----If the `merge_stderr` option is specified in spawn, closing the stderr direction will return `nil` and the error string "merged to stdout". ---- ----Shutting down a direction when a light thread is waiting on it (such as during reading or writing) will abort the light thread and return true. ---- ----Shutting down directions of an exited process will return `nil` and the error string "closed". ---- ----It is fine to shut down the same direction of the same stream multiple times; no side effects are to be expected. ---- ----@param direction '"stdin"'|'"stdout"'|'"stderr"' ----@return boolean ok ----@return string? error -function proc:shutdown(direction) end - ---- Writes data to the current sub-process's stdin stream. ---- ---- The data argument can be a string or a single level array-like Lua table with string values. ---- ---- This method is a synchronous and non-blocking operation that will not return until all the data has been flushed to the sub-process's stdin buffer, or an error occurs. ---- ---- In case of success, it returns the total number of bytes that have been sent. Otherwise, it returns `nil` and a string describing the error. ---- ---- The timeout threshold of this write operation can be controlled by the `set_timeouts` method. The default timeout threshold is 10 seconds. ---- ---- When a timeout occurs, the data may be partially written into the sub-process's stdin buffer and read by the sub-process. ---- ---- Only one light thread is allowed to write to the sub-process at a time. If another light thread tries to write to it, this method will return `nil` and the error string "pipe busy writing". ---- ---- If the write operation is aborted by the shutdown method, it will return `nil` and the error string "aborted". ---- ---- Writing to an exited sub-process will return `nil` and the error string "closed". ---- ----@param data string ----@return integer? nbytes ----@return string? error -function proc:write(data) end - ---- Reads all data from the current sub-process's stderr stream until it is closed. ---- ---- This method is a synchronous and non-blocking operation, just like the write method. ---- ---- The timeout threshold of this reading operation can be controlled by `set_timeouts`. The default timeout is 10 seconds. ---- ---- In case of success, it returns the data received. Otherwise, it returns three values: `nil`, a string describing the error, and, optionally, the partial data received so far. ---- ---- When `merge_stderr` is specified in spawn, calling `stderr_read_all` will return `nil` and the error string "merged to stdout". ---- ---- Only one light thread is allowed to read from a sub-process's stderr or stdout stream at a time. If another thread tries to read from the same stream, this method will return `nil` and the error string "pipe busy reading". ---- ---- If the reading operation is aborted by the shutdown method, it will return `nil` and the error string "aborted". ---- ---- Streams for stdout and stderr are separated, so at most two light threads may be reading from a sub-process at a time (one for each stream). ---- ---- The same way, a light thread may read from a stream while another light thread is writing to the sub-process stdin stream. ---- ---- Reading from an exited process's stream will return `nil` and the error string "closed". ---- ----@return string? data ----@return string? error ----@return string? partial -function proc:stderr_read_all() end - ---- Similar to the `stderr_read_all` method, but reading from the stdout stream of the sub-process. ----@return string? data ----@return string? error ----@return string? partial -function proc:stdout_read_all() end - ---- Reads from stderr like `stderr_read_all`, but only reads a single line of data. ---- ---- When `merge_stderr` is specified in spawn, calling `stderr_read_line` will return `nil` plus the error string "merged to stdout". ---- ---- When the data stream is truncated without a new-line character, it returns 3 values: `nil`, the error string "closed", and the partial data received so far. ---- ---- The line should be terminated by a Line Feed (LF) character (ASCII 10), optionally preceded by a Carriage Return (CR) character (ASCII 13). The CR and LF characters are not included in the returned line data. ----@return string? data ----@return string? error ----@return string? partial -function proc:stderr_read_line() end - ---- Similar to `stderr_read_line`, but reading from the stdout stream of the sub-process. ----@return string? data ----@return string? error ----@return string? partial -function proc:stdout_read_line() end - ---- Reads from stderr like `stderr_read_all`, but only reads the specified number of bytes. ---- ---- If `merge_stderr` is specified in spawn, calling `stderr_read_bytes` will return `nil` plus the error string "merged to stdout". ---- ---- If the data stream is truncated (fewer bytes of data available than requested), this method returns 3 values: `nil`, the error string "closed", and the partial data string received so far. ---- ----@param len number ----@return string? data ----@return string? error ----@return string? partial -function proc:stderr_read_bytes(len) end - ---- Similar to `stderr_read_bytes`, but reading from the stdout stream of the sub-process. ---- ----@param len number ----@return string? data ----@return string? error ----@return string? partial -function proc:stdout_read_bytes(len) end - - ---- Reads from stderr like `stderr_read_all`, but returns immediately when any amount of data is received. ---- ---- At most max bytes are received. ---- ---- If `merge_stderr` is specified in spawn, calling `stderr_read_any` will return `nil` plus the error string "merged to stdout". ---- ---- If the received data is more than `max` bytes, this method will return with exactly `max` bytes of data. The remaining data in the underlying receive buffer can be fetched with a subsequent reading operation. ----@param max number ----@return string? data ----@return string? error -function proc:stderr_read_any(max) end - ---- Similar to `stderr_read_any`, but reading from the stdout stream of the sub-process. ---- ----@param max number ----@return string? data ----@return string? error -function proc:stdout_read_any(max) end - -return pipe
\ No newline at end of file diff --git a/meta/3rd/OpenResty/library/ngx/process.lua b/meta/3rd/OpenResty/library/ngx/process.lua deleted file mode 100644 index 3a2e424e..00000000 --- a/meta/3rd/OpenResty/library/ngx/process.lua +++ /dev/null @@ -1,52 +0,0 @@ ----@meta -local process = { - version = require("resty.core.base").version, -} - ---- Returns a number value for the nginx master process's process ID (or PID). ---- ----@return integer? pid -function process.get_master_pid() end - - ---- Enables the privileged agent process in Nginx. ---- ---- The privileged agent process does not listen on any virtual server ports ---- like those worker processes. And it uses the same system account as the ---- nginx master process, which is usually a privileged account like root. ---- ---- The `init_worker_by_lua*` directive handler still runs in the privileged ---- agent process. And one can use the `type()` function provided by this module ---- to check if the current process is a privileged agent. ---- ---- In case of failures, returns `nil` and a string describing the error. ---- ----@param connections integer sets the maximum number of simultaneous connections that can be opened by the privileged agent process. ----@return boolean ok ----@return string? error -function process.enable_privileged_agent(connections) end - - ----@alias ngx.process.type ----| '"master"' # the NGINX master process ----| '"worker"' # an NGINX worker process ----| '"privileged agent"' # the NGINX privileged agent process ----| '"single"' # returned when Nginx is running in the single process mode ----| '"signaller"' # returned when Nginx is running as a signaller process - ---- Returns the type of the current NGINX process. ---- ----@return ngx.process.type type -function process.type() end - - ---- Signals the current NGINX worker process to quit gracefully, after all the ---- timers have expired (in time or expired prematurely). ---- ---- Note that this API function simply sets the nginx global C variable ---- `ngx_quit` to signal the nginx event loop directly. No UNIX signals or IPC ---- are involved here. -function process.signal_graceful_exit() end - - -return process
\ No newline at end of file diff --git a/meta/3rd/OpenResty/library/ngx/re.lua b/meta/3rd/OpenResty/library/ngx/re.lua deleted file mode 100644 index 826d9b3d..00000000 --- a/meta/3rd/OpenResty/library/ngx/re.lua +++ /dev/null @@ -1,102 +0,0 @@ ----@meta -local re={} - -re.version = require("resty.core.base").version - ---- Allows changing of regex settings. Currently, it can only change the `jit_stack_size` of the PCRE engine, like so: ---- ----```nginx ---- init_by_lua_block { require "ngx.re".opt("jit_stack_size", 200 * 1024) } ---- ---- server { ---- location /re { ---- content_by_lua_block { ---- -- full regex and string are taken from https://github.com/JuliaLang/julia/issues/8278 ---- local very_long_string = [[71.163.72.113 - - [30/Jul/2014:16:40:55 -0700] ...]] ---- local very_complicated_regex = [[([\d\.]+) ([\w.-]+) ([\w.-]+) (\[.+\]) ...]] ---- local from, to, err = ngx.re.find(very_long_string, very_complicated_regex, "jo") ---- ---- -- with the regular jit_stack_size, we would get the error 'pcre_exec() failed: -27' ---- -- instead, we get a match ---- ngx.print(from .. "-" .. to) -- prints '1-1563' ---- } ---- } ---- } ----``` ---- ---- The `jit_stack_size` cannot be set to a value lower than PCRE's default of 32K. ---- ----@param option string '"jit_stack_size"' ----@param value any -function re.opt(option, value) end - ---- Splits the subject string using the Perl compatible regular expression regex with the optional options. ---- ---- This function returns a Lua (array) table (with integer keys) containing the split values. ---- ---- In case of error, `nil` will be returned as well as a string describing the error. ---- ---- When regex contains a sub-match capturing group, and when such a match is found, the first submatch capture will be inserted in between each split value, like so: ---- ----```lua ---- local ngx_re = require "ngx.re" ---- ---- local res, err = ngx_re.split("a,b,c,d", "(,)") ---- -- res is now {"a", ",", "b", ",", "c", ",", "d"} ----``` ---- ---- When regex is empty string "", the subject will be split into chars, like so: ---- ----```lua ---- local ngx_re = require "ngx.re" ---- ---- local res, err = ngx_re.split("abcd", "") ---- -- res is now {"a", "b", "c", "d"} ----``` ---- ---- The optional max argument is a number that when specified, will prevent `split()` from adding more than max matches to the res array: ---- ----```lua ---- local ngx_re = require "ngx.re" ---- ---- local res, err = ngx_re.split("a,b,c,d", ",", nil, nil, 3) ---- -- res is now {"a", "b", "c,d"} ----``` ---- ---- Specifying max <= 0 disables this behavior, meaning that the number of results won't be limited. ---- ---- The optional 6th argument res can be a table that `split()` will re-use to hold the results instead of creating a new one, which can improve performance in hot code paths. It is used like so: ---- ----```lua ---- local ngx_re = require "ngx.re" ---- ---- local my_table = {"hello world"} ---- ---- local res, err = ngx_re.split("a,b,c,d", ",", nil, nil, nil, my_table) ---- -- res/my_table is now {"a", "b", "c", "d"} ----``` ---- ---- When provided with a res table, `split()` won't clear the table for performance reasons, but will rather insert a trailing `nil` value when the split is completed: ---- ----```lua ---- local ngx_re = require "ngx.re" ---- ---- local my_table = {"W", "X", "Y", "Z"} ---- ---- local res, err = ngx_re.split("a,b", ",", nil, nil, nil, my_table) ---- -- res/my_table is now {"a", "b", nil, "Z"} ----``` ---- ---- When the trailing `nil` is not enough for your purpose, you should clear the table yourself before feeding it into the split function. ---- ----@param subj string ----@param regex string ----@param opts? ngx.re.options ----@param ctx? ngx.re.ctx ----@param max? number ----@param res? string[] ----@return string[]? res ----@return string? error -function re.split(subj, regex, opts, ctx, max, res) end - -return re
\ No newline at end of file diff --git a/meta/3rd/OpenResty/library/ngx/req.lua b/meta/3rd/OpenResty/library/ngx/req.lua deleted file mode 100644 index 7bf14494..00000000 --- a/meta/3rd/OpenResty/library/ngx/req.lua +++ /dev/null @@ -1,16 +0,0 @@ ----@meta -local req = {} - -req.version = require("resty.core.base").version - ----This method adds the specified header and its value to the current request. It works similarly as ngx.req.set_header, with the exception that when the header already exists, the specified value(s) will be appended instead of overriden. ---- ----When the specified `header_name` is a builtin header (e.g. User-Agent), this method will override its values. ---- ----The `header_value` argument can either be a string or a non-empty, array-like table. A nil or empty table value will cause this function to throw an error. ---- ----@param header_name string must be a non-empty string. ----@param header_value string|string[] -function req.add_header(header_name, header_value) end - -return req diff --git a/meta/3rd/OpenResty/library/ngx/resp.lua b/meta/3rd/OpenResty/library/ngx/resp.lua deleted file mode 100644 index c2de299a..00000000 --- a/meta/3rd/OpenResty/library/ngx/resp.lua +++ /dev/null @@ -1,23 +0,0 @@ ----@meta -local resp={} - -resp.version = require("resty.core.base").version - ---- This function adds specified header with corresponding value to the response of current request. ---- ---- The `header_value` could be either a string or a table. ---- ---- The ngx.resp.add_header works mostly like: ---- ---- `ngx.header.HEADER` ---- Nginx's `add_header` directive. ---- ---- However, unlike `ngx.header.HEADER`, this method appends new header to the old one instead of overriding it. ---- ---- Unlike `add_header` directive, this method will override the builtin header instead of appending it. ---- ----@param key string ----@param value string|string[] -function resp.add_header(key, value) end - -return resp
\ No newline at end of file diff --git a/meta/3rd/OpenResty/library/ngx/semaphore.lua b/meta/3rd/OpenResty/library/ngx/semaphore.lua deleted file mode 100644 index cd5c7586..00000000 --- a/meta/3rd/OpenResty/library/ngx/semaphore.lua +++ /dev/null @@ -1,66 +0,0 @@ ----@meta - ----@class ngx.semaphore ---- sem is the internal c handler ----@field sem userdata -local semaphore = { - version = require("resty.core.base").version, -} - ----Creates and returns a new semaphore instance. ---- ----@param n? integer the number of resources the semaphore will begin with (default 0) ----@return ngx.semaphore? semaphore ----@return string? error -function semaphore.new(n) end - - ---- Returns the number of resources readily available in the sema semaphore ---- instance (if any). ---- ---- When the returned number is negative, it means the number of "light threads" ---- waiting on this semaphore. ---- ----@return integer count -function semaphore:count() end - - ---- Requests a resource from the semaphore instance. ---- ---- Returns `true` immediately when there is resources available for the current ---- running "light thread". Otherwise the current "light thread" will enter the ---- waiting queue and yield execution. The current "light thread" will be ---- automatically waken up and the wait function call will return true when there ---- is resources available for it, or return nil and a string describing the error ---- in case of failure (like "timeout"). ---- ---- The timeout argument specifies the maximum time this function call should ---- wait for (in seconds). ---- ---- When the timeout argument is 0, it means "no wait", that is, when there is ---- no readily available "resources" for the current running "light thread", ---- this wait function call returns immediately nil and the error string "timeout". ---- ---- You can specify millisecond precision in the timeout value by using floating ---- point numbers like 0.001 (which means 1ms). ---- ---- "Light threads" created by different contexts (like request handlers) can ---- wait on the same semaphore instance without problem. ---- ----@param timeout? number ----@return boolean ok ----@return string|'"timeout"' error -function semaphore:wait(timeout) end - - ---- Releases n (default to 1) "resources" to the semaphore instance. ---- ---- This will not yield the current running "light thread". ---- ---- At most n "light threads" will be waken up when the current running "light thread" later yields (or terminates). ---- ----@param n? integer -function semaphore:post(n) end - - -return semaphore
\ No newline at end of file diff --git a/meta/3rd/OpenResty/library/ngx/ssl.lua b/meta/3rd/OpenResty/library/ngx/ssl.lua deleted file mode 100644 index 42da031b..00000000 --- a/meta/3rd/OpenResty/library/ngx/ssl.lua +++ /dev/null @@ -1,286 +0,0 @@ ----@meta -local ssl={} - ---- Sets the DER-formatted prviate key for the current SSL connection. ---- ---- Returns true on success, or a nil value and a string describing the error otherwise. ---- ---- Usually, the private keys are encoded in the PEM format. You can either use the priv_key_pem_to_der function to do the PEM to DER conversion or just use the openssl command-line utility offline, like below ---- ---- openssl rsa -in key.pem -outform DER -out key.der ---- ----@param der_priv_key string ----@return boolean ok ----@return string? error -function ssl.set_der_priv_key(der_priv_key) end - - ---- Converts the PEM-formatted SSL private key data into an opaque cdata pointer (for later uses in the set_priv_key function, for example). ---- ---- In case of failures, returns nil and a string describing the error. ---- ---- This function can be called in any context. ---- ----@param pem_priv_key string ----@return ffi.cdata*? priv_key ----@return string? error -function ssl.parse_pem_priv_key(pem_priv_key) end - - ---- Returns the TLS 1.x version number used by the current SSL connection. Returns nil and a string describing the error otherwise. ---- ---- Typical return values are: ---- ---- 0x0300(SSLv3) ---- 0x0301(TLSv1) ---- 0x0302(TLSv1.1) ---- 0x0303(TLSv1.2) ---- 0x0304(TLSv1.3) ---- ---- This function can be called in any context where downstream https is used. ----@return number? version ----@return string? error -function ssl.get_tls1_version() end - - ---- Sets the SSL certificate chain opaque pointer returned by the parse_pem_cert function for the current SSL connection. ---- ---- Returns true on success, or a nil value and a string describing the error otherwise. ---- ---- Note that this set_cert function will run slightly faster, in terms of CPU cycles wasted, than the set_der_cert variant, since the first function uses opaque cdata pointers which do not require any additional conversion needed to be performed by the SSL library during the SSL handshake. ---- ----@param cert_chain ffi.cdata* ----@return boolean ok ----@return string? error -function ssl.set_cert(cert_chain) end - - -ssl.TLS1_VERSION=769 - ---- Sets the SSL private key opaque pointer returned by the parse_pem_priv_key function for the current SSL connection. ---- ---- Returns true on success, or a nil value and a string describing the error otherwise. ---- ---- Note that this set_priv_key function will run slightly faster, in terms of CPU cycles wasted, than the set_der_priv_key variant, since the first function uses opaque cdata pointers which do not require any additional conversion needed to be performed by the SSL library during the SSL handshake. ---- ----@param priv_key ffi.cdata* ----@return boolean ok ----@return string? error -function ssl.set_priv_key(priv_key) end - ---- Returns the raw server address actually accessed by the client in the current SSL connection. ---- ---- The first two return values are strings representing the address data and the address type, respectively. The address values are interpreted differently according to the address type values: ---- ---- unix : The address data is a file path for the UNIX domain socket. ---- inet : The address data is a binary IPv4 address of 4 bytes long. ---- inet6 : The address data is a binary IPv6 address of 16 bytes long. ---- ---- Returns two nil values and a Lua string describing the error. ---- ---- The following code snippet shows how to print out the UNIX domain socket address and the IPv4 address as human-readable strings: ---- ----```lua ---- local ssl = require "ngx.ssl" ---- local byte = string.byte ---- ---- local addr, addrtyp, err = ssl.raw_server_addr() ---- if not addr then ---- ngx.log(ngx.ERR, "failed to fetch raw server addr: ", err) ---- return ---- end ---- ---- if addrtyp == "inet" then -- IPv4 ---- ip = string.format("%d.%d.%d.%d", byte(addr, 1), byte(addr, 2), ---- byte(addr, 3), byte(addr, 4)) ---- print("Using IPv4 address: ", ip) ---- ---- elseif addrtyp == "unix" then -- UNIX ---- print("Using unix socket file ", addr) ---- ---- else -- IPv6 ---- -- leave as an exercise for the readers ---- end ----``` ---- ---- This function can be called in any context where downstream https is used. ---- ----@return string? addr_data ----@return ngx.ssl.addr_type? addr_type ----@return string? error -function ssl.raw_server_addr() end - ----@alias ngx.ssl.addr_type ----| '"unix"' # a file path for the UNIX domain socket. ----| '"inet"' # a binary IPv4 address of 4 bytes long. ----| '"inet6"' # a binary IPv6 address of 16 bytes long. - - ---- Clears any existing SSL certificates and/or private keys set on the current SSL connection. ---- ---- Returns true on success, or a nil value and a string describing the error otherwise. ----@return boolean ok ----@return string? error -function ssl.clear_certs() end - ---- Returns the raw client address of the current SSL connection. ---- ---- The first two return values are strings representing the address data and the address type, respectively. The address values are interpreted differently according to the address type values: ---- ---- unix : The address data is a file path for the UNIX domain socket. ---- inet : The address data is a binary IPv4 address of 4 bytes long. ---- inet6 : The address data is a binary IPv6 address of 16 bytes long. ---- ---- Returns two nil values and a Lua string describing the error. ---- ---- The following code snippet shows how to print out the UNIX domain socket address and the IPv4 address as human-readable strings: ---- ----```lua ---- local ssl = require "ngx.ssl" ---- local byte = string.byte ---- ---- local addr, addrtyp, err = ssl.raw_client_addr() ---- if not addr then ---- ngx.log(ngx.ERR, "failed to fetch raw client addr: ", err) ---- return ---- end ---- ---- if addrtyp == "inet" then -- IPv4 ---- ip = string.format("%d.%d.%d.%d", byte(addr, 1), byte(addr, 2), ---- byte(addr, 3), byte(addr, 4)) ---- print("Client IPv4 address: ", ip) ---- ---- elseif addrtyp == "unix" then -- UNIX ---- print("Client unix socket file ", addr) ---- ---- else -- IPv6 ---- -- leave as an exercise for the readers ---- end ----``` ---- ---- This function can be called in any context where downstream https is used. ---- ----@return string? addr_data ----@return ngx.ssl.addr_type? addr_type ----@return string? error -function ssl.raw_client_addr() end - - ---- Converts the PEM-formated SSL certificate chain data into an opaque cdata pointer (for later uses in the set_cert function, for example). ---- ---- In case of failures, returns nil and a string describing the error. ---- ---- You can always use libraries like lua-resty-lrucache to cache the cdata result. ---- ---- This function can be called in any context. ---- ----@param pem_cert_chain string ----@return ffi.cdata*? cert_chain ----@return string? error -function ssl.parse_pem_cert(pem_cert_chain) end - -ssl.version = require("resty.core.base").version -ssl.TLS1_2_VERSION=771 - ---- Returns the TLS SNI (Server Name Indication) name set by the client. Returns nil when the client does not set it. ---- ---- In case of failures, it returns nil and a string describing the error. ---- ---- Usually we use this SNI name as the domain name (like www.openresty.org) to identify the current web site while loading the corresponding SSL certificate chain and private key for the site. ---- ---- Please note that not all https clients set the SNI name, so when the SNI name is missing from the client handshake request, we use the server IP address accessed by the client to identify the site. See the raw_server_addr method for more details. ---- ---- This function can be called in any context where downstream https is used. ---- ----@return string? server_name ----@return string? error -function ssl.server_name() end - ---- Returns the server port. Returns nil when server dont have a port. ---- ---- In case of failures, it returns nil and a string describing the error. ---- ---- This function can be called in any context where downstream https is used. ---- ----@return number? server_port ----@return string? error -function ssl.server_port() end - - - -ssl.TLS1_1_VERSION=770 -ssl.SSL3_VERSION=768 - ---- Sets the DER-formatted SSL certificate chain data for the current SSL connection. Note that the DER data is directly in the Lua string argument. No external file names are supported here. ---- ---- Returns true on success, or a nil value and a string describing the error otherwise. ---- ---- Note that, the SSL certificate chain is usually encoded in the PEM format. So you need to use the cert_pem_to_der function to do the conversion first. ----@param der_cert_chain string ----@return boolean ok ----@return string? error -function ssl.set_der_cert(der_cert_chain) end - - ---- Returns the TLS 1.x version string used by the current SSL connection. Returns nil and a string describing the error otherwise. ---- ---- If the TLS 1.x version number used by the current SSL connection is not recognized, the return values will be nil and the string "unknown version". ---- ---- Typical return values are: ---- ---- SSLv3 ---- TLSv1 ---- TLSv1.1 ---- TLSv1.2 ---- TLSv1.3 ---- ---- This function can be called in any context where downstream https is used. ---- ----@return string? version ----@return string? error -function ssl.get_tls1_version_str() end - ---- Converts the PEM-formatted SSL private key data into the DER format (for later uses in the set_der_priv_key function, for example). ---- ---- In case of failures, returns nil and a string describing the error. ---- ---- Alternatively, you can do the PEM to DER conversion offline with the openssl command-line utility, like below ---- ---- openssl rsa -in key.pem -outform DER -out key.der ---- ---- This function can be called in any context. ---- ----@param pem_priv_key string ----@return string? der_priv_key ----@return string? error -function ssl.priv_key_pem_to_der(pem_priv_key) end - ---- Converts the PEM-formatted SSL certificate chain data into the DER format (for later uses in the set_der_cert function, for example). ---- ---- In case of failures, returns nil and a string describing the error. ---- ---- It is known that the openssl command-line utility may not convert the whole SSL certificate chain from PEM to DER correctly. So always use this Lua function to do the conversion. You can always use libraries like lua-resty-lrucache and/or ngx_lua APIs like lua_shared_dict to do the caching of the DER-formatted results, for example. ---- ---- This function can be called in any context. ---- ----@param pem_cert_chain string ----@return string? der_cert_chain ----@return string? error -function ssl.cert_pem_to_der(pem_cert_chain) end - - ---- Requires a client certificate during TLS handshake. ---- ---- Returns true on success, or a nil value and a string describing the error otherwise. ---- ---- Note that TLS is not terminated when verification fails. You need to examine Nginx variable $ssl_client_verify later to determine next steps. ---- ---- This function was first added in version 0.1.20. ---- ----@param ca_certs? ffi.cdata* # the CA certificate chain opaque pointer returned by the parse_pem_cert function for the current SSL connection. The list of certificates will be sent to clients. Also, they will be added to trusted store. If omitted, will not send any CA certificate to clients. ----@param depth? number verification depth in the client certificates chain. If omitted, will use the value specified by ssl_verify_depth. ----@return boolean ok ----@return string? error -function ssl.verify_client(ca_certs, depth) end - -return ssl
\ No newline at end of file diff --git a/meta/3rd/OpenResty/library/ngx/ssl/clienthello.lua b/meta/3rd/OpenResty/library/ngx/ssl/clienthello.lua deleted file mode 100644 index d2e40665..00000000 --- a/meta/3rd/OpenResty/library/ngx/ssl/clienthello.lua +++ /dev/null @@ -1,102 +0,0 @@ ----@meta -local clienthello = {} - -clienthello.version = require("resty.core.base").version - ----Returns the TLS SNI (Server Name Indication) name set by the client. ---- ----Return `nil` when then the extension does not exist. ---- ----In case of errors, it returns `nil` and a string describing the error. ---- ----Note that the SNI name is gotten from the raw extensions of the client hello message associated with the current downstream SSL connection. ---- ----So this function can only be called in the context of `ssl_client_hello_by_lua*`. ----@return string? host ----@return string? error -function clienthello.get_client_hello_server_name() end - - ---- Returns raw data of arbitrary SSL client hello extension including custom extensions. ---- ---- Returns `nil` if the specified extension type does not exist. ---- ---- In case of errors, it returns `nil` and a string describing the error. ---- ---- Note that the ext is gotten from the raw extensions of the client hello message associated with the current downstream SSL connection. ---- ---- So this function can only be called in the context of `ssl_client_hello_by_lua*`. ---- ---- Example: ---- ---- Gets server name from raw extension data. The `0` in `ssl_clt.get_client_hello_ext(0)` denotes `TLSEXT_TYPE_server_name`, and the `0` in `byte(ext, 3) ~= 0` denotes `TLSEXT_NAMETYPE_host_name`. ---- ---- ```nginx ---- # nginx.conf ---- server { ---- listen 443 ssl; ---- server_name test.com; ---- ssl_client_hello_by_lua_block { ---- local ssl_clt = require "ngx.ssl.clienthello" ---- local byte = string.byte ---- local ext = ssl_clt.get_client_hello_ext(0) ---- if not ext then ---- print("failed to get_client_hello_ext(0)") ---- ngx.exit(ngx.ERROR) ---- end ---- local total_len = string.len(ext) ---- if total_len <= 2 then ---- print("bad SSL Client Hello Extension") ---- ngx.exit(ngx.ERROR) ---- end ---- local len = byte(ext, 1) * 256 + byte(ext, 2) ---- if len + 2 ~= total_len then ---- print("bad SSL Client Hello Extension") ---- ngx.exit(ngx.ERROR) ---- end ---- if byte(ext, 3) ~= 0 then ---- print("bad SSL Client Hello Extension") ---- ngx.exit(ngx.ERROR) ---- end ---- if total_len <= 5 then ---- print("bad SSL Client Hello Extension") ---- ngx.exit(ngx.ERROR) ---- end ---- len = byte(ext, 4) * 256 + byte(ext, 5) ---- if len + 5 > total_len then ---- print("bad SSL Client Hello Extension") ---- ngx.exit(ngx.ERROR) ---- end ---- local name = string.sub(ext, 6, 6 + len -1) ---- ---- print("read SNI name from Lua: ", name) ---- } ---- ssl_certificate test.crt; ---- ssl_certificate_key test.key; ---- } ---- ``` ---- ----@param ext_type number ----@return string? ext -function clienthello.get_client_hello_ext(ext_type) end - - ---- Sets the SSL protocols supported by the current downstream SSL connection. ---- ---- Returns `true` on success, or a `nil` value and a string describing the error otherwise. ---- ---- Considering it is meaningless to set ssl protocols after the protocol is determined, ---- so this function may only be called in the context of `ssl_client_hello_by_lua*`. ---- ---- Example: ---- ```lua ---- ssl_clt.set_protocols({"TLSv1.1", "TLSv1.2", "TLSv1.3"})` ---- ``` ---- ----@param protocols string[] ----@return boolean ok ----@return string? error -function clienthello.set_protocols(protocols) end - - -return clienthello diff --git a/meta/3rd/OpenResty/library/ngx/ssl/session.lua b/meta/3rd/OpenResty/library/ngx/ssl/session.lua deleted file mode 100644 index 7307b00c..00000000 --- a/meta/3rd/OpenResty/library/ngx/ssl/session.lua +++ /dev/null @@ -1,52 +0,0 @@ ----@meta -local session={} - -session.version = require("resty.core.base").version - - ---- Sets the serialized SSL session provided as the argument to the current SSL connection. ---- If the SSL session is successfully set, the current SSL connection can resume the session ---- directly without going through the full SSL handshake process (which is very expensive in terms of CPU time). ---- ---- This API is usually used in the context of `ssl_session_fetch_by_lua*` ---- when a cache hit is found with the current SSL session ID. ---- ---- The serialized SSL session used as the argument should be originally returned by the ---- `get_serialized_session` function. ---- ----@param session string ----@return boolean ok ----@return string? error -function session.set_serialized_session(session) end - ---- Returns the serialized form of the SSL session data of the current SSL connection, in a Lua string. ---- ---- This session can be cached in `lua-resty-lrucache`, `lua_shared_dict`, ---- and/or external data storage services like `memcached` and `redis`. The SSL session ID returned ---- by the `get_session_id` function is usually used as the cache key. ---- ---- The returned SSL session data can later be loaded into other SSL connections using the same ---- session ID via the `set_serialized_session` function. ---- ---- In case of errors, it returns `nil` and a string describing the error. ---- ---- This API function is usually called in the context of `ssl_session_store_by_lua*` ---- where the SSL handshake has just completed. ---- ----@return string? session ----@return string? error -function session.get_serialized_session() end - ---- Fetches the SSL session ID associated with the current downstream SSL connection. ---- The ID is returned as a Lua string. ---- ---- In case of errors, it returns `nil` and a string describing the error. ---- ---- This API function is usually called in the contexts of ---- `ssl_session_store_by_lua*` and `ssl_session_fetch_by_lua*`. ---- ----@return string? id ----@return string? error -function session.get_session_id() end - -return session
\ No newline at end of file diff --git a/meta/3rd/OpenResty/library/ngx/upstream.lua b/meta/3rd/OpenResty/library/ngx/upstream.lua deleted file mode 100644 index 7313481c..00000000 --- a/meta/3rd/OpenResty/library/ngx/upstream.lua +++ /dev/null @@ -1,9 +0,0 @@ ----@meta -local upstream={} -function upstream.get_backup_peers() end -function upstream.get_servers() end -function upstream.current_upstream_name() end -function upstream.get_primary_peers() end -function upstream.set_peer_down() end -function upstream.get_upstreams() end -return upstream
\ No newline at end of file diff --git a/meta/3rd/OpenResty/library/prometheus.lua b/meta/3rd/OpenResty/library/prometheus.lua deleted file mode 100644 index 88036b81..00000000 --- a/meta/3rd/OpenResty/library/prometheus.lua +++ /dev/null @@ -1,247 +0,0 @@ ----@meta - ----@class PrometheusLib -local PrometheusLib = {} - ----@class PrometheusOptions ----is a table of configuration options that can be provided. -local PrometheusOptions = {} - ----metric name prefix. ----This string will be prepended to metric names on output. -PrometheusOptions.prefix = '' ----Can be used to change the default name of error metric (see ----[Built-in metrics](https://github.com/knyar/nginx-lua-prometheus#built-in-metrics) ----for details). -PrometheusOptions.error_metric_name = '' ----sets per-worker counter sync interval in seconds. ----This sets the boundary on eventual consistency of counter metrics. ----Defaults to `1`. -PrometheusOptions.sync_interval = 0 ----maximum size of a per-metric lookup table maintained by ----each worker to cache full metric names. Defaults to `1000`. ----If you have metrics with extremely high cardinality and lots ----of available RAM, you might want to increase this to avoid ----cache getting flushed too often. ----Decreasing this makes sense if you have a very large number of metrics ----or need to minimize memory usage of this library. -PrometheusOptions.lookup_max_size = 0 - ----Initializes the module. ----This should be called once from the ----[init_worker_by_lua_block](https://github.com/openresty/lua-nginx-module#init_worker_by_lua_block) ----section of nginx configuration. ---- ----Example: ----``` ----init_worker_by_lua_block { ---- prometheus = require("prometheus").init("prometheus_metrics", {sync_interval=3}) ----} ----``` ----@param dict_name string is the name of the nginx shared dictionary which will be used to store all metrics. Defaults to `prometheus_metrics` if not specified. ----@param options? PrometheusOptions is a table of configuration options that can be provided. ----@return Prometheus prometheus Returns a `prometheus` object that should be used to register metrics. -PrometheusLib.init = function(dict_name, options) end - ----@class Prometheus -local Prometheus = {} - ----Registers a counter. ---- ----Should be called once for each gauge from the ----[init_worker_by_lua_block](https://github.com/openresty/lua-nginx-module#init_worker_by_lua_block) ----section. ---- ----Example: ----``` ----init_worker_by_lua_block { ---- prometheus = require("prometheus").init("prometheus_metrics") ---- ---- metric_bytes = prometheus:counter( ---- "nginx_http_request_size_bytes", "Total size of incoming requests") ---- metric_requests = prometheus:counter( ---- "nginx_http_requests_total", "Number of HTTP requests", {"host", "status"}) ----} ----``` ----@param name string is the name of the metric. ----@param description? string is the text description. Optional. ----@param label_names? string[] is an array of label names for the metric. Optional. ----@return PrometheusCounter -function Prometheus:counter(name, description, label_names) end - ----Registers a gauge. ---- ----Should be called once for each gauge from the ----[init_worker_by_lua_block](https://github.com/openresty/lua-nginx-module#init_worker_by_lua_block) ----section. ---- ----Example: ----``` ----init_worker_by_lua_block { ---- prometheus = require("prometheus").init("prometheus_metrics") ---- ---- metric_connections = prometheus:gauge( ---- "nginx_http_connections", "Number of HTTP connections", {"state"}) ----} ----``` ----@param name string is the name of the metric. ----@param description? string is the text description. Optional. ----@param label_names? string[] is an array of label names for the metric. Optional. ----@return PrometheusGauge -function Prometheus:gauge(name, description, label_names) end - ----Registers a histogram. ---- ----Should be called once for each histogram from the ----[init_worker_by_lua_block](https://github.com/openresty/lua-nginx-module#init_worker_by_lua_block) ----section. ---- ----Example: ----``` ----init_worker_by_lua_block { ---- prometheus = require("prometheus").init("prometheus_metrics") ---- ---- metric_latency = prometheus:histogram( ---- "nginx_http_request_duration_seconds", "HTTP request latency", {"host"}) ---- metric_response_sizes = prometheus:histogram( ---- "nginx_http_response_size_bytes", "Size of HTTP responses", nil, ---- {10,100,1000,10000,100000,1000000}) ----} ----``` ----@param name string is the name of the metric. ----@param description? string is the text description. Optional. ----@param label_names? string[] is an array of label names for the metric. Optional. ----@param buckets? number[] is an array of numbers defining bucket boundaries. Optional, defaults to 20 latency buckets covering a range from 5ms to 10s (in seconds). ----@return PrometheusHist -function Prometheus:histogram(name, description, label_names, buckets) end - ----Presents all metrics in a text format compatible with Prometheus. ----This should be called in [content_by_lua_block](https://github.com/openresty/lua-nginx-module#content_by_lua_block) ----to expose the metrics on a separate HTTP page. ---- ----Example: ----``` ----location /metrics { ---- content_by_lua_block { prometheus:collect() } ---- allow 192.168.0.0/16; ---- deny all; ----} ----``` -function Prometheus:collect() end - ----Returns metric data as an array of strings. ----@return string[] -function Prometheus:metric_data() end - ----@class PrometheusCounter -local PrometheusCounter = {} - ----Increments a previously registered counter. ----This is usually called from log_by_lua_block globally or per server/location. ---- ----The number of label values should match the number of label names ----defined when the counter was registered using `prometheus:counter()`. ----No label values should be provided for counters with no labels. ----Non-printable characters will be stripped from label values. ---- ----Example: ----``` ----log_by_lua_block { ---- metric_bytes:inc(tonumber(ngx.var.request_length)) ---- metric_requests:inc(1, {ngx.var.server_name, ngx.var.status}) ----} ----``` ----@param value number is a value that should be added to the counter. Defaults to 1. ----@param label_values? string[] is an array of label values. -function PrometheusCounter:inc(value, label_values) end - ----Delete a previously registered counter. ----This is usually called when you don't need to observe such counter ----(or a metric with specific label values in this counter) any more. ----If this counter has labels, you have to pass `label_values` to delete ----the specific metric of this counter. ----If you want to delete all the metrics of a counter with labels, ----you should call `Counter:reset()`. ---- ----This function will wait for sync_interval before deleting the metric to ----allow all workers to sync their counters. ----@param label_values string[] The number of label values should match the number of label names defined when the counter was registered using `prometheus:counter()`. No label values should be provided for counters with no labels. Non-printable characters will be stripped from label values. -function PrometheusCounter:del(label_values) end - ----Delete all metrics for a previously registered counter. ----If this counter have no labels, it is just the same as `Counter:del()` function. ----If this counter have labels, it will delete all the metrics with different label values. ---- ----This function will wait for `sync_interval` before deleting the metrics to allow all workers to sync their counters. -function PrometheusCounter:reset() end - ----@class PrometheusGauge -local PrometheusGauge = {} - ----Sets the current value of a previously registered gauge. ----This could be called from ----[log_by_lua_block](https://github.com/openresty/lua-nginx-module#log_by_lua_block) ----globally or per server/location to modify a gauge on each request, or from ----[content_by_lua_block](https://github.com/openresty/lua-nginx-module#content_by_lua_block) ----just before `prometheus::collect()` to return a real-time value. ---- ----@param value number is a value that the gauge should be set to. Required. ----@param label_values? string[] is an array of label values. -function PrometheusGauge:set(value, label_values) end - ----Increments a previously registered gauge. ----This is usually called from log_by_lua_block globally or per server/location. ---- ----The number of label values should match the number of label names ----defined when the gauge was registered using `prometheus:gauge()`. ----No label values should be provided for gauge with no labels. ----Non-printable characters will be stripped from label values. ----@param value number is a value that should be added to the gauge. Defaults to 1. ----@param label_values? string[] is an array of label values. -function PrometheusGauge:inc(value, label_values) end - ----Delete a previously registered gauge. ----This is usually called when you don't need to observe such gauge ----(or a metric with specific label values in this gauge) any more. ----If this gauge has labels, you have to pass `label_values` to delete ----the specific metric of this gauge. ----If you want to delete all the metrics of a gauge with labels, ----you should call `Gauge:reset()`. ---- ----This function will wait for sync_interval before deleting the metric to ----allow all workers to sync their counters. ----@param label_values string[] The number of label values should match the number of label names defined when the gauge was registered using `prometheus:gauge()`. No label values should be provided for counters with no labels. Non-printable characters will be stripped from label values. -function PrometheusGauge:del(label_values) end - ----Delete all metrics for a previously registered gauge. ----If this gauge have no labels, it is just the same as `Gauge:del()` function. ----If this gauge have labels, it will delete all the metrics with different ----label values. -function PrometheusGauge:reset() end - ----@class PrometheusHist -local PrometheusHist = {} - ----Records a value in a previously registered histogram. ----Usually called from ----[log_by_lua_block](https://github.com/openresty/lua-nginx-module#log_by_lua_block) ----globally or per server/location. ---- ----Example: ----``` ----log_by_lua_block { ---- metric_latency:observe(tonumber(ngx.var.request_time), {ngx.var.server_name}) ---- metric_response_sizes:observe(tonumber(ngx.var.bytes_sent)) ----} ----``` ----@param value number is a value that should be recorded. Required. ----@param label_values? string[] is an array of label values. -function PrometheusHist:observe(value, label_values) end - ----Delete all metrics for a previously registered histogram. ---- ----This function will wait for `sync_interval` before deleting the ----metrics to allow all workers to sync their counters. -function PrometheusHist:reset() end - -return PrometheusLib diff --git a/meta/3rd/OpenResty/library/resty/aes.lua b/meta/3rd/OpenResty/library/resty/aes.lua deleted file mode 100644 index 7e627ef6..00000000 --- a/meta/3rd/OpenResty/library/resty/aes.lua +++ /dev/null @@ -1,75 +0,0 @@ ----@meta - -local aes={} - ----@alias resty.aes.cipher.name ----| '"ecb"' ----| '"cbc"' ----| '"cfb1"' ----| '"cfb128"' ----| '"cfb8"' ----| '"ctr" ----| '"gcm"' ----| '"ofb"' - ----@alias resty.aes.cipher.size '128'|'192'|'256' - ----@class resty.aes.cipher : table ----@field size resty.aes.cipher.size ----@field cipher resty.aes.cipher.name ----@field method userdata - ----@param size resty.aes.cipher.size # cipher size (default `128`) ----@param cipher? resty.aes.cipher.name # cipher name (default `"cbc"`) ----@return resty.aes.cipher? -function aes.cipher(size, cipher) end - ----@class resty.aes.hash_table : table ----@field iv string ----@field method? fun(key:string):string - ----@class resty.aes.hash_cdata : userdata - ----@type table<string, resty.aes.hash_cdata> -aes.hash = {} -aes.hash.sha1={} -aes.hash.md5={} -aes.hash.sha224={} -aes.hash.sha512={} -aes.hash.sha256={} -aes.hash.sha384={} - ----@alias resty.aes.hash resty.aes.hash_cdata|resty.aes.hash_table - ----@param key string encryption key ----@param salt? string if provided, must be exactly 8 characters in length ----@param cipher? resty.aes.cipher (default is 128 CBC) ----@param hash? resty.aes.hash (default is md5) ----@param hash_rounds? number (default: `1`) ----@param iv_len? number ----@param enable_padding? boolean (default: `true`) ---- ----@return resty.aes? ----@return string? error -function aes:new(key, salt, cipher, hash, hash_rounds, iv_len, enable_padding) end - ----@class resty.aes : table -local aes_ctx = {} - ---- Decrypt a string ---- ----@param s string ----@param tag? string ----@return string? decrypted ----@return string? error -function aes_ctx:decrypt(s, tag) end - - ---- Encrypt a string. ---- ----@param s string ----@return string? encrypted ----@return string? error -function aes_ctx:encrypt(s) end - -return aes
\ No newline at end of file diff --git a/meta/3rd/OpenResty/library/resty/core.lua b/meta/3rd/OpenResty/library/resty/core.lua deleted file mode 100644 index e143818e..00000000 --- a/meta/3rd/OpenResty/library/resty/core.lua +++ /dev/null @@ -1,4 +0,0 @@ ----@meta -local resty_core={} -resty_core.version = require("resty.core.base").version -return resty_core
\ No newline at end of file diff --git a/meta/3rd/OpenResty/library/resty/core/base.lua b/meta/3rd/OpenResty/library/resty/core/base.lua deleted file mode 100644 index d84c3486..00000000 --- a/meta/3rd/OpenResty/library/resty/core/base.lua +++ /dev/null @@ -1,51 +0,0 @@ ----@meta -local resty_core_base = {} - ----@param ... string -function resty_core_base.allows_subsystem(...) end - ----@param t table -function resty_core_base.clear_tab(t) end - ----@return userdata -function resty_core_base.get_errmsg_ptr() end - ----@return userdata -function resty_core_base.get_request() end - ----@return userdata -function resty_core_base.get_size_ptr() end - ----@param size number ----@param must_alloc? boolean ----@return userdata -function resty_core_base.get_string_buf(size, must_alloc) end - ----@return number -function resty_core_base.get_string_buf_size() end - ----@param narr number ----@param nrec number ----@return table -function resty_core_base.new_tab(narr, nrec) end - ----@param tb table ----@param key any ----@return any -function resty_core_base.ref_in_table(tb, key) end - ----@param size number -function resty_core_base.set_string_buf_size(size) end - -resty_core_base.FFI_OK = 0 -resty_core_base.FFI_NO_REQ_CTX = -100 -resty_core_base.FFI_BAD_CONTEXT = -101 -resty_core_base.FFI_ERROR = -1 -resty_core_base.FFI_AGAIN = -2 -resty_core_base.FFI_BUSY = -3 -resty_core_base.FFI_DONE = -4 -resty_core_base.FFI_DECLINED = -5 - -resty_core_base.version = "0.1.23" - -return resty_core_base
\ No newline at end of file diff --git a/meta/3rd/OpenResty/library/resty/core/base64.lua b/meta/3rd/OpenResty/library/resty/core/base64.lua deleted file mode 100644 index 21534411..00000000 --- a/meta/3rd/OpenResty/library/resty/core/base64.lua +++ /dev/null @@ -1,4 +0,0 @@ ----@meta -local resty_core_base64={} -resty_core_base64.version = require("resty.core.base").version -return resty_core_base64
\ No newline at end of file diff --git a/meta/3rd/OpenResty/library/resty/core/ctx.lua b/meta/3rd/OpenResty/library/resty/core/ctx.lua deleted file mode 100644 index 7f94db15..00000000 --- a/meta/3rd/OpenResty/library/resty/core/ctx.lua +++ /dev/null @@ -1,9 +0,0 @@ ----@meta -local resty_core_ctx={} -resty_core_ctx._VERSION = require("resty.core.base").version - ----@param ctx? table ----@return table -function resty_core_ctx.get_ctx_table(ctx) end - -return resty_core_ctx
\ No newline at end of file diff --git a/meta/3rd/OpenResty/library/resty/core/exit.lua b/meta/3rd/OpenResty/library/resty/core/exit.lua deleted file mode 100644 index 57f08c71..00000000 --- a/meta/3rd/OpenResty/library/resty/core/exit.lua +++ /dev/null @@ -1,4 +0,0 @@ ----@meta -local resty_core_exit={} -resty_core_exit.version = require("resty.core.base").version -return resty_core_exit
\ No newline at end of file diff --git a/meta/3rd/OpenResty/library/resty/core/hash.lua b/meta/3rd/OpenResty/library/resty/core/hash.lua deleted file mode 100644 index 54ef2c8a..00000000 --- a/meta/3rd/OpenResty/library/resty/core/hash.lua +++ /dev/null @@ -1,4 +0,0 @@ ----@meta -local resty_core_hash={} -resty_core_hash.version = require("resty.core.base").version -return resty_core_hash
\ No newline at end of file diff --git a/meta/3rd/OpenResty/library/resty/core/misc.lua b/meta/3rd/OpenResty/library/resty/core/misc.lua deleted file mode 100644 index bd355c02..00000000 --- a/meta/3rd/OpenResty/library/resty/core/misc.lua +++ /dev/null @@ -1,6 +0,0 @@ ----@meta -local resty_core_misc={} -function resty_core_misc.register_ngx_magic_key_getter() end -function resty_core_misc.register_ngx_magic_key_setter() end -resty_core_misc._VERSION = require("resty.core.base").version -return resty_core_misc
\ No newline at end of file diff --git a/meta/3rd/OpenResty/library/resty/core/ndk.lua b/meta/3rd/OpenResty/library/resty/core/ndk.lua deleted file mode 100644 index 6a243329..00000000 --- a/meta/3rd/OpenResty/library/resty/core/ndk.lua +++ /dev/null @@ -1,4 +0,0 @@ ----@meta -local resty_core_ndk={} -resty_core_ndk.version = require("resty.core.base").version -return resty_core_ndk
\ No newline at end of file diff --git a/meta/3rd/OpenResty/library/resty/core/phase.lua b/meta/3rd/OpenResty/library/resty/core/phase.lua deleted file mode 100644 index 1ac451c0..00000000 --- a/meta/3rd/OpenResty/library/resty/core/phase.lua +++ /dev/null @@ -1,4 +0,0 @@ ----@meta -local resty_core_phase={} -resty_core_phase.version = require("resty.core.base").version -return resty_core_phase
\ No newline at end of file diff --git a/meta/3rd/OpenResty/library/resty/core/regex.lua b/meta/3rd/OpenResty/library/resty/core/regex.lua deleted file mode 100644 index 4876d1de..00000000 --- a/meta/3rd/OpenResty/library/resty/core/regex.lua +++ /dev/null @@ -1,55 +0,0 @@ ----@meta - ----@class resty.core.regex ----@field no_pcre boolean -local regex = {} - ----@param ratio integer -function regex.set_buf_grow_ratio(ratio) end - ----@return boolean is_empty -function regex.is_regex_cache_empty() end - ----@class resty.core.regex.compiled : ffi.cdata* ----@field captures ffi.cdata* ----@field ncaptures integer ----@field name_count integer ----@field name_table ffi.cdata* ----@field name_entry_size integer - ----@param compiled resty.core.regex.compiled ----@param flags integer ----@param res ngx.re.captures -function regex.collect_captures(compiled, flags, res) end - ----@param compiled resty.core.regex.compiled -function regex.destroy_compiled_regex(compiled) end - ----@param re string ----@param opts ngx.re.options ----@return resty.core.regex.compiled? compiled ----@return boolean|string compile_once_or_error ----@return integer? flags -function regex.re_match_compile(re, opts) end - ----@param buf ffi.cdata* ----@param buf_size integer ----@param pos integer ----@param len integer ----@param new_len integer ----@param must_alloc boolean ----@return ffi.cdata* buf ----@return integer buf_size ----@return integer new_len -function regex.check_buf_size(buf, buf_size, pos, len, new_len, must_alloc) end - ----@param re string ----@param opts ngx.re.options ----@param replace? string ----@param func? fun(match:string):string ----@return resty.core.regex.compiled? compiled ----@return boolean|string compile_once_or_error ----@return integer? flags -function regex.re_sub_compile(re, opts, replace, func) end - -return regex
\ No newline at end of file diff --git a/meta/3rd/OpenResty/library/resty/core/request.lua b/meta/3rd/OpenResty/library/resty/core/request.lua deleted file mode 100644 index 3b4d81bd..00000000 --- a/meta/3rd/OpenResty/library/resty/core/request.lua +++ /dev/null @@ -1,5 +0,0 @@ ----@meta -local resty_core_request={} -resty_core_request.version = require("resty.core.base").version -function resty_core_request.set_req_header(name, value, override) end -return resty_core_request
\ No newline at end of file diff --git a/meta/3rd/OpenResty/library/resty/core/response.lua b/meta/3rd/OpenResty/library/resty/core/response.lua deleted file mode 100644 index a3a4d4d7..00000000 --- a/meta/3rd/OpenResty/library/resty/core/response.lua +++ /dev/null @@ -1,5 +0,0 @@ ----@meta -local resty_core_response={} -function resty_core_response.set_resp_header() end -resty_core_response.version = require("resty.core.base").version -return resty_core_response
\ No newline at end of file diff --git a/meta/3rd/OpenResty/library/resty/core/shdict.lua b/meta/3rd/OpenResty/library/resty/core/shdict.lua deleted file mode 100644 index 054a9dc5..00000000 --- a/meta/3rd/OpenResty/library/resty/core/shdict.lua +++ /dev/null @@ -1,4 +0,0 @@ ----@meta -local resty_core_shdict={} -resty_core_shdict.version = require("resty.core.base").version -return resty_core_shdict
\ No newline at end of file diff --git a/meta/3rd/OpenResty/library/resty/core/time.lua b/meta/3rd/OpenResty/library/resty/core/time.lua deleted file mode 100644 index 30f89b1e..00000000 --- a/meta/3rd/OpenResty/library/resty/core/time.lua +++ /dev/null @@ -1,4 +0,0 @@ ----@meta -local resty_core_time={} -resty_core_time.version = require("resty.core.base").version -return resty_core_time
\ No newline at end of file diff --git a/meta/3rd/OpenResty/library/resty/core/uri.lua b/meta/3rd/OpenResty/library/resty/core/uri.lua deleted file mode 100644 index 3e2c3e51..00000000 --- a/meta/3rd/OpenResty/library/resty/core/uri.lua +++ /dev/null @@ -1,4 +0,0 @@ ----@meta -local resty_core_uri={} -resty_core_uri.version = require("resty.core.base").version -return resty_core_uri
\ No newline at end of file diff --git a/meta/3rd/OpenResty/library/resty/core/utils.lua b/meta/3rd/OpenResty/library/resty/core/utils.lua deleted file mode 100644 index 8070a33b..00000000 --- a/meta/3rd/OpenResty/library/resty/core/utils.lua +++ /dev/null @@ -1,10 +0,0 @@ ----@meta -local resty_core_utils={} - ----@param str string ----@param find string ----@param replace string ----@return string -function resty_core_utils.str_replace_char(str, find, replace) end -resty_core_utils.version = require("resty.core.base").version -return resty_core_utils
\ No newline at end of file diff --git a/meta/3rd/OpenResty/library/resty/core/var.lua b/meta/3rd/OpenResty/library/resty/core/var.lua deleted file mode 100644 index df884ff9..00000000 --- a/meta/3rd/OpenResty/library/resty/core/var.lua +++ /dev/null @@ -1,4 +0,0 @@ ----@meta -local resty_core_var={} -resty_core_var.version = require("resty.core.base").version -return resty_core_var
\ No newline at end of file diff --git a/meta/3rd/OpenResty/library/resty/core/worker.lua b/meta/3rd/OpenResty/library/resty/core/worker.lua deleted file mode 100644 index 92a8351c..00000000 --- a/meta/3rd/OpenResty/library/resty/core/worker.lua +++ /dev/null @@ -1,4 +0,0 @@ ----@meta -local resty_core_worker={} -resty_core_worker._VERSION = require("resty.core.base").version -return resty_core_worker
\ No newline at end of file diff --git a/meta/3rd/OpenResty/library/resty/dns/resolver.lua b/meta/3rd/OpenResty/library/resty/dns/resolver.lua deleted file mode 100644 index 1ddc1b5b..00000000 --- a/meta/3rd/OpenResty/library/resty/dns/resolver.lua +++ /dev/null @@ -1,424 +0,0 @@ ----@meta - ---- ---- lua-resty-dns - Lua DNS resolver for the ngx_lua based on the cosocket API ---- ---- https://github.com/openresty/lua-resty-dns ---- ----# Description ---- ---- This Lua library provides a DNS resolver for the ngx_lua nginx module: ---- ---- https://github.com/openresty/lua-nginx-module/#readme ---- ---- This Lua library takes advantage of ngx_lua's cosocket API, which ensures ---- 100% nonblocking behavior. ---- ---- Note that at least [ngx_lua 0.5.12](https://github.com/openresty/lua-nginx-module/tags) or [OpenResty 1.2.1.11](http://openresty.org/#Download) is required. ---- ---- Also, the [bit library](http://bitop.luajit.org/) is also required. If you're using LuaJIT 2.0 with ngx_lua, then the `bit` library is already available by default. ---- ---- Note that, this library is bundled and enabled by default in the [OpenResty bundle](http://openresty.org/). ---- ---- IMPORTANT: to be able to generate unique ids, the random generator must be properly seeded using `math.randomseed` prior to using this module. ---- ----# Automatic Error Logging ---- ---- By default, the underlying [ngx_lua](https://github.com/openresty/lua-nginx-module/#readme) module does error logging when socket errors happen. If you are already doing proper error handling in your own Lua code, then you are recommended to disable this automatic error logging by turning off [ngx_lua](https://github.com/openresty/lua-nginx-module/#readme)'s [lua_socket_log_errors](https://github.com/openresty/lua-nginx-module/#lua_socket_log_errors) directive, that is: ---- ----```nginx ---- lua_socket_log_errors off; ----``` ---- ----# Limitations ---- ---- * This library cannot be used in code contexts like `set_by_lua*`, `log_by_lua*`, and `header_filter_by_lua*` where the ngx_lua cosocket API is not available. ---- * The `resty.dns.resolver` object instance cannot be stored in a Lua variable at the Lua module level, because it will then be shared by all the concurrent requests handled by the same nginx worker process (see https://github.com/openresty/lua-nginx-module/#data-sharing-within-an-nginx-worker ) and result in bad race conditions when concurrent requests are trying to use the same `resty.dns.resolver` instance. You should always initiate `resty.dns.resolver` objects in function local variables or in the `ngx.ctx` table. These places all have their own data copies for each request. ---- ----@class resty.dns.resolver ----@field _VERSION string ---- ---- undocumented/private fields--use at your own risk ---- ----@field cur integer ----@field socks udpsock[] ----@field tcp_sock tcpsock ----@field servers resty.dns.resolver.nameserver_tuple[] ----@field retrans integer ----@field no_recurse boolean -local resolver = {} - - ---- The `A` resource record type, equal to the decimal number 1. ----@class resty.dns.resolver.TYPE_A -resolver.TYPE_A = 1 - ---- The `NS` resource record type, equal to the decimal number `2`. ----@class resty.dns.resolver.TYPE_NS -resolver.TYPE_NS = 2 - ---- The `CNAME` resource record type, equal to the decimal number `5`. ----@class resty.dns.resolver.TYPE_CNAME -resolver.TYPE_CNAME = 5 - ---- The `SOA` resource record type, equal to the decimal number `6`. ----@class resty.dns.resolver.TYPE_SOA -resolver.TYPE_SOA = 6 - ---- The `PTR` resource record type, equal to the decimal number `12`. ----@class resty.dns.resolver.TYPE_PTR -resolver.TYPE_PTR = 12 - ---- The `MX` resource record type, equal to the decimal number `15`. ----@class resty.dns.resolver.TYPE_MX -resolver.TYPE_MX = 15 - ---- The `TXT` resource record type, equal to the decimal number `16`. ----@class resty.dns.resolver.TYPE_TXT -resolver.TYPE_TXT = 16 - ---- The `AAAA` resource record type, equal to the decimal number `28`. ----@class resty.dns.resolver.TYPE_AAAA -resolver.TYPE_AAAA = 28 - ---- The `SRV` resource record type, equal to the decimal number `33`. ---- ---- See RFC 2782 for details. ----@class resty.dns.resolver.TYPE_SRV -resolver.TYPE_SRV = 33 - ---- The `SPF` resource record type, equal to the decimal number `99`. ---- ---- See RFC 4408 for details. ----@class resty.dns.resolver.TYPE_SPF -resolver.TYPE_SPF = 99 - - ----@alias resty.dns.resolver.TYPE integer ----| `resolver.TYPE_A` # A ----| 1 # A ----| `resolver.TYPE_NS` # NS ----| 2 # NS ----| `resolver.TYPE_CNAME` # CNAME ----| 5 # CNAME ----| `resolver.TYPE_SOA` # SOA ----| 6 # SOA ----| `resolver.TYPE_PTR` # PTR ----| 12 # PTR ----| `resolver.TYPE_MX` # MX ----| 15 # MX ----| `resolver.TYPE_TXT` # TXT ----| 16 # TXT ----| `resolver.TYPE_AAAA` # AAAA ----| 28 # AAAA ----| `resolver.TYPE_SRV` # SRV ----| 33 # SRV ----| `resolver.TYPE_SPF` # SPF ----| 99 # SPF - - ----@alias resty.dns.resolver.CLASS integer ----| `resolver.CLASS_IN` ----| 1 - ---- The `Internet` resource record type ----@class resty.dns.resolver.CLASS_IN -resolver.CLASS_IN = 1 - - ----@alias resty.dns.resolver.SECTION integer ----| `resolver.SECTION_AN` # Answer section ----| 1 # Answer section ----| `resolver.SECTION_NS` # Authority section ----| 2 # Authority section ----| `resolver.SECTION_AR` # Additional section ----| 3 # Additional section - - ---- Identifier of the `Answer` section in the DNS response. ----@class resty.dns.resolver.SECTION_AN -resolver.SECTION_AN = 1 - - ---- Identifier of the `Authority` section in the DNS response. ----@class resty.dns.resolver.SECTION_NS -resolver.SECTION_NS = 2 - - ---- Identifier of the `Additional` section in the DNS response. ----@class resty.dns.resolver.SECTION_AR -resolver.SECTION_AR = 3 - - ----@alias resty.dns.resolver.ERRCODE integer ----| 1 # format error ----| 2 # server failure ----| 3 # name error ----| 4 # not implemented ----| 5 # refused - - ----@alias resty.dns.resolver.ERRSTR ----| "format error" # errcode 1 ----| "server failure" # errcode 2 ----| "name error" # errcode 3 ----| "not implemented" # errcode 4 ----| "refused" # errcode 5 ----| "unknown" # errcode unknown - - ---- Creates a dns.resolver object. ---- ---- On error, returns `nil` and an error string. ---- ----@param opts resty.dns.resolver.new.opts ----@return resty.dns.resolver? resolver ----@return string? error -function resolver:new(opts) end - - ----@class resty.dns.resolver.nameserver_tuple ----@field [1] string # hostname or addr ----@field [2] integer # port number - ----@alias resty.dns.resolver.nameserver ----| string ----| resty.dns.resolver.nameserver_tuple - - ---- Options for `resty.dns.resolver:new()` ---- ----@class resty.dns.resolver.new.opts : table ---- ----@field nameservers resty.dns.resolver.nameserver[] # a list of nameservers to be used. Each nameserver entry can be either a single hostname string or a table holding both the hostname string and the port number. The nameserver is picked up by a simple round-robin algorithm for each `query` method call. This option is required. ---- ----@field retrans? number # (default: `5`) the total number of times of retransmitting the DNS request when receiving a DNS response times out according to the `timeout` setting. When trying to retransmit the query, the next nameserver according to the round-robin algorithm will be picked up. ---- ----@field timeout? number # (default: `2000`) the time in milliseconds for waiting for the response for a single attempt of request transmission. note that this is ''not'' the maximal total waiting time before giving up, the maximal total waiting time can be calculated by the expression `timeout x retrans`. The `timeout` setting can also be changed by calling the `set_timeout` method. ---- ----@field no_recurse? boolean # (default: `false`) a boolean flag controls whether to disable the "recursion desired" (RD) flag in the UDP request. ---- ----@field no_random? boolean # (default: `false`) a boolean flag controls whether to randomly pick the nameserver to query first, if `true` will always start with the first nameserver listed. - - ---- Performs a DNS standard query. ---- ---- The query is sent to the nameservers specified by the `new` method, and ---- ---- Returns all the answer records in an array-like Lua table. ---- ---- In case of errors, it will return nil and a string describing the error instead. ---- ---- If the server returns a non-zero error code, the fields `errcode` and `errstr` will be set accordingly in the Lua table returned. ---- ---- The optional parameter `tries` can be provided as an empty table, and will be returned as a third result. The table will be an array with the error message for each (if any) failed try. ---- ---- When data truncation happens, the resolver will automatically retry using the TCP transport mode to query the current nameserver. All TCP connections are short lived. ---- ----@param qname string ----@param opts? resty.dns.resolver.query.opts ----@param tries? string[] ----@return resty.dns.resolver.query.answer[] results ----@return string? error ----@return string[]? tries -function resolver:query(qname, opts, tries) end - - ----@class resty.dns.resolver.answer : table ---- ----@field name string # The resource record name. ---- ----@field type resty.dns.resolver.TYPE # The current resource record type, possible values are 1 (TYPE_A), 5 (TYPE_CNAME), 28 (TYPE_AAAA), and any other values allowed by RFC 1035. ---- ----@field section resty.dns.resolver.SECTION # The identifier of the section that the current answer record belongs to. Possible values are 1 (SECTION_AN), 2 (SECTION_NS), and 3 (SECTION_AR). ---- ----@field ttl number # The time-to-live (TTL) value in seconds for the current resource record. ---- ----@field class resty.dns.resolver.CLASS # The current resource record class, possible values are 1 (CLASS_IN) or any other values allowed by RFC 1035. ---- ----@field rdata string # The raw resource data (RDATA) for resource records that are not recognized. ---- ----@field errcode? resty.dns.resolver.ERRCODE # Error code returned by the DNS server ---- ----@field errstr? resty.dns.resolver.ERRSTR # Error string returned by the DNS server - - ---- A-type answer ---- ----@class resty.dns.resolver.answer.A : resty.dns.resolver.answer ---- ----@field address string # The IPv4 address. - ---- AAAA-type answer ---- ----@class resty.dns.resolver.answer.AAAA : resty.dns.resolver.answer ---- ----@field address string # The IPv6 address. Successive 16-bit zero groups in IPv6 addresses will not be compressed by default, if you want that, you need to call the compress_ipv6_addr static method instead. - - ---- CNAME-type answer ---- ----@class resty.dns.resolver.answer.CNAME : resty.dns.resolver.answer ---- ----@field cname? string # The (decoded) record data value for CNAME resource records. - - ---- MX-type answer ---- ----@class resty.dns.resolver.answer.MX : resty.dns.resolver.answer ---- ----@field preference integer # The preference integer number for MX resource records. ---- ----@field exchange? string # The exchange domain name for MX resource records. - - ---- SRV-type answer ---- ----@class resty.dns.resolver.answer.SRV : resty.dns.resolver.answer ---- ----@field priority number ---- ----@field weight number ---- ----@field port integer ---- ----@field target string - - ---- NS-type answer ---- ----@class resty.dns.resolver.answer.NS : resty.dns.resolver.answer ---- ----@field nsdname string # A domain-name which specifies a host which should be authoritative for the specified class and domain. Usually present for NS type records. ---- - - ---- TXT-type answer ---- ----@class resty.dns.resolver.answer.TXT : resty.dns.resolver.answer ---- ----@field txt? string|string[] # The record value for TXT records. When there is only one character string in this record, then this field takes a single Lua string. Otherwise this field takes a Lua table holding all the strings. - - ---- SPF-type answer ---- ----@class resty.dns.resolver.answer.SPF : resty.dns.resolver.answer ---- ----@field spf? string|string[] # The record value for SPF records. When there is only one character string in this record, then this field takes a single Lua string. Otherwise this field takes a Lua table holding all the strings. - - ---- PTR-type answer ---- ----@class resty.dns.resolver.answer.PTR : resty.dns.resolver.answer ---- ----@field ptrdname string # The record value for PTR records. - - ---- SOA-type answer ---- ----@class resty.dns.resolver.answer.SOA : resty.dns.resolver.answer ---- ----@field serial integer # SOA serial ----@field refresh integer # SOA refresh ----@field retry integer # SOA retry ----@field expire integer # SOA expire ----@field minimum integer # SOA minimum - - ----@alias resty.dns.resolver.query.answer ----| resty.dns.resolver.answer ----| resty.dns.resolver.answer.A ----| resty.dns.resolver.answer.AAAA ----| resty.dns.resolver.answer.CNAME ----| resty.dns.resolver.answer.MX ----| resty.dns.resolver.answer.NS ----| resty.dns.resolver.answer.PTR ----| resty.dns.resolver.answer.SOA ----| resty.dns.resolver.answer.SPF ----| resty.dns.resolver.answer.SRV ----| resty.dns.resolver.answer.TXT - - ---- Options for `resty.dns.resolver:query()` ---- ----@class resty.dns.resolver.query.opts : table ---- ----@field qtype? resty.dns.resolver.TYPE # (default: `1`) The type of the question. Possible values are 1 (TYPE_A), 5 (TYPE_CNAME), 28 (TYPE_AAAA), or any other QTYPE value specified by RFC 1035 and RFC 3596. ---- ----@field authority_section? boolean # (default: `false`) When `true`, the answers return value includes the `Authority` section of the DNS response. ---- ----@field additional_section? boolean # (default: `false`) When `true`, the answers return value includes the `Additional` section of the DNS response. - - ---- Just like the query method, but enforce the TCP transport mode instead of UDP. ---- ---- All TCP connections are short lived. ---- ----@param qname string ----@param opts? resty.dns.resolver.query.opts ----@return resty.dns.resolver.query.answer[] results ----@return string? error -function resolver:tcp_query(qname, opts) end - - ---- Performs a PTR lookup for both IPv4 and IPv6 addresses. ---- ---- This function is basically a wrapper for the query command which uses the `arpa_str` function to convert the IP address on the fly. ---- ----@param addr string ----@return resty.dns.resolver.query.answer[] results ----@return string? error -function resolver:reverse_query(addr) end - - ---- Overrides the current timeout setting for all nameserver peers. ---- ----@param timeout number # timeout in milliseconds -function resolver:set_timeout(timeout) end - ---- Compresses the successive 16-bit zero groups in the textual format of the IPv6 address. ---- ---- For example, the following will yield `FF01::101` in the new_addr return value: ---- ----```lua ---- local resolver = require "resty.dns.resolver" ---- local compress = resolver.compress_ipv6_addr ---- local new_addr = compress("FF01:0:0:0:0:0:0:101") ----``` ---- ----@param addr string ----@return string compressed -function resolver.compress_ipv6_addr(addr) end - ---- Expands the successive 16-bit zero groups in the textual format of the IPv6 address. ---- ---- For example, the following will yield `FF01:0:0:0:0:0:0:101` in the new_addr return value: ---- ----```lua ---- local resolver = require "resty.dns.resolver" ---- local expand = resolver.expand_ipv6_addr ---- local new_addr = expand("FF01::101") ----``` ---- ----@param addr string ----@return string expanded -function resolver.expand_ipv6_addr(addr) end - ---- Generates the reverse domain name for PTR lookups for both IPv4 and IPv6 addresses. ---- ---- Compressed IPv6 addresses will be automatically expanded. ---- ---- For example, the following will yield `4.3.2.1.in-addr.arpa` for `ptr4` and `1.0.1.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.1.0.F.F.ip6.arpa` for `ptr6`: ---- ----```lua ---- local resolver = require "resty.dns.resolver" ---- local ptr4 = resolver.arpa_str("1.2.3.4") ---- local ptr6 = resolver.arpa_str("FF01::101") ----``` ---- ----@param addr string ----@return string -function resolver.arpa_str(addr) end - - -return resolver
\ No newline at end of file diff --git a/meta/3rd/OpenResty/library/resty/limit/conn.lua b/meta/3rd/OpenResty/library/resty/limit/conn.lua deleted file mode 100644 index e68c3356..00000000 --- a/meta/3rd/OpenResty/library/resty/limit/conn.lua +++ /dev/null @@ -1,11 +0,0 @@ ----@meta -resty_limit_conn={} -function resty_limit_conn.set_conn(self, conn) end -function resty_limit_conn.uncommit(self, key) end -function resty_limit_conn.is_committed(self) end -function resty_limit_conn.new(dict_name, max, burst, default_conn_delay) end -function resty_limit_conn.set_burst(self, burst) end -function resty_limit_conn.leaving(self, key, req_latency) end -function resty_limit_conn.incoming(self, key, commit) end -resty_limit_conn._VERSION="0.06" -return resty_limit_conn
\ No newline at end of file diff --git a/meta/3rd/OpenResty/library/resty/limit/count.lua b/meta/3rd/OpenResty/library/resty/limit/count.lua deleted file mode 100644 index 9c05c45c..00000000 --- a/meta/3rd/OpenResty/library/resty/limit/count.lua +++ /dev/null @@ -1,7 +0,0 @@ ----@meta -resty_limit_count={} -function resty_limit_count.uncommit(self, key) end -function resty_limit_count.incoming(self, key, commit) end -resty_limit_count._VERSION="0.06" -function resty_limit_count.new(dict_name, limit, window) end -return resty_limit_count
\ No newline at end of file diff --git a/meta/3rd/OpenResty/library/resty/limit/req.lua b/meta/3rd/OpenResty/library/resty/limit/req.lua deleted file mode 100644 index f75269c8..00000000 --- a/meta/3rd/OpenResty/library/resty/limit/req.lua +++ /dev/null @@ -1,9 +0,0 @@ ----@meta -resty_limit_req={} -function resty_limit_req.set_rate(self, rate) end -function resty_limit_req.uncommit(self, key) end -function resty_limit_req.set_burst(self, burst) end -function resty_limit_req.new(dict_name, rate, burst) end -function resty_limit_req.incoming(self, key, commit) end -resty_limit_req._VERSION="0.06" -return resty_limit_req
\ No newline at end of file diff --git a/meta/3rd/OpenResty/library/resty/limit/traffic.lua b/meta/3rd/OpenResty/library/resty/limit/traffic.lua deleted file mode 100644 index f3e53e16..00000000 --- a/meta/3rd/OpenResty/library/resty/limit/traffic.lua +++ /dev/null @@ -1,5 +0,0 @@ ----@meta -resty_limit_traffic={} -resty_limit_traffic._VERSION="0.06" -function resty_limit_traffic.combine(limiters, keys, states) end -return resty_limit_traffic
\ No newline at end of file diff --git a/meta/3rd/OpenResty/library/resty/lock.lua b/meta/3rd/OpenResty/library/resty/lock.lua deleted file mode 100644 index e5543597..00000000 --- a/meta/3rd/OpenResty/library/resty/lock.lua +++ /dev/null @@ -1,127 +0,0 @@ ----@meta - ---- lua-resty-lock ---- ---- https://github.com/openresty/lua-resty-lock ---- ----@class resty.lock : table -local lock = { - _VERSION = "0.08", -} - - ----@class resty.lock.opts : table ---- ---- Specifies expiration time (in seconds) for the lock entry in the shared memory ---- dictionary. You can specify up to 0.001 seconds. Default to 30 (seconds). Even ---- if the invoker does not call unlock or the object holding the lock is not GC'd, ---- the lock will be released after this time. So deadlock won't happen even when the ---- worker process holding the lock crashes. ----@field exptime number ---- ---- Specifies the maximal waiting time (in seconds) for the lock method calls on ---- the current object instance. You can specify up to 0.001 seconds. Default to 5 ---- (seconds). This option value cannot be bigger than `exptime`. This timeout is ---- to prevent a lock method call from waiting forever. You can specify 0 to make ---- the lock method return immediately without waiting if it cannot acquire the ---- lock right away. ----@field timeout number ---- ---- Specifies the initial step (in seconds) of sleeping when waiting for the lock. ---- Default to 0.001 (seconds). When the lock method is waiting on a busy lock, it ---- sleeps by steps. The step size is increased by a ratio (specified by the ratio ---- option) until reaching the step size limit (specified by the max_step option). ----@field step number ---- ---- Specifies the step increasing ratio. Default to 2, that is, the step size ---- doubles at each waiting iteration. ----@field ratio number ---- ---- Specifies the maximal step size (i.e., sleep interval, in seconds) allowed. ---- See also the step and ratio options). Default to 0.5 (seconds). ----@field max_step number - - ---- Creates a new lock object instance by specifying the shared dictionary name ---- (created by `lua_shared_dict`) and an optional options table `opts`. ---- ----@param dict_name string ----@param opts? resty.lock.opts ----@return resty.lock? lock ----@return string? err -function lock.new(_, dict_name, opts) end - ---- Tries to lock a key across all the Nginx worker processes in the current ---- NGINX server instance. Different keys are different locks. ---- ---- The length of the key string must not be larger than 65535 bytes. ---- ---- Returns the waiting time (in seconds) if the lock is successfully acquired. ---- Otherwise returns `nil` and a string describing the error. ---- ---- The waiting time is not from the wallclock, but rather is from simply adding ---- up all the waiting "steps". A nonzero elapsed return value indicates that ---- someone else has just hold this lock. But a zero return value cannot gurantee ---- that no one else has just acquired and released the lock. ---- ---- When this method is waiting on fetching the lock, no operating system threads ---- will be blocked and the current Lua "light thread" will be automatically yielded ---- behind the scene. ---- ---- It is strongly recommended to always call the unlock() method to actively ---- release the lock as soon as possible. ---- ---- If the `unlock()` method is never called after this method call, the lock ---- will get released when ---- ---- The current `resty.lock` object instance is collected automatically by the Lua GC. ---- OR ---- The exptime for the lock entry is reached. ---- ---- Common errors for this method call is ---- ---- "timeout" : The timeout threshold specified by the timeout option of the new method is exceeded. ---- "locked" : The current `resty.lock` object instance is already holding a lock (not necessarily of the same key). ---- ---- Other possible errors are from ngx_lua's shared dictionary API. ---- ---- It is required to create different `resty.lock` instances for multiple ---- simultaneous locks (i.e., those around different keys). ---- ----@param key string ----@return number? elapsed ----@return string? error -function lock:lock(key) end - ---- Releases the lock held by the current `resty.lock` object instance. ---- ---- Returns 1 on success. Returns `nil` and a string describing the error otherwise. ---- ---- If you call unlock when no lock is currently held, the error "unlocked" will ---- be returned. ---- ----@return boolean ok ----@return string? error -function lock:unlock() end - ---- Sets the TTL of the lock held by the current `resty.lock` object instance. ---- This will reset the timeout of the lock to timeout seconds if it is given, ---- otherwise the timeout provided while calling new will be used. ---- ---- Note that the timeout supplied inside this function is independent from the ---- timeout provided while calling new. Calling `expire()` will not change the ---- timeout value specified inside new and subsequent `expire(nil)` call will ---- still use the timeout number from new. ---- ---- Returns true on success. Returns `nil` and a string describing the error ---- otherwise. ---- ---- If you call expire when no lock is currently held, the error "unlocked" will ---- be returned. ---- ----@param timeout? number ----@return boolean ok ----@return string? error -function lock:expire(timeout) end - -return lock
\ No newline at end of file diff --git a/meta/3rd/OpenResty/library/resty/lrucache.lua b/meta/3rd/OpenResty/library/resty/lrucache.lua deleted file mode 100644 index c7e675b9..00000000 --- a/meta/3rd/OpenResty/library/resty/lrucache.lua +++ /dev/null @@ -1,115 +0,0 @@ ----@meta - ----@class resty.lrucache : table -local lrucache = { - _VERSION = "0.11", -} - ---- User flags value associated with the item to be stored. ---- ---- It can be retrieved later with the item. The user flags are stored as an ---- unsigned 32-bit integer internally, and thus must be specified as a Lua ---- number. If not specified, flags will have a default value of 0. This ---- argument was added in the v0.10 release. ---- ----@alias resty.lrucache.flags integer - ---- Creates a new cache instance. ---- ---- Upon failure, returns nil and a string describing the error. ---- ----@param max_items number specifies the maximal number of items this cache can hold. ----@return resty.lrucache? cache ----@return string? error -function lrucache.new(max_items) end - - ---- Sets a key with a value and an expiration time. ---- ---- When the cache is full, the cache will automatically evict the least ---- recently used item. ---- ---- ----@param key string ----@param value any ----@param ttl? number Expiration time, in seconds. If omitted, the value never expires. ----@param flags? resty.lrucache.flags -function lrucache:set(key, value, ttl, flags) end - - ---- Fetches a value with the key. ---- ---- If the key does not exist in the cache or has already expired, `nil` will ---- be returned. ---- ---- Starting from v0.03, the stale data is also returned as the second return ---- value if available. ---- ----@param key string ----@return any? data ----@return any? stale_data ----@return resty.lrucache.flags? integer -function lrucache:get(key) end - - ---- Removes an item specified by the key from the cache. ---- ----@param key string -function lrucache:delete(key) end - - ---- Returns the number of items currently stored in the cache, including expired ---- items if any. ---- ---- The returned count value will always be greater or equal to 0 and smaller ---- than or equal to the size argument given to cache:new. ---- ---- This method was added in the v0.10 release. ---- ----@return integer -function lrucache:count() end - - ---- Returns the maximum number of items the cache can hold. ---- ---- The return value is the same as the size argument given to ---- `resty.lrucache.new()` when the cache was created. ---- ---- This method was added in the v0.10 release. ---- ----@return integer -function lrucache:capacity() end - - ---- Fetch the list of keys currently inside the cache, up to `max_count`. ---- ---- The keys will be ordered in MRU fashion (Most-Recently-Used keys first). ---- ---- This function returns a Lua (array) table (with integer keys) containing ---- the keys. ---- ---- When `max_count` is `nil` or `0`, all keys (if any) will be returned. ---- ---- When provided with a `res` table argument, this function will not allocate a ---- table and will instead insert the keys in `res`, along with a trailing `nil` ---- value. ---- ---- This method was added in the v0.10 release. ---- ----@param max_count? integer ----@param res? table ----@return table keys -function lrucache:get_keys(max_count, res) end - - ---- Flushes all the existing data (if any) in the current cache instance. ---- ---- This is an O(1) operation and should be much faster than creating a brand ---- new cache instance. ---- ---- Note however that the `flush_all()` method of `resty.lrucache.pureffi` is any ---- O(n) operation. -function lrucache:flush_all() end - - -return lrucache
\ No newline at end of file diff --git a/meta/3rd/OpenResty/library/resty/lrucache/pureffi.lua b/meta/3rd/OpenResty/library/resty/lrucache/pureffi.lua deleted file mode 100644 index af5e9821..00000000 --- a/meta/3rd/OpenResty/library/resty/lrucache/pureffi.lua +++ /dev/null @@ -1,18 +0,0 @@ ----@meta - ----@class resty.lrucache.pureffi : resty.lrucache -local lrucache_pureffi = { - _VERSION = "0.11", -} - ---- Creates a new cache instance. ---- ---- Upon failure, returns nil and a string describing the error. ---- ----@param max_items number specifies the maximal number of items this cache can hold. ----@param load_factor? number designates the "load factor" of the FFI-based hash-table used internally by `resty.lrucache.pureffi`; the default value is 0.5 (i.e. 50%); if the load factor is specified, it will be clamped to the range of [0.1, 1] (i.e. if load factor is greater than 1, it will be saturated to 1; likewise, if load-factor is smaller than 0.1, it will be clamped to 0.1). ----@return resty.lrucache.pureffi? cache ----@return string? error -function lrucache_pureffi.new(max_items, load_factor) end - -return lrucache_pureffi
\ No newline at end of file diff --git a/meta/3rd/OpenResty/library/resty/md5.lua b/meta/3rd/OpenResty/library/resty/md5.lua deleted file mode 100644 index de82b49e..00000000 --- a/meta/3rd/OpenResty/library/resty/md5.lua +++ /dev/null @@ -1,16 +0,0 @@ ----@meta - ----@class resty.md5 : resty.string.checksum -local md5={} - ---- Create a new md5 checksum object. ----@return resty.md5 -function md5:new() end - ---- Add a string to the md5 checksum data ----@param s string ----@param len? number Optional length (defaults to the length of `s`) ----@return boolean ok -function md5:update(s, len) end - -return md5
\ No newline at end of file diff --git a/meta/3rd/OpenResty/library/resty/memcached.lua b/meta/3rd/OpenResty/library/resty/memcached.lua deleted file mode 100644 index 79092d4c..00000000 --- a/meta/3rd/OpenResty/library/resty/memcached.lua +++ /dev/null @@ -1,27 +0,0 @@ ----@meta -resty_memcached={} -function resty_memcached.cas(self, key, value, cas_uniq, exptime, flags) end -function resty_memcached.new(self, opts) end -function resty_memcached.append(self, ...) end -function resty_memcached.gets(self, key) end -function resty_memcached.quit(self) end -function resty_memcached.get_reused_times(self) end -function resty_memcached.close(self) end -function resty_memcached.touch(self, key, exptime) end -function resty_memcached.replace(self, ...) end -function resty_memcached.delete(self, key) end -function resty_memcached.version(self) end -function resty_memcached.set(self, ...) end -function resty_memcached.stats(self, args) end -function resty_memcached.flush_all(self, time) end -function resty_memcached.add(self, ...) end -function resty_memcached.set_timeout(self, timeout) end -function resty_memcached.incr(self, key, value) end -function resty_memcached.set_keepalive(self, ...) end -function resty_memcached.connect(self, ...) end -function resty_memcached.prepend(self, ...) end -function resty_memcached.decr(self, key, value) end -function resty_memcached.verbosity(self, level) end -resty_memcached._VERSION="0.13" -function resty_memcached.get(self, key) end -return resty_memcached
\ No newline at end of file diff --git a/meta/3rd/OpenResty/library/resty/mysql.lua b/meta/3rd/OpenResty/library/resty/mysql.lua deleted file mode 100644 index 540d5d00..00000000 --- a/meta/3rd/OpenResty/library/resty/mysql.lua +++ /dev/null @@ -1,15 +0,0 @@ ----@meta -resty_mysql={} -function resty_mysql.read_result() end -function resty_mysql.new(self) end -function resty_mysql.connect(self, opts) end -function resty_mysql.server_ver(self) end -function resty_mysql.send_query() end -function resty_mysql.set_keepalive(self, ...) end -function resty_mysql.set_compact_arrays(self, value) end -function resty_mysql.query(self, query, est_nrows) end -function resty_mysql.set_timeout(self, timeout) end -function resty_mysql.close(self) end -resty_mysql._VERSION="0.21" -function resty_mysql.get_reused_times(self) end -return resty_mysql
\ No newline at end of file diff --git a/meta/3rd/OpenResty/library/resty/random.lua b/meta/3rd/OpenResty/library/resty/random.lua deleted file mode 100644 index c71dae05..00000000 --- a/meta/3rd/OpenResty/library/resty/random.lua +++ /dev/null @@ -1,10 +0,0 @@ ----@meta -local random={} - ---- Generate random bytes. ----@param len integer ----@param strong boolean ----@return string -function random.bytes(len, strong) end - -return random
\ No newline at end of file diff --git a/meta/3rd/OpenResty/library/resty/redis.lua b/meta/3rd/OpenResty/library/resty/redis.lua deleted file mode 100644 index 6238f338..00000000 --- a/meta/3rd/OpenResty/library/resty/redis.lua +++ /dev/null @@ -1,57 +0,0 @@ ----@meta -resty_redis={} -function resty_redis.lrange() end -function resty_redis.new(self) end -function resty_redis.hset() end -function resty_redis.hexists() end -function resty_redis.punsubscribe() end -function resty_redis.incr() end -function resty_redis.lindex() end -function resty_redis.read_reply(self) end -function resty_redis.sismember() end -function resty_redis.set() end -function resty_redis.unsubscribe() end -function resty_redis.linsert() end -function resty_redis.zrem() end -function resty_redis.add_commands(...) end -function resty_redis.array_to_hash(self, t) end -function resty_redis.mset() end -function resty_redis.commit_pipeline(self) end -function resty_redis.zrange() end -function resty_redis.auth() end -function resty_redis.cancel_pipeline(self) end -resty_redis._VERSION="0.27" -function resty_redis.eval() end -function resty_redis.expire() end -function resty_redis.sdiff() end -function resty_redis.sinter() end -function resty_redis.hmset(self, hashname, ...) end -function resty_redis.zrank() end -function resty_redis.psubscribe() end -function resty_redis.sunion() end -function resty_redis.sadd() end -function resty_redis.srem() end -function resty_redis.script() end -function resty_redis.lpush() end -function resty_redis.init_pipeline(self, n) end -function resty_redis.zincrby() end -function resty_redis.get_reused_times(self) end -function resty_redis.zrangebyscore() end -function resty_redis.zadd() end -function resty_redis.subscribe() end -function resty_redis.hdel() end -function resty_redis.hget() end -function resty_redis.sort() end -function resty_redis.smembers() end -function resty_redis.connect(self, ...) end -function resty_redis.hmget() end -function resty_redis.set_timeout(self, timeout) end -function resty_redis.mget() end -function resty_redis.set_keepalive(self, ...) end -function resty_redis.llen() end -function resty_redis.del() end -function resty_redis.decr() end -function resty_redis.lpop() end -function resty_redis.close() end -function resty_redis.get() end -return resty_redis
\ No newline at end of file diff --git a/meta/3rd/OpenResty/library/resty/sha.lua b/meta/3rd/OpenResty/library/resty/sha.lua deleted file mode 100644 index 716d0bd1..00000000 --- a/meta/3rd/OpenResty/library/resty/sha.lua +++ /dev/null @@ -1,4 +0,0 @@ ----@meta -local resty_sha={} -resty_sha._VERSION = require("resty.string")._VERSION -return resty_sha
\ No newline at end of file diff --git a/meta/3rd/OpenResty/library/resty/sha1.lua b/meta/3rd/OpenResty/library/resty/sha1.lua deleted file mode 100644 index 85d5ace1..00000000 --- a/meta/3rd/OpenResty/library/resty/sha1.lua +++ /dev/null @@ -1,10 +0,0 @@ ----@meta - ----@class resty.sha1 : resty.string.checksum -local sha1={} - ---- Create a new sha1 checksum object. ----@return resty.sha1 -function sha1:new() end - -return sha1
\ No newline at end of file diff --git a/meta/3rd/OpenResty/library/resty/sha224.lua b/meta/3rd/OpenResty/library/resty/sha224.lua deleted file mode 100644 index b45f55cb..00000000 --- a/meta/3rd/OpenResty/library/resty/sha224.lua +++ /dev/null @@ -1,10 +0,0 @@ ----@meta - ----@class resty.sha244 : resty.string.checksum -local sha224={} - ---- Create a new sha244 checksum object. ----@return resty.sha244 -function sha224:new() end - -return sha224
\ No newline at end of file diff --git a/meta/3rd/OpenResty/library/resty/sha256.lua b/meta/3rd/OpenResty/library/resty/sha256.lua deleted file mode 100644 index 29e00eeb..00000000 --- a/meta/3rd/OpenResty/library/resty/sha256.lua +++ /dev/null @@ -1,10 +0,0 @@ ----@meta - ----@class resty.sha256 : resty.string.checksum -local sha256={} - ---- Create a new sha256 checksum object. ----@return resty.sha256 -function sha256:new() end - -return sha256
\ No newline at end of file diff --git a/meta/3rd/OpenResty/library/resty/sha384.lua b/meta/3rd/OpenResty/library/resty/sha384.lua deleted file mode 100644 index f0e6e7b3..00000000 --- a/meta/3rd/OpenResty/library/resty/sha384.lua +++ /dev/null @@ -1,10 +0,0 @@ ----@meta - ----@class resty.sha384 : resty.string.checksum -local sha384={} - ---- Create a new sha384 checksum object. ----@return resty.sha384 -function sha384:new() end - -return sha384
\ No newline at end of file diff --git a/meta/3rd/OpenResty/library/resty/sha512.lua b/meta/3rd/OpenResty/library/resty/sha512.lua deleted file mode 100644 index afa1e946..00000000 --- a/meta/3rd/OpenResty/library/resty/sha512.lua +++ /dev/null @@ -1,10 +0,0 @@ ----@meta - ----@class resty.sha512 : resty.string.checksum -local sha512={} - ---- Create a new sha512 checksum object. ----@return resty.sha512 -function sha512:new() end - -return sha512
\ No newline at end of file diff --git a/meta/3rd/OpenResty/library/resty/shell.lua b/meta/3rd/OpenResty/library/resty/shell.lua deleted file mode 100644 index be2d41ea..00000000 --- a/meta/3rd/OpenResty/library/resty/shell.lua +++ /dev/null @@ -1,62 +0,0 @@ ----@meta - -local shell = { - version = 0.03, -} - - ---- Runs a shell command, `cmd`, with an optional stdin. ---- ---- The `cmd` argument can either be a single string value (e.g. `"echo 'hello, ---- world'"`) or an array-like Lua table (e.g. `{"echo", "hello, world"}`). The ---- former is equivalent to `{"/bin/sh", "-c", "echo 'hello, world'"}`, but simpler ---- and slightly faster. ---- ---- When the `stdin` argument is `nil` or `""`, the stdin device will immediately ---- be closed. ---- ---- The `timeout` argument specifies the timeout threshold (in ms) for ---- stderr/stdout reading timeout, stdin writing timeout, and process waiting ---- timeout. The default is 10 seconds as per https://github.com/openresty/lua-resty-core/blob/master/lib/ngx/pipe.md#set_timeouts ---- ---- The `max_size` argument specifies the maximum size allowed for each output ---- data stream of stdout and stderr. When exceeding the limit, the `run()` ---- function will immediately stop reading any more data from the stream and return ---- an error string in the `reason` return value: `"failed to read stdout: too much ---- data"`. ---- ---- Upon terminating successfully (with a zero exit status), `ok` will be `true`, ---- `reason` will be `"exit"`, and `status` will hold the sub-process exit status. ---- ---- Upon terminating abnormally (non-zero exit status), `ok` will be `false`, ---- `reason` will be `"exit"`, and `status` will hold the sub-process exit status. ---- ---- Upon exceeding a timeout threshold or any other unexpected error, `ok` will be ---- `nil`, and `reason` will be a string describing the error. ---- ---- When a timeout threshold is exceeded, the sub-process will be terminated as ---- such: ---- ---- 1. first, by receiving a `SIGTERM` signal from this library, ---- 2. then, after 1ms, by receiving a `SIGKILL` signal from this library. ---- ---- Note that child processes of the sub-process (if any) will not be terminated. ---- You may need to terminate these processes yourself. ---- ---- When the sub-process is terminated by a UNIX signal, the `reason` return value ---- will be `"signal"` and the `status` return value will hold the signal number. ---- ----@param cmd string|string[] ----@param stdin? string ----@param timeout? number ----@param max_size? number ---- ----@return boolean ok ----@return string? stdout ----@return string? stderr ----@return string|'"exit"'|'"signal"' reason ----@return number? status -function shell.run(cmd, stdin, timeout, max_size) end - - -return shell
\ No newline at end of file diff --git a/meta/3rd/OpenResty/library/resty/signal.lua b/meta/3rd/OpenResty/library/resty/signal.lua deleted file mode 100644 index a7e42d42..00000000 --- a/meta/3rd/OpenResty/library/resty/signal.lua +++ /dev/null @@ -1,74 +0,0 @@ ----@meta - -local signal = { - version = 0.03, -} - - ----@alias resty.signal.name ----| "NONE" # SIG_NONE ----| "HUP" # SIG_HUP ----| "INT" # SIG_INT ----| "QUIT" # SIG_QUIT ----| "ILL" # SIG_ILL ----| "TRAP" # SIG_TRAP ----| "ABRT" # SIG_ABRT ----| "BUS" # SIG_BUS ----| "FPE" # SIG_FPE ----| "KILL" # SIG_KILL ----| "USR1" # SIG_USR1 ----| "SEGV" # SIG_SEGV ----| "USR2" # SIG_USR2 ----| "PIPE" # SIG_PIPE ----| "ALRM" # SIG_ALRM ----| "TERM" # SIG_TERM ----| "CHLD" # SIG_CHLD ----| "CONT" # SIG_CONT ----| "STOP" # SIG_STOP ----| "TSTP" # SIG_TSTP ----| "TTIN" # SIG_TTIN ----| "TTOU" # SIG_TTOU ----| "URG" # SIG_URG ----| "XCPU" # SIG_XCPU ----| "XFSZ" # SIG_XFSZ ----| "VTALRM" # SIG_VTALRM ----| "PROF" # SIG_PROF ----| "WINCH" # SIG_WINCH ----| "IO" # SIG_IO ----| "PWR" # SIG_PWR ----| "EMT" # SIG_EMT ----| "SYS" # SIG_SYS ----| "INFO" # SIG_INFO - - ----@alias resty.signal.signal ----| resty.signal.name ----| integer ----| string - - ---- --- Sends a signal with its name string or number value to the process of the specified pid. --- --- All signal names accepted by signum are supported, like HUP, KILL, and TERM. --- --- Signal numbers are also supported when specifying nonportable system-specific signals is desired. --- ----@param pid number ----@param signal_name_or_num resty.signal.signal ---- ----@return boolean ok ----@return string? error -function signal.kill(pid, signal_name_or_num) end - - ---- --- Maps the signal name specified to the system-specific signal number. --- Returns `nil` if the signal name is not known. --- ----@param name string|resty.signal.name ----@return integer|nil -function signal.signum(name) end - - -return signal
\ No newline at end of file diff --git a/meta/3rd/OpenResty/library/resty/string.lua b/meta/3rd/OpenResty/library/resty/string.lua deleted file mode 100644 index e9852da8..00000000 --- a/meta/3rd/OpenResty/library/resty/string.lua +++ /dev/null @@ -1,75 +0,0 @@ ----@meta - ---- OpenResty string functions. ---- https://github.com/openresty/lua-resty-string -local str = { - _VERSION = "0.14", -} - - ---- Encode byte string in hexidecimal. ---- ---- This is most useful for retrieving a printable string from a checksum ---- result. ---- ---- Usage: ---- ----```lua ---- local str = require "resty.string" ---- local md5 = require "resty.md5" ---- ---- local sum = md5:new() ---- sum:update("hello") ---- sum:update("goodbye") ---- local digest = sum:final() ---- print(str.to_hex(digest)) --> 441add4718519b71e42d329a834d6d5e ----``` ----@param s string ----@return string hex -function str.to_hex(s) end - ---- Convert an ASCII string to an integer. ---- ---- If the string is not numeric, `-1` is returned. ---- ---- Usage: ---- ----```lua ---- local str = require "resty.string" ---- print(str.atoi("250")) --> 250 ---- print(str.atoi("abc")) --> -1 ----``` ---- ----@param s string ----@return number -function str.atoi(s) end - - ---- A lua-resty-string checksum object. ----@class resty.string.checksum : table -local checksum = { - _VERSION = str._VERSION, -} - ---- Create a new checksum object. ----@return resty.string.checksum? -function checksum:new() end - ---- Add a string to the checksum data. ---- ---- This can be called multiple times. ---- ----@param s string ----@return boolean ok -function checksum:update(s) end - ---- Calculate the final checksum. ----@return string? digest -function checksum:final() end - ---- Reset the checksum object. ----@return boolean ok -function checksum:reset() end - - -return str
\ No newline at end of file diff --git a/meta/3rd/OpenResty/library/resty/upload.lua b/meta/3rd/OpenResty/library/resty/upload.lua deleted file mode 100644 index 505bf766..00000000 --- a/meta/3rd/OpenResty/library/resty/upload.lua +++ /dev/null @@ -1,7 +0,0 @@ ----@meta -resty_upload={} -function resty_upload.read(self) end -function resty_upload.set_timeout(self, timeout) end -resty_upload._VERSION="0.10" -function resty_upload.new(self, chunk_size, max_line_size) end -return resty_upload
\ No newline at end of file diff --git a/meta/3rd/OpenResty/library/resty/upstream/healthcheck.lua b/meta/3rd/OpenResty/library/resty/upstream/healthcheck.lua deleted file mode 100644 index 824dc183..00000000 --- a/meta/3rd/OpenResty/library/resty/upstream/healthcheck.lua +++ /dev/null @@ -1,6 +0,0 @@ ----@meta -resty_upstream_healthcheck={} -function resty_upstream_healthcheck.status_page() end -resty_upstream_healthcheck._VERSION="0.05" -function resty_upstream_healthcheck.spawn_checker(opts) end -return resty_upstream_healthcheck
\ No newline at end of file diff --git a/meta/3rd/OpenResty/library/resty/websocket/client.lua b/meta/3rd/OpenResty/library/resty/websocket/client.lua deleted file mode 100644 index 12615483..00000000 --- a/meta/3rd/OpenResty/library/resty/websocket/client.lua +++ /dev/null @@ -1,63 +0,0 @@ ----@meta - ----@class resty.websocket.client : resty.websocket -local client = { - _VERSION = "0.09" -} - ----Instantiates a WebSocket client object. ---- ----In case of error, it returns nil and a string describing the error. ---- ----An optional options table can be specified. ---- ----@param opts? resty.websocket.new.opts ----@return resty.websocket.client? client ----@return string? error -function client:new(opts) end - ----Connects to the remote WebSocket service port and performs the websocket ----handshake process on the client side. ---- ----Before actually resolving the host name and connecting to the remote backend, ----this method will always look up the connection pool for matched idle ----connections created by previous calls of this method. ---- ----@param url string ----@param opts? resty.websocket.client.connect.opts ----@return boolean ok ----@return string? error -function client:connect(uri, opts) end - ---- Puts the current WebSocket connection immediately into the ngx_lua cosocket connection pool. ---- ---- You can specify the max idle timeout (in ms) when the connection is in the pool and the maximal size of the pool every nginx worker process. ---- ---- In case of success, returns 1. In case of errors, returns nil with a string describing the error. ---- ---- Only call this method in the place you would have called the close method instead. Calling this method will immediately turn the current WebSocket object into the closed state. Any subsequent operations other than connect() on the current object will return the closed error. ----- ----@param max_idle_timeout number ----@param pool_size integer ----@return boolean ok ----@return string? error -function client:set_keepalive(max_idle_timeout, pool_size) end - ----Closes the current WebSocket connection. ---- ----If no close frame is sent yet, then the close frame will be automatically sent. ---- ----@return boolean ok ----@return string? error -function client:close() end - ----@class resty.websocket.client.connect.opts : table ---- ----@field protocols string|string[] subprotocol(s) used for the current WebSocket session ----@field origin string the value of the Origin request header ----@field pool string custom name for the connection pool being used. If omitted, then the connection pool name will be generated from the string template <host>:<port>. ----@field ssl_verify boolean whether to perform SSL certificate verification during the SSL handshake if the wss:// scheme is used. ----@field headers string[] custom headers to be sent in the handshake request. The table is expected to contain strings in the format {"a-header: a header value", "another-header: another header value"}. - - -return client
\ No newline at end of file diff --git a/meta/3rd/OpenResty/library/resty/websocket/protocol.lua b/meta/3rd/OpenResty/library/resty/websocket/protocol.lua deleted file mode 100644 index 23591928..00000000 --- a/meta/3rd/OpenResty/library/resty/websocket/protocol.lua +++ /dev/null @@ -1,173 +0,0 @@ ----@meta - ----@class resty.websocket.protocol -local protocol = { - _VERSION = "0.09", -} - ---- websocket object ---- https://github.com/openresty/lua-resty-websocket ---- ----@class resty.websocket : table ----@field sock tcpsock ----@field fatal boolean ----@field max_payload_len number ----@field send_masked boolean -local websocket = {} - ----@param ms integer sets the timeout delay (in milliseconds) for the network-related operations -function websocket:set_timeout(ms) end - ----Sends the text argument out as an unfragmented data frame of the text type. ---- ----Returns the number of bytes that have actually been sent on the TCP level. ---- ----In case of errors, returns nil and a string describing the error. ---- ----@param text string ----@return integer? bytes ----@return string? error -function websocket:send_text(text) end - ----Sends the data argument out as an unfragmented data frame of the binary type. ---- ----Returns the number of bytes that have actually been sent on the TCP level. ---- ----In case of errors, returns nil and a string describing the error. ---- ----@param data string ----@return integer? bytes ----@return string? error -function websocket:send_binary(data) end - ----Sends out a ping frame with an optional message specified by the msg argument. ----Returns the number of bytes that have actually been sent on the TCP level. ---- ----In case of errors, returns nil and a string describing the error. ---- ----Note that this method does not wait for a pong frame from the remote end. ---- ----@param msg? string ----@return integer? bytes ----@return string? error -function websocket:send_ping(msg) end - ----Sends out a pong frame with an optional message specified by the msg argument. ----Returns the number of bytes that have actually been sent on the TCP level. ---- ----In case of errors, returns nil and a string describing the error. ----@param msg? string ----@return integer? bytes ----@return string? error -function websocket:send_pong(msg) end - ----Sends out a close frame with an optional status code and a message. ---- ----In case of errors, returns nil and a string describing the error. ---- ----For a list of valid status code, see the following document: ---- ----http://tools.ietf.org/html/rfc6455#section-7.4.1 ---- ----Note that this method does not wait for a close frame from the remote end. ----@param code? integer ----@param msg? string ----@return integer? bytes ----@return string? error -function websocket:send_close(code, msg) end - ----Sends out a raw websocket frame by specifying the fin field (boolean value), the opcode, and the payload. ---- ----For a list of valid opcode, see ---- ----http://tools.ietf.org/html/rfc6455#section-5.2 ---- ----In case of errors, returns nil and a string describing the error. ---- ----To control the maximal payload length allowed, you can pass the max_payload_len option to the new constructor. ---- ----To control whether to send masked frames, you can pass true to the send_masked option in the new constructor method. By default, unmasked frames are sent. ----@param fin boolean ----@param opcode resty.websocket.protocol.opcode ----@param payload string ----@return integer? bytes ----@return string? error -function websocket:send_frame(fin, opcode, payload) end - ----Receives a WebSocket frame from the wire. ---- ----In case of an error, returns two nil values and a string describing the error. ---- ----The second return value is always the frame type, which could be one of continuation, text, binary, close, ping, pong, or nil (for unknown types). ---- ----For close frames, returns 3 values: the extra status message (which could be an empty string), the string "close", and a Lua number for the status code (if any). For possible closing status codes, see ---- ----http://tools.ietf.org/html/rfc6455#section-7.4.1 ---- ----For other types of frames, just returns the payload and the type. ---- ----For fragmented frames, the err return value is the Lua string "again". ---- ----@return string? data ----@return resty.websocket.protocol.type? typ ----@return string|integer? error_or_status_code -function websocket:recv_frame() end - ----@class resty.websocket.new.opts : table ----@field max_payload_len integer maximal length of payload allowed when sending and receiving WebSocket frames ----@field send_masked boolean whether to send out masked WebSocket frames ----@field timeout integer network timeout threshold in milliseconds - - ---- Websocket op code ---- ---- Defines the interpretation of the payload data. ---- ---- See RFC 6455 section 5.2 ---- ----@alias resty.websocket.protocol.opcode ----| '0x0' # continuation ----| '0x1' # text ----| '0x2' # binary ----| '0x8' # close ----| '0x9' # ping ----| '0xa' # pong - ----@alias resty.websocket.protocol.type ----| '"continuation"' ----| '"text"' ----| '"binary"' ----| '"close"' ----| '"ping"' ----| '"pong"' - ---- Builds a raw WebSocket frame. ----@param fin boolean ----@param opcode resty.websocket.protocol.opcode ----@param payload_len integer ----@param payload string ----@param masking boolean ----@return string -function protocol.build_frame(fin, opcode, payload_len, payload, masking) end - ---- Sends a raw WebSocket frame. ----@param sock tcpsock ----@param fin boolean ----@param opcode resty.websocket.protocol.opcode ----@param payload string ----@param max_payload_len interger ----@param masking boolean ----@return bytes? number ----@return string? error -function protocol.send_frame(sock, fin, opcode, payload, max_payload_len, masking) end - ---- Receives a WebSocket frame from the wire. ----@param sock tcpsock ----@param max_payload_len interger ----@param force_masking boolean ----@return string? data ----@return resty.websocket.protocol.type? typ ----@return string? error -function protocol.recv_frame(sock, max_payload_len, force_masking) end - -return protocol
\ No newline at end of file diff --git a/meta/3rd/OpenResty/library/resty/websocket/server.lua b/meta/3rd/OpenResty/library/resty/websocket/server.lua deleted file mode 100644 index c8f502a2..00000000 --- a/meta/3rd/OpenResty/library/resty/websocket/server.lua +++ /dev/null @@ -1,16 +0,0 @@ ----@meta - ----@class resty.websocket.server : resty.websocket -local server = { - _VERSION = "0.09" -} - ----Performs the websocket handshake process on the server side and returns a WebSocket server object. ---- ----In case of error, it returns nil and a string describing the error. ----@param opts? resty.websocket.new.opts ----@return resty.websocket.server? server ----@return string? error -function server:new(opts) end - -return server
\ No newline at end of file diff --git a/meta/3rd/OpenResty/library/table/clone.lua b/meta/3rd/OpenResty/library/table/clone.lua deleted file mode 100644 index ff2ce870..00000000 --- a/meta/3rd/OpenResty/library/table/clone.lua +++ /dev/null @@ -1,25 +0,0 @@ ----@meta - ---- Returns a shallow copy of the given Lua table. ---- ---- This API can be JIT compiled. ---- ---- Usage: ---- ---- ```lua ---- local clone = require "table.clone" ---- ---- local x = {x=12, y={5, 6, 7}} ---- local y = clone(x) ---- ``` ---- ---- **Note:** We observe 7% over-all speedup in the edgelang-fan compiler's ---- compiling speed whose Lua is generated by the fanlang compiler. ---- ---- **Note bis:** Deep cloning is planned to be supported by adding `true` as a second argument. ---- ----@param t table ----@return table -local function clone(t) end - -return clone diff --git a/meta/3rd/OpenResty/library/table/isarray.lua b/meta/3rd/OpenResty/library/table/isarray.lua deleted file mode 100644 index f2ee3c72..00000000 --- a/meta/3rd/OpenResty/library/table/isarray.lua +++ /dev/null @@ -1,23 +0,0 @@ ----@meta - ---- Returns `true` when the given Lua table is a pure array-like Lua table, or ---- `false` otherwise. ---- ---- Empty Lua tables are treated as arrays. ---- ---- This API can be JIT compiled. ---- ---- Usage: ---- ---- ```lua ---- local isarray = require "table.isarray" ---- ---- print(isarray{"a", true, 3.14}) -- true ---- print(isarray{dog = 3}) -- false ---- print(isarray{}) -- true ---- ``` ----@param t table ----@return boolean -local function isarray(t) end - -return isarray diff --git a/meta/3rd/OpenResty/library/table/isempty.lua b/meta/3rd/OpenResty/library/table/isempty.lua deleted file mode 100644 index b1cef6fb..00000000 --- a/meta/3rd/OpenResty/library/table/isempty.lua +++ /dev/null @@ -1,22 +0,0 @@ ----@meta - ---- Returns `true` when the given Lua table contains neither non-nil array elements nor non-nil key-value pairs, or `false` otherwise. ---- ---- This API can be JIT compiled. ---- Usage: ---- ---- ```lua ---- local isempty = require "table.isempty" ---- ---- print(isempty({})) -- true ---- print(isempty({nil, dog = nil})) -- true ---- print(isempty({"a", "b"})) -- false ---- print(isempty({nil, 3})) -- false ---- print(isempty({cat = 3})) -- false ---- ``` ---- ----@param t table ----@return boolean -local function isempty(t) end - -return isempty diff --git a/meta/3rd/OpenResty/library/table/nkeys.lua b/meta/3rd/OpenResty/library/table/nkeys.lua deleted file mode 100644 index 41a42d6a..00000000 --- a/meta/3rd/OpenResty/library/table/nkeys.lua +++ /dev/null @@ -1,23 +0,0 @@ ----@meta - ---- Returns the total number of elements in a given Lua table (i.e. from both the ---- array and hash parts combined). ---- ---- This API can be JIT compiled. ---- ---- Usage: ---- ---- ```lua ---- local nkeys = require "table.nkeys" ---- ---- print(nkeys({})) -- 0 ---- print(nkeys({ "a", nil, "b" })) -- 2 ---- print(nkeys({ dog = 3, cat = 4, bird = nil })) -- 2 ---- print(nkeys({ "a", dog = 3, cat = 4 })) -- 3 ---- ``` ---- ----@param t table ----@return integer -local function nkeys(t) end - -return nkeys diff --git a/meta/3rd/OpenResty/library/tablepool.lua b/meta/3rd/OpenResty/library/tablepool.lua deleted file mode 100644 index db47f3e7..00000000 --- a/meta/3rd/OpenResty/library/tablepool.lua +++ /dev/null @@ -1,29 +0,0 @@ ----@meta -local tablepool = {} - ---- Releases the already used Lua table, `tb`, into the table pool named `pool_name`. If the specified table pool does not exist, create it right away. ---- ---- The caller must *not* continue using the released Lua table, `tb`, after this call. Otherwise random data corruption is expected. ---- ---- The optional `no_clear` parameter specifies whether to clear the contents in the Lua table `tb` before putting it into the pool. Defaults to `false`, that is, always clearing the Lua table. ---- ---- If you always initialize all the elements in the Lua table and always use the exactly same number of elements in the Lua table, then you can set this argument to `true` to avoid the overhead of explicit table clearing. ---- ---- According to the current implementation, for maximum 200 Lua tables can be cached in an individual pool. We may make this configurable in the future. If the specified table pool already exceeds its size limit, then the `tb` table is subject to garbage collection. This behavior is to avoid potential memory leak due to unbalanced `fetch` and `release` method calls. ---- ----@param pool_name string ----@param tb table ----@param no_clear? boolean -function tablepool.release(pool_name, tb, no_clear) end - ---- Fetches a (free) Lua table from the table pool of the specified name `pool_name`. ---- ---- If the pool does not exist or the pool is empty, simply create a Lua table whose array part has `narr` elements and whose hash table part has `nrec` elements. ---- ----@param pool_name string ----@param narr number size of the array-like part of the table ----@param nrec number size of the hash-like part of the table ----@return table -function tablepool.fetch(pool_name, narr, nrec) end - -return tablepool
\ No newline at end of file diff --git a/meta/3rd/OpenResty/library/thread/exdata.lua b/meta/3rd/OpenResty/library/thread/exdata.lua deleted file mode 100644 index 22573d84..00000000 --- a/meta/3rd/OpenResty/library/thread/exdata.lua +++ /dev/null @@ -1,43 +0,0 @@ ----@meta - ---- **syntax:** *exdata = th_exdata(data?)* ---- ---- This API allows for embedding user data into a thread (`lua_State`). ---- ---- The retrieved `exdata` value on the Lua land is represented as a cdata object ---- of the ctype `void*`. ---- ---- As of this version, retrieving the `exdata` (i.e. `th_exdata()` without any ---- argument) can be JIT compiled. ---- ---- Usage: ---- ---- ```lua ---- local th_exdata = require "thread.exdata" ---- ---- th_exdata(0xdeadbeefLL) -- set the exdata of the current Lua thread ---- local exdata = th_exdata() -- fetch the exdata of the current Lua thread ---- ``` ---- ---- Also available are the following public C API functions for manipulating ---- `exdata` on the C land: ---- ---- ```C ---- void lua_setexdata(lua_State *L, void *exdata); ---- void *lua_getexdata(lua_State *L); ---- ``` ---- ---- The `exdata` pointer is initialized to `NULL` when the main thread is created. ---- Any child Lua thread will inherit its parent's `exdata`, but still can override ---- it. ---- ---- **Note:** This API will not be available if LuaJIT is compiled with ---- `-DLUAJIT_DISABLE_FFI`. ---- ---- **Note bis:** This API is used internally by the OpenResty core, and it is ---- strongly discouraged to use it yourself in the context of OpenResty. ----@param data? any ----@return any? data -local function exdata(data) end - -return exdata
\ No newline at end of file diff --git a/meta/3rd/OpenResty/library/thread/exdata2.lua b/meta/3rd/OpenResty/library/thread/exdata2.lua deleted file mode 100644 index 0387849d..00000000 --- a/meta/3rd/OpenResty/library/thread/exdata2.lua +++ /dev/null @@ -1,8 +0,0 @@ ----@meta - ---- Similar to `thread.exdata` but for a 2nd separate user data as a pointer value. ----@param data? any ----@return any? data -local function exdata2(data) end - -return exdata2 diff --git a/meta/3rd/OpenResty/library/toComment.lua b/meta/3rd/OpenResty/library/toComment.lua deleted file mode 100644 index 32a4d758..00000000 --- a/meta/3rd/OpenResty/library/toComment.lua +++ /dev/null @@ -1,3 +0,0 @@ ----@meta -toComment={} -return toComment
\ No newline at end of file |