from jinja2 import Environment, Template
from typing_extensions import Literal
-from knot_resolver_manager.datamodel.dns64_config import Dns64
-from knot_resolver_manager.datamodel.dnssec_config import Dnssec
-from knot_resolver_manager.datamodel.lua_config import Lua
-from knot_resolver_manager.datamodel.network_config import Network
-from knot_resolver_manager.datamodel.options_config import Options
-from knot_resolver_manager.datamodel.server_config import Server
+from knot_resolver_manager.datamodel.dns64_config import Dns64Schema
+from knot_resolver_manager.datamodel.dnssec_config import DnssecSchema
+from knot_resolver_manager.datamodel.lua_config import LuaSchema
+from knot_resolver_manager.datamodel.network_config import NetworkSchema
+from knot_resolver_manager.datamodel.options_config import OptionsSchema
+from knot_resolver_manager.datamodel.server_config import ServerSchema
from knot_resolver_manager.utils import SchemaNode
class KresConfig(SchemaNode):
class Raw(SchemaNode):
- server: Server = Server()
- options: Options = Options()
- network: Network = Network()
- dnssec: Union[bool, Dnssec] = True
- dns64: Union[bool, Dns64] = False
- lua: Lua = Lua()
+ server: ServerSchema = ServerSchema()
+ options: OptionsSchema = OptionsSchema()
+ network: NetworkSchema = NetworkSchema()
+ dnssec: Union[bool, DnssecSchema] = True
+ dns64: Union[bool, Dns64Schema] = False
+ lua: LuaSchema = LuaSchema()
_PREVIOUS_SCHEMA = Raw
- server: Server
- options: Options
- network: Network
- dnssec: Union[Literal[False], Dnssec]
- dns64: Union[Literal[False], Dns64]
- lua: Lua
+ server: ServerSchema
+ options: OptionsSchema
+ network: NetworkSchema
+ dnssec: Union[Literal[False], DnssecSchema]
+ dns64: Union[Literal[False], Dns64Schema]
+ lua: LuaSchema
- def _dnssec(self, obj: Raw) -> Union[Literal[False], Dnssec]:
+ def _dnssec(self, obj: Raw) -> Union[Literal[False], DnssecSchema]:
if obj.dnssec is True:
- return Dnssec()
+ return DnssecSchema()
return obj.dnssec
- def _dns64(self, obj: Raw) -> Union[Literal[False], Dns64]:
+ def _dns64(self, obj: Raw) -> Union[Literal[False], Dns64Schema]:
if obj.dns64 is True:
- return Dns64()
+ return Dns64Schema()
return obj.dns64
def render_lua(self) -> Text:
from knot_resolver_manager.utils import SchemaNode
-class Dns64(SchemaNode):
+class Dns64Schema(SchemaNode):
prefix: IPv6Network96 = IPv6Network96("64:ff9b::/96")
from knot_resolver_manager.utils import SchemaNode
-class TrustAnchorFile(SchemaNode):
+class TrustAnchorFileSchema(SchemaNode):
file: str
read_only: bool = False
-class Dnssec(SchemaNode):
+class DnssecSchema(SchemaNode):
trust_anchor_sentinel: bool = True
trust_anchor_signal_query: bool = True
time_skew_detection: bool = True
trust_anchors: Optional[List[str]] = None
negative_trust_anchors: Optional[List[str]] = None
- trust_anchors_files: Optional[List[TrustAnchorFile]] = None
+ trust_anchors_files: Optional[List[TrustAnchorFileSchema]] = None
from knot_resolver_manager.utils import SchemaNode
-class Lua(SchemaNode):
+class LuaSchema(SchemaNode):
script_only: bool = False
script: Optional[str] = None
script_file: Optional[str] = None
KindEnum = LiteralEnum["dns", "xdp", "dot", "doh"]
-class Interface(SchemaNode):
+class InterfaceSchema(SchemaNode):
listen: Listen
kind: KindEnum = "dns"
freebind: bool = False
-class Network(SchemaNode):
- interfaces: List[Interface] = [
- Interface({"listen": {"ip": "127.0.0.1", "port": 53}}),
- Interface({"listen": {"ip": "::1", "port": 53}, "freebind": True}),
+class NetworkSchema(SchemaNode):
+ interfaces: List[InterfaceSchema] = [
+ InterfaceSchema({"listen": {"ip": "127.0.0.1", "port": 53}}),
+ InterfaceSchema({"listen": {"ip": "::1", "port": 53}, "freebind": True}),
]
GlueCheckingEnum = LiteralEnum["normal", "strict", "permissive"]
-class Prediction(SchemaNode):
+class PredictionSchema(SchemaNode):
window: TimeUnit = TimeUnit("15m")
period: int = 24
-class Options(SchemaNode):
+class OptionsSchema(SchemaNode):
class Raw(SchemaNode):
glue_checking: GlueCheckingEnum = "normal"
qname_minimisation: bool = True
time_jump_detection: bool = True
violators_workarounds: bool = False
serve_stale: bool = False
- prediction: Union[bool, Prediction] = False
+ prediction: Union[bool, PredictionSchema] = False
_PREVIOUS_SCHEMA = Raw
time_jump_detection: bool
violators_workarounds: bool
serve_stale: bool
- prediction: Union[Literal[False], Prediction]
+ prediction: Union[Literal[False], PredictionSchema]
def _prediction(self, obj: Raw) -> Any:
if obj.prediction is True:
- return Prediction()
+ return PredictionSchema()
return obj.prediction
BackendEnum = LiteralEnum["auto", "systemd", "supervisord"]
-class Management(SchemaNode):
+class ManagementSchema(SchemaNode):
listen: Listen = Listen({"unix-socket": "/tmp/manager.sock"})
backend: BackendEnum = "auto"
rundir: AnyPath = AnyPath(".")
-class Webmgmt(SchemaNode):
+class WebmgmtSchema(SchemaNode):
listen: Listen
tls: bool = False
cert_file: Optional[AnyPath] = None
key_file: Optional[AnyPath] = None
-class Server(SchemaNode):
+class ServerSchema(SchemaNode):
class Raw(SchemaNode):
hostname: Optional[str] = None
groupid: Optional[str] = None
nsid: Optional[str] = None
workers: Union[Literal["auto"], int] = 1
use_cache_gc: bool = True
- management: Management = Management()
- webmgmt: Optional[Webmgmt] = None
+ management: ManagementSchema = ManagementSchema()
+ webmgmt: Optional[WebmgmtSchema] = None
_PREVIOUS_SCHEMA = Raw
nsid: Optional[str]
workers: int
use_cache_gc: bool
- management: Management
- webmgmt: Optional[Webmgmt]
+ management: ManagementSchema
+ webmgmt: Optional[WebmgmtSchema]
def _hostname(self, obj: Raw) -> Any:
if obj.hostname is None:
-from knot_resolver_manager.datamodel.dnssec_config import Dnssec
+from knot_resolver_manager.datamodel.dnssec_config import DnssecSchema
from knot_resolver_manager.datamodel.types import TimeUnit
tree = {
"trust-anchors-files": [{"file": "root.key", "read-only": True}],
}
-strict = Dnssec(tree)
+strict = DnssecSchema(tree)
def test_validating():
from pytest import raises
-from knot_resolver_manager.datamodel.lua_config import Lua
+from knot_resolver_manager.datamodel.lua_config import LuaSchema
from knot_resolver_manager.exceptions import KresdManagerException
tree = {"script-only": True, "script": "-- lua script"}
-strict = Lua(tree)
+strict = LuaSchema(tree)
def test_validating():
def test_exception_raises():
with raises(KresdManagerException):
- Lua({"script": "-- lua script", "script-file": "path/to/file"})
+ LuaSchema({"script": "-- lua script", "script-file": "path/to/file"})
import ipaddress
-from knot_resolver_manager.datamodel.network_config import Network
+from knot_resolver_manager.datamodel.network_config import NetworkSchema
def test_interfaces_default():
- o = Network()
+ o = NetworkSchema()
assert len(o.interfaces) == 2
# {"listen": {"ip": "127.0.0.1", "port": 53}}
-from knot_resolver_manager.datamodel.options_config import Options
+from knot_resolver_manager.datamodel.options_config import OptionsSchema
from knot_resolver_manager.datamodel.types import TimeUnit
tree = {
"prediction": {"window": "10m", "period": 20},
}
-strict = Options(tree)
+strict = OptionsSchema(tree)
def test_validating():
def test_prediction_true_defaults():
- y = Options({"prediction": True})
+ y = OptionsSchema({"prediction": True})
assert y.prediction.window == TimeUnit("15m")
assert y.prediction.period == 24
projects / thirdparty / knot-resolver.git / commitdiff
