{
- "server": {
- "instances": 4
+ "network": {
+ "interfaces": [
+ {
+ "listen": "127.0.0.1"
+ },
+ {
+ "listen": "127.0.0.1",
+ "kind": "dot"
+ },
+ {
+ "listen": "::1",
+ "feebind": true
+ },
+ {
+ "listen": "::1",
+ "kind": "dot",
+ "feebind": true
+ }
+ ],
+ "edns_buffer_size": {
+ "downstream": "4K"
+ }
},
- "dns64": {
- "prefix": "64:ff9b::"
+ "options": {
+ "prediction": true
},
- "logging": {
- "level": 4
- },
- "lua": {
- "script": [
- "net.listen('127.0.0.1', 53, { kind = 'dns' })",
- "net.listen('127.0.0.1', 853, { kind = 'tls' })",
- "net.listen('::1', 53, { kind = 'dns', freebind = true })",
- "net.listen('::1', 853, { kind = 'tls', freebind = true })",
- "-- Cache size",
- "cache.size = 100 * MB"
- ]
+ "cache": {
+ "size_max": "100M"
}
}
\ No newline at end of file
-server:
- instances: 1
-
-dns64:
- prefix: "64:ff9b::"
-
-logging:
- level: 4
-
-lua:
- script: |
- """
- net.listen('127.0.0.1', 53, { kind = 'dns' })
- net.listen('127.0.0.1', 853, { kind = 'tls' })
- net.listen('::1', 53, { kind = 'dns', freebind = true })
- net.listen('::1', 853, { kind = 'tls', freebind = true })
-
- -- Cache size
- cache.size = 100 * MB
- """
\ No newline at end of file
+network:
+ interfaces:
+ - listen: 127.0.0.1
+ - listen: 127.0.0.1
+ kind: dot
+ - listen: ::1
+ freebind: true
+ - listen: ::1
+ kind: dot
+ freebind: true
+ edns_buffer_size:
+ downstream: 4K
+options:
+ prediction: true
+cache:
+ size_max: 100M
+{% if cfg.server.hostname %}
+-- server.hostname
+hostname('{{ cfg.server.hostname }}')
+{% endif %}
+
+-- network.interfaces
+{% for item in cfg.network.interfaces %}
+net.listen('{{ item.get_address() }}', {{ item.get_port() if item.get_port() else 'nil' }}, {
+ kind = '{{ item.kind if item.kind != 'dot' else 'tls' }}',
+ freebind = {{ 'true' if item.freebind else 'false'}}
+})
+{% endfor %}
+
+-- network.edns-buffer-size
+net.bufsize({{ cfg.network.edns_buffer_size.get_downstream() }}, {{ cfg.network.edns_buffer_size.get_upstream() }})
+
+-- modules
modules = {
'hints > iterate', -- Load /etc/hosts and allow custom root hints",
'stats', -- Track internal statistics",
- 'predict', -- Prefetch expiring/frequent records",
-{%- if cfg.dns64 %}
+{% if cfg.options.prediction %}
+ predict = { -- Prefetch expiring/frequent records"
+ window = {{ cfg.options.prediction.get_window() }},
+ period = {{ cfg.options.prediction.period }}
+ },
+{% endif %}
+{% if cfg.dns64 %}
dns64 = '{{ cfg.dns64.prefix }}', -- dns64
-{%- endif %}
+{% endif %}
}
-{%- if ( cfg.logging.level > 3 ) %}
+-- cache
+cache.open({{ cfg.cache.get_size_max() }}, 'lmdb://{{ cfg.cache.storage }}')
+
-- logging level
-verbose(true)
-{%- endif %}
+verbose({{ 'true' if cfg.logging.level > 3 else 'false'}})
+{% if cfg.lua.script %}
-- lua
-{%- if cfg.lua.script %}
{{ cfg.lua.script }}
-{%- endif %}
\ No newline at end of file
+{% endif %}
\ No newline at end of file
"server": {
"instances": %s
},
- "lua": {
- "script_list": [
- "net.listen('127.0.0.1', 53, { kind = 'dns' })",
- "net.listen('127.0.0.1', 853, { kind = 'tls' })",
- "net.listen('::1', 53, { kind = 'dns', freebind = true })",
- "net.listen('::1', 853, { kind = 'tls', freebind = true })",
- "-- Cache size",
- "cache.size = 100 * MB"
- ]
+ "logging": {
+ "level": 7
}
}
\ No newline at end of file
{
"server": {
- "instances": 1
+ "hostname": "knot-resolver-manager",
+ "instances": 2,
+ "use_cache_gc": false
},
- "dns64": {
- "prefix": "64:ff9b::"
+ "network": {
+ "interfaces": [
+ {
+ "listen": "127.0.0.1"
+ },
+ {
+ "listen": "::1",
+ "freebind": true
+ },
+ {
+ "listen": "127.0.0.1",
+ "kind": "dot"
+ },
+ {
+ "listen": "::1",
+ "kind": "dot",
+ "freebind": true
+ }
+ ],
+ "edns_buffer_size": {
+ "downstream": "4K"
+ }
},
- "logging": {
- "level": 4
+ "options": {
+ "prediction": true
+ },
+ "dnssec": false,
+ "dns64": true,
+ "cache": {
+ "size_max": "10M"
},
- "lua": {
- "script_list": [
- "net.listen('127.0.0.1', 53, { kind = 'dns' })",
- "net.listen('127.0.0.1', 853, { kind = 'tls' })",
- "net.listen('::1', 53, { kind = 'dns', freebind = true })",
- "net.listen('::1', 853, { kind = 'tls', freebind = true })",
- "-- Cache size",
- "cache.size = 100 * MB"
- ]
+ "logging": {
+ "level": 7
}
}
\ No newline at end of file
"server": {
"instances": %s
},
- "lua": {
- "script_list": [
- "net.listen('127.0.0.1', 53, { kind = 'dns' })",
- "net.listen('127.0.0.1', 853, { kind = 'tls' })",
- "net.listen('::1', 53, { kind = 'dns', freebind = true })",
- "net.listen('::1', 853, { kind = 'tls', freebind = true })",
- "-- Cache size",
- "cache.size = 100 * MB"
- ]
+ "logging": {
+ "level": 7
}
}
\ No newline at end of file
"""
-from dataclasses import dataclass, is_dataclass
+from dataclasses import dataclass, field, is_dataclass
-__all__ = ["dataclass", "is_dataclass"]
+__all__ = ["dataclass", "is_dataclass", "field"]
from .datamodel import KresConfig
_LUA_TEMPLATE_STR = """
+{% if cfg.server.hostname %}
+-- server.hostname
+hostname('{{ cfg.server.hostname }}')
+{% endif %}
+
+-- network.interfaces
+{% for item in cfg.network.interfaces %}
+net.listen('{{ item.get_address() }}', {{ item.get_port() if item.get_port() else 'nil' }}, {
+ kind = '{{ item.kind if item.kind != 'dot' else 'tls' }}',
+ freebind = {{ 'true' if item.freebind else 'false'}}
+})
+{% endfor %}
+
+-- network.edns-buffer-size
+net.bufsize({{ cfg.network.edns_buffer_size.get_downstream() }}, {{ cfg.network.edns_buffer_size.get_upstream() }})
+
+-- modules
modules = {
'hints > iterate', -- Load /etc/hosts and allow custom root hints",
'stats', -- Track internal statistics",
- 'predict', -- Prefetch expiring/frequent records",
-{%- if cfg.dns64 %}
+{% if cfg.options.prediction %}
+ predict = { -- Prefetch expiring/frequent records"
+ window = {{ cfg.options.prediction.get_window() }},
+ period = {{ cfg.options.prediction.period }}
+ },
+{% endif %}
+{% if cfg.dns64 %}
dns64 = '{{ cfg.dns64.prefix }}', -- dns64
-{%- endif %}
+{% endif %}
}
-{%- if ( cfg.logging.level > 3 ) %}
+-- cache
+cache.open({{ cfg.cache.get_size_max() }}, 'lmdb://{{ cfg.cache.storage }}')
+
-- logging level
-verbose(true)
-{%- endif %}
+verbose({{ 'true' if cfg.logging.level > 3 else 'false'}})
+{% if cfg.lua.script %}
-- lua
-{%- if cfg.lua.script %}
{{ cfg.lua.script }}
-{%- endif %}
+{% endif %}
"""
-_ENV = Environment(enable_async=True)
+_ENV = Environment(enable_async=True, trim_blocks=True, lstrip_blocks=True)
_LUA_TEMPLATE: Template = _ENV.from_string(_LUA_TEMPLATE_STR)
+from typing import Optional
+
from knot_resolver_manager.compat.dataclasses import dataclass
+from knot_resolver_manager.datamodel.types import SizeUnits
from knot_resolver_manager.utils.dataclasses_parservalidator import DataclassParserValidatorMixin
@dataclass
class CacheConfig(DataclassParserValidatorMixin):
+ storage: str = "/var/cache/knot-resolver"
+ size_max: Optional[str] = None
+ _size_max_bytes: int = 100 * SizeUnits.mebibyte
+
+ def __post_init__(self):
+ if self.size_max:
+ self._size_max_bytes = SizeUnits.parse(self.size_max)
+
+ def get_size_max(self) -> int:
+ return self._size_max_bytes
+
def _validate(self):
pass
-from typing import Optional
+from typing import Optional, Union
from knot_resolver_manager.compat.dataclasses import dataclass
from knot_resolver_manager.utils.dataclasses_parservalidator import DataclassParserValidatorMixin
from .cache_config import CacheConfig
from .dns64_config import Dns64Config
-from .dnssec_config import DnssecConfig
-from .hints_config import StaticHintsConfig
from .logging_config import LoggingConfig
from .lua_config import LuaConfig
from .network_config import NetworkConfig
class KresConfig(DataclassParserValidatorMixin):
# pylint: disable=too-many-instance-attributes
server: ServerConfig = ServerConfig()
+ network: NetworkConfig = NetworkConfig()
options: OptionsConfig = OptionsConfig()
- network: Optional[NetworkConfig] = None
- static_hints: StaticHintsConfig = StaticHintsConfig()
- dnssec: Optional[DnssecConfig] = None
cache: CacheConfig = CacheConfig()
- dns64: Optional[Dns64Config] = None
+ # DNS64 is disabled by default
+ dns64: Union[bool, Dns64Config] = False
logging: LoggingConfig = LoggingConfig()
- lua: LuaConfig = LuaConfig()
+ lua: Optional[LuaConfig] = None
+
+ def __post_init__(self):
+ # if DNS64 is enabled with defaults
+ if self.dns64 is True:
+ self.dns64 = Dns64Config()
def _validate(self):
pass
from knot_resolver_manager.utils.dataclasses_parservalidator import DataclassParserValidatorMixin
from .errors import DataValidationError
-from .types import IPV6_PREFIX_96
+from .types import RE_IPV6_PREFIX_96
@dataclass
prefix: str = "64:ff9b::"
def _validate(self):
- if not bool(IPV6_PREFIX_96.match(self.prefix)):
+ if not bool(RE_IPV6_PREFIX_96.match(self.prefix)):
raise DataValidationError("'dns64.prefix' must be valid IPv6 /96 prefix")
-from knot_resolver_manager.compat.dataclasses import dataclass
+from typing import List, Optional, Union
+
+from knot_resolver_manager.compat.dataclasses import dataclass, field
+from knot_resolver_manager.datamodel.types import SizeUnits
from knot_resolver_manager.utils.dataclasses_parservalidator import DataclassParserValidatorMixin
+@dataclass
+class InterfacesConfig(DataclassParserValidatorMixin):
+ listen: str
+ kind: str = "dns"
+ freebind: bool = False
+ _address: Optional[str] = None
+ _port: Optional[int] = None
+ _kind_port_map = {"dns": 53, "xdp": 53, "dot": 853, "doh": 443}
+
+ def __post_init__(self):
+ # split 'address@port'
+ if "@" in self.listen:
+ tmp = self.listen.split("@", maxsplit=1)
+ self._address = tmp[0]
+ self._port = int(tmp[1])
+ # if port number not specified
+ self._address = self.listen
+ # set port number based on 'kind'
+ self._port = self._kind_port_map.get(self.kind)
+
+ def get_address(self) -> Optional[str]:
+ return self._address
+
+ def get_port(self) -> Optional[int]:
+ return self._port
+
+ def _validate(self):
+ pass
+
+
+@dataclass
+class EdnsBufferSizeConfig(DataclassParserValidatorMixin):
+ downstream: Optional[str] = None
+ upstream: Optional[str] = None
+ _downstream_bytes: int = 1232
+ _upstream_bytes: int = 1232
+
+ def __post_init__(self):
+ if self.downstream:
+ self._downstream_bytes = SizeUnits.parse(self.downstream)
+ if self.upstream:
+ self._upstream_bytes = SizeUnits.parse(self.upstream)
+
+ def _validate(self):
+ pass
+
+ def get_downstream(self) -> int:
+ return self._downstream_bytes
+
+ def get_upstream(self) -> int:
+ return self._upstream_bytes
+
+
@dataclass
class NetworkConfig(DataclassParserValidatorMixin):
+ interfaces: List[InterfacesConfig] = field(
+ default_factory=lambda: [InterfacesConfig(listen="127.0.0.1"), InterfacesConfig(listen="::1", freebind=True)]
+ )
+ edns_buffer_size: Union[str, EdnsBufferSizeConfig] = EdnsBufferSizeConfig()
+
+ def __post_init__(self):
+ if isinstance(self.edns_buffer_size, str):
+ bufsize = self.edns_buffer_size
+ self.edns_buffer_size = EdnsBufferSizeConfig(downstream=bufsize, upstream=bufsize)
+
def _validate(self):
pass
+from typing import Optional, Union
+
from knot_resolver_manager.compat.dataclasses import dataclass
+from knot_resolver_manager.datamodel.types import TimeUnits
from knot_resolver_manager.utils.dataclasses_parservalidator import DataclassParserValidatorMixin
+@dataclass
+class PredictionConfig(DataclassParserValidatorMixin):
+ window: Optional[str] = None
+ _window_seconds: int = 15 * TimeUnits.minute
+ period: int = 24
+
+ def __post_init__(self):
+ if self.window:
+ self._window_seconds = TimeUnits.parse(self.window)
+
+ def get_window(self) -> int:
+ return self._window_seconds
+
+ def _validate(self):
+ pass
+
+
@dataclass
class OptionsConfig(DataclassParserValidatorMixin):
+ prediction: Union[bool, PredictionConfig] = False
+
+ def __post_init__(self):
+ if self.prediction is True:
+ self.prediction = PredictionConfig()
+
def _validate(self):
pass
import re
-IPV6_PREFIX_96 = re.compile(r"^([0-9A-Fa-f]{1,4}:){2}:$")
+from .errors import DataValidationError
+
+RE_IPV6_PREFIX_96 = re.compile(r"^([0-9A-Fa-f]{1,4}:){2}:$")
+
+
+class TimeUnits:
+ second = 1
+ minute = 60
+ hour = 3600
+ day = 24 * 3600
+
+ _re = re.compile(r"^(\d+)\s{0,1}([smhd]){0,1}$")
+ _map = {"s": second, "m": minute, "h": hour, "d": day}
+
+ @staticmethod
+ def parse(time_str: str) -> int:
+ searched = TimeUnits._re.search(time_str)
+ if searched:
+ value, unit = searched.groups()
+ return int(value) * TimeUnits._map.get(unit, 1)
+ raise DataValidationError(f"failed to parse: {time_str}")
+
+
+class SizeUnits:
+ byte = 1
+ kibibyte = 1024
+ mebibyte = 1024 ** 2
+ gibibyte = 1024 ** 3
+
+ _re = re.compile(r"^([0-9]+)\s{0,1}([BKMG]){0,1}$")
+ _map = {"B": byte, "K": kibibyte, "M": mebibyte, "G": gibibyte}
+
+ @staticmethod
+ def parse(size_str: str) -> int:
+ searched = SizeUnits._re.search(size_str)
+ if searched:
+ value, unit = searched.groups()
+ return int(value) * SizeUnits._map.get(unit, 1)
+ raise DataValidationError(f"failed to parse: {size_str}")
projects / thirdparty / knot-resolver.git / commitdiff
