git mv Ingress ingress

controllers/nginx-third-party/lua/vendor/lua-resty-dns-cache/.gitignore

@@ -0,0 +1,2 @@
+t/servroot/
+t/error.log

controllers/nginx-third-party/lua/vendor/lua-resty-dns-cache/LICENSE.txt

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 Hamish Forbes
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

controllers/nginx-third-party/lua/vendor/lua-resty-dns-cache/Makefile

@@ -0,0 +1,23 @@
+OPENRESTY_PREFIX=/usr/local/openresty
+
+PREFIX ?=          /usr/local
+LUA_INCLUDE_DIR ?= $(PREFIX)/include
+LUA_LIB_DIR ?=     $(PREFIX)/lib/lua/$(LUA_VERSION)
+INSTALL ?= install
+TEST_FILE ?= t
+
+.PHONY: all test leak
+
+all: ;
+
+
+install: all
+	$(INSTALL) -d $(DESTDIR)/$(LUA_LIB_DIR)/resty/dns
+
+leak: all
+	TEST_NGINX_CHECK_LEAK=1	TEST_NGINX_NO_SHUFFLE=1 PATH=$(OPENRESTY_PREFIX)/nginx/sbin:$$PATH prove -I../test-nginx/lib -r $(TEST_FILE)
+
+test: all
+	TEST_NGINX_NO_SHUFFLE=1 PATH=$(OPENRESTY_PREFIX)/nginx/sbin:$$PATH prove -I../test-nginx/lib -r $(TEST_FILE)
+	util/lua-releng.pl
+

controllers/nginx-third-party/lua/vendor/lua-resty-dns-cache/README.md

