{
"ext_modules": [
Extension(
- name="knot_resolver_manager.controller.supervisord.plugin.notify",
- sources=["python/knot_resolver_manager/controller/supervisord/plugin/notifymodule.c"],
+ name="knot_resolver.controller.supervisord.plugin.notify",
+ sources=["python/knot_resolver/controller/supervisord/plugin/notifymodule.c"],
),
]
}
[tool.poetry]
-name = "knot-resolver-manager"
+name = "knot-resolver"
version = "6.0.8"
description = "Knot Resolver Manager - a Python program that automatically manages the other components of the resolver"
license = "GPL-3.0-or-later"
documentation = "https://www.knot-resolver.cz/documentation"
packages = [
- {include = "knot_resolver_manager", from = "python"}
+ {include = "knot_resolver", from = "python"}
]
# See currently open issue about building C extensions here:
json-schema-for-humans = "^0.47"
[tool.poetry.scripts]
-kresctl = 'knot_resolver_manager.client.main:main'
-knot-resolver = 'knot_resolver_manager.manager.main:main'
+kresctl = 'knot_resolver.client.main:main'
+knot-resolver = 'knot_resolver.manager.main:main'
[tool.poe.tasks]
# tasks runed through scripts located in 'scripts/poe-tasks/'
--- /dev/null
+from pathlib import Path
+
+from knot_resolver.datamodel.globals import Context, set_global_validation_context
+
+set_global_validation_context(Context(Path("."), False))
--- /dev/null
+from knot_resolver.client.main import main
+
+if __name__ == "__main__":
+ main()
import argparse
-from knot_resolver_manager.client.command import CommandArgs
+from knot_resolver.client.command import CommandArgs
KRES_CLIENT_NAME = "kresctl"
from typing import Dict, List, Optional, Tuple, Type, TypeVar
from urllib.parse import quote
-from knot_resolver_manager.manager.constants import API_SOCK_ENV_VAR, CONFIG_FILE_ENV_VAR, DEFAULT_MANAGER_CONFIG_FILE
-from knot_resolver_manager.datamodel.config_schema import DEFAULT_MANAGER_API_SOCK
-from knot_resolver_manager.datamodel.types import IPAddressPort
-from knot_resolver_manager.utils.modeling import parsing
-from knot_resolver_manager.utils.modeling.exceptions import DataValidationError
-from knot_resolver_manager.utils.requests import SocketDesc
+from knot_resolver.manager.constants import API_SOCK_ENV_VAR, CONFIG_FILE_ENV_VAR, DEFAULT_MANAGER_CONFIG_FILE
+from knot_resolver.datamodel.config_schema import DEFAULT_MANAGER_API_SOCK
+from knot_resolver.datamodel.types import IPAddressPort
+from knot_resolver.utils.modeling import parsing
+from knot_resolver.utils.modeling.exceptions import DataValidationError
+from knot_resolver.utils.requests import SocketDesc
T = TypeVar("T", bound=Type["Command"])
from enum import Enum
from typing import Any, Dict, List, Optional, Tuple, Type
-from knot_resolver_manager.client.command import Command, CommandArgs, CompWords, register_command
-from knot_resolver_manager.datamodel.cache_schema import CacheClearRPCSchema
-from knot_resolver_manager.utils.modeling.exceptions import AggregateDataValidationError, DataValidationError
-from knot_resolver_manager.utils.modeling.parsing import DataFormat, parse_json
-from knot_resolver_manager.utils.requests import request
+from knot_resolver.client.command import Command, CommandArgs, CompWords, register_command
+from knot_resolver.datamodel.cache_schema import CacheClearRPCSchema
+from knot_resolver.utils.modeling.exceptions import AggregateDataValidationError, DataValidationError
+from knot_resolver.utils.modeling.parsing import DataFormat, parse_json
+from knot_resolver.utils.requests import request
class CacheOperations(Enum):
from enum import Enum
from typing import List, Tuple, Type
-from knot_resolver_manager.client.command import Command, CommandArgs, CompWords, register_command
+from knot_resolver.client.command import Command, CommandArgs, CompWords, register_command
class Shells(Enum):
from typing_extensions import Literal
-from knot_resolver_manager.client.command import Command, CommandArgs, CompWords, register_command
-from knot_resolver_manager.utils.modeling.parsing import DataFormat, parse_json, try_to_parse
-from knot_resolver_manager.utils.requests import request
+from knot_resolver.client.command import Command, CommandArgs, CompWords, register_command
+from knot_resolver.utils.modeling.parsing import DataFormat, parse_json, try_to_parse
+from knot_resolver.utils.requests import request
class Operations(Enum):
from pathlib import Path
from typing import List, Optional, Tuple, Type
-from knot_resolver_manager.client.command import Command, CommandArgs, CompWords, register_command
-from knot_resolver_manager.datamodel import KresConfig
-from knot_resolver_manager.datamodel.globals import (
+from knot_resolver.client.command import Command, CommandArgs, CompWords, register_command
+from knot_resolver.datamodel import KresConfig
+from knot_resolver.datamodel.globals import (
Context,
reset_global_validation_context,
set_global_validation_context,
)
-from knot_resolver_manager.utils.modeling import try_to_parse
-from knot_resolver_manager.utils.modeling.exceptions import DataParsingError, DataValidationError
+from knot_resolver.utils.modeling import try_to_parse
+from knot_resolver.utils.modeling.exceptions import DataParsingError, DataValidationError
@register_command
import argparse
from typing import List, Tuple, Type
-from knot_resolver_manager.client.command import Command, CommandArgs, CompWords, register_command
+from knot_resolver.client.command import Command, CommandArgs, CompWords, register_command
@register_command
import sys
from typing import List, Optional, Tuple, Type
-from knot_resolver_manager.client.command import Command, CommandArgs, CompWords, register_command
-from knot_resolver_manager.utils.modeling.parsing import DataFormat, parse_json
-from knot_resolver_manager.utils.requests import request
+from knot_resolver.client.command import Command, CommandArgs, CompWords, register_command
+from knot_resolver.utils.modeling.parsing import DataFormat, parse_json
+from knot_resolver.utils.requests import request
@register_command
import sys
from typing import List, Tuple, Type
-from knot_resolver_manager.client.command import Command, CommandArgs, CompWords, register_command
-from knot_resolver_manager.utils.requests import request
+from knot_resolver.client.command import Command, CommandArgs, CompWords, register_command
+from knot_resolver.utils.requests import request
@register_command
import sys
from typing import List, Optional, Tuple, Type
-from knot_resolver_manager.client.command import Command, CommandArgs, CompWords, register_command
-from knot_resolver_manager.datamodel.config_schema import KresConfig
-from knot_resolver_manager.utils.requests import request
+from knot_resolver.client.command import Command, CommandArgs, CompWords, register_command
+from knot_resolver.datamodel.config_schema import KresConfig
+from knot_resolver.utils.requests import request
@register_command
import sys
from typing import List, Tuple, Type
-from knot_resolver_manager.client.command import Command, CommandArgs, CompWords, register_command
-from knot_resolver_manager.utils.requests import request
+from knot_resolver.client.command import Command, CommandArgs, CompWords, register_command
+from knot_resolver.utils.requests import request
@register_command
from pathlib import Path
from typing import List, Tuple, Type
-from knot_resolver_manager.client.command import Command, CommandArgs, CompWords, register_command
-from knot_resolver_manager.datamodel import KresConfig
-from knot_resolver_manager.datamodel.globals import (
+from knot_resolver.client.command import Command, CommandArgs, CompWords, register_command
+from knot_resolver.datamodel import KresConfig
+from knot_resolver.datamodel.globals import (
Context,
reset_global_validation_context,
set_global_validation_context,
)
-from knot_resolver_manager.utils.modeling import try_to_parse
-from knot_resolver_manager.utils.modeling.exceptions import DataParsingError, DataValidationError
+from knot_resolver.utils.modeling import try_to_parse
+from knot_resolver.utils.modeling.exceptions import DataParsingError, DataValidationError
@register_command
import logging
from typing import List, Optional
-from knot_resolver_manager.datamodel.config_schema import KresConfig
-from knot_resolver_manager.controller.interface import SubprocessController
+from knot_resolver.datamodel.config_schema import KresConfig
+from knot_resolver.controller.interface import SubprocessController
logger = logging.getLogger(__name__)
Attempt to load supervisord controllers.
"""
try:
- from knot_resolver_manager.controller.supervisord import SupervisordSubprocessController
+ from knot_resolver.controller.supervisord import SupervisordSubprocessController
_registered_controllers.append(SupervisordSubprocessController())
except ImportError:
from typing import Dict, Iterable, Optional, Type, TypeVar
from weakref import WeakValueDictionary
-from knot_resolver_manager.manager.constants import kresd_config_file, policy_loader_config_file
-from knot_resolver_manager.datamodel.config_schema import KresConfig
-from knot_resolver_manager.manager.exceptions import SubprocessControllerException
-from knot_resolver_manager.controller.registered_workers import register_worker, unregister_worker
-from knot_resolver_manager.utils.async_utils import writefile
+from knot_resolver.manager.constants import kresd_config_file, policy_loader_config_file
+from knot_resolver.datamodel.config_schema import KresConfig
+from knot_resolver.manager.exceptions import SubprocessControllerException
+from knot_resolver.controller.registered_workers import register_worker, unregister_worker
+from knot_resolver.utils.async_utils import writefile
logger = logging.getLogger(__name__)
import logging
from typing import TYPE_CHECKING, Dict, List, Tuple
-from knot_resolver_manager.manager.exceptions import SubprocessControllerException
+from knot_resolver.manager.exceptions import SubprocessControllerException
if TYPE_CHECKING:
- from knot_resolver_manager.controller.interface import KresID, Subprocess
+ from knot_resolver.controller.interface import KresID, Subprocess
logger = logging.getLogger(__name__)
import supervisor.xmlrpc # type: ignore[import]
-from knot_resolver_manager.compat.asyncio import async_in_a_thread
-from knot_resolver_manager.manager.constants import supervisord_config_file, supervisord_pid_file, supervisord_sock_file
-from knot_resolver_manager.datamodel.config_schema import KresConfig
-from knot_resolver_manager.manager.exceptions import CancelStartupExecInsteadException, SubprocessControllerException
-from knot_resolver_manager.controller.interface import (
+from knot_resolver.compat.asyncio import async_in_a_thread
+from knot_resolver.manager.constants import supervisord_config_file, supervisord_pid_file, supervisord_sock_file
+from knot_resolver.datamodel.config_schema import KresConfig
+from knot_resolver.manager.exceptions import CancelStartupExecInsteadException, SubprocessControllerException
+from knot_resolver.controller.interface import (
KresID,
Subprocess,
SubprocessController,
SubprocessStatus,
SubprocessType,
)
-from knot_resolver_manager.controller.supervisord.config_file import SupervisordKresID, write_config_file
-from knot_resolver_manager.utils import which
-from knot_resolver_manager.utils.async_utils import call, readfile
+from knot_resolver.controller.supervisord.config_file import SupervisordKresID, write_config_file
+from knot_resolver.utils import which
+from knot_resolver.utils.async_utils import call, readfile
logger = logging.getLogger(__name__)
from jinja2 import Template
from typing_extensions import Literal
-from knot_resolver_manager.manager.constants import (
+from knot_resolver.manager.constants import (
kres_gc_executable,
kresd_cache_dir,
kresd_config_file_supervisord_pattern,
supervisord_subprocess_log_dir,
user_constants,
)
-from knot_resolver_manager.datamodel.config_schema import KresConfig
-from knot_resolver_manager.datamodel.logging_schema import LogTargetEnum
-from knot_resolver_manager.controller.interface import KresID, SubprocessType
-from knot_resolver_manager.utils.async_utils import read_resource, writefile
+from knot_resolver.datamodel.config_schema import KresConfig
+from knot_resolver.datamodel.logging_schema import LogTargetEnum
+from knot_resolver.controller.interface import KresID, SubprocessType
+from knot_resolver.utils.async_utils import read_resource, writefile
logger = logging.getLogger(__name__)
if os.environ.get("KRES_DEBUG_MANAGER"):
logger.warning("Injecting debugger into the supervisord config")
# the args array looks like this:
- # [PYTHON_PATH, "-m", "knot_resolver_manager", ...]
+ # [PYTHON_PATH, "-m", "knot_resolver", ...]
args = args[:1] + ["-m", "debugpy", "--listen", "0.0.0.0:5678", "--wait-for-client"] + args[2:]
cmd = '"' + '" "'.join(args) + '"'
from supervisor.states import SupervisorStates
from supervisor.supervisord import Supervisor
-from knot_resolver_manager.utils.systemd_notify import systemd_notify
+from knot_resolver.utils.systemd_notify import systemd_notify
superd: Optional[Supervisor] = None
from supervisor.states import ProcessStates
from supervisor.supervisord import Supervisor
-from knot_resolver_manager.controller.supervisord.plugin import notify
+from knot_resolver.controller.supervisord.plugin import notify
starting_processes: List[Subprocess] = []
{# Extensions to changing the supervisord behavior #}
[rpcinterface:patch_logger]
-supervisor.rpcinterface_factory = knot_resolver_manager.controller.supervisord.plugin.patch_logger:inject
+supervisor.rpcinterface_factory = knot_resolver.controller.supervisord.plugin.patch_logger:inject
target = {{ config.target }}
[rpcinterface:manager_integration]
-supervisor.rpcinterface_factory = knot_resolver_manager.controller.supervisord.plugin.manager_integration:inject
+supervisor.rpcinterface_factory = knot_resolver.controller.supervisord.plugin.manager_integration:inject
[rpcinterface:sd_notify]
-supervisor.rpcinterface_factory = knot_resolver_manager.controller.supervisord.plugin.sd_notify:inject
+supervisor.rpcinterface_factory = knot_resolver.controller.supervisord.plugin.sd_notify:inject
{# Extensions for actual API control #}
[rpcinterface:supervisor]
supervisor.rpcinterface_factory = supervisor.rpcinterface:make_main_rpcinterface
[rpcinterface:fast]
-supervisor.rpcinterface_factory = knot_resolver_manager.controller.supervisord.plugin.fast_rpcinterface:make_main_rpcinterface
+supervisor.rpcinterface_factory = knot_resolver.controller.supervisord.plugin.fast_rpcinterface:make_main_rpcinterface
[program:manager]
redirect_stderr=false
from typing_extensions import Literal
-from knot_resolver_manager.datamodel.templates import template_from_str
-from knot_resolver_manager.datamodel.types import (
+from knot_resolver.datamodel.templates import template_from_str
+from knot_resolver.datamodel.types import (
DNSRecordTypeEnum,
DomainName,
EscapedStr,
TimeUnit,
WritableDir,
)
-from knot_resolver_manager.utils.modeling import ConfigSchema
-from knot_resolver_manager.utils.modeling.base_schema import lazy_default
+from knot_resolver.utils.modeling import ConfigSchema
+from knot_resolver.utils.modeling.base_schema import lazy_default
_CACHE_CLEAR_TEMPLATE = template_from_str(
"{% from 'macros/cache_macros.lua.j2' import cache_clear %} {{ cache_clear(params) }}"
from typing_extensions import Literal
-from knot_resolver_manager.manager.constants import MAX_WORKERS
-from knot_resolver_manager.datamodel.cache_schema import CacheSchema
-from knot_resolver_manager.datamodel.dns64_schema import Dns64Schema
-from knot_resolver_manager.datamodel.dnssec_schema import DnssecSchema
-from knot_resolver_manager.datamodel.forward_schema import ForwardSchema
-from knot_resolver_manager.datamodel.local_data_schema import LocalDataSchema, RPZSchema, RuleSchema
-from knot_resolver_manager.datamodel.logging_schema import LoggingSchema
-from knot_resolver_manager.datamodel.lua_schema import LuaSchema
-from knot_resolver_manager.datamodel.management_schema import ManagementSchema
-from knot_resolver_manager.datamodel.monitoring_schema import MonitoringSchema
-from knot_resolver_manager.datamodel.network_schema import NetworkSchema
-from knot_resolver_manager.datamodel.options_schema import OptionsSchema
-from knot_resolver_manager.datamodel.templates import POLICY_CONFIG_TEMPLATE, WORKER_CONFIG_TEMPLATE
-from knot_resolver_manager.datamodel.types import EscapedStr, IntPositive, WritableDir
-from knot_resolver_manager.datamodel.view_schema import ViewSchema
-from knot_resolver_manager.datamodel.webmgmt_schema import WebmgmtSchema
-from knot_resolver_manager.utils.modeling import ConfigSchema
-from knot_resolver_manager.utils.modeling.base_schema import lazy_default
-from knot_resolver_manager.utils.modeling.exceptions import AggregateDataValidationError, DataValidationError
+from knot_resolver.manager.constants import MAX_WORKERS
+from knot_resolver.datamodel.cache_schema import CacheSchema
+from knot_resolver.datamodel.dns64_schema import Dns64Schema
+from knot_resolver.datamodel.dnssec_schema import DnssecSchema
+from knot_resolver.datamodel.forward_schema import ForwardSchema
+from knot_resolver.datamodel.local_data_schema import LocalDataSchema, RPZSchema, RuleSchema
+from knot_resolver.datamodel.logging_schema import LoggingSchema
+from knot_resolver.datamodel.lua_schema import LuaSchema
+from knot_resolver.datamodel.management_schema import ManagementSchema
+from knot_resolver.datamodel.monitoring_schema import MonitoringSchema
+from knot_resolver.datamodel.network_schema import NetworkSchema
+from knot_resolver.datamodel.options_schema import OptionsSchema
+from knot_resolver.datamodel.templates import POLICY_CONFIG_TEMPLATE, WORKER_CONFIG_TEMPLATE
+from knot_resolver.datamodel.types import EscapedStr, IntPositive, WritableDir
+from knot_resolver.datamodel.view_schema import ViewSchema
+from knot_resolver.datamodel.webmgmt_schema import WebmgmtSchema
+from knot_resolver.utils.modeling import ConfigSchema
+from knot_resolver.utils.modeling.base_schema import lazy_default
+from knot_resolver.utils.modeling.exceptions import AggregateDataValidationError, DataValidationError
_DEFAULT_RUNDIR = "/var/run/knot-resolver"
from typing import List, Optional
-from knot_resolver_manager.datamodel.types import IPv6Network, IPv6Network96, TimeUnit
-from knot_resolver_manager.utils.modeling import ConfigSchema
+from knot_resolver.datamodel.types import IPv6Network, IPv6Network96, TimeUnit
+from knot_resolver.utils.modeling import ConfigSchema
class Dns64Schema(ConfigSchema):
from typing import List, Optional
-from knot_resolver_manager.datamodel.types import DomainName, EscapedStr, IntNonNegative, ReadableFile, TimeUnit
-from knot_resolver_manager.utils.modeling import ConfigSchema
+from knot_resolver.datamodel.types import DomainName, EscapedStr, IntNonNegative, ReadableFile, TimeUnit
+from knot_resolver.utils.modeling import ConfigSchema
class TrustAnchorFileSchema(ConfigSchema):
from typing_extensions import Literal
-from knot_resolver_manager.datamodel.types import (
+from knot_resolver.datamodel.types import (
DomainName,
IPAddressOptionalPort,
ListOrItem,
PinSha256,
ReadableFile,
)
-from knot_resolver_manager.utils.modeling import ConfigSchema
+from knot_resolver.utils.modeling import ConfigSchema
class ForwardServerSchema(ConfigSchema):
from typing_extensions import Literal
-from knot_resolver_manager.datamodel.types import (
+from knot_resolver.datamodel.types import (
DomainName,
EscapedStr,
IDPattern,
ReadableFile,
TimeUnit,
)
-from knot_resolver_manager.utils.modeling import ConfigSchema
+from knot_resolver.utils.modeling import ConfigSchema
class RuleSchema(ConfigSchema):
from typing_extensions import Literal
-from knot_resolver_manager.datamodel.types import TimeUnit, WritableFilePath
-from knot_resolver_manager.utils.modeling import ConfigSchema
-from knot_resolver_manager.utils.modeling.base_schema import is_obj_type_valid
+from knot_resolver.datamodel.types import TimeUnit, WritableFilePath
+from knot_resolver.utils.modeling import ConfigSchema
+from knot_resolver.utils.modeling.base_schema import is_obj_type_valid
try:
# On Debian 10, the typing_extensions library does not contain TypeAlias.
from typing import Optional
-from knot_resolver_manager.datamodel.types import ReadableFile
-from knot_resolver_manager.utils.modeling import ConfigSchema
+from knot_resolver.datamodel.types import ReadableFile
+from knot_resolver.utils.modeling import ConfigSchema
class LuaSchema(ConfigSchema):
from typing import Optional
-from knot_resolver_manager.datamodel.types import WritableFilePath, IPAddressPort
-from knot_resolver_manager.utils.modeling import ConfigSchema
+from knot_resolver.datamodel.types import WritableFilePath, IPAddressPort
+from knot_resolver.utils.modeling import ConfigSchema
class ManagementSchema(ConfigSchema):
from typing_extensions import Literal
-from knot_resolver_manager.datamodel.types import DomainName, EscapedStr, IPAddress, PortNumber, TimeUnit
-from knot_resolver_manager.utils.modeling import ConfigSchema
+from knot_resolver.datamodel.types import DomainName, EscapedStr, IPAddress, PortNumber, TimeUnit
+from knot_resolver.utils.modeling import ConfigSchema
class GraphiteSchema(ConfigSchema):
from typing_extensions import Literal
-from knot_resolver_manager.datamodel.types import (
+from knot_resolver.datamodel.types import (
EscapedStr32B,
WritableFilePath,
Int0_512,
ReadableFile,
SizeUnit,
)
-from knot_resolver_manager.utils.modeling import ConfigSchema
+from knot_resolver.utils.modeling import ConfigSchema
KindEnum = Literal["dns", "xdp", "dot", "doh-legacy", "doh2"]
from typing_extensions import Literal
-from knot_resolver_manager.utils.modeling import ConfigSchema
+from knot_resolver.utils.modeling import ConfigSchema
GlueCheckingEnum = Literal["normal", "strict", "permissive"]
from typing import List, Optional, Union
-from knot_resolver_manager.datamodel.forward_schema import ForwardServerSchema
-from knot_resolver_manager.datamodel.network_schema import AddressRenumberingSchema
-from knot_resolver_manager.datamodel.types import (
+from knot_resolver.datamodel.forward_schema import ForwardServerSchema
+from knot_resolver.datamodel.network_schema import AddressRenumberingSchema
+from knot_resolver.datamodel.types import (
DNSRecordTypeEnum,
IPAddressOptionalPort,
PolicyActionEnum,
PolicyFlagEnum,
TimeUnit,
)
-from knot_resolver_manager.utils.modeling import ConfigSchema
+from knot_resolver.utils.modeling import ConfigSchema
class FilterSchema(ConfigSchema):
from typing import List, Optional
-from knot_resolver_manager.datamodel.types import PolicyActionEnum, PolicyFlagEnum, ReadableFile
-from knot_resolver_manager.utils.modeling import ConfigSchema
+from knot_resolver.datamodel.types import PolicyActionEnum, PolicyFlagEnum, ReadableFile
+from knot_resolver.utils.modeling import ConfigSchema
class RPZSchema(ConfigSchema):
from typing_extensions import Literal
-from knot_resolver_manager.datamodel.policy_schema import ActionSchema
-from knot_resolver_manager.utils.modeling import ConfigSchema
+from knot_resolver.datamodel.policy_schema import ActionSchema
+from knot_resolver.utils.modeling import ConfigSchema
class SliceSchema(ConfigSchema):
from typing import Dict, List, Optional
-from knot_resolver_manager.datamodel.types import DomainName, IPAddress, ReadableFile, TimeUnit
-from knot_resolver_manager.utils.modeling import ConfigSchema
+from knot_resolver.datamodel.types import DomainName, IPAddress, ReadableFile, TimeUnit
+from knot_resolver.utils.modeling import ConfigSchema
class StaticHintsSchema(ConfigSchema):
from typing import List, Optional, Union
-from knot_resolver_manager.datamodel.types import DomainName, IPAddressOptionalPort, PolicyFlagEnum
-from knot_resolver_manager.utils.modeling import ConfigSchema
+from knot_resolver.datamodel.types import DomainName, IPAddressOptionalPort, PolicyFlagEnum
+from knot_resolver.utils.modeling import ConfigSchema
class StubServerSchema(ConfigSchema):
def _get_templates_dir() -> str:
- module = sys.modules["knot_resolver_manager.datamodel"].__file__
+ module = sys.modules["knot_resolver.datamodel"].__file__
if module:
templates_dir = os.path.join(os.path.dirname(module), "templates")
if os.path.isdir(templates_dir):
return templates_dir
raise NotADirectoryError(f"the templates dir '{templates_dir}' is not a directory or does not exist")
- raise OSError("package 'knot_resolver_manager.datamodel' cannot be located or loaded")
+ raise OSError("package 'knot_resolver.datamodel' cannot be located or loaded")
_TEMPLATES_DIR = _get_templates_dir()
import re
from typing import Any, Dict, Pattern, Type
-from knot_resolver_manager.utils.modeling import BaseValueType
+from knot_resolver.utils.modeling import BaseValueType
class IntBase(BaseValueType):
from pwd import getpwnam
from typing import Any, Dict, Tuple, Type, TypeVar
-from knot_resolver_manager.manager.constants import kresd_group, kresd_user
-from knot_resolver_manager.datamodel.globals import get_resolve_root, get_strict_validation
-from knot_resolver_manager.utils.modeling.base_value_type import BaseValueType
+from knot_resolver.manager.constants import kresd_group, kresd_user
+from knot_resolver.datamodel.globals import get_resolve_root, get_strict_validation
+from knot_resolver.utils.modeling.base_value_type import BaseValueType
class UncheckedPath(BaseValueType):
from typing import Any, List, TypeVar, Union
-from knot_resolver_manager.utils.modeling import BaseGenericTypeWrapper
+from knot_resolver.utils.modeling import BaseGenericTypeWrapper
T = TypeVar("T")
import re
from typing import Any, Dict, Optional, Type, Union
-from knot_resolver_manager.datamodel.types.base_types import (
+from knot_resolver.datamodel.types.base_types import (
IntRangeBase,
PatternBase,
StrBase,
StringLengthBase,
UnitBase,
)
-from knot_resolver_manager.utils.modeling import BaseValueType
+from knot_resolver.utils.modeling import BaseValueType
class IntNonNegative(IntRangeBase):
from typing_extensions import Literal
-from knot_resolver_manager.datamodel.types import IDPattern, IPNetwork
-from knot_resolver_manager.utils.modeling import ConfigSchema
+from knot_resolver.datamodel.types import IDPattern, IPNetwork
+from knot_resolver.utils.modeling import ConfigSchema
class ViewOptionsSchema(ConfigSchema):
from typing import Optional
-from knot_resolver_manager.datamodel.types import WritableFilePath, InterfacePort, ReadableFile
-from knot_resolver_manager.utils.modeling import ConfigSchema
+from knot_resolver.datamodel.types import WritableFilePath, InterfacePort, ReadableFile
+from knot_resolver.utils.modeling import ConfigSchema
class WebmgmtSchema(ConfigSchema):
--- /dev/null
+from knot_resolver.manager.main import main
+
+
+if __name__ == "__main__":
+ main()
from asyncio import Lock
from typing import Any, Awaitable, Callable, List, Tuple
-from knot_resolver_manager.datamodel import KresConfig
-from knot_resolver_manager.manager.exceptions import KresManagerException
-from knot_resolver_manager.utils.functional import Result
-from knot_resolver_manager.utils.modeling.exceptions import DataParsingError
-from knot_resolver_manager.utils.modeling.types import NoneType
+from knot_resolver.datamodel import KresConfig
+from knot_resolver.manager.exceptions import KresManagerException
+from knot_resolver.utils.functional import Result
+from knot_resolver.utils.modeling.exceptions import DataParsingError
+from knot_resolver.utils.modeling.types import NoneType
VerifyCallback = Callable[[KresConfig, KresConfig], Awaitable[Result[None, str]]]
UpdateCallback = Callable[[KresConfig], Awaitable[None]]
knot_resolver = None
if TYPE_CHECKING:
- from knot_resolver_manager.manager.config_store import ConfigStore
- from knot_resolver_manager.datamodel.config_schema import KresConfig
- from knot_resolver_manager.controller.interface import KresID
+ from knot_resolver.manager.config_store import ConfigStore
+ from knot_resolver.datamodel.config_schema import KresConfig
+ from knot_resolver.controller.interface import KresID
STARTUP_LOG_LEVEL = logging.DEBUG
DEFAULT_MANAGER_CONFIG_FILE = Path("/etc/knot-resolver/config.yaml")
from subprocess import SubprocessError
from typing import Any, Callable, List, Optional
-from knot_resolver_manager.compat.asyncio import create_task
-from knot_resolver_manager.manager.config_store import (
+from knot_resolver.compat.asyncio import create_task
+from knot_resolver.manager.config_store import (
ConfigStore,
only_on_real_changes_update,
only_on_real_changes_verifier,
)
-from knot_resolver_manager.manager.constants import (
+from knot_resolver.manager.constants import (
FIX_COUNTER_DECREASE_INTERVAL_SEC,
MANAGER_FIX_ATTEMPT_MAX_COUNTER,
WATCHDOG_INTERVAL,
)
-from knot_resolver_manager.manager.exceptions import SubprocessControllerException
-from knot_resolver_manager.controller.interface import (
+from knot_resolver.manager.exceptions import SubprocessControllerException
+from knot_resolver.controller.interface import (
Subprocess,
SubprocessController,
SubprocessStatus,
SubprocessType,
)
-from knot_resolver_manager.controller.registered_workers import (
+from knot_resolver.controller.registered_workers import (
command_registered_workers,
get_registered_workers_kresids,
)
-from knot_resolver_manager.utils.functional import Result
-from knot_resolver_manager.utils.modeling.types import NoneType
+from knot_resolver.utils.functional import Result
+from knot_resolver.utils.modeling.types import NoneType
-from knot_resolver_manager import KresConfig
+from knot_resolver import KresConfig
logger = logging.getLogger(__name__)
import sys
from typing import Optional
-from knot_resolver_manager.manager.config_store import ConfigStore, only_on_real_changes_update
-from knot_resolver_manager.manager.constants import STARTUP_LOG_LEVEL
-from knot_resolver_manager.datamodel.config_schema import KresConfig
-from knot_resolver_manager.datamodel.logging_schema import LogTargetEnum
+from knot_resolver.manager.config_store import ConfigStore, only_on_real_changes_update
+from knot_resolver.manager.constants import STARTUP_LOG_LEVEL
+from knot_resolver.datamodel.config_schema import KresConfig
+from knot_resolver.datamodel.logging_schema import LogTargetEnum
logger = logging.getLogger(__name__)
from pathlib import Path
from typing import NoReturn
-from knot_resolver_manager import compat
-from knot_resolver_manager.manager.constants import CONFIG_FILE_ENV_VAR, DEFAULT_MANAGER_CONFIG_FILE
-from knot_resolver_manager.manager.log import logger_startup
-from knot_resolver_manager.manager.server import start_server
+from knot_resolver import compat
+from knot_resolver.manager.constants import CONFIG_FILE_ENV_VAR, DEFAULT_MANAGER_CONFIG_FILE
+from knot_resolver.manager.log import logger_startup
+from knot_resolver.manager.server import start_server
def parse_args() -> argparse.Namespace:
from aiohttp.web_runner import AppRunner, TCPSite, UnixSite
from typing_extensions import Literal
-import knot_resolver_manager.utils.custom_atexit as atexit
-from knot_resolver_manager.manager import log, statistics
-from knot_resolver_manager.compat import asyncio as asyncio_compat
-from knot_resolver_manager.manager.config_store import ConfigStore
-from knot_resolver_manager.manager.constants import DEFAULT_MANAGER_CONFIG_FILE, PID_FILE_NAME, init_user_constants
-from knot_resolver_manager.datamodel.cache_schema import CacheClearRPCSchema
-from knot_resolver_manager.datamodel.config_schema import KresConfig, get_rundir_without_validation
-from knot_resolver_manager.datamodel.globals import Context, set_global_validation_context
-from knot_resolver_manager.datamodel.management_schema import ManagementSchema
-from knot_resolver_manager.manager.exceptions import CancelStartupExecInsteadException, KresManagerException
-from knot_resolver_manager.controller import get_best_controller_implementation
-from knot_resolver_manager.controller.registered_workers import command_single_registered_worker
-from knot_resolver_manager.utils import ignore_exceptions_optional
-from knot_resolver_manager.utils.async_utils import readfile
-from knot_resolver_manager.utils.etag import structural_etag
-from knot_resolver_manager.utils.functional import Result
-from knot_resolver_manager.utils.modeling.exceptions import (
+import knot_resolver.utils.custom_atexit as atexit
+from knot_resolver.manager import log, statistics
+from knot_resolver.compat import asyncio as asyncio_compat
+from knot_resolver.manager.config_store import ConfigStore
+from knot_resolver.manager.constants import DEFAULT_MANAGER_CONFIG_FILE, PID_FILE_NAME, init_user_constants
+from knot_resolver.datamodel.cache_schema import CacheClearRPCSchema
+from knot_resolver.datamodel.config_schema import KresConfig, get_rundir_without_validation
+from knot_resolver.datamodel.globals import Context, set_global_validation_context
+from knot_resolver.datamodel.management_schema import ManagementSchema
+from knot_resolver.manager.exceptions import CancelStartupExecInsteadException, KresManagerException
+from knot_resolver.controller import get_best_controller_implementation
+from knot_resolver.controller.registered_workers import command_single_registered_worker
+from knot_resolver.utils import ignore_exceptions_optional
+from knot_resolver.utils.async_utils import readfile
+from knot_resolver.utils.etag import structural_etag
+from knot_resolver.utils.functional import Result
+from knot_resolver.utils.modeling.exceptions import (
AggregateDataValidationError,
DataParsingError,
DataValidationError,
)
-from knot_resolver_manager.utils.modeling.parsing import DataFormat, try_to_parse
-from knot_resolver_manager.utils.modeling.query import query
-from knot_resolver_manager.utils.modeling.types import NoneType
-from knot_resolver_manager.utils.systemd_notify import systemd_notify
+from knot_resolver.utils.modeling.parsing import DataFormat, try_to_parse
+from knot_resolver.utils.modeling.query import query
+from knot_resolver.utils.modeling.types import NoneType
+from knot_resolver.utils.systemd_notify import systemd_notify
from .kres_manager import KresManager
import logging
from typing import TYPE_CHECKING, Any, Dict, Generator, List, Optional, Tuple
-from knot_resolver_manager import compat
-from knot_resolver_manager.manager.config_store import ConfigStore, only_on_real_changes_update
-from knot_resolver_manager.datamodel.config_schema import KresConfig
-from knot_resolver_manager.controller.registered_workers import (
+from knot_resolver import compat
+from knot_resolver.manager.config_store import ConfigStore, only_on_real_changes_update
+from knot_resolver.datamodel.config_schema import KresConfig
+from knot_resolver.controller.registered_workers import (
command_registered_workers,
get_registered_workers_kresids,
)
-from knot_resolver_manager.utils.functional import Result
-from knot_resolver_manager.utils.modeling.parsing import DataFormat
+from knot_resolver.utils.functional import Result
+from knot_resolver.utils.modeling.parsing import DataFormat
if TYPE_CHECKING:
- from knot_resolver_manager.controller.interface import KresID
+ from knot_resolver.controller.interface import KresID
logger = logging.getLogger(__name__)
from threading import Thread
from typing import Any, Dict, Generic, List, Optional, TypeVar, Union
-from knot_resolver_manager.compat.asyncio import to_thread
+from knot_resolver.compat.asyncio import to_thread
def unblock_signals():
import yaml
-from knot_resolver_manager.utils.functional import all_matches
+from knot_resolver.utils.functional import all_matches
from .base_generic_type_wrapper import BaseGenericTypeWrapper
from .base_value_type import BaseValueType
from typing import Iterable, List
-from knot_resolver_manager.manager.exceptions import KresManagerException
+from knot_resolver.manager.exceptions import KresManagerException
class DataModelingBaseException(KresManagerException):
from typing_extensions import Literal
-from knot_resolver_manager.utils.modeling.base_schema import BaseSchema, map_object
-from knot_resolver_manager.utils.modeling.json_pointer import json_ptr_resolve
+from knot_resolver.utils.modeling.base_schema import BaseSchema, map_object
+from knot_resolver.utils.modeling.json_pointer import json_ptr_resolve
class PatchError(Exception):
+++ /dev/null
-from pathlib import Path
-
-from knot_resolver_manager.datamodel.globals import Context, set_global_validation_context
-
-set_global_validation_context(Context(Path("."), False))
+++ /dev/null
-from knot_resolver_manager.client.main import main
-
-if __name__ == "__main__":
- main()
+++ /dev/null
-from knot_resolver_manager.manager.main import main
-
-
-if __name__ == "__main__":
- main()
cd "$(dirname "${0}")/../.."
# generate JSON schema for the manager's declarative config
-pushd python
## the following python command should hopefully run without any dependencies except for standard python
-mkdir -p ../doc/_static/
-python3 -m knot_resolver_manager.client schema > ../doc/_static/config.schema.json
-generate-schema-doc --config expand_buttons=true ../doc/_static/config.schema.json ../doc/_static/schema_doc.html
-popd
+mkdir -p doc/_static/
+python3 -m python.knot_resolver.client schema > doc/_static/config.schema.json
+generate-schema-doc --config expand_buttons=true doc/_static/config.schema.json doc/_static/schema_doc.html
# generating the user documentation
SPHINX=$(type -P sphinx-build-3 sphinx-build | head -n1)
# check formatting using black
echo -e "${yellow}Checking formatting using black...${reset}"
-black python/knot_resolver_manager tests/manager scripts/poe-tasks/utils/create_setup.py --check --diff
+black python/knot_resolver tests/manager scripts/poe-tasks/utils/create_setup.py --check --diff
check_rv $?
echo
# check code with pylint
echo -e "${yellow}Linting using pylint...${reset}"
-pylint python/knot_resolver_manager
+pylint python/knot_resolver
check_rv $?
echo
# check code with flake8
echo -e "${yellow}Linting using flake8...${reset}"
-flake8 --max-line-length=200 --ignore=E266,W503 --extend-ignore=E203 python/knot_resolver_manager
+flake8 --max-line-length=200 --ignore=E266,W503 --extend-ignore=E203 python/knot_resolver
check_rv $?
echo
# check types with mypy
echo -e "${yellow}Type checking using mypy...${reset}"
-mypy python/knot_resolver_manager
+mypy python/knot_resolver
check_rv $?
echo
source $src_dir/utils/_env.sh
# run knot-resolver client
-python3 -m knot_resolver_manager.client $@
+python3 -m knot_resolver.client $@
echo -----------------------------------------------------------------------
# run the knot-resolver manager
-python3 -m knot_resolver_manager.manager $@
+python3 -m knot_resolver.manager $@
source $src_dir/utils/_env.sh
# run pytest
-env PYTHONPATH=. pytest --junitxml=unit.junit.xml --cov=python/knot_resolver_manager --show-capture=all tests/manager
+env PYTHONPATH=. pytest --junitxml=unit.junit.xml --cov=python/knot_resolver --show-capture=all tests/manager
{'': 'python'}
packages = \
-['knot_resolver_manager',
- 'knot_resolver_manager.client',
- 'knot_resolver_manager.client.commands',
- 'knot_resolver_manager.compat',
- 'knot_resolver_manager.controller',
- 'knot_resolver_manager.controller.supervisord',
- 'knot_resolver_manager.controller.supervisord.plugin',
- 'knot_resolver_manager.datamodel',
- 'knot_resolver_manager.datamodel.templates',
- 'knot_resolver_manager.datamodel.types',
- 'knot_resolver_manager.manager',
- 'knot_resolver_manager.utils',
- 'knot_resolver_manager.utils.modeling']
+['knot_resolver',
+ 'knot_resolver.client',
+ 'knot_resolver.client.commands',
+ 'knot_resolver.compat',
+ 'knot_resolver.controller',
+ 'knot_resolver.controller.supervisord',
+ 'knot_resolver.controller.supervisord.plugin',
+ 'knot_resolver.datamodel',
+ 'knot_resolver.datamodel.templates',
+ 'knot_resolver.datamodel.types',
+ 'knot_resolver.manager',
+ 'knot_resolver.utils',
+ 'knot_resolver.utils.modeling']
package_data = \
-{'': ['*'], 'knot_resolver_manager.datamodel.templates': ['macros/*']}
+{'': ['*'], 'knot_resolver.datamodel.templates': ['macros/*']}
install_requires = \
['aiohttp', 'jinja2', 'pyyaml', 'supervisor', 'typing-extensions']
{'prometheus': ['prometheus-client']}
entry_points = \
-{'console_scripts': ['knot-resolver = knot_resolver_manager.manager.main:main',
- 'kresctl = knot_resolver_manager.client.main:main']}
+{'console_scripts': ['knot-resolver = knot_resolver.manager.main:main',
+ 'kresctl = knot_resolver.client.main:main']}
setup_kwargs = {
- 'name': 'knot-resolver-manager',
+ 'name': 'knot-resolver',
'version': '6.0.8',
'description': 'Knot Resolver Manager - a Python program that automatically manages the other components of the resolver',
'long_description': "# Knot Resolver\n\n[](https://gitlab.nic.cz/knot/knot-resolver/commits/nightly)\n[](https://www.knot-resolver.cz/documentation/latest)\n[](https://repology.org/project/knot-resolver/versions)\n\nKnot Resolver is a full caching DNS resolver implementation. The core architecture is tiny and efficient, written in C and [LuaJIT][luajit], providing a foundation and a state-machine-like API for extension modules. There are three built-in modules - *iterator*, *validator* and *cache* - which provide the main functionality of the resolver. A few other modules are automatically loaded by default to extend the resolver's functionality.\n\nSince Knot Resolver version 6, it also includes a so-called [manager][manager]. It is a new component written in [Python][python] that hides the complexity of older versions and makes it more user friendly. For example, new features include declarative configuration in YAML format and HTTP API for dynamic changes in the resolver and more.\n\nKnot Resolver uses a [different scaling strategy][scaling] than the rest of the DNS resolvers - no threading, shared-nothing architecture (except MVCC cache which can be shared), which allows you to pin workers to available CPU cores and grow by self-replication. You can start and stop additional workers based on the contention without downtime, which is automated by the [manager][manager] by default.\n\nThe LuaJIT modules, support for DNS privacy and DNSSEC, and persistent cache with low memory footprint make it a great personal DNS resolver or a research tool to tap into DNS data. Strong filtering rules, and auto-configuration with etcd make it a great large-scale resolver solution. It also has strong support for DNS over TCP, in particular TCP Fast-Open, query pipelining and deduplication, and response reordering.\n\nFor more on using the resolver, see the [User Documentation][doc]. See the [Developer Documentation][doc-dev] for detailed architecture and development.\n\n## Packages\n\nThe latest stable packages for various distributions are available in our\n[upstream repository](https://pkg.labs.nic.cz/doc/?project=knot-resolver).\nFollow the installation instructions to add this repository to your system.\n\nKnot Resolver is also available from the following distributions' repositories:\n\n* [Fedora and Fedora EPEL](https://src.fedoraproject.org/rpms/knot-resolver)\n* [Debian stable](https://packages.debian.org/stable/knot-resolver),\n [Debian testing](https://packages.debian.org/testing/knot-resolver),\n [Debian unstable](https://packages.debian.org/sid/knot-resolver)\n* [Ubuntu](https://packages.ubuntu.com/jammy/knot-resolver)\n* [Arch Linux](https://archlinux.org/packages/extra/x86_64/knot-resolver/)\n* [Alpine Linux](https://pkgs.alpinelinux.org/packages?name=knot-resolver)\n\n### Packaging\n\nThe project uses [`apkg`](https://gitlab.nic.cz/packaging/apkg) for packaging.\nSee [`distro/README.md`](distro/README.md) for packaging specific instructions.\n\n## Building from sources\n\nKnot Resolver mainly depends on [KnotDNS][knot-dns] libraries, [LuaJIT][luajit], [libuv][libuv] and [Python][python].\n\nSee the [Building project][build] documentation page for more information.\n\n## Running\n\nBy default, Knot Resolver comes with [systemd][systemd] integration and you just need to start its service. It requires no configuration changes to run a server on localhost.\n\n```\n# systemctl start knot-resolver\n```\n\nSee the documentation at [knot-resolver.cz/documentation/latest][doc] for more information.\n\n## Running the Docker image\n\nRunning the Docker image is simple and doesn't require any dependencies or system modifications, just run:\n\n```\n$ docker run -Pit cznic/knot-resolver\n```\n\nThe images are meant as an easy way to try the resolver, and they're not designed for production use.\n\n## Contacting us\n\n- [GitLab issues](https://gitlab.nic.cz/knot/knot-resolver/issues) (you may authenticate via GitHub)\n- [mailing list](https://lists.nic.cz/postorius/lists/knot-resolver-announce.lists.nic.cz/)\n- [](https://gitter.im/CZ-NIC/knot-resolver?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)\n\n[build]: https://www.knot-resolver.cz/documentation/latest/dev/build.html\n[doc]: https://www.knot-resolver.cz/documentation/latest/\n[doc-dev]: https://www.knot-resolver.cz/documentation/latest/dev\n[knot-dns]: https://www.knot-dns.cz/\n[luajit]: https://luajit.org/\n[libuv]: http://libuv.org\n[python]: https://www.python.org/\n[systemd]: https://systemd.io/\n[scaling]: https://www.knot-resolver.cz/documentation/latest/config-multiple-workers.html\n[manager]: https://www.knot-resolver.cz/documentation/latest/dev/architecture.html\n",
from pathlib import Path
-from knot_resolver_manager.datamodel.globals import Context, set_global_validation_context
+from knot_resolver.datamodel.globals import Context, set_global_validation_context
set_global_validation_context(Context(Path("."), False))
import pytest
-from knot_resolver_manager.datamodel.cache_schema import CacheClearRPCSchema
-from knot_resolver_manager.datamodel.templates import template_from_str
+from knot_resolver.datamodel.cache_schema import CacheClearRPCSchema
+from knot_resolver.datamodel.templates import template_from_str
@pytest.mark.parametrize(
-from knot_resolver_manager.datamodel.forward_schema import ForwardServerSchema
-from knot_resolver_manager.datamodel.templates import template_from_str
+from knot_resolver.datamodel.forward_schema import ForwardServerSchema
+from knot_resolver.datamodel.templates import template_from_str
def test_boolean():
-from knot_resolver_manager.datamodel.forward_schema import ForwardSchema
-from knot_resolver_manager.datamodel.templates import template_from_str
-from knot_resolver_manager.datamodel.types import IPAddressOptionalPort
+from knot_resolver.datamodel.forward_schema import ForwardSchema
+from knot_resolver.datamodel.templates import template_from_str
+from knot_resolver.datamodel.types import IPAddressOptionalPort
def test_policy_rule_forward_add():
-from knot_resolver_manager.datamodel.network_schema import ListenSchema
-from knot_resolver_manager.datamodel.templates import template_from_str
+from knot_resolver.datamodel.network_schema import ListenSchema
+from knot_resolver.datamodel.templates import template_from_str
def test_network_listen():
from typing import List
-from knot_resolver_manager.datamodel.network_schema import AddressRenumberingSchema
-from knot_resolver_manager.datamodel.policy_schema import AnswerSchema
-from knot_resolver_manager.datamodel.templates import template_from_str
-from knot_resolver_manager.datamodel.types import PolicyFlagEnum
+from knot_resolver.datamodel.network_schema import AddressRenumberingSchema
+from knot_resolver.datamodel.policy_schema import AnswerSchema
+from knot_resolver.datamodel.templates import template_from_str
+from knot_resolver.datamodel.types import PolicyFlagEnum
def test_policy_add():
import pytest
from jinja2 import Template
-from knot_resolver_manager.datamodel.types import EscapedStr
-from knot_resolver_manager.utils.modeling import ConfigSchema
+from knot_resolver.datamodel.types import EscapedStr
+from knot_resolver.utils.modeling import ConfigSchema
str_template = Template("'{{ string }}'")
import pytest
-from knot_resolver_manager.datamodel.templates import template_from_str
-from knot_resolver_manager.datamodel.view_schema import ViewOptionsSchema, ViewSchema
+from knot_resolver.datamodel.templates import template_from_str
+from knot_resolver.datamodel.view_schema import ViewOptionsSchema, ViewSchema
def test_view_flags():
import json
from typing import Any, Dict, Type, cast
-from knot_resolver_manager.datamodel import KresConfig
-from knot_resolver_manager.datamodel.lua_schema import LuaSchema
-from knot_resolver_manager.utils.modeling import BaseSchema
-from knot_resolver_manager.utils.modeling.types import (
+from knot_resolver.datamodel import KresConfig
+from knot_resolver.datamodel.lua_schema import LuaSchema
+from knot_resolver.utils.modeling import BaseSchema
+from knot_resolver.utils.modeling.types import (
get_generic_type_argument,
get_generic_type_arguments,
get_optional_inner_type,
import pytest
from pytest import raises
-from knot_resolver_manager.datamodel.forward_schema import ForwardSchema
-from knot_resolver_manager.utils.modeling.exceptions import DataValidationError
+from knot_resolver.datamodel.forward_schema import ForwardSchema
+from knot_resolver.utils.modeling.exceptions import DataValidationError
@pytest.mark.parametrize("port,auth", [(5353, False), (53, True)])
import pytest
from pytest import raises
-from knot_resolver_manager.datamodel.local_data_schema import RuleSchema
-from knot_resolver_manager.utils.modeling.exceptions import DataValidationError
+from knot_resolver.datamodel.local_data_schema import RuleSchema
+from knot_resolver.utils.modeling.exceptions import DataValidationError
@pytest.mark.parametrize(
from pytest import raises
-from knot_resolver_manager.datamodel.lua_schema import LuaSchema
-from knot_resolver_manager.utils.modeling.exceptions import DataValidationError
+from knot_resolver.datamodel.lua_schema import LuaSchema
+from knot_resolver.utils.modeling.exceptions import DataValidationError
def test_invalid():
import pytest
-from knot_resolver_manager.datamodel.management_schema import ManagementSchema
-from knot_resolver_manager.utils.modeling.exceptions import DataValidationError
+from knot_resolver.datamodel.management_schema import ManagementSchema
+from knot_resolver.utils.modeling.exceptions import DataValidationError
@pytest.mark.parametrize("val", [{"interface": "::1@53"}, {"unix-socket": "/tmp/socket"}])
import pytest
from pytest import raises
-from knot_resolver_manager.datamodel.network_schema import ListenSchema, NetworkSchema
-from knot_resolver_manager.datamodel.types import InterfaceOptionalPort, PortNumber
-from knot_resolver_manager.utils.modeling.exceptions import DataValidationError
+from knot_resolver.datamodel.network_schema import ListenSchema, NetworkSchema
+from knot_resolver.datamodel.types import InterfaceOptionalPort, PortNumber
+from knot_resolver.utils.modeling.exceptions import DataValidationError
def test_listen_defaults():
import pytest
from pytest import raises
-from knot_resolver_manager.datamodel.policy_schema import ActionSchema, PolicySchema
-from knot_resolver_manager.datamodel.types import PolicyActionEnum
-from knot_resolver_manager.utils.modeling.exceptions import DataValidationError
-from knot_resolver_manager.utils.modeling.types import get_generic_type_arguments
+from knot_resolver.datamodel.policy_schema import ActionSchema, PolicySchema
+from knot_resolver.datamodel.types import PolicyActionEnum
+from knot_resolver.utils.modeling.exceptions import DataValidationError
+from knot_resolver.utils.modeling.types import get_generic_type_arguments
noconfig_actions = [
"pass",
import pytest
from pytest import raises
-from knot_resolver_manager.datamodel.rpz_schema import RPZSchema
-from knot_resolver_manager.utils.modeling.exceptions import DataValidationError
+from knot_resolver.datamodel.rpz_schema import RPZSchema
+from knot_resolver.utils.modeling.exceptions import DataValidationError
@pytest.mark.parametrize(
import pytest
from pytest import raises
-from knot_resolver_manager.datamodel.types.base_types import IntRangeBase, StringLengthBase
-from knot_resolver_manager.manager.exceptions import KresManagerException
+from knot_resolver.datamodel.types.base_types import IntRangeBase, StringLengthBase
+from knot_resolver.manager.exceptions import KresManagerException
@pytest.mark.parametrize("min,max", [(0, None), (None, 0), (1, 65535), (-65535, -1)])
import pytest
from pytest import raises
-from knot_resolver_manager.datamodel.types import (
+from knot_resolver.datamodel.types import (
Dir,
DomainName,
EscapedStr,
SizeUnit,
TimeUnit,
)
-from knot_resolver_manager.utils.modeling import BaseSchema
+from knot_resolver.utils.modeling import BaseSchema
def _rand_domain(label_chars: int, levels: int = 1) -> str:
import pytest
from pytest import raises
-from knot_resolver_manager.datamodel.types import ListOrItem
-from knot_resolver_manager.utils.modeling import BaseSchema
-from knot_resolver_manager.utils.modeling.exceptions import DataValidationError
-from knot_resolver_manager.utils.modeling.types import get_generic_type_wrapper_argument
+from knot_resolver.datamodel.types import ListOrItem
+from knot_resolver.utils.modeling import BaseSchema
+from knot_resolver.utils.modeling.exceptions import DataValidationError
+from knot_resolver.utils.modeling.types import get_generic_type_wrapper_argument
@pytest.mark.parametrize("val", [str, int])
import pytest
-from knot_resolver_manager.manager.config_store import ConfigStore, only_on_real_changes_update
-from knot_resolver_manager.datamodel.config_schema import KresConfig
+from knot_resolver.manager.config_store import ConfigStore, only_on_real_changes_update
+from knot_resolver.datamodel.config_schema import KresConfig
@pytest.mark.asyncio # type: ignore
-from knot_resolver_manager import __version__
+from knot_resolver import __version__
def test_version():
from pytest import raises
from typing_extensions import Literal
-from knot_resolver_manager.utils.modeling import ConfigSchema, parse_json, parse_yaml
-from knot_resolver_manager.utils.modeling.exceptions import DataDescriptionError, DataValidationError
+from knot_resolver.utils.modeling import ConfigSchema, parse_json, parse_yaml
+from knot_resolver.utils.modeling.exceptions import DataDescriptionError, DataValidationError
class _TestBool(ConfigSchema):
from pyparsing import empty
-from knot_resolver_manager.utils.etag import structural_etag
+from knot_resolver.utils.etag import structural_etag
def test_etag():
from pytest import raises
-from knot_resolver_manager.utils.modeling.json_pointer import json_ptr_resolve
+from knot_resolver.utils.modeling.json_pointer import json_ptr_resolve
# example adopted from https://www.sitepoint.com/json-server-example/
TEST = {
from pytest import raises
-from knot_resolver_manager.utils.modeling.query import query
+from knot_resolver.utils.modeling.query import query
def test_example_from_spec():
-from knot_resolver_manager.utils.modeling.renaming import renamed
+from knot_resolver.utils.modeling.renaming import renamed
def test_all():
import pytest
from typing_extensions import Literal
-from knot_resolver_manager.utils.modeling import BaseSchema
-from knot_resolver_manager.utils.modeling.types import is_list, is_literal
+from knot_resolver.utils.modeling import BaseSchema
+from knot_resolver.utils.modeling.types import is_list, is_literal
types = [
bool,
-from knot_resolver_manager.utils.functional import all_matches, contains_element_matching, foldl
+from knot_resolver.utils.functional import all_matches, contains_element_matching, foldl
def test_foldl():
projects / thirdparty / knot-resolver.git / commitdiff
