from typing import Dict, List, Optional, Tuple, Type, TypeVar
from urllib.parse import quote
-from knot_resolver.constants import (
- API_SOCK_PATH_DEFAULT,
- API_SOCK_PATH_ENV_VAR,
- CONFIG_FILE_PATH_DEFAULT,
- CONFIG_FILE_PATH_ENV_VAR,
-)
+from knot_resolver.constants import API_SOCK_FILE, API_SOCK_FILE_ENV_VAR, CONFIG_FILE, CONFIG_FILE_ENV_VAR
from knot_resolver.datamodel.types import IPAddressPort
from knot_resolver.utils.modeling import parsing
from knot_resolver.utils.modeling.exceptions import DataValidationError
if len(namespace.socket) > 0:
return SocketDesc(namespace.socket[0], "--socket argument")
- config_path = os.getenv(CONFIG_FILE_PATH_ENV_VAR)
- socket_env = os.getenv(API_SOCK_PATH_ENV_VAR)
+ config_path = os.getenv(CONFIG_FILE_ENV_VAR)
+ socket_env = os.getenv(API_SOCK_FILE_ENV_VAR)
socket: Optional[SocketDesc] = None
# 2) socket from config file ('--config' argument)
socket = get_socket_from_config(Path(config_path), False)
# 4) socket from environment variable
elif socket_env:
- socket = SocketDesc(socket_env, f'Environment variable "{API_SOCK_PATH_ENV_VAR}"')
+ socket = SocketDesc(socket_env, f'Environment variable "{API_SOCK_FILE_ENV_VAR}"')
# 5) socket from config file (default config file constant)
else:
- socket = get_socket_from_config(CONFIG_FILE_PATH_DEFAULT, True)
+ socket = get_socket_from_config(CONFIG_FILE, True)
if socket:
return socket
# 6) socket default
- return SocketDesc(str(API_SOCK_PATH_DEFAULT), f'Default value "{API_SOCK_PATH_DEFAULT}"')
+ return SocketDesc(str(API_SOCK_FILE), f'Default value "{API_SOCK_FILE}"')
class CommandArgs:
from jinja2 import Template
-from knot_resolver.constants import kres_cache_gc_executable, kresd_executable
+from knot_resolver.constants import KRES_CACHE_GC_EXECUTABLE, KRESD_EXECUTABLE
from knot_resolver.controller.interface import KresID, SubprocessType
from knot_resolver.datamodel.config_schema import KresConfig
from knot_resolver.datamodel.logging_schema import LogTargetEnum
return ProcessTypeConfig( # type: ignore[call-arg]
logfile=supervisord_subprocess_log_dir(config) / "gc.log",
workdir=cwd,
- command=f"{kres_cache_gc_executable()} -c {kres_cache_dir(config)}{kres_cache_gc_args(config)}",
+ command=f"{KRES_CACHE_GC_EXECUTABLE} -c {kres_cache_dir(config)}{kres_cache_gc_args(config)}",
environment="",
)
return ProcessTypeConfig( # type: ignore[call-arg]
logfile=supervisord_subprocess_log_dir(config) / "policy-loader.log",
workdir=cwd,
- command=f"{kresd_executable()} -c {(policy_loader_config_file(config))} -c - -n",
+ command=f"{KRESD_EXECUTABLE} -c {(policy_loader_config_file(config))} -c - -n",
environment="X-SUPERVISORD-TYPE=notify",
)
return ProcessTypeConfig( # type: ignore[call-arg]
logfile=supervisord_subprocess_log_dir(config) / "kresd%(process_num)d.log",
workdir=cwd,
- command=f"{kresd_executable()} -c {kresd_config_file_supervisord_pattern(config)} -n",
+ command=f"{KRESD_EXECUTABLE} -c {kresd_config_file_supervisord_pattern(config)} -n",
environment='SYSTEMD_INSTANCE="%(process_num)d",X-SUPERVISORD-TYPE=notify',
max_procs=int(config.max_workers) + 1, # +1 for the canary process
)
import socket
from typing import Any, Dict, List, Literal, Optional, Tuple, Union
-from knot_resolver.constants import API_SOCK_PATH_DEFAULT, RUN_DIR_DEFAULT, VERSION, WORKERS_MAX_DEFAULT
+from knot_resolver.constants import API_SOCK_FILE, RUN_DIR, VERSION
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.utils.modeling.base_schema import lazy_default
from knot_resolver.utils.modeling.exceptions import AggregateDataValidationError, DataValidationError
+WORKERS_MAX = 256
+
logger = logging.getLogger(__name__)
c = _cpu_count()
if c:
return c * 10
- return WORKERS_MAX_DEFAULT
+ return WORKERS_MAX
def _get_views_tags(views: List[ViewSchema]) -> List[str]:
version: int = 1
nsid: Optional[EscapedStr] = None
hostname: Optional[EscapedStr] = None
- rundir: WritableDir = lazy_default(WritableDir, str(RUN_DIR_DEFAULT))
+ rundir: WritableDir = lazy_default(WritableDir, str(RUN_DIR))
workers: Union[Literal["auto"], IntPositive] = IntPositive(1)
- max_workers: IntPositive = IntPositive(WORKERS_MAX_DEFAULT)
- management: ManagementSchema = lazy_default(ManagementSchema, {"unix-socket": str(API_SOCK_PATH_DEFAULT)})
+ max_workers: IntPositive = IntPositive(WORKERS_MAX)
+ management: ManagementSchema = lazy_default(ManagementSchema, {"unix-socket": str(API_SOCK_FILE)})
webmgmt: Optional[WebmgmtSchema] = None
options: OptionsSchema = OptionsSchema()
network: NetworkSchema = NetworkSchema()
workers_max = _workers_max_count()
if int(self.workers) > workers_max:
raise ValueError(
- f"can't run with more workers then the recommended maximum {workers_max} or hardcoded {WORKERS_MAX_DEFAULT}"
+ f"can't run with more workers then the recommended maximum {workers_max} or hardcoded {WORKERS_MAX}"
)
# sanity check
Used for initial manager startup.
"""
- return WritableDir(data["rundir"] if "rundir" in data else RUN_DIR_DEFAULT, object_path="/rundir")
+ return WritableDir(data["rundir"] if "rundir" in data else RUN_DIR, object_path="/rundir")
def kres_config_json_schema() -> Dict[str, Any]:
from pwd import getpwnam
from typing import Any, Dict, Tuple, Type, TypeVar
-from knot_resolver.constants import GROUP_DEFAULT, USER_DEFAULT
+from knot_resolver.constants import GROUP, USER
from knot_resolver.datamodel.globals import get_resolve_root, get_strict_validation
from knot_resolver.utils.modeling.base_value_type import BaseValueType
_PermissionMode.EXECUTE: [stat.S_IXUSR, stat.S_IXGRP, stat.S_IXOTH],
}
- user_uid = getpwnam(USER_DEFAULT).pw_uid
- user_gid = getgrnam(GROUP_DEFAULT).gr_gid
+ user_uid = getpwnam(USER).pw_uid
+ user_gid = getgrnam(GROUP).gr_gid
dest_stat = os.stat(dest_path)
dest_uid = dest_stat.st_uid
super().__init__(source_value, parents=parents, object_path=object_path)
if self.strict_validation and not _kres_accessible(self._value, _PermissionMode.READ):
- raise ValueError(f"{USER_DEFAULT}:{GROUP_DEFAULT} has insufficient permissions to read '{self._value}'")
+ raise ValueError(f"{USER}:{GROUP} has insufficient permissions to read '{self._value}'")
class WritableDir(Dir):
if self.strict_validation and not _kres_accessible(
self._value, _PermissionMode.WRITE | _PermissionMode.EXECUTE
):
- raise ValueError(
- f"{USER_DEFAULT}:{GROUP_DEFAULT} has insufficient permissions to write/execute '{self._value}'"
- )
+ raise ValueError(f"{USER}:{GROUP} has insufficient permissions to write/execute '{self._value}'")
class WritableFilePath(FilePath):
if self.strict_validation and not _kres_accessible(
self._value.parent, _PermissionMode.WRITE | _PermissionMode.EXECUTE
):
- raise ValueError(
- f"{USER_DEFAULT}:{GROUP_DEFAULT} has insufficient permissions to write/execute'{self._value.parent}'"
- )
+ raise ValueError(f"{USER}:{GROUP} has insufficient permissions to write/execute'{self._value.parent}'")
+import logging
from pathlib import Path
from typing import TYPE_CHECKING, Optional
from knot_resolver.manager.config_store import ConfigStore
+LOGGING_LEVEL_STARTUP = logging.DEBUG
+PID_FILE_NAME = "knot-resolver.pid"
+
+FIX_COUNTER_ATTEMPTS_MAX = 2
+FIX_COUNTER_DECREASE_INTERVAL_SEC = 30 * 60
+WATCHDOG_INTERVAL_SEC: float = 5
+
+
def kres_cache_dir(config: "KresConfig") -> Path:
return config.cache.storage.to_path()
import sys
from typing import Optional
-from knot_resolver.constants import LOGGING_LEVEL_STARTUP
from knot_resolver.datamodel.config_schema import KresConfig
from knot_resolver.datamodel.logging_schema import LogTargetEnum
from knot_resolver.manager.config_store import ConfigStore, only_on_real_changes_update
+from .constants import LOGGING_LEVEL_STARTUP
+
logger = logging.getLogger(__name__)
from pathlib import Path
from typing import NoReturn
-from knot_resolver.constants import CONFIG_FILE_PATH_DEFAULT, CONFIG_FILE_PATH_ENV_VAR, VERSION
+from knot_resolver.constants import CONFIG_FILE, CONFIG_FILE_ENV_VAR, VERSION
from knot_resolver.manager.logging import logger_startup
from knot_resolver.manager.server import start_server
from knot_resolver.utils import compat
parser.add_argument(
"-c",
"--config",
- help="Config file to load. Overrides default config location at '" + str(CONFIG_FILE_PATH_ENV_VAR) + "'",
+ help="Config file to load. Overrides default config location at '" + str(CONFIG_FILE) + "'",
type=str,
nargs=1,
required=False,
args = parse_args()
# where to look for config
- config_env = os.getenv(CONFIG_FILE_PATH_ENV_VAR)
+ config_env = os.getenv(CONFIG_FILE_ENV_VAR)
if args.config is not None:
config_path = Path(args.config[0])
elif config_env is not None:
config_path = Path(config_env)
else:
- config_path = CONFIG_FILE_PATH_DEFAULT
+ config_path = CONFIG_FILE
exit_code = compat.asyncio.run(start_server(config=config_path))
sys.exit(exit_code)
from subprocess import SubprocessError
from typing import Any, Callable, List, Optional
-from knot_resolver.constants import FIX_COUNTER_ATTEMPTS_MAX, FIX_COUNTER_DECREASE_INTERVAL_SEC, WATCHDOG_INTERVAL_SEC
from knot_resolver.controller.exceptions import SubprocessControllerException
from knot_resolver.controller.interface import Subprocess, SubprocessController, SubprocessStatus, SubprocessType
from knot_resolver.controller.registered_workers import command_registered_workers, get_registered_workers_kresids
from knot_resolver.utils.functional import Result
from knot_resolver.utils.modeling.types import NoneType
+from .constants import FIX_COUNTER_ATTEMPTS_MAX, FIX_COUNTER_DECREASE_INTERVAL_SEC, WATCHDOG_INTERVAL_SEC
+
logger = logging.getLogger(__name__)
from aiohttp.web_response import json_response
from aiohttp.web_runner import AppRunner, TCPSite, UnixSite
-from knot_resolver.constants import CONFIG_FILE_PATH_DEFAULT, PID_FILE_NAME
+from knot_resolver.constants import CONFIG_FILE
from knot_resolver.controller import get_best_controller_implementation
from knot_resolver.controller.exceptions import SubprocessControllerExecException
from knot_resolver.controller.registered_workers import command_single_registered_worker
from knot_resolver.utils.systemd_notify import systemd_notify
from .config_store import ConfigStore
-from .constants import init_user_constants
+from .constants import PID_FILE_NAME, init_user_constants
from .exceptions import KresManagerException
from .logging import logger_init
from .manager import KresManager
sys.exit(128 + signal.SIGTERM)
-async def start_server(config: Path = CONFIG_FILE_PATH_DEFAULT) -> int:
+async def start_server(config: Path = CONFIG_FILE) -> int:
# This function is quite long, but it describes how manager runs. So let's silence pylint
# pylint: disable=too-many-statements
projects / thirdparty / knot-resolver.git / commitdiff