@@ -0,0 +1,111 @@
+#lua-resty-dns-cache
+
+A wrapper for [lua-resty-dns](https://github.com/openresty/lua-resty-dns) to cache responses based on record TTLs.
+
+Uses [lua-resty-lrucache](https://github.com/openresty/lua-resty-lrucache) and [ngx.shared.DICT](https://github.com/openresty/lua-nginx-module#ngxshareddict) to provide a 2 level cache.
+
+Can repopulate cache in the background while returning stale answers.
+
+#Overview
+
+```lua
+  lua_shared_dict dns_cache 1m;
+
+  init_by_lua '
+      require("resty.dns.cache").init_cache(200)
+  ';
+
+    server {
+
+        listen 80;
+        server_name dns_cache;
+
+        location / {
+            content_by_lua '
+                local DNS_Cache = require("resty.dns.cache")
+                local dns = DNS_Cache.new({
+                        dict = "dns_cache",
+                        negative_ttl = 30,
+                        max_stale = 300,
+                        resolver  = {
+                            nameservers = {"123.123.123.123"}
+                        }
+                    })
+
+                local host = ngx.req.get_uri_args()["host"] or "www.google.com"
+
+                local answer, err, stale = dns:query(host)
+                if err then
+                    if stale then
+                        ngx.header["Warning"] = "110: Response is stale"
+                        answer = stale
+                        ngx.log(ngx.ERR, err)
+                    else
+                        ngx.status = 500
+                        ngx.say(err)
+                        return ngx.exit(ngx.status)
+                    end
+                end
+
+                local cjson = require "cjson"
+                ngx.say(cjson.encode(answer))
+            ';
+        }
+    }
+```
+
+#Methods
+### init_cache
+`syntax: ok, err = dns_cache.init_cache(max_items?)`
+
+Creates a global lrucache object for caching responses.
+
+Accepts an optional `max_items` argument, defaults to 200 entries.
+
+Calling this repeatedly will reset the LRU cache
+
+### initted
+`syntax: ok = dns_cache.initted()`
+
+Returns `true` if LRU Cache has been initialised
+
+### new
+`syntax: ok, err = dns_cache.new(opts)`
+
+Returns a new DNS cache instance. Returns `nil` and a string on error
+
+Accepts a table of options, if no shared dictionary is provided only lrucache is used.
+
+* `dict` - Name of the [ngx.shared.DICT](https://github.com/openresty/lua-nginx-module#ngxshareddict) to use for cache.
+* `resolver` - Table of options passed to [lua-resty-dns](https://github.com/openresty/lua-resty-dns#new). Defaults to using Google DNS.
+* `normalise_ttl` - Boolean. Reduces TTL in cached answers to account for cached time. Defaults to `true`.
+* `negative_ttl` - Time in seconds to cache negative / error responses. `nil` or `false` disables caching negative responses. Defaults to `false`
+* `minimise_ttl` - Boolean. Set cache TTL based on the shortest DNS TTL in all responses rather than the first response. Defaults to `false`
+* `max_stale` - Number of seconds past expiry to return stale content rather than querying. Stale hits will trigger a non-blocking background query to repopulate cache.
+
+
+### query
+`syntax: answers, err, stale = c:query(name, opts?)`
+
+Passes through to lua-resty-dns' [query](https://github.com/openresty/lua-resty-dns#query) method.
+
+Returns an extra `stale` variable containing stale data if a resolver cannot be contacted.
+
+### tcp_query
+`syntax: answers, err, stale = c:tcp_query(name, opts?)`
+
+Passes through to lua-resty-dns' [tcp_query](https://github.com/openresty/lua-resty-dns#tcp_query) method.
+
+Returns an extra `stale` variable containing stale data if a resolver cannot be contacted.
+
+### set_timeout
+`syntax: c:set_timeout(time)`
+
+Passes through to lua-resty-dns' [set_timeout](https://github.com/openresty/lua-resty-dns#set_timeout) method.
+
+## Constants
+lua-resty-dns' [constants](https://github.com/openresty/lua-resty-dns#constants) are accessible on the `resty.dns.cache` object too.
+
+## TODO
+ * Cap'n'proto serialisation
+

controllers/nginx-third-party/lua/vendor/lua-resty-dns-cache/lib/resty/dns/cache.lua

@@ -0,0 +1,449 @@
+local ngx_log = ngx.log
+local ngx_DEBUG = ngx.DEBUG
+local ngx_ERR = ngx.ERR
+local ngx_shared = ngx.shared
+local ngx_time = ngx.time
+local resty_resolver = require "resty.dns.resolver"
+local resty_lrucache = require "resty.lrucache"
+local cjson = require "cjson"
+local json_encode = cjson.encode
+local json_decode = cjson.decode
+local tbl_concat = table.concat
+local tonumber = tonumber
+local _ngx_timer_at = ngx.timer.at
+local ngx_worker_pid = ngx.worker.pid
+
+local function ngx_timer_at(delay, func, ...)
+    local ok, err = _ngx_timer_at(delay, func, ...)
+    if not ok then
+        ngx_log(ngx_ERR, "Timer Error: ", err)
+    end
+    return ok, err
+end
+
+
+local debug_log = function(msg, ...)
+    if type(msg) == 'table' then
+        local ok, json = pcall(json_encode, msg)
+        if ok then
+            msg = json
+        else
+            ngx_log(ngx_ERR, json)
+        end
+    end
+    ngx_log(ngx_DEBUG, msg, ...)
+end
+
+local _M = {
+    _VERSION = '0.01',
+    TYPE_A      = resty_resolver.TYPE_A,
+    TYPE_NS     = resty_resolver.TYPE_NS,
+    TYPE_CNAME  = resty_resolver.TYPE_CNAME,
+    TYPE_PTR    = resty_resolver.TYPE_PTR,
+    TYPE_MX     = resty_resolver.TYPE_MX,
+    TYPE_TXT    = resty_resolver.TYPE_TXT,
+    TYPE_AAAA   = resty_resolver.TYPE_AAAA,
+    TYPE_SRV    = resty_resolver.TYPE_SRV,
+    TYPE_SPF    = resty_resolver.TYPE_SPF,
+    CLASS_IN    = resty_resolver.CLASS_IN
+}
+
+local DEBUG = false
+
+local mt = { __index = _M }
+
+local lru_cache_defaults = {200}
+local resolver_defaults = {
+    nameservers = {"8.8.8.8", "8.8.4.4"}
+}
+
+-- Global lrucache instance
+local lru_cache
+local max_items = 200
+
+function _M.init_cache(size)
+    if size then max_items = size end
+    local err
+    if DEBUG then debug_log("Initialising lru cache with ", max_items, " max items") end
+    lru_cache, err = resty_lrucache.new(max_items)
+    if not lru_cache then
+        return nil, err
+    end
+    return true
+end
+
+
+function _M.initted()
+    if lru_cache then return true end
+    return false
+end
+
+
+function _M.new(opts)
+    local self, err = { opts = opts}, nil
+    opts = opts or {}
+
+    -- Set defaults
+    if opts.normalise_ttl ~= nil then self.normalise_ttl = opts.normalise_ttl else self.normalise_ttl = true  end
+    if opts.minimise_ttl  ~= nil then self.minimise_ttl  = opts.minimise_ttl  else self.minimise_ttl  = false end
+    if opts.negative_ttl  ~= nil then
+        self.negative_ttl = tonumber(opts.negative_ttl)
+    else
+        self.negative_ttl = false
+    end
+    if opts.max_stale ~= nil then
+        self.max_stale = tonumber(opts.max_stale)
+    else
+        self.max_stale = 0
+    end
+
+    opts.resolver = opts.resolver or resolver_defaults
+    self.resolver, err = resty_resolver:new(opts.resolver)
+    if not self.resolver then
+        return nil, err
+    end
+
+    if opts.dict then
+        self.dict = ngx_shared[opts.dict]
+    end
+    return setmetatable(self, mt)
+end
+
+
+function _M.flush(self, hard)
+    local ok, err = self.init_cache()
+    if not ok then
+        ngx_log(ngx_ERR, err)
+    end
+    if self.dict then
+        if DEBUG then debug_log("Flushing dictionary") end
+        self.dict:flush_all()
+        if hard then
+            local flushed = self.dict:flush_expired()
+            if DEBUG then debug_log("Flushed ", flushed, " keys from memory") end
+        end
+    end
+end
+
+
+function _M._debug(flag)
+    DEBUG = flag
+end
+
+
+function _M.set_timeout(self, ...)
+    return self.resolver:set_timeout(...)
+end
+
+
+local function minimise_ttl(answer)
+    if DEBUG then debug_log('Minimising TTL') end
+    local ttl
+    for _, ans in ipairs(answer) do
+        if DEBUG then debug_log('TTL ', ans.name, ': ', ans.ttl) end
+        if ttl == nil or ans.ttl < ttl then
+            ttl = ans.ttl
+        end
+    end
+    return ttl
+end
+
+
+local function normalise_ttl(self, data)
+    -- Calculate time since query and subtract from answer's TTL
+    if self.normalise_ttl then
+        local now = ngx_time()
+        local diff = now - data.now
+        if DEBUG then debug_log("Normalising TTL, diff: ", diff) end
+        for _, answer in ipairs(data.answer) do
+            if DEBUG then debug_log("Old: ", answer.ttl, ", new: ", answer.ttl - diff) end
+            answer.ttl = answer.ttl - diff
+        end
+        data.now = now
+    end
+    return data
+end
+
+
+local function cache_get(self, key)
+    -- Try local LRU cache first
+    local data, lru_stale
+    if lru_cache then
+        data, lru_stale = lru_cache:get(key)
+        -- Set stale if should have expired
+        if data and data.expires <= ngx_time() then
+            lru_stale = data
+            data = nil
+        end
+        if data then
+            if DEBUG then
+                debug_log('lru_cache HIT: ', key)
+                debug_log(data)
+            end
+            return normalise_ttl(self, data)
+        elseif DEBUG then
+            debug_log('lru_cache MISS: ', key)
+        end
+    end
+
+    -- lru_cache miss, try shared dict
+    local dict = self.dict
+    if dict then
+        local data, flags, stale = dict:get_stale(key)
+        -- Set stale if should have expired
+        if data then
+            data = json_decode(data)
+            if data.expires <= ngx_time() then
+                stale = true
+            end
+        end
+
+        -- Dict data is stale, prefer stale LRU data
+        if stale and lru_stale then
+            if DEBUG then
+                debug_log('lru_cache STALE: ', key)
+                debug_log(lru_stale)
+            end
+            return nil, normalise_ttl(self, lru_stale)
+        end
+
+        -- Definitely no lru data, going to have to try shared dict
+        if not data then
+            -- Full MISS on dict, return nil
+            if DEBUG then debug_log('shared_dict MISS: ', key) end
+            return nil
+        end
+
+        -- Return nil and dict cache if its stale
+        if stale then
+            if DEBUG then debug_log('shared_dict STALE: ', key) end
+            return nil, normalise_ttl(self, data)
+        end
+
+        -- Fresh HIT from dict, repopulate the lru_cache
+        if DEBUG then debug_log('shared_dict HIT: ', key) end
+        if lru_cache then
+            local ttl = data.expires - ngx_time()
+            if DEBUG then debug_log('lru_cache SET: ', key, ' ', ttl) end
+            lru_cache:set(key, data, ttl)
+        end
+        return normalise_ttl(self, data)
+    elseif lru_stale then
+        -- Return lru stale if no dict configured
+        if DEBUG then
+            debug_log('lru_cache STALE: ', key)
+            debug_log(lru_stale)
+        end
+        return nil, normalise_ttl(self, lru_stale)
+    end
+
+    if not lru_cache or dict then
+        ngx_log(ngx_ERR, "No cache defined")
+    end
+end
+
+
+local function cache_set(self, key, answer, ttl)
+    -- Don't cache records with 0 TTL
+    if ttl == 0 or ttl == nil then
+        return
+    end
+
+    -- Calculate absolute expiry - used to populate lru_cache from shared_dict
+    local now = ngx_time()
+    local data = {
+        answer = answer,
+        now = now,
+        queried = now,
+        expires = now + ttl
+    }
+
+    -- Extend cache expiry if using stale
+    local real_ttl = ttl
+    if self.max_stale then
+        real_ttl = real_ttl + self.max_stale
+    end
+
+    -- Set lru cache
+    if lru_cache then
+        if DEBUG then debug_log('lru_cache SET: ', key, ' ', real_ttl) end
+        lru_cache:set(key, data, real_ttl)
+    end
+
+    -- Set dict cache
+    local dict = self.dict
+    if dict then
+        if DEBUG then debug_log('shared_dict SET: ', key, ' ', real_ttl) end
+        local ok, err, forcible = dict:set(key, json_encode(data), real_ttl)
+        if not ok then
+            ngx_log(ngx_ERR, 'shared_dict ERR: ', err)
+        end
+        if forcible then
+            ngx_log(ngx_DEBUG, 'shared_dict full')
+        end
+    end
+end
+
+
+local function _resolve(resolver, query_func, host, opts)
+    if DEBUG then debug_log('Querying: ', host) end
+    local answers, err = query_func(resolver, host, opts)
+    if not answers then
+        return answers, err
+    end
+    if DEBUG then debug_log(answers) end
+
+    return answers
+end
+
+
+local function cache_key(host, qtype)
+    return tbl_concat({host,'|',qtype})
+end
+
+
+local function get_repopulate_lock(dict, host, qtype)
+    local key = cache_key(host, qtype or 1) .. '|lock'
+    if DEBUG then debug_log("Locking '", key, "' for ", 30, "s: ", ngx_worker_pid()) end
+    return dict:add(key, ngx_worker_pid(), 30)
+end
+
+
+local function release_repopulate_lock(dict, host, qtype)
+    local key = cache_key(host, qtype or 1) .. '|lock'
+    local pid, err = dict:get(key)
+    if DEBUG then debug_log("Releasing '", key, "' for ", ngx_worker_pid(), " from ", pid) end
+    if pid == ngx_worker_pid() then
+        dict:delete(key)
+    else
+        ngx_log(ngx_DEBUG, "couldnt release lock")
+    end
+end
+
+
+local _query
+
+local function _repopulate(premature, self, host, opts, tcp)
+    if premature then return end
+
+    if DEBUG then debug_log("Repopulating '", host, "'") end
+    -- Create a new resolver instance, cannot share sockets
+    local err
+    self.resolver, err = resty_resolver:new(self.opts.resolver)
+    if err then
+        ngx_log(ngx_ERR, err)
+        return nil
+    end
+    -- Do not use stale when repopulating
+    _query(self, host, opts, tcp, true)
+end
+
+
+local function repopulate(self, host, opts, tcp)
+    -- Lock, there's a window between the key expiring and the background query completing
+    -- during which another query could trigger duplicate repopulate jobs
+    local ok, err = get_repopulate_lock(self.dict, host, opts.qtype)
+    if ok then
+        if DEBUG then debug_log("Attempting to repopulate '", host, "'") end
+        local ok, err = ngx_timer_at(0, _repopulate, self, host, opts, tcp)
+        if not ok then
+            -- Release lock if we couldn't start the timer
+            release_repopulate_lock(self.dict, host, opts.qtype)
+        end
+    else
+        if err == "exists" then
+            if DEBUG then debug_log("Lock not acquired") end
+            return
+        else
+            ngx.log(ngx.ERR, err)
+        end
+    end
+end
+
+
+_query = function(self, host, opts, tcp, repopulating)
+    -- Build cache key
+    opts = opts or {}
+    local key = cache_key(host, opts.qtype or 1)
+
+    -- Check caches
+    local answer
+    local data, stale = cache_get(self, key)
+    if data then
+        -- Shouldn't get a cache hit when repopulating but better safe than sorry
+        if repopulating then release_repopulate_lock(self.dict, host, opts.qtype) end
+        answer = data.answer
+        -- Don't return negative cache hits if negative_ttl is off in this instance
+        if not answer.errcode or self.negative_ttl then
+            return answer
+        end
+    end
+
+    -- No fresh cache entry, return stale if within max_stale and trigger background repopulate
+    if stale and not repopulating and self.max_stale > 0
+        and (ngx_time() - stale.expires) < self.max_stale then
+            if DEBUG then debug_log('max_stale ', self.max_stale) end
+            repopulate(self, host, opts, tcp)
+            if DEBUG then debug_log('Returning STALE: ', key) end
+            return nil, nil, stale.answer
+    end
+
+    -- Try to resolve
+    local resolver = self.resolver
+    local query_func = resolver.query
+    if tcp then
+        query_func = resolver.tcp_query
+    end
+
+    local answer, err = _resolve(resolver, query_func, host, opts)
+    if not answer then
+        -- Couldn't resolve, return potential stale response with error msg
+        if DEBUG then
+            debug_log('Resolver error ', key, ': ', err)
+            if stale then debug_log('Returning STALE: ', key) end
+        end
+        if repopulating then release_repopulate_lock(self.dict, host, opts.qtype) end
+        if stale then stale = stale.answer end
+        return nil, err, stale
+    end
+
+    local ttl
+
+    -- Cache server errors for negative_cache seconds
+    if answer.errcode then
+        if self.negative_ttl then
+            ttl = self.negative_ttl
+        else
+            if repopulating then release_repopulate_lock(self.dict, host, opts.qtype) end
+            return answer
+        end
+    else
+        -- Cache for the lowest TTL in the chain of responses...
+        if self.minimise_ttl then
+            ttl = minimise_ttl(answer)
+        elseif answer[1] then
+            -- ... or just the first one
+            ttl = answer[1].ttl or nil
+        end
+    end
+
+    -- Set cache
+    cache_set(self, key, answer, ttl)
+
+    if repopulating then release_repopulate_lock(self.dict, host, opts.qtype) end
+
+    return answer
+end
+
+
+function _M.query(self, host, opts)
+    return _query(self, host, opts, false)
+end
+
+
+function _M.tcp_query(self, host, opts)
+    return _query(self, host, opts, true)
+end
+
+
+return _M

controllers/nginx-third-party/lua/vendor/lua-resty-dns-cache/t/01-sanity.t

@@ -0,0 +1,233 @@
+use Test::Nginx::Socket;
+use Cwd qw(cwd);
+
+plan tests => repeat_each() * 24;
+
+my $pwd = cwd();
+
+our $HttpConfig = qq{
+    lua_package_path "$pwd/lib/?.lua;;";
+};
+
+no_long_string();
+run_tests();
+
+__DATA__
+=== TEST 1: Load module without errors.
+--- http_config eval
+"$::HttpConfig"
+. q{
+    init_by_lua '
+        local DNS_Cache = require("resty.dns.cache")
+    ';
+}
+--- config
+    location /sanity {
+        echo "OK";
+    }
+--- request
+GET /sanity
+--- no_error_log
+[error]
+--- response_body
+OK
+
+
+=== TEST 2: Can init cache - defaults
+--- http_config eval
+"$::HttpConfig"
+. q{
+    init_by_lua '
+        local DNS_Cache = require("resty.dns.cache")
+        DNS_Cache.init_cache()
+    ';
+}
+--- config
+    location /sanity {
+        content_by_lua '
+            local DNS_Cache = require("resty.dns.cache")
+            ngx.say(DNS_Cache.initted())
+        ';
+    }
+--- request
+GET /sanity
+--- no_error_log
+[error]
+--- response_body
+true
+
+=== TEST 3: Can init cache - user config
+--- http_config eval
+"$::HttpConfig"
+. q{
+    init_by_lua '
+        local DNS_Cache = require("resty.dns.cache")
+        DNS_Cache.init_cache(300)
+    ';
+}
+--- config
+    location /sanity {
+        content_by_lua '
+            local DNS_Cache = require("resty.dns.cache")
+            ngx.say(DNS_Cache.initted())
+        ';
+    }
+--- request
+GET /sanity
+--- no_error_log
+[error]
+--- response_body
+true
+
+=== TEST 4: Can init new instance - defaults
+--- http_config eval
+"$::HttpConfig"
+. q{
+    init_by_lua '
+        local DNS_Cache = require("resty.dns.cache")
+        DNS_Cache.init_cache(300)
+    ';
+}
+--- config
+    location /sanity {
+        content_by_lua '
+            local DNS_Cache = require("resty.dns.cache")
+            local dns, err = DNS_Cache.new()
+            if dns then
+                ngx.say("OK")
+            else
+                ngx.say(err)
+            end
+        ';
+    }
+--- request
+GET /sanity
+--- no_error_log
+[error]
+--- response_body
+OK
+
+=== TEST 5: Can init new instance - user config
+--- http_config eval
+"$::HttpConfig"
+. q{
+    init_by_lua '
+        local DNS_Cache = require("resty.dns.cache")
+        DNS_Cache.init_cache(300)
+    ';
+}
+--- config
+    location /sanity {
+        content_by_lua '
+            local DNS_Cache = require("resty.dns.cache")
+            local dns, err = DNS_Cache.new({
+                negative_ttl = 10,
+                resolver = { nameservers = {"10.10.10.10"} }
+            })
+            if dns then
+                ngx.say("OK")
+            else
+                ngx.say(err)
+            end
+        ';
+    }
+--- request
+GET /sanity
+--- no_error_log
+[error]
+--- response_body
+OK
+
+=== TEST 6: Resty DNS errors are passed through
+--- http_config eval
+"$::HttpConfig"
+. q{
+    init_by_lua '
+        local DNS_Cache = require("resty.dns.cache")
+        DNS_Cache.init_cache(300)
+    ';
+}
+--- config
+    location /sanity {
+        content_by_lua '
+            local DNS_Cache = require("resty.dns.cache")
+            local dns, err = DNS_Cache.new({
+                resolver = {  }
+            })
+            if dns then
+                ngx.say("OK")
+            else
+                ngx.say(err)
+            end
+        ';
+    }
+--- request
+GET /sanity
+--- no_error_log
+[error]
+--- response_body
+no nameservers specified
+
+=== TEST 7: Can create instance with shared dict
+--- http_config eval
+"$::HttpConfig"
+. q{
+    lua_shared_dict dns_cache 1m;
+    init_by_lua '
+        local DNS_Cache = require("resty.dns.cache")
+        DNS_Cache.init_cache()
+    ';
+}
+--- config
+    location /sanity {
+        content_by_lua '
+            local DNS_Cache = require("resty.dns.cache")
+            ngx.say(DNS_Cache.initted())
+
+            local dns, err = DNS_Cache.new({
+                dict = "dns_cache"
+            })
+            if dns then
+                ngx.say("OK")
+            else
+                ngx.say(err)
+            end
+        ';
+    }
+--- request
+GET /sanity
+--- no_error_log
+[error]
+--- response_body
+true
+OK
+
+=== TEST 8: Can create instance with shared dict and no lru_cache
+--- http_config eval
+"$::HttpConfig"
+. q{
+    lua_shared_dict dns_cache 1m;
+}
+--- config
+    location /sanity {
+        content_by_lua '
+            local DNS_Cache = require("resty.dns.cache")
+            ngx.say(DNS_Cache.initted())
+
+            local dns, err = DNS_Cache.new({
+                dict = "dns_cache"
+            })
+            if dns then
+                ngx.say("OK")
+            else
+                ngx.say(err)
+            end
+        ';
+    }
+--- request
+GET /sanity
+--- no_error_log
+[error]
+--- response_body
+false
+OK

controllers/nginx-third-party/lua/vendor/lua-resty-dns-cache/t/02-resolve.t

@@ -0,0 +1,195 @@
+
+use lib 't';
+use TestDNS;
+use Cwd qw(cwd);
+
+plan tests => repeat_each() * 12;
+
+my $pwd = cwd();
+
+our $HttpConfig = qq{
+    lua_package_path "$pwd/lib/?.lua;;";
+};
+
+no_long_string();
+run_tests();
+
+__DATA__
+=== TEST 1: Can resolve with lru + dict
+--- http_config eval
+"$::HttpConfig"
+. q{
+    lua_shared_dict dns_cache 1m;
+    init_by_lua '
+        local DNS_Cache = require("resty.dns.cache")
+        DNS_Cache.init_cache()
+    ';
+}
+--- config
+    location /t {
+        content_by_lua '
+            local DNS_Cache = require("resty.dns.cache")
+            local dns, err = DNS_Cache.new({
+                dict = "dns_cache",
+                resolver = {
+                    nameservers = { {"127.0.0.1", "1953"} }
+                }
+            })
+            if not dns then
+                ngx.say(err)
+            end
+            dns.resolver._id = 125
+
+            local answer, err, stale = dns:query("www.google.com", { qtype = dns.TYPE_A })
+            if not answer then
+                ngx.say(err)
+            end
+            local cjson = require"cjson"
+            ngx.say(cjson.encode(answer))
+        ';
+    }
+--- udp_listen: 1953
+--- udp_reply dns
+{
+    id => 125,
+    opcode => 0,
+    qname => 'www.google.com',
+    answer => [{ name => "www.google.com", ipv4 => "127.0.0.1", ttl => 123456 }],
+}
+--- request
+GET /t
+--- no_error_log
+[error]
+--- response_body
+[{"address":"127.0.0.1","type":1,"class":1,"name":"www.google.com","ttl":123456}]
+
+=== TEST 2: Can resolve with lru only
+--- http_config eval
+"$::HttpConfig"
+. q{
+    init_by_lua '
+        local DNS_Cache = require("resty.dns.cache")
+        DNS_Cache.init_cache()
+    ';
+}
+--- config
+    location /t {
+        content_by_lua '
+            local DNS_Cache = require("resty.dns.cache")
+            local dns, err = DNS_Cache.new({
+                resolver = {
+                    nameservers = { {"127.0.0.1", "1953"} }
+                }
+            })
+            if not dns then
+                ngx.say(err)
+            end
+            dns.resolver._id = 125
+
+            local answer, err, stale = dns:query("www.google.com", { qtype = dns.TYPE_A })
+            if not answer then
+                ngx.say(err)
+            end
+            local cjson = require"cjson"
+            ngx.say(cjson.encode(answer))
+        ';
+    }
+--- udp_listen: 1953
+--- udp_reply dns
+{
+    id => 125,
+    opcode => 0,
+    qname => 'www.google.com',
+    answer => [{ name => "www.google.com", ipv4 => "127.0.0.1", ttl => 123456 }],
+}
+--- request
+GET /t
+--- no_error_log
+[error]
+--- response_body
+[{"address":"127.0.0.1","type":1,"class":1,"name":"www.google.com","ttl":123456}]
+
+=== TEST 3: Can resolve with dict only
+--- http_config eval
+"$::HttpConfig"
+. q{
+    lua_shared_dict dns_cache 1m;
+}
+--- config
+    location /t {
+        content_by_lua '
+            local DNS_Cache = require("resty.dns.cache")
+            local dns, err = DNS_Cache.new({
+                dict = "dns_cache",
+                resolver = {
+                    nameservers = { {"127.0.0.1", "1953"} }
+                }
+            })
+            if not dns then
+                ngx.say(err)
+            end
+            dns.resolver._id = 125
+
+            local answer, err, stale = dns:query("www.google.com", { qtype = dns.TYPE_A })
+            if not answer then
+                ngx.say(err)
+            end
+            local cjson = require"cjson"
+            ngx.say(cjson.encode(answer))
+        ';
+    }
+--- udp_listen: 1953
+--- udp_reply dns
+{
+    id => 125,
+    opcode => 0,
+    qname => 'www.google.com',
+    answer => [{ name => "www.google.com", ipv4 => "127.0.0.1", ttl => 123456 }],
+}
+--- request
+GET /t
+--- no_error_log
+[error]
+--- response_body
+[{"address":"127.0.0.1","type":1,"class":1,"name":"www.google.com","ttl":123456}]
+
+=== TEST 4: Can resolve with no cache, error thrown
+--- http_config eval
+"$::HttpConfig"
+--- config
+    location /t {
+        content_by_lua '
+            local DNS_Cache = require("resty.dns.cache")
+            local dns, err = DNS_Cache.new({
+                resolver = {
+                    nameservers = { {"127.0.0.1", "1953"} }
+                }
+            })
+            if not dns then
+                ngx.say(err)
+            end
+            dns.resolver._id = 125
+
+            local answer, err, stale = dns:query("www.google.com", { qtype = dns.TYPE_A })
+            if not answer then
+                ngx.say(err)
+            end
+            local cjson = require"cjson"
+            ngx.say(cjson.encode(answer))
+        ';
+    }
+--- udp_listen: 1953
+--- udp_reply dns
+{
+    id => 125,
+    opcode => 0,
+    qname => 'www.google.com',
+    answer => [{ name => "www.google.com", ipv4 => "127.0.0.1", ttl => 123456 }],
+}
+--- request
+GET /t
+--- error_log
+No cache defined
+--- response_body
+[{"address":"127.0.0.1","type":1,"class":1,"name":"www.google.com","ttl":123456}]
+

controllers/nginx-third-party/lua/vendor/lua-resty-dns-cache/t/03-cache.t

@@ -0,0 +1,873 @@
+use lib 't';
+use TestDNS;
+use Cwd qw(cwd);
+
+plan tests => repeat_each() * 47;
+
+my $pwd = cwd();
+
+our $HttpConfig = qq{
+    lua_package_path "$pwd/lib/?.lua;;";
+    lua_socket_log_errors off;
+};
+
+no_long_string();
+run_tests();
+
+__DATA__
+=== TEST 1: Response comes from cache on second hit
+--- http_config eval
+"$::HttpConfig"
+. q{
+    lua_shared_dict dns_cache 1m;
+    init_by_lua '
+        local DNS_Cache = require("resty.dns.cache")
+        DNS_Cache.init_cache()
+    ';
+}
+--- config
+    location /t {
+        echo_location /_t;
+        echo_location /_t2;
+    }
+    location /_t {
+        content_by_lua '
+            local DNS_Cache = require("resty.dns.cache")
+            local dns, err = DNS_Cache.new({
+                dict = "dns_cache",
+                resolver = {nameservers = {{"127.0.0.1", "1953"}}}
+            })
+            if not dns then
+                ngx.say(err)
+            end
+            dns.resolver._id = 125
+
+            local answer, err, stale = dns:query("www.google.com", { qtype = dns.TYPE_A })
+            if not answer then
+                ngx.say(err)
+            end
+        ';
+    }
+    location /_t2 {
+        content_by_lua '
+            local DNS_Cache = require("resty.dns.cache")
+            local dns, err = DNS_Cache.new({
+                dict = "dns_cache",
+                resolver = {nameservers = {{"127.0.0.1", "1953"}}}
+            })
+            if not dns then
+                ngx.say(err)
+            end
+            dns.resolver._id = 125
+            dns._debug(true)
+
+            local answer, err, stale = dns:query("www.google.com", { qtype = dns.TYPE_A })
+            if not answer then
+                ngx.say(err)
+            end
+            local cjson = require"cjson"
+            ngx.say(cjson.encode(answer))
+
+        ';
+    }
+--- udp_listen: 1953
+--- udp_reply dns
+{
+    id => 125,
+    opcode => 0,
+    qname => 'www.google.com',
+    answer => [{ name => "www.google.com", ipv4 => "127.0.0.1", ttl => 123456 }],
+}
+--- request
+GET /t
+--- error_log
+lru_cache HIT
+--- response_body
+[{"address":"127.0.0.1","type":1,"class":1,"name":"www.google.com","ttl":123456}]
+
+=== TEST 2: Response comes from dict on miss
+--- http_config eval
+"$::HttpConfig"
+. q{
+    lua_shared_dict dns_cache 1m;
+    init_by_lua '
+        local DNS_Cache = require("resty.dns.cache")
+        DNS_Cache.init_cache()
+    ';
+}
+--- config
+    location /t {
+        echo_location /_t;
+        echo_location /_t2;
+    }
+    location /_t {
+        content_by_lua '
+            local DNS_Cache = require("resty.dns.cache")
+            local dns, err = DNS_Cache.new({
+                dict = "dns_cache",
+                resolver = {nameservers = {{"127.0.0.1", "1953"}}}
+            })
+            if not dns then
+                ngx.say(err)
+            end
+            dns.resolver._id = 125
+
+            local answer, err, stale = dns:query("www.google.com", { qtype = dns.TYPE_A })
+            if not answer then
+                ngx.say(err)
+            end
+        ';
+    }
+    location /_t2 {
+        content_by_lua '
+            local DNS_Cache = require("resty.dns.cache")
+            DNS_Cache.init_cache() -- reset cache
+            local dns, err = DNS_Cache.new({
+                dict = "dns_cache",
+                resolver = {nameservers = {{"127.0.0.1", "1953"}}}
+            })
+            if not dns then
+                ngx.say(err)
+            end
+            dns.resolver._id = 125
+            dns._debug(true)
+
+            local answer, err, stale = dns:query("www.google.com", { qtype = dns.TYPE_A })
+            if not answer then
+                ngx.say(err)
+            end
+            local cjson = require"cjson"
+            ngx.say(cjson.encode(answer))
+
+        ';
+    }
+--- udp_listen: 1953
+--- udp_reply dns
+{
+    id => 125,
+    opcode => 0,
+    qname => 'www.google.com',
+    answer => [{ name => "www.google.com", ipv4 => "127.0.0.1", ttl => 123456 }],
+}
+--- request
+GET /t
+--- error_log
+lru_cache MISS
+shared_dict HIT
+lru_cache SET
+--- response_body
+[{"address":"127.0.0.1","type":1,"class":1,"name":"www.google.com","ttl":123456}]
+
+
+=== TEST 3: Stale response from lru served if resolver down
+--- http_config eval
+"$::HttpConfig"
+. q{
+    lua_shared_dict dns_cache 1m;
+    init_by_lua '
+        local DNS_Cache = require("resty.dns.cache")
+        DNS_Cache.init_cache()
+    ';
+}
+--- config
+    location /t {
+        echo_location /_t;
+        echo_sleep 2;
+        echo_location /_t2;
+    }
+    location /_t {
+        content_by_lua '
+            local DNS_Cache = require("resty.dns.cache")
+            local dns, err = DNS_Cache.new({
+                dict = "dns_cache",
+                resolver = {nameservers = {{"127.0.0.1", "1953"}}}
+            })
+            if not dns then
+                ngx.say(err)
+            end
+            dns.resolver._id = 125
+
+            local answer, err, stale = dns:query("www.google.com", { qtype = dns.TYPE_A })
+            if not answer then
+                ngx.say(err)
+            end
+        ';
+    }
+    location /_t2 {
+        content_by_lua '
+            local DNS_Cache = require("resty.dns.cache")
+            local dns, err = DNS_Cache.new({
+                dict = "dns_cache",
+                resolver = {nameservers = {{"127.0.0.1", "1954"}}, retrans = 1, timeout = 100}
+            })
+            if not dns then
+                ngx.say(err)
+            end
+            dns.resolver._id = 125
+            dns._debug(true)
+
+            local answer, err, stale = dns:query("www.google.com", { qtype = dns.TYPE_A })
+            if stale then
+                answer = stale
+            end
+            local cjson = require"cjson"
+            ngx.say(cjson.encode(answer))
+
+        ';
+    }
+--- udp_listen: 1953
+--- udp_reply dns
+{
+    id => 125,
+    opcode => 0,
+    qname => 'www.google.com',
+    answer => [{ name => "www.google.com", ipv4 => "127.0.0.1", ttl => 1 }],
+}
+--- request
+GET /t
+--- error_log
+lru_cache MISS
+lru_cache STALE
+--- response_body
+[{"address":"127.0.0.1","type":1,"class":1,"name":"www.google.com","ttl":-1}]
+
+
+=== TEST 4: Stale response from dict served if resolver down
+--- http_config eval
+"$::HttpConfig"
+. q{
+    lua_shared_dict dns_cache 1m;
+    init_by_lua '
+        local DNS_Cache = require("resty.dns.cache")
+        DNS_Cache.init_cache()
+    ';
+}
+--- config
+    location /t {
+        echo_location /_t;
+        echo_sleep 2;
+        echo_location /_t2;
+    }
+    location /_t {
+        content_by_lua '
+            local DNS_Cache = require("resty.dns.cache")
+            local dns, err = DNS_Cache.new({
+                dict = "dns_cache",
+                resolver = {nameservers = {{"127.0.0.1", "1953"}}}
+            })
+            if not dns then
+                ngx.say(err)
+            end
+            dns.resolver._id = 125
+
+            local answer, err, stale = dns:query("www.google.com", { qtype = dns.TYPE_A })
+            if not answer then
+                ngx.say(err)
+            end
+        ';
+    }
+    location /_t2 {
+        content_by_lua '
+            local DNS_Cache = require("resty.dns.cache")
+            local dns, err = DNS_Cache.new({
+                dict = "dns_cache",
+                resolver = {nameservers = {{"127.0.0.1", "1954"}}, retrans = 1, timeout = 100}
+            })
+            DNS_Cache.init_cache() -- reset cache
+            if not dns then
+                ngx.say(err)
+            end
+            dns.resolver._id = 125
+            dns._debug(true)
+
+            local answer, err, stale = dns:query("www.google.com", { qtype = dns.TYPE_A })
+            if stale then
+                answer = stale
+            end
+            local cjson = require"cjson"
+            ngx.say(cjson.encode(answer))
+        ';
+    }
+--- udp_listen: 1953
+--- udp_reply dns
+{
+    id => 125,
+    opcode => 0,
+    qname => 'www.google.com',
+    answer => [{ name => "www.google.com", ipv4 => "127.0.0.1", ttl => 1 }],
+}
+--- request
+GET /t
+--- error_log
+lru_cache MISS
+shared_dict STALE
+--- response_body
+[{"address":"127.0.0.1","type":1,"class":1,"name":"www.google.com","ttl":-1}]
+
+=== TEST 5: Stale response from lru served if resolver down, no dict
+--- http_config eval
+"$::HttpConfig"
+. q{
+    init_by_lua '
+        local DNS_Cache = require("resty.dns.cache")
+        DNS_Cache.init_cache()
+    ';
+}
+--- config
+    location /t {
+        echo_location /_t;
+        echo_sleep 2;
+        echo_location /_t2;
+    }
+    location /_t {
+        content_by_lua '
+            local DNS_Cache = require("resty.dns.cache")
+            local dns, err = DNS_Cache.new({
+                resolver = {nameservers = {{"127.0.0.1", "1953"}}}
+            })
+            if not dns then
+                ngx.say(err)
+            end
+            dns.resolver._id = 125
+
+            local answer, err, stale = dns:query("www.google.com", { qtype = dns.TYPE_A })
+            if not answer then
+                ngx.say(err)
+            end
+        ';
+    }
+    location /_t2 {
+        content_by_lua '
+            local DNS_Cache = require("resty.dns.cache")
+            local dns, err = DNS_Cache.new({
+                dict = "dns_cache",
+                resolver = {nameservers = {{"127.0.0.1", "1954"}}, retrans = 1, timeout = 100}
+            })
+            if not dns then
+                ngx.say(err)
+            end
+            dns.resolver._id = 125
+            dns._debug(true)
+
+            local answer, err, stale = dns:query("www.google.com", { qtype = dns.TYPE_A })
+            if stale then
+                answer = stale
+            end
+            local cjson = require"cjson"
+            ngx.say(cjson.encode(answer))
+
+        ';
+    }
+--- udp_listen: 1953
+--- udp_reply dns
+{
+    id => 125,
+    opcode => 0,
+    qname => 'www.google.com',
+    answer => [{ name => "www.google.com", ipv4 => "127.0.0.1", ttl => 1 }],
+}
+--- request
+GET /t
+--- error_log
+lru_cache MISS
+lru_cache STALE
+--- response_body
+[{"address":"127.0.0.1","type":1,"class":1,"name":"www.google.com","ttl":-1}]
+
+=== TEST 6: Stale response from dict served if resolver down, no lru
+--- http_config eval
+"$::HttpConfig"
+. q{
+    lua_shared_dict dns_cache 1m;
+}
+--- config
+    location /t {
+        echo_location /_t;
+        echo_sleep 2;
+        echo_location /_t2;
+    }
+    location /_t {
+        content_by_lua '
+            local DNS_Cache = require("resty.dns.cache")
+            local dns, err = DNS_Cache.new({
+                dict = "dns_cache",
+                resolver = {nameservers = {{"127.0.0.1", "1953"}}}
+            })
+            if not dns then
+                ngx.say(err)
+            end
+            dns.resolver._id = 125
+
+            local answer, err, stale = dns:query("www.google.com", { qtype = dns.TYPE_A })
+            if not answer then
+                ngx.say(err)
+            end
+        ';
+    }
+    location /_t2 {
+        content_by_lua '
+            local DNS_Cache = require("resty.dns.cache")
+            local dns, err = DNS_Cache.new({
+                dict = "dns_cache",
+                resolver = {nameservers = {{"127.0.0.1", "1954"}}, retrans = 1, timeout = 100}
+            })
+            if not dns then
+                ngx.say(err)
+            end
+            dns.resolver._id = 125
+            dns._debug(true)
+
+            local answer, err, stale = dns:query("www.google.com", { qtype = dns.TYPE_A })
+            if stale then
+                answer = stale
+            end
+            local cjson = require"cjson"
+            ngx.say(cjson.encode(answer))
+        ';
+    }
+--- udp_listen: 1953
+--- udp_reply dns
+{
+    id => 125,
+    opcode => 0,
+    qname => 'www.google.com',
+    answer => [{ name => "www.google.com", ipv4 => "127.0.0.1", ttl => 1 }],
+}
+--- request
+GET /t
+--- error_log
+shared_dict STALE
+--- response_body
+[{"address":"127.0.0.1","type":1,"class":1,"name":"www.google.com","ttl":-1}]
+
+=== TEST 7: TTLs are reduced
+--- http_config eval
+"$::HttpConfig"
+. q{
+    lua_shared_dict dns_cache 1m;
+    init_by_lua '
+        local DNS_Cache = require("resty.dns.cache")
+        DNS_Cache.init_cache()
+    ';
+}
+--- config
+    location /t {
+        echo_location /_t;
+        echo_sleep 2;
+        echo_location /_t2;
+    }
+    location /_t {
+        content_by_lua '
+            local DNS_Cache = require("resty.dns.cache")
+            local dns, err = DNS_Cache.new({
+                dict = "dns_cache",
+                resolver = {nameservers = {{"127.0.0.1", "1953"}}}
+            })
+            if not dns then
+                ngx.say(err)
+            end
+            dns.resolver._id = 125
+
+            local answer, err, stale = dns:query("www.google.com", { qtype = dns.TYPE_A })
+            if not answer then
+                ngx.say(err)
+            end
+        ';
+    }
+    location /_t2 {
+        content_by_lua '
+            local DNS_Cache = require("resty.dns.cache")
+            local dns, err = DNS_Cache.new({
+                dict = "dns_cache",
+                resolver = {nameservers = {{"127.0.0.1", "1953"}}, retrans = 1, timeout = 100}
+            })
+            if not dns then
+                ngx.say(err)
+            end
+            dns.resolver._id = 125
+
+            local answer, err, stale = dns:query("www.google.com", { qtype = dns.TYPE_A })
+            if not answer then
+                ngx.say(answer)
+            end
+            local cjson = require"cjson"
+            ngx.say(cjson.encode(answer))
+
+        ';
+    }
+--- udp_listen: 1953
+--- udp_reply dns
+{
+    id => 125,
+    opcode => 0,
+    qname => 'www.google.com',
+    answer => [{ name => "www.google.com", ipv4 => "127.0.0.1", ttl => 10 }],
+}
+--- request
+GET /t
+--- no_error_log
+[error]
+--- response_body
+[{"address":"127.0.0.1","type":1,"class":1,"name":"www.google.com","ttl":8}]
+
+=== TEST 8: TTL reduction can be disabled
+--- http_config eval
+"$::HttpConfig"
+. q{
+    lua_shared_dict dns_cache 1m;
+    init_by_lua '
+        local DNS_Cache = require("resty.dns.cache")
+        DNS_Cache.init_cache()
+    ';
+}
+--- config
+    location /t {
+        echo_location /_t;
+        echo_sleep 2;
+        echo_location /_t2;
+    }
+    location /_t {
+        content_by_lua '
+            local DNS_Cache = require("resty.dns.cache")
+            local dns, err = DNS_Cache.new({
+                dict = "dns_cache",
+                resolver = {nameservers = {{"127.0.0.1", "1953"}}}
+            })
+            if not dns then
+                ngx.say(err)
+            end
+            dns.resolver._id = 125
+
+            local answer, err, stale = dns:query("www.google.com", { qtype = dns.TYPE_A })
+            if not answer then
+                ngx.say(err)
+            end
+        ';
+    }
+    location /_t2 {
+        content_by_lua '
+            local DNS_Cache = require("resty.dns.cache")
+            local dns, err = DNS_Cache.new({
+                dict = "dns_cache",
+                normalise_ttl = false,
+                resolver = {nameservers = {{"127.0.0.1", "1953"}}, retrans = 1, timeout = 100}
+            })
+            if not dns then
+                ngx.say(err)
+            end
+            dns.resolver._id = 125
+
+            local answer, err, stale = dns:query("www.google.com", { qtype = dns.TYPE_A })
+            if not answer then
+                ngx.say(answer)
+            end
+            local cjson = require"cjson"
+            ngx.say(cjson.encode(answer))
+
+        ';
+    }
+--- udp_listen: 1953
+--- udp_reply dns
+{
+    id => 125,
+    opcode => 0,
+    qname => 'www.google.com',
+    answer => [{ name => "www.google.com", ipv4 => "127.0.0.1", ttl => 10 }],
+}
+--- request
+GET /t
+--- no_error_log
+[error]
+--- response_body
+[{"address":"127.0.0.1","type":1,"class":1,"name":"www.google.com","ttl":10}]
+
+=== TEST 9: Negative responses are not cached by default
+--- http_config eval
+"$::HttpConfig"
+. q{
+    lua_shared_dict dns_cache 1m;
+    init_by_lua '
+        local DNS_Cache = require("resty.dns.cache")
+        DNS_Cache.init_cache()
+    ';
+}
+--- config
+    location /t {
+        content_by_lua '
+            local DNS_Cache = require("resty.dns.cache")
+            local dns, err = DNS_Cache.new({
+                dict = "dns_cache",
+                resolver = {nameservers = {{"127.0.0.1", "1953"}}}
+            })
+            if not dns then
+                ngx.say(err)
+            end
+            dns._debug(true)
+            dns.resolver._id = 125
+
+            local answer, err, stale = dns:query("www.google.com", { qtype = dns.TYPE_A })
+            if not answer then
+                ngx.say(err)
+            end
+            local cjson = require"cjson"
+            ngx.say(cjson.encode(answer))
+        ';
+    }
+--- udp_listen: 1953
+--- udp_reply dns
+{
+    id => 125,
+    rcode => 3,
+    opcode => 0,
+    qname => 'www.google.com',
+}
+--- request
+GET /t
+--- no_error_log
+SET
+--- response_body
+{"errcode":3,"errstr":"name error"}
+
+
+=== TEST 10: Negative responses can be cached
+--- http_config eval
+"$::HttpConfig"
+. q{
+    lua_shared_dict dns_cache 1m;
+    init_by_lua '
+        local DNS_Cache = require("resty.dns.cache")
+        DNS_Cache.init_cache()
+    ';
+}
+--- config
+    location /t {
+        echo_location /_t;
+        echo_location /_t2;
+    }
+    location /_t {
+        content_by_lua '
+            local DNS_Cache = require("resty.dns.cache")
+            local dns, err = DNS_Cache.new({
+                dict = "dns_cache",
+                negative_ttl = 10,
+                resolver = {nameservers = {{"127.0.0.1", "1953"}}}
+            })
+            if not dns then
+                ngx.say(err)
+            end
+            dns.resolver._id = 125
+
+            local answer, err, stale = dns:query("www.google.com", { qtype = dns.TYPE_A })
+            if not answer then
+                ngx.say(err)
+            end
+        ';
+    }
+    location /_t2 {
+        content_by_lua '
+            local DNS_Cache = require("resty.dns.cache")
+            local dns, err = DNS_Cache.new({
+                dict = "dns_cache",
+                negative_ttl = 10,
+                resolver = {nameservers = {{"127.0.0.1", "1953"}}}
+            })
+            if not dns then
+                ngx.say(err)
+            end
+            dns.resolver._id = 125
+            dns._debug(true)
+
+            local answer, err, stale = dns:query("www.google.com", { qtype = dns.TYPE_A })
+            if not answer then
+                ngx.say(err)
+            end
+            local cjson = require"cjson"
+            ngx.say(cjson.encode(answer))
+        ';
+    }
+--- udp_listen: 1953
+--- udp_reply dns
+{
+    id => 125,
+    rcode => 3,
+    opcode => 0,
+    qname => 'www.google.com',
+}
+--- request
+GET /t
+--- error_log
+lru_cache HIT
+--- response_body
+{"errcode":3,"errstr":"name error"}
+
+=== TEST 11: Cached negative responses are not returned by default
+--- http_config eval
+"$::HttpConfig"
+. q{
+    lua_shared_dict dns_cache 1m;
+    init_by_lua '
+        local DNS_Cache = require("resty.dns.cache")
+        DNS_Cache.init_cache()
+    ';
+}
+--- config
+    location /t {
+        echo_location /_t;
+        echo_location /_t2;
+    }
+    location /_t {
+        content_by_lua '
+            local DNS_Cache = require("resty.dns.cache")
+            local dns, err = DNS_Cache.new({
+                dict = "dns_cache",
+                negative_ttl = 10,
+                resolver = {nameservers = {{"127.0.0.1", "1953"}}}
+            })
+            if not dns then
+                ngx.say(err)
+            end
+            dns._debug(true)
+            dns.resolver._id = 125
+
+            local answer, err, stale = dns:query("www.google.com", { qtype = dns.TYPE_A })
+            if not answer then
+                ngx.say(err)
+            end
+        ';
+    }
+    location /_t2 {
+        content_by_lua '
+            local DNS_Cache = require("resty.dns.cache")
+            local dns, err = DNS_Cache.new({
+                dict = "dns_cache",
+                resolver = {nameservers = {{"127.0.0.1", "1954"}, retrans = 1, timeout = 100}}
+            })
+            if not dns then
+                ngx.say(err)
+            end
+            dns.resolver._id = 125
+            dns._debug(true)
+
+            local answer, err, stale = dns:query("www.google.com", { qtype = dns.TYPE_A })
+            local cjson = require"cjson"
+            ngx.say(cjson.encode(answer))
+        ';
+    }
+--- udp_listen: 1953
+--- udp_reply dns
+{
+    id => 125,
+    rcode => 3,
+    opcode => 0,
+    qname => 'www.google.com',
+}
+--- request
+GET /t
+--- error_log
+lru_cache SET
+lru_cache HIT
+--- response_body
+null
+
+=== TEST 12: Cache TTL can be minimised
+--- http_config eval
+"$::HttpConfig"
+. q{
+    lua_shared_dict dns_cache 1m;
+    init_by_lua '
+        local DNS_Cache = require("resty.dns.cache")
+        DNS_Cache.init_cache()
+    ';
+}
+--- config
+    location /t {
+        content_by_lua '
+            local DNS_Cache = require("resty.dns.cache")
+            local dns, err = DNS_Cache.new({
+                dict = "dns_cache",
+                minimise_ttl = true,
+                resolver = {nameservers = {{"127.0.0.1", "1953"}}}
+            })
+            if not dns then
+                ngx.say(err)
+            end
+            dns.resolver._id = 125
+            dns._debug(true)
+
+            local answer, err, stale = dns:query("www.google.com", { qtype = dns.TYPE_A })
+            if not answer then
+                ngx.say(err)
+            end
+            local cjson = require"cjson"
+            ngx.say(cjson.encode(answer))
+        ';
+    }
+--- udp_listen: 1953
+--- udp_reply dns
+{
+    id => 125,
+    opcode => 0,
+    qname => 'www.google.com',
+    answer => [
+        { name => "www.google.com", ipv4 => "127.0.0.1", ttl => 123456 },
+        { name => "l.www.google.com", ipv6 => "::1", ttl => 10 },
+    ],
+}
+--- request
+GET /t
+--- error_log
+lru_cache SET: www.google.com|1 10
+shared_dict SET: www.google.com|1 10
+--- response_body
+[{"address":"127.0.0.1","type":1,"class":1,"name":"www.google.com","ttl":123456},{"address":"0:0:0:0:0:0:0:1","type":28,"class":1,"name":"l.www.google.com","ttl":10}]
+
+=== TEST 13: Cache TTLs not minimised by default
+--- http_config eval
+"$::HttpConfig"
+. q{
+    lua_shared_dict dns_cache 1m;
+    init_by_lua '
+        local DNS_Cache = require("resty.dns.cache")
+        DNS_Cache.init_cache()
+    ';
+}
+--- config
+    location /t {
+        content_by_lua '
+            local DNS_Cache = require("resty.dns.cache")
+            local dns, err = DNS_Cache.new({
+                dict = "dns_cache",
+                resolver = {nameservers = {{"127.0.0.1", "1953"}}}
+            })
+            if not dns then
+                ngx.say(err)
+            end
+            dns.resolver._id = 125
+            dns._debug(true)
+
+            local answer, err, stale = dns:query("www.google.com", { qtype = dns.TYPE_A })
+            if not answer then
+                ngx.say(err)
+            end
+            local cjson = require"cjson"
+            ngx.say(cjson.encode(answer))
+        ';
+    }
+--- udp_listen: 1953
+--- udp_reply dns
+{
+    id => 125,
+    opcode => 0,
+    qname => 'www.google.com',
+    answer => [
+        { name => "www.google.com", ipv4 => "127.0.0.1", ttl => 123456 },
+        { name => "l.www.google.com", ipv6 => "::1", ttl => 10 },
+    ],
+}
+--- request
+GET /t
+--- error_log
+lru_cache SET: www.google.com|1 123456
+shared_dict SET: www.google.com|1 123456
+--- response_body
+[{"address":"127.0.0.1","type":1,"class":1,"name":"www.google.com","ttl":123456},{"address":"0:0:0:0:0:0:0:1","type":28,"class":1,"name":"l.www.google.com","ttl":10}]

controllers/nginx-third-party/lua/vendor/lua-resty-dns-cache/t/04-repopulate.t

@@ -0,0 +1,275 @@
+use lib 't';
+use TestDNS;
+use Cwd qw(cwd);
+
+plan tests => repeat_each() * 17;
+
+my $pwd = cwd();
+
+our $HttpConfig = qq{
+    lua_package_path "$pwd/lib/?.lua;;";
+    lua_socket_log_errors off;
+};
+
+no_long_string();
+run_tests();
+
+__DATA__
+=== TEST 1: Query is triggered when cache is expired
+--- http_config eval
+"$::HttpConfig"
+. q{
+    lua_shared_dict dns_cache 1m;
+    init_by_lua '
+        local DNS_Cache = require("resty.dns.cache")
+        DNS_Cache.init_cache()
+    ';
+}
+--- config
+    location /t {
+        content_by_lua '
+            local DNS_Cache = require("resty.dns.cache")
+            local dns, err = DNS_Cache.new({
+                dict = "dns_cache",
+                resolver = {nameservers = {{"127.0.0.1", "1953"}}},
+                max_stale = 10
+            })
+            if not dns then
+                ngx.say(err)
+            end
+            dns.resolver._id = 125
+
+            local answer, err, stale = dns:query("www.google.com", { qtype = dns.TYPE_A })
+            if not answer then
+                ngx.say(err)
+            end
+
+            local cjson = require"cjson"
+            ngx.say(cjson.encode(answer))
+
+            dns._debug(true)
+
+            -- Sleep beyond response TTL
+            ngx.sleep(1.1)
+
+            local answer, err, stale = dns:query("www.google.com", { qtype = dns.TYPE_A })
+            if not answer then
+                if stale then
+                    answer = stale
+                else
+                    ngx.say(err)
+                end
+            end
+
+            local cjson = require"cjson"
+            ngx.say(cjson.encode(answer))
+
+            ngx.sleep(0.1)
+
+        ';
+    }
+--- udp_listen: 1953
+--- udp_reply dns
+{
+    id => 125,
+    opcode => 0,
+    qname => 'www.google.com',
+    answer => [{ name => "www.google.com", ipv4 => "127.0.0.1", ttl => 1 }],
+}
+--- request
+GET /t
+--- error_log
+Returning STALE
+Attempting to repopulate 'www.google.com'
+Repopulating 'www.google.com'
+--- response_body
+[{"address":"127.0.0.1","type":1,"class":1,"name":"www.google.com","ttl":1}]
+[{"address":"127.0.0.1","type":1,"class":1,"name":"www.google.com","ttl":0}]
+
+=== TEST 2: Query is not triggered when cache expires and max_stale is disabled
+--- http_config eval
+"$::HttpConfig"
+. q{
+    lua_shared_dict dns_cache 1m;
+    init_by_lua '
+        local DNS_Cache = require("resty.dns.cache")
+        DNS_Cache.init_cache()
+    ';
+}
+--- config
+    location /t {
+        content_by_lua '
+            local DNS_Cache = require("resty.dns.cache")
+            local dns, err = DNS_Cache.new({
+                dict = "dns_cache",
+                resolver = {nameservers = {{"127.0.0.1", "1953"}}, retrans = 1, timeout = 50 },
+                max_stale = 0
+            })
+            if not dns then
+                ngx.say(err)
+            end
+            dns.resolver._id = 125
+
+            local answer, err, stale = dns:query("www.google.com", { qtype = dns.TYPE_A })
+            if not answer then
+                ngx.say(err)
+            end
+
+            dns._debug(true)
+
+            -- Sleep beyond response TTL
+            ngx.sleep(1.1)
+
+            local answer, err, stale = dns:query("www.google.com", { qtype = dns.TYPE_A })
+            if not answer then
+                if stale then
+                    answer = stale
+                else
+                    ngx.say(err)
+                end
+            end
+
+            local cjson = require"cjson"
+            ngx.say(cjson.encode(answer))
+
+            ngx.sleep(0.1)
+        ';
+    }
+--- udp_listen: 1953
+--- udp_reply dns
+{
+    id => 125,
+    opcode => 0,
+    qname => 'www.google.com',
+    answer => [{ name => "www.google.com", ipv4 => "127.0.0.1", ttl => 1 }],
+}
+--- request
+GET /t
+--- no_error_log
+Attempting to repopulate 'www.google.com'
+Repopulating 'www.google.com'
+--- response_body
+[{"address":"127.0.0.1","type":1,"class":1,"name":"www.google.com","ttl":0}]
+
+
+=== TEST 3: Repopulate ignores max_stale
+--- http_config eval
+"$::HttpConfig"
+. q{
+    lua_shared_dict dns_cache 1m;
+    init_by_lua '
+        local DNS_Cache = require("resty.dns.cache")
+        DNS_Cache.init_cache()
+    ';
+}
+--- config
+    location /t {
+        content_by_lua '
+            local DNS_Cache = require("resty.dns.cache")
+            local dns, err = DNS_Cache.new({
+                dict = "dns_cache",
+                resolver = {nameservers = {{"127.0.0.1", "1953"}}, retrans = 1, timeout = 50 },
+                max_stale = 10,
+            })
+            if not dns then
+                ngx.say(err)
+            end
+            dns.resolver._id = 125
+            dns._debug(true)
+
+            local answer, err, stale = dns:query("www.google.com", { qtype = dns.TYPE_A })
+            if not answer then
+                ngx.say(err)
+            end
+
+            -- Sleep beyond response TTL
+            ngx.sleep(1.1)
+
+            local answer, err, stale = dns:query("www.google.com", { qtype = dns.TYPE_A })
+            if not answer then
+                if stale then
+                    answer = stale
+                else
+                    ngx.say(err)
+                end
+            end
+
+            local cjson = require"cjson"
+            ngx.say(cjson.encode(answer))
+
+            ngx.sleep(0.1)
+        ';
+    }
+--- udp_listen: 1953
+--- udp_reply dns
+{
+    id => 125,
+    opcode => 0,
+    qname => 'www.google.com',
+    answer => [{ name => "www.google.com", ipv4 => "127.0.0.1", ttl => 1 }],
+}
+--- request
+GET /t
+--- error_log
+Repopulating 'www.google.com'
+Querying: www.google.com
+Resolver error
+--- response_body
+[{"address":"127.0.0.1","type":1,"class":1,"name":"www.google.com","ttl":0}]
+
+=== TEST 4: Multiple queries only trigger 1 repopulate timer
+--- http_config eval
+"$::HttpConfig"
+. q{
+    lua_shared_dict dns_cache 1m;
+    init_by_lua '
+        local DNS_Cache = require("resty.dns.cache")
+        DNS_Cache.init_cache()
+    ';
+}
+--- config
+    location /t {
+        content_by_lua '
+            local DNS_Cache = require("resty.dns.cache")
+            local dns, err = DNS_Cache.new({
+                dict = "dns_cache",
+                resolver = {nameservers = {{"127.0.0.1", "1953"}}, retrans = 1, timeout = 50 },
+                repopulate = true,
+            })
+            if not dns then
+                ngx.say(err)
+            end
+            dns.resolver._id = 125
+
+            local answer, err, stale = dns:query("www.google.com", { qtype = dns.TYPE_A })
+            if not answer then
+                ngx.say(err)
+            end
+            dns._debug(true)
+            local answer, err, stale = dns:query("www.google.com", { qtype = dns.TYPE_A })
+            if not answer then
+                ngx.say(err)
+            end
+            local answer, err, stale = dns:query("www.google.com", { qtype = dns.TYPE_A })
+            if not answer then
+                ngx.say(err)
+            end
+
+            local cjson = require"cjson"
+            ngx.say(cjson.encode(answer))
+        ';
+    }
+--- udp_listen: 1953
+--- udp_reply dns
+{
+    id => 125,
+    opcode => 0,
+    qname => 'www.google.com',
+    answer => [{ name => "www.google.com", ipv4 => "127.0.0.1", ttl => 1 }],
+}
+--- request
+GET /t
+--- no_error_log
+Attempting to repopulate www.google.com
+--- response_body
+[{"address":"127.0.0.1","type":1,"class":1,"name":"www.google.com","ttl":1}]

controllers/nginx-third-party/lua/vendor/lua-resty-dns-cache/t/TestDNS.pm

@@ -0,0 +1,271 @@
+package TestDNS;
+
+use strict;
+use warnings;
+
+use 5.010001;
+use Test::Nginx::Socket::Lua -Base;
+#use JSON::XS;
+
+use constant {
+    TYPE_A => 1,
+    TYPE_TXT => 16,
+    TYPE_CNAME => 5,
+    TYPE_AAAA => 28,
+    CLASS_INTERNET => 1,
+};
+
+sub encode_name ($);
+sub encode_ipv4 ($);
+sub encode_ipv6 ($);
+sub gen_dns_reply ($$);
+
+sub Test::Base::Filter::dns {
+    my ($self, $code) = @_;
+
+    my $args = $self->current_arguments;
+    #warn "args: $args";
+    if (defined $args && $args ne 'tcp' && $args ne 'udp') {
+        die "Invalid argument to the \"dns\" filter: $args\n";
+    }
+
+    my $mode = $args // 'udp';
+
+    my $block = $self->current_block;
+
+    my $pointer_spec = $block->dns_pointers;
+    my @pointers;
+    if (defined $pointer_spec) {
+        my @loops = split /\s*,\s*/, $pointer_spec;
+        for my $loop (@loops) {
+            my @nodes = split /\s*=>\s*/, $loop;
+            my $prev;
+            for my $n (@nodes) {
+                if ($n !~ /^\d+$/ || $n == 0) {
+                    die "bad name ID in the --- dns_pointers: $n\n";
+                }
+
+                if (!defined $prev) {
+                    $prev = $n;
+                    next;
+                }
+
+                $pointers[$prev] = $n;
+            }
+        }
+    }
+
+    my $input = eval $code;
+    if ($@) {
+        die "failed to evaluate code $code: $@\n";
+    }
+
+    if (!ref $input) {
+        return $input;
+    }
+
+    if (ref $input eq 'ARRAY') {
+        my @replies;
+        for my $t (@$input) {
+            push @replies, gen_dns_reply($t, $mode);
+        }
+
+        return \@replies;
+    }
+
+    if (ref $input eq 'HASH') {
+        return gen_dns_reply($input, $mode);
+    }
+
+    return $input;
+}
+
+sub gen_dns_reply ($$) {
+    my ($t, $mode) = @_;
+
+    my @raw_names;
+    push @raw_names, \($t->{qname});
+
+    my $answers = $t->{answer} // [];
+    if (!ref $answers) {
+        $answers = [$answers];
+    }
+
+    for my $ans (@$answers) {
+        push @raw_names, \($ans->{name});
+        if (defined $ans->{cname}) {
+            push @raw_names, \($ans->{cname});
+        }
+    }
+
+    for my $rname (@raw_names) {
+        $$rname = encode_name($$rname // "");
+    }
+
+    my $qname = $t->{qname};
+
+    my $s = '';
+
+    my $id = $t->{id} // 0;
+
+    $s .= pack("n", $id);
+    #warn "id: ", length($s), " ", encode_json([$s]);
+
+    my $qr = $t->{qr} // 1;
+
+    my $opcode = $t->{opcode} // 0;
+
+    my $aa = $t->{aa} // 0;
+
+    my $tc = $t->{tc} // 0;
+    my $rd = $t->{rd} // 1;
+    my $ra = $t->{ra} // 1;
+    my $rcode = $t->{rcode} // 0;
+
+    my $flags = ($qr << 15) + ($opcode << 11) + ($aa << 10) + ($tc << 9) + ($rd << 8) + ($ra << 7) + $rcode;
+    #warn sprintf("flags: %b", $flags);
+
+    $flags = pack("n", $flags);
+    $s .= $flags;
+
+    #warn "flags: ", length($flags), " ", encode_json([$flags]);
+
+    my $qdcount = $t->{qdcount} // 1;
+    my $ancount = $t->{ancount} // scalar @$answers;
+    my $nscount = 0;
+    my $arcount = 0;
+
+    $s .= pack("nnnn", $qdcount, $ancount, $nscount, $arcount);
+
+    #warn "qname: ", length($qname), " ", encode_json([$qname]);
+
+    $s .= $qname;
+
+    my $qs_type = $t->{qtype} // TYPE_A;
+    my $qs_class = $t->{qclass} // CLASS_INTERNET;
+
+    $s .= pack("nn", $qs_type, $qs_class);
+
+    for my $ans (@$answers) {
+        my $name = $ans->{name};
+        my $type = $ans->{type};
+        my $class = $ans->{class};
+        my $ttl = $ans->{ttl};
+        my $rdlength = $ans->{rdlength};
+        my $rddata = $ans->{rddata};
+
+        my $ipv4 = $ans->{ipv4};
+        if (defined $ipv4) {
+            my ($data, $len) = encode_ipv4($ipv4);
+            $rddata //= $data;
+            $rdlength //= $len;
+            $type //= TYPE_A;
+            $class //= CLASS_INTERNET;
+        }
+
+        my $ipv6 = $ans->{ipv6};
+        if (defined $ipv6) {
+            my ($data, $len) = encode_ipv6($ipv6);
+            $rddata //= $data;
+            $rdlength //= $len;
+            $type //= TYPE_AAAA;
+            $class //= CLASS_INTERNET;
+        }
+
+        my $cname = $ans->{cname};
+        if (defined $cname) {
+            $rddata //= $cname;
+            $rdlength //= length $rddata;
+            $type //= TYPE_CNAME;
+            $class //= CLASS_INTERNET;
+        }
+
+        my $txt = $ans->{txt};
+        if (defined $txt) {
+            $rddata //= $txt;
+            $rdlength //= length $rddata;
+            $type //= TYPE_TXT;
+            $class //= CLASS_INTERNET;
+        }
+
+        $type //= 0;
+        $class //= 0;
+        $ttl //= 0;
+
+        #warn "rdlength: $rdlength, rddata: ", encode_json([$rddata]), "\n";
+
+        $s .= $name . pack("nnNn", $type, $class, $ttl, $rdlength) . $rddata;
+    }
+
+    if ($mode eq 'tcp') {
+        return pack("n", length($s)) . $s;
+    }
+
+    return $s;
+}
+
+sub encode_ipv4 ($) {
+    my $txt = shift;
+    my @bytes = split /\./, $txt;
+    return pack("CCCC", @bytes), 4;
+}
+
+sub encode_ipv6 ($) {
+    my $txt = shift;
+    my @groups = split /:/, $txt;
+    my $nils = 0;
+    my $nonnils = 0;
+    for my $g (@groups) {
+        if ($g eq '') {
+            $nils++;
+        } else {
+            $nonnils++;
+            $g = hex($g);
+        }
+    }
+
+    my $total = $nils + $nonnils;
+    if ($total > 8 ) {
+        die "Invalid IPv6 address: too many groups: $total: $txt";
+    }
+
+    if ($nils) {
+        my $found = 0;
+        my @new_groups;
+        for my $g (@groups) {
+            if ($g eq '') {
+                if ($found) {
+                    next;
+                }
+
+                for (1 .. 8 - $nonnils) {
+                    push @new_groups, 0;
+                }
+
+                $found = 1;
+
+            } else {
+                push @new_groups, $g;
+            }
+        }
+
+        @groups = @new_groups;
+    }
+
+    if (@groups != 8) {
+        die "Invalid IPv6 address: $txt: @groups\n";
+    }
+
+    #warn "IPv6 groups: @groups";
+
+    return pack("nnnnnnnn", @groups), 16;
+}
+
+sub encode_name ($) {
+    my $name = shift;
+    $name =~ s/([^.]+)\.?/chr(length($1)) . $1/ge;
+    $name .= "\0";
+    return $name;
+}
+
+1

controllers/nginx-third-party/lua/vendor/lua-resty-dns-cache/util/lua-releng.pl

@@ -0,0 +1,32 @@
+#!/usr/bin/env perl
+
+use strict;
+use warnings;
+
+sub file_contains ($$);
+
+my $version;
+for my $file (map glob, qw{ *.lua lib/*.lua lib/*/*.lua lib/*/*/*.lua lib/*/*/*/*.lua lib/*/*/*/*/*.lua }) {
+
+
+    print "Checking use of Lua global variables in file $file ...\n";
+    system("luac -p -l $file | grep ETGLOBAL | grep -vE 'require|type|tostring|error|ngx|ndk|jit|setmetatable|getmetatable|string|table|io|os|print|tonumber|math|pcall|xpcall|unpack|pairs|ipairs|assert|module|package|coroutine|[gs]etfenv|next|rawget|rawset|rawlen'");
+    file_contains($file, "attempt to write to undeclared variable");
+    #system("grep -H -n -E --color '.{81}' $file");
+}
+
+sub file_contains ($$) {
+    my ($file, $regex) = @_;
+    open my $in, $file
+        or die "Cannot open $file fo reading: $!\n";
+    my $content = do { local $/; <$in> };
+    close $in;
+    #print "$content";
+    return scalar ($content =~ /$regex/);
+}
+
+if (-d 't') {
+    for my $file (map glob, qw{ t/*.t t/*/*.t t/*/*/*.t }) {
+        system(qq{grep -H -n --color -E '\\--- ?(ONLY|LAST)' $file});
+    }
+}