tests: integration test for cache overflow situation

Resolvers must answer queries even if the shared cache overflown during query processing.

lib/cache/overflow.test.integr/deckard.yaml

+# SPDX-License-Identifier: GPL-3.0-or-later
+programs:
+- name: kresd1
+  binary: kresd
+  additional:
+    - -n
+  templates:
+    - lib/cache/overflow.test.integr/kresd_config.j2
+    - tests/config/test_dns_generators.lua
+  configs:
+    - config
+    - dns_gen.lua
+- name: kresd2
+  binary: kresd
+  additional:
+    - -n
+  templates:
+    - lib/cache/overflow.test.integr/kresd_config.j2
+    - tests/config/test_dns_generators.lua
+  configs:
+    - config
+    - dns_gen.lua

lib/cache/overflow.test.integr/kresd_config.j2

+-- SPDX-License-Identifier: GPL-3.0-or-later
+
+trust_anchors.remove('.')
+{% for TAF in TRUST_ANCHOR_FILES %}
+trust_anchors.add_file('{{TAF}}')
+{% endfor %}
+
+{% raw %}
+-- Disable RFC5011 TA update
+if ta_update then
+        modules.unload('ta_update')
+end
+
+-- Disable RFC8145 signaling, scenario doesn't provide expected answers
+if ta_signal_query then
+        modules.unload('ta_signal_query')
+end
+
+-- Disable RFC8109 priming, scenario doesn't provide expected answers
+if priming then
+        modules.unload('priming')
+end
+
+-- Disable this module because it make one priming query
+if detect_time_skew then
+        modules.unload('detect_time_skew')
+end
+
+verbose(true)
+policy.add(policy.all(policy.DEBUG_ALWAYS))
+
+cache.open(1*MB)
+
+{% endraw %}
+
+-- both instances listen on both addresses
+-- so queries get distributed between them randomly
+net.listen('{{programs[0]["address"]}}')
+net.listen('{{programs[1]["address"]}}')
+
+{% raw %}
+-- Self-checks on globals
+assert(help() ~= nil)
+assert(worker.id ~= nil)
+-- Self-checks on facilities
+assert(cache.stats() ~= nil)
+assert(cache.backends() ~= nil)
+assert(worker.stats() ~= nil)
+assert(net.interfaces() ~= nil)
+-- Self-checks on loaded stuff
+{% endraw %}
+
+assert(net.list()[1].transport.ip == '{{programs[0]["address"]}}')
+
+{% raw %}
+assert(#modules.list() > 0)
+-- Self-check timers
+ev = event.recurrent(1 * sec, function (ev) return 1 end)
+event.cancel(ev)
+ev = event.after(0, function (ev) return 1 end)
+
+local ffi = require('ffi')
+local kr_cach = kres.context().cache
+
+-- canary for cache overflow
+local kr_rrset = kres.rrset(
+	todname('www.example.com'),
+	kres.type.A,
+	kres.class.IN,
+	604800)
+assert(kr_rrset:add_rdata('\192\000\002\001', 4))
+assert(kr_cach:insert(kr_rrset, nil, ffi.C.KR_RANK_SECURE))
+
+local generators = dofile('./dns_gen.lua')
+event.after(0, generators.gen_batch)
+{% endraw %}

lib/meson.build

@@ -74,6 +74,7 @@ unit_tests += [
 ]
 
 integr_tests += [
+  ['cache_overflow', join_paths(meson.current_source_dir(), 'cache', 'overflow.test.integr')],
   ['cache_minimal_nsec', join_paths(meson.current_source_dir(), 'cache', 'test.integr')],
   ['iter_limits' , join_paths(meson.current_source_dir(), 'layer', 'test.integr')],
   ['validate' , join_paths(meson.current_source_dir(), 'layer', 'validate.test.integr')],

tests/config/test_dns_generators.lua

+-- SPDX-License-Identifier: GPL-3.0-or-later
+local ffi = require('ffi')
+local kr_cach = kres.context().cache
+
+
+local charset = {
+	'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l',
+	'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x',
+	'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '-'}
+
+local function gen_bytes(len)
+	local bytes = {}
+	for _ = 1,len do
+		table.insert(bytes, charset[math.random(1, #charset)])
+	end
+	local result = table.concat(bytes)
+	assert(#result == len)
+	return result
+end
+
+local function gen_ttl()
+	return math.random(0, 2^31-1)
+end
+
+local function gen_rrtype()
+	return math.random(1024, 61000)
+end
+
+local function gen_rdata(len)
+	assert(len >= 1 and len <= 65535)
+	return gen_bytes(len)
+end
+
+local function gen_label(len)  -- in bytes including the length byte
+	assert(len >= 2 and len <= 64)
+	local bytes = {string.char(len - 1), gen_bytes(len - 1)}
+	return table.concat(bytes)
+end
+
+local function gen_dname()
+	local target_len  -- length 2 bytes does not make sense
+	while target_len == nil or target_len == 2 do
+		target_len = math.random(1, 255)
+	end
+
+	local labels = {string.char(0)}
+	local cur_len = 1
+	while target_len > cur_len do
+		local new_len = math.random(
+					2,
+					math.min(target_len - cur_len,
+						64))
+		if (target_len - cur_len - new_len) == 1 then
+			-- it is a trap, single-byte label is allowed only at the end
+			-- we cannot leave room for single-byte label in the next round
+			if new_len == 64 then
+				goto continue  -- we are at max label length, try again
+			end
+			new_len = new_len + 1
+		end
+		table.insert(labels, 1, gen_label(new_len))
+		cur_len = cur_len + new_len
+		::continue::
+	end
+	assert(target_len == cur_len)
+	local dname = table.concat(labels)
+	assert(#dname >= 1 and #dname <= 255)
+	assert(string.byte(dname, #dname) == 0)
+	return dname
+end
+
+
+local function gen_rrset()
+	local rrs = {}
+	local maxsize = 300  -- RR data size in bytes per RR set, does not include owner etc.
+	local target_len = math.random(1, maxsize)
+	local cur_len = 0
+	while target_len > cur_len do
+		local new_len = math.random(1, target_len - cur_len)
+		local new_rr = gen_rdata(new_len)
+		cur_len = cur_len + #new_rr
+		table.insert(rrs, new_rr)
+	end
+	assert(target_len == cur_len)
+	return rrs, cur_len
+end
+
+
+local function add_random_rrset()
+	local owner = gen_dname()
+	local ttl = gen_ttl()
+	local rr_type = gen_rrtype()
+	local rdata_set = gen_rrset()
+
+	local kr_rrset = kres.rrset(owner, rr_type, kres.class.IN, ttl)
+	for _, rr in ipairs(rdata_set) do
+		assert(kr_rrset:add_rdata(rr, #rr))
+	end
+	assert(kr_cach:insert(kr_rrset, nil, ffi.C.KR_RANK_SECURE))
+end
+
+
+local rr_count = 0
+local function gen_batch()
+	for _ = 1,math.random(1,10) do
+		add_random_rrset()
+		rr_count = rr_count + 1
+		if rr_count % 100 == 0 then
+			print('cache usage ', cache.stats()['usage_percent'], '%')
+		end
+	end
+	kr_cach:commit()
+	local delay
+	if math.random(1,4) == 1 then
+		delay = 1  -- give a chance to DNS resolving
+	else
+		delay = 0
+	end
+	event.after(delay, gen_batch)
+end
+
+return {
+	add_random_rrset=add_random_rrset,
+	gen_batch=gen_batch,
+	gen_bytes=gen_bytes,
+	gen_dname=gen_dname,
+	gen_label=gen_label,
+	gen_rdata=gen_rdata,
+	gen_rrset=gen_rrset,
+	gen_rrtype=gen_rrtype,
+	gen_ttl=gen_ttl
+}

deckard @ 81e1c94e

-Subproject commit 4df86d9cbec25588cec454d7246a3ee5227ad65d
+Subproject commit 81e1c94e4cfe4f2e4a31ea70574a8e5278434825