{"id":13635971,"url":"https://github.com/openresty/lua-resty-memcached","last_synced_at":"2025-04-19T04:31:44.094Z","repository":{"id":2370362,"uuid":"3334760","full_name":"openresty/lua-resty-memcached","owner":"openresty","description":"Lua memcached client driver for the ngx_lua based on the cosocket API","archived":false,"fork":false,"pushed_at":"2023-11-23T11:39:02.000Z","size":131,"stargazers_count":208,"open_issues_count":7,"forks_count":65,"subscribers_count":29,"default_branch":"master","last_synced_at":"2024-02-13T20:31:41.642Z","etag":null,"topics":[],"latest_commit_sha":null,"homepage":"","language":"Lua","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":null,"status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/openresty.png","metadata":{"files":{"readme":"README.markdown","changelog":null,"contributing":null,"funding":null,"license":null,"code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null}},"created_at":"2012-02-02T13:01:00.000Z","updated_at":"2023-07-25T13:44:12.000Z","dependencies_parsed_at":"2023-11-23T12:44:00.143Z","dependency_job_id":null,"html_url":"https://github.com/openresty/lua-resty-memcached","commit_stats":{"total_commits":158,"total_committers":13,"mean_commits":"12.153846153846153","dds":"0.15189873417721522","last_synced_commit":"122cba2b1cd36cddd941444bcdda7ba37aaad021"},"previous_names":[],"tags_count":19,"template":false,"template_full_name":null,"repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/openresty%2Flua-resty-memcached","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/openresty%2Flua-resty-memcached/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/openresty%2Flua-resty-memcached/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/openresty%2Flua-resty-memcached/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/openresty","download_url":"https://codeload.github.com/openresty/lua-resty-memcached/tar.gz/refs/heads/master","host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":249606373,"owners_count":21298851,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":[],"created_at":"2024-08-02T00:00:54.773Z","updated_at":"2025-04-19T04:31:43.837Z","avatar_url":"https://github.com/openresty.png","language":"Lua","funding_links":[],"categories":["Libraries","Third Modules","Rust Modules"],"sub_categories":["C Modules","Lua Modules"],"readme":"Name\n====\n\nlua-resty-memcached - Lua memcached client driver for the ngx_lua based on the cosocket API\n\nTable of Contents\n=================\n\n* [Name](#name)\n* [Status](#status)\n* [Description](#description)\n* [Synopsis](#synopsis)\n* [Methods](#methods)\n    * [new](#new)\n    * [connect](#connect)\n    * [sslhandshake](#sslhandshake)\n    * [set](#set)\n    * [set_timeout](#set_timeout)\n    * [set_timeouts](#set_timeouts)\n    * [set_keepalive](#set_keepalive)\n    * [get_reused_times](#get_reused_times)\n    * [close](#close)\n    * [add](#add)\n    * [replace](#replace)\n    * [append](#append)\n    * [prepend](#prepend)\n    * [get](#get)\n    * [gets](#gets)\n    * [cas](#cas)\n    * [touch](#touch)\n    * [flush_all](#flush_all)\n    * [delete](#delete)\n    * [incr](#incr)\n    * [decr](#decr)\n    * [stats](#stats)\n    * [version](#version)\n    * [quit](#quit)\n    * [verbosity](#verbosity)\n    * [init_pipeline](#init_pipeline)\n    * [commit_pipeline](#commit_pipeline)\n    * [cancel_pipeline](#cancel_pipeline)\n* [Automatic Error Logging](#automatic-error-logging)\n* [Limitations](#limitations)\n* [TODO](#todo)\n* [Author](#author)\n* [Copyright and License](#copyright-and-license)\n* [See Also](#see-also)\n\nStatus\n======\n\nThis library is considered production ready.\n\nDescription\n===========\n\nThis Lua library is a memcached client driver for the ngx_lua nginx module:\n\nhttp://wiki.nginx.org/HttpLuaModule\n\nThis Lua library takes advantage of ngx_lua's cosocket API, which ensures\n100% nonblocking behavior.\n\nNote that at least [ngx_lua 0.5.0rc29](https://github.com/chaoslawful/lua-nginx-module/tags) or [OpenResty 1.0.15.7](http://openresty.org/#Download) is required.\n\nSynopsis\n========\n\n```lua\n    lua_package_path \"/path/to/lua-resty-memcached/lib/?.lua;;\";\n\n    server {\n        location /test {\n            content_by_lua '\n                local memcached = require \"resty.memcached\"\n                local memc, err = memcached:new()\n                if not memc then\n                    ngx.say(\"failed to instantiate memc: \", err)\n                    return\n                end\n\n                memc:set_timeout(1000) -- 1 sec\n\n                -- or connect to a unix domain socket file listened\n                -- by a memcached server:\n                --     local ok, err = memc:connect(\"unix:/path/to/memc.sock\")\n\n                local ok, err = memc:connect(\"127.0.0.1\", 11211)\n                if not ok then\n                    ngx.say(\"failed to connect: \", err)\n                    return\n                end\n\n                local ok, err = memc:flush_all()\n                if not ok then\n                    ngx.say(\"failed to flush all: \", err)\n                    return\n                end\n\n                local ok, err = memc:set(\"dog\", 32)\n                if not ok then\n                    ngx.say(\"failed to set dog: \", err)\n                    return\n                end\n\n                local res, flags, err = memc:get(\"dog\")\n                if err then\n                    ngx.say(\"failed to get dog: \", err)\n                    return\n                end\n\n                if not res then\n                    ngx.say(\"dog not found\")\n                    return\n                end\n\n                ngx.say(\"dog: \", res)\n\n                -- put it into the connection pool of size 100,\n                -- with 10 seconds max idle timeout\n                local ok, err = memc:set_keepalive(10000, 100)\n                if not ok then\n                    ngx.say(\"cannot set keepalive: \", err)\n                    return\n                end\n\n                -- or just close the connection right away:\n                -- local ok, err = memc:close()\n                -- if not ok then\n                --     ngx.say(\"failed to close: \", err)\n                --     return\n                -- end\n            ';\n        }\n    }\n```\n\n[Back to TOC](#table-of-contents)\n\nMethods\n=======\n\nThe `key` argument provided in the following methods will be automatically escaped according to the URI escaping rules before sending to the memcached server.\n\n[Back to TOC](#table-of-contents)\n\nnew\n---\n`syntax: memc, err = memcached:new(opts?)`\n\nCreates a memcached object. In case of failures, returns `nil` and a string describing the error.\n\nIt accepts an optional `opts` table argument. The following options are supported:\n\n* `key_transform`\n\n    an array table containing two functions for escaping and unescaping the\n    memcached keys, respectively. By default,\n    the memcached keys will be escaped and unescaped as URI components, that is\n\n```lua\n    memached:new{\n        key_transform = { ngx.escape_uri, ngx.unescape_uri }\n    }\n```\n\n[Back to TOC](#table-of-contents)\n\nconnect\n-------\n`syntax: ok, err = memc:connect(host, port)`\n\n`syntax: ok, err = memc:connect(\"unix:/path/to/unix.sock\")`\n\nAttempts to connect to the remote host and port that the memcached server is listening to or a local unix domain socket file listened by the memcached server.\n\nBefore 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.\n\n[Back to TOC](#table-of-contents)\n\nsslhandshake\n------------\n\n**syntax:** *session, err = memc:sslhandshake(reused_session?, server_name?, ssl_verify?, send_status_req?)*\n\nDoes SSL/TLS handshake on the currently established connection. See the\n[tcpsock.sslhandshake](https://github.com/openresty/lua-nginx-module#tcpsocksslhandshake)\nAPI from OpenResty for more details.\n\n[Back to TOC](#table-of-contents)\n\nset\n---\n`syntax: ok, err = memc:set(key, value, exptime, flags)`\n\nInserts an entry into memcached unconditionally. If the key already exists, overrides it.\n\nThe `value` argument could also be a Lua table holding multiple Lua\nstrings that are supposed to be concatenated as a whole\n(without any delimiters). For example,\n\n```lua\n    memc:set(\"dog\", {\"a \", {\"kind of\"}, \" animal\"})\n```\n\nis functionally equivalent to\n\n```lua\n    memc:set(\"dog\", \"a kind of animal\")\n```\n\nThe `exptime` parameter is optional and defaults to `0` (meaning never expires). The expiration time is in seconds.\n\nThe `flags` parameter is optional and defaults to `0`.\n\n[Back to TOC](#table-of-contents)\n\nset_timeout\n----------\n`syntax: ok, err = memc:set_timeout(timeout)`\n\nSets the timeout (in ms) protection for subsequent operations, including the `connect` method.\n\nReturns 1 when successful and nil plus a string describing the error otherwise.\n\n[Back to TOC](#table-of-contents)\n\nset_timeouts\n----------\n`syntax: ok, err = memc:set_timeouts(connect_timeout, send_timeout, read_timeout)`\n\nSets the timeouts (in ms) for connect, send and read operations respectively.\n\nReturns 1 when successful and nil plus a string describing the error otherwise.\n\nset_keepalive\n------------\n`syntax: ok, err = memc:set_keepalive(max_idle_timeout, pool_size)`\n\nPuts the current memcached connection immediately into the ngx_lua cosocket connection pool.\n\nYou 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.\n\nIn case of success, returns `1`. In case of errors, returns `nil` with a string describing the error.\n\nOnly call this method in the place you would have called the `close` method instead. Calling this method will immediately turn the current memcached object into the `closed` state. Any subsequent operations other than `connect()` on the current object will return the `closed` error.\n\n[Back to TOC](#table-of-contents)\n\nget_reused_times\n----------------\n`syntax: times, err = memc:get_reused_times()`\n\nThis method returns the (successfully) reused times for the current connection. In case of error, it returns `nil` and a string describing the error.\n\nIf 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.\n\n[Back to TOC](#table-of-contents)\n\nclose\n-----\n`syntax: ok, err = memc:close()`\n\nCloses the current memcached connection and returns the status.\n\nIn case of success, returns `1`. In case of errors, returns `nil` with a string describing the error.\n\n\n[Back to TOC](#table-of-contents)\n\nadd\n---\n`syntax: ok, err = memc:add(key, value, exptime, flags)`\n\nInserts an entry into memcached if and only if the key does not exist.\n\nThe `value` argument could also be a Lua table holding multiple Lua\nstrings that are supposed to be concatenated as a whole\n(without any delimiters). For example,\n\n```lua\n    memc:add(\"dog\", {\"a \", {\"kind of\"}, \" animal\"})\n```\n\nis functionally equivalent to\n\n```lua\n    memc:add(\"dog\", \"a kind of animal\")\n```\n\nThe `exptime` parameter is optional and defaults to `0` (meaning never expires). The expiration time is in seconds.\n\nThe `flags` parameter is optional, defaults to `0`.\n\nIn case of success, returns `1`. In case of errors, returns `nil` with a string describing the error.\n\n[Back to TOC](#table-of-contents)\n\nreplace\n-------\n`syntax: ok, err = memc:replace(key, value, exptime, flags)`\n\nInserts an entry into memcached if and only if the key does exist.\n\nThe `value` argument could also be a Lua table holding multiple Lua\nstrings that are supposed to be concatenated as a whole\n(without any delimiters). For example,\n\n```lua\n    memc:replace(\"dog\", {\"a \", {\"kind of\"}, \" animal\"})\n```\n\nis functionally equivalent to\n\n```lua\n    memc:replace(\"dog\", \"a kind of animal\")\n```\n\nThe `exptime` parameter is optional and defaults to `0` (meaning never expires). The expiration time is in seconds.\n\nThe `flags` parameter is optional, defaults to `0`.\n\nIn case of success, returns `1`. In case of errors, returns `nil` with a string describing the error.\n\n[Back to TOC](#table-of-contents)\n\nappend\n------\n`syntax: ok, err = memc:append(key, value, exptime, flags)`\n\nAppends the value to an entry with the same key that already exists in memcached.\n\nThe `value` argument could also be a Lua table holding multiple Lua\nstrings that are supposed to be concatenated as a whole\n(without any delimiters). For example,\n\n```lua\n    memc:append(\"dog\", {\"a \", {\"kind of\"}, \" animal\"})\n```\n\nis functionally equivalent to\n\n```lua\n    memc:append(\"dog\", \"a kind of animal\")\n```\n\nThe `exptime` parameter is optional and defaults to `0` (meaning never expires). The expiration time is in seconds.\n\nThe `flags` parameter is optional, defaults to `0`.\n\nIn case of success, returns `1`. In case of errors, returns `nil` with a string describing the error.\n\n[Back to TOC](#table-of-contents)\n\nprepend\n-------\n`syntax: ok, err = memc:prepend(key, value, exptime, flags)`\n\nPrepends the value to an entry with the same key that already exists in memcached.\n\nThe `value` argument could also be a Lua table holding multiple Lua\nstrings that are supposed to be concatenated as a whole\n(without any delimiters). For example,\n\n```lua\n    memc:prepend(\"dog\", {\"a \", {\"kind of\"}, \" animal\"})\n```\n\nis functionally equivalent to\n\n```lua\n    memc:prepend(\"dog\", \"a kind of animal\")\n```\n\nThe `exptime` parameter is optional and defaults to `0` (meaning never expires). The expiration time is in seconds.\n\nThe `flags` parameter is optional and defaults to `0`.\n\nIn case of success, returns `1`. In case of errors, returns `nil` with a string describing the error.\n\n[Back to TOC](#table-of-contents)\n\nget\n---\n`syntax: value, flags, err = memc:get(key)`\n`syntax: results, err = memc:get(keys)`\n\nGet a single entry or multiple entries in the memcached server via a single key or a table of keys.\n\nLet us first discuss the case When the key is a single string.\n\nThe key's value and associated flags value will be returned if the entry is found and no error happens.\n\nIn case of errors, `nil` values will be turned for `value` and `flags` and a 3rd (string) value will also be returned for describing the error.\n\nIf the entry is not found, then three `nil` values will be returned.\n\nThen let us discuss the case when the a Lua table of multiple keys are provided.\n\nIn this case, a Lua table holding the key-result pairs will be always returned in case of success. Each value corresponding each key in the table is also a table holding two values, the key's value and the key's flags. If a key does not exist, then there is no responding entries in the `results` table.\n\nIn case of errors, `nil` will be returned, and the second return value will be a string describing the error.\n\n[Back to TOC](#table-of-contents)\n\ngets\n----\n`syntax: value, flags, cas_unique, err = memc:gets(key)`\n\n`syntax: results, err = memc:gets(keys)`\n\nJust like the `get` method, but will also return the CAS unique value associated with the entry in addition to the key's value and flags.\n\nThis method is usually used together with the `cas` method.\n\n[Back to TOC](#table-of-contents)\n\ncas\n---\n`syntax: ok, err = memc:cas(key, value, cas_unique, exptime?, flags?)`\n\nJust like the `set` method but does a check and set operation, which means \"store this data but\n  only if no one else has updated since I last fetched it.\"\n\nThe `cas_unique` argument can be obtained from the `gets` method.\n\n[Back to TOC](#table-of-contents)\n\ntouch\n---\n`syntax: ok, err = memc:touch(key, exptime)`\n\nUpdate the expiration time of an existing key.\n\nReturns `1` for success or `nil` with a string describing the error otherwise.\n\nThis method was first introduced in the `v0.11` release.\n\n[Back to TOC](#table-of-contents)\n\nflush_all\n---------\n`syntax: ok, err = memc:flush_all(time?)`\n\nFlushes (or invalidates) all the existing entries in the memcached server immediately (by default) or after the expiration\nspecified by the `time` argument (in seconds).\n\nIn case of success, returns `1`. In case of errors, returns `nil` with a string describing the error.\n\n[Back to TOC](#table-of-contents)\n\ndelete\n------\n`syntax: ok, err = memc:delete(key)`\n\nDeletes the key from memcached immediately.\n\nThe key to be deleted must already exist in memcached.\n\nIn case of success, returns `1`. In case of errors, returns `nil` with a string describing the error.\n\n[Back to TOC](#table-of-contents)\n\nincr\n----\n`syntax: new_value, err = memc:incr(key, delta)`\n\nIncrements the value of the specified key by the integer value specified in the `delta` argument.\n\nReturns the new value after incrementation in success, and `nil` with a string describing the error in case of failures.\n\n[Back to TOC](#table-of-contents)\n\ndecr\n----\n`syntax: new_value, err = memc:decr(key, value)`\n\nDecrements the value of the specified key by the integer value specified in the `delta` argument.\n\nReturns the new value after decrementation in success, and `nil` with a string describing the error in case of failures.\n\n[Back to TOC](#table-of-contents)\n\nstats\n-----\n`syntax: lines, err = memc:stats(args?)`\n\nReturns memcached server statistics information with an optional `args` argument.\n\nIn case of success, this method returns a lua table holding all of the lines of the output; in case of failures, it returns `nil` with a string describing the error.\n\nIf the `args` argument is omitted, general server statistics is returned. Possible `args` argument values are `items`, `sizes`, `slabs`, among others.\n\n[Back to TOC](#table-of-contents)\n\nversion\n-------\n`syntax: version, err = memc:version(args?)`\n\nReturns the server version number, like `1.2.8`.\n\nIn case of error, it returns `nil` with a string describing the error.\n\n[Back to TOC](#table-of-contents)\n\nquit\n----\n`syntax: ok, err = memc:quit()`\n\nTells the server to close the current memcached connection.\n\nReturns `1` in case of success and `nil` other wise. In case of failures, another string value will also be returned to describe the error.\n\nGenerally you can just directly call the `close` method to achieve the same effect.\n\n[Back to TOC](#table-of-contents)\n\nverbosity\n---------\n`syntax: ok, err = memc:verbosity(level)`\n\nSets the verbosity level used by the memcached server. The `level` argument should be given integers only.\n\nReturns `1` in case of success and `nil` other wise. In case of failures, another string value will also be returned to describe the error.\n\n[Back to TOC](#table-of-contents)\n\ninit_pipeline\n---------\n`syntax: err = memc:init_pipeline(n?)`\n\nEnable the Memcache pipelining mode. All subsequent calls to Memcache command methods will automatically get buffer and will send to the server in one run when the commit_pipeline method is called or get cancelled by calling the cancel_pipeline method.\n\nThe optional params `n` is buffer tables size. default value 4\n\n[Back to TOC](#table-of-contents)\n\ncommit_pipeline\n---------\n`syntax: results, err = memc:commit_pipeline()`\n\nQuits the pipelining mode by committing all the cached Memcache queries to the remote server in a single run. All the replies for these queries will be collected automatically and are returned as if a big multi-bulk reply at the highest level.\n\nThis method success return a lua table. failed return a lua string describing the error upon failures.\n\n[Back to TOC](#table-of-contents)\n\ncancel_pipeline\n---------\n`syntax: memc:cancel_pipeline()`\n\nQuits the pipelining mode by discarding all existing buffer Memcache commands since the last call to the init_pipeline method.\n\nthe method no return. always succeeds.\n\n[Back to TOC](#table-of-contents)\n\nAutomatic Error Logging\n=======================\n\nBy default the underlying [ngx_lua](http://wiki.nginx.org/HttpLuaModule) module\ndoes error logging when socket errors happen. If you are already doing proper error\nhandling in your own Lua code, then you are recommended to disable this automatic error logging by turning off [ngx_lua](http://wiki.nginx.org/HttpLuaModule)'s [lua_socket_log_errors](http://wiki.nginx.org/HttpLuaModule#lua_socket_log_errors) directive, that is,\n\n```nginx\n    lua_socket_log_errors off;\n```\n\n[Back to TOC](#table-of-contents)\n\nLimitations\n===========\n\n* This library cannot be used in code contexts like `set_by_lua*`, `log_by_lua*`, and\n`header_filter_by_lua*` where the ngx\\_lua cosocket API is not available.\n* The `resty.memcached` object instance cannot be stored in a Lua variable at the Lua module level,\nbecause it will then be shared by all the concurrent requests handled by the same nginx\n worker process (see\nhttp://wiki.nginx.org/HttpLuaModule#Data_Sharing_within_an_Nginx_Worker ) and\nresult in bad race conditions when concurrent requests are trying to use the same `resty.memcached` instance.\nYou should always initiate `resty.memcached` objects in function local\nvariables or in the `ngx.ctx` table. These places all have their own data copies for\neach request.\n\n[Back to TOC](#table-of-contents)\n\nTODO\n====\n\n* implement the memcached pipelining API.\n* implement the UDP part of the memcached ascii protocol.\n\n[Back to TOC](#table-of-contents)\n\nAuthor\n======\n\nYichun \"agentzh\" Zhang (章亦春) \u003cagentzh@gmail.com\u003e, OpenResty Inc.\n\n[Back to TOC](#table-of-contents)\n\nCopyright and License\n=====================\n\nThis module is licensed under the BSD license.\n\nCopyright (C) 2012-2017, by Yichun \"agentzh\" Zhang (章亦春) \u003cagentzh@gmail.com\u003e, OpenResty Inc.\n\nAll rights reserved.\n\nRedistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:\n\n* Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.\n\n* Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n[Back to TOC](#table-of-contents)\n\nSee Also\n========\n* the ngx_lua module: http://wiki.nginx.org/HttpLuaModule\n* the memcached wired protocol specification: http://code.sixapart.com/svn/memcached/trunk/server/doc/protocol.txt\n* the [lua-resty-redis](https://github.com/agentzh/lua-resty-redis) library.\n* the [lua-resty-mysql](https://github.com/agentzh/lua-resty-mysql) library.\n\n[Back to TOC](#table-of-contents)\n\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fopenresty%2Flua-resty-memcached","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fopenresty%2Flua-resty-memcached","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fopenresty%2Flua-resty-memcached/lists"}