from typing import List, Optional
-from knot_resolver_manager.datamodel.types import TimeUnit
+from knot_resolver_manager.datamodel.types import IntNonNegative, TimeUnit
from knot_resolver_manager.utils import SchemaNode
trust_anchor_sentinel: bool = True
trust_anchor_signal_query: bool = True
time_skew_detection: bool = True
- keep_removed: int = 0
+ keep_removed: IntNonNegative = IntNonNegative(0)
refresh_time: Optional[TimeUnit] = None
hold_down_time: TimeUnit = TimeUnit("30d")
trust_anchors: Optional[List[str]] = None
from knot_resolver_manager.datamodel.types import (
CheckedPath,
+ Int0_512,
+ Int0_65535,
InterfaceOptionalPort,
IPAddress,
IPNetwork,
sticket_secret: Optional[str] = None
sticket_secret_file: Optional[CheckedPath] = None
auto_discovery: bool = False
- padding: int = 1
+ padding: Union[bool, Int0_512] = True
def _validate(self):
if self.sticket_secret and self.sticket_secret_file:
raise ValueError("'sticket_secret' and 'sticket_secret_file' are both defined, only one can be used")
- if not 0 <= self.padding <= 512:
- raise ValueError("'padding' must be number in range<0-512>")
class ListenSchema(SchemaNode):
do_ipv6: bool = True
out_interface_v4: Optional[IPv4Address] = None
out_interface_v6: Optional[IPv6Address] = None
- tcp_pipeline: int = 100
+ tcp_pipeline: Int0_65535 = Int0_65535(100)
edns_tcp_keepalive: bool = True
edns_buffer_size: EdnsBufferSizeSchema = EdnsBufferSizeSchema()
address_renumbering: Optional[List[AddressRenumberingSchema]] = None
ListenSchema({"interface": "127.0.0.1"}),
ListenSchema({"interface": "::1", "freebind": True}),
]
-
- def _validate(self):
- if self.tcp_pipeline < 0:
- raise ValueError("'tcp-pipeline' must be nonnegative number")
from typing_extensions import Literal
+from knot_resolver_manager.datamodel.types import IntNonNegative, TimeUnit
from knot_resolver_manager.utils import SchemaNode
-from .types import TimeUnit
-
GlueCheckingEnum = Literal["normal", "strict", "permissive"]
"""
window: TimeUnit = TimeUnit("15m")
- period: int = 24
+ period: IntNonNegative = IntNonNegative(24)
class OptionsSchema(SchemaNode):
DNSRecordTypeEnum,
DomainName,
InterfacePort,
+ IntPositive,
IPAddressPort,
UncheckedPath,
)
hostname: Optional[str] = None
groupid: Optional[str] = None
nsid: Optional[str] = None
- workers: Union[Literal["auto"], int] = 1
+ workers: Union[Literal["auto"], IntPositive] = IntPositive(1)
use_cache_gc: bool = True
backend: BackendEnum = "auto"
watchdog: Union[bool, WatchDogSchema] = True
hostname: str
groupid: Optional[str]
nsid: Optional[str]
- workers: int
+ workers: IntPositive
use_cache_gc: bool
backend: BackendEnum = "auto"
watchdog: Union[bool, WatchDogSchema]
def _workers(self, obj: Raw) -> Any:
if obj.workers == "auto":
- return _cpu_count()
+ return IntPositive(_cpu_count())
return obj.workers
def _validate(self) -> None:
- if self.workers < 0:
- raise ValueError("Number of workers must be non-negative")
if self.watchdog and self.backend not in ["auto", "systemd"]:
raise ValueError("'watchdog' can only be configured for 'systemd' backend")
async def apply_config(self, config: KresConfig) -> None:
async with self._manager_lock:
logger.debug("Applying new config to all workers")
- await self._ensure_number_of_children(config, config.server.workers)
+ await self._ensure_number_of_children(config, int(config.server.workers))
await self._rolling_restart(config)
if self._is_gc_running() != config.server.use_cache_gc:
from typing import Any, Dict, cast
from pytest import raises
-from yaml.nodes import Node
from knot_resolver_manager.datamodel import KresConfig
from knot_resolver_manager.datamodel.types import IPv6Network96, TimeUnit
assert config.dnssec.trust_anchor_sentinel == True
assert config.dnssec.trust_anchor_signal_query == True
assert config.dnssec.time_skew_detection == True
- assert config.dnssec.keep_removed == 0
+ assert int(config.dnssec.keep_removed) == 0
assert config.dnssec.refresh_time == None
assert config.dnssec.hold_down_time == TimeUnit("30d")
from knot_resolver_manager.datamodel.options_schema import OptionsSchema
-from knot_resolver_manager.datamodel.types import TimeUnit
+from knot_resolver_manager.datamodel.types import IntNonNegative, TimeUnit
def test_prediction_true():
y = OptionsSchema({"prediction": True})
assert y.prediction.window == TimeUnit("15m")
- assert y.prediction.period == 24
+ assert int(y.prediction.period) == 24