ddns 4.1.0b4__py2.py3-none-any.whl → 4.1.1__py2.py3-none-any.whl

ddns/config/config.py

@@ -0,0 +1,214 @@
+# coding=utf-8
+"""
+Configuration class merged from CLI, JSON, and environment variables.
+@author: NewFuture
+"""
+
+from hashlib import md5
+from .cli import str_bool, log_level as get_log_level
+
+__all__ = ["Config", "split_array_string"]
+
+# 简单数组，支持',', ';' 分隔的参数列表
+SIMPLE_ARRAY_PARAMS = ["ipv4", "ipv6", "proxy", "index4", "index6"]
+
+
+def is_false(value):
+    """
+    判断值是否为 False
+    字符串 'false', 或者 False, 或者 'none';
+    0 不是 False
+    """
+    if hasattr(value, "strip"):  # 字符串
+        return value.strip().lower() in ["false", "none"]
+    return value is False
+
+
+def split_array_string(value):
+    # type: (str|list) -> list
+    """
+    解析数组字符串
+    逐个分解，遇到特殊前缀时停止分割
+    """
+    if isinstance(value, list):
+        return value
+    if not value or not hasattr(value, "strip"):
+        return [value] if value else []
+
+    trimmed = value.strip()
+
+    # 选择分隔符（逗号优先）
+    sep = "," if "," in trimmed else (";" if ";" in trimmed else None)
+    if not sep:
+        return [trimmed]
+
+    # 逐个分解，遇到特殊前缀时停止
+    parts = []
+    split_parts = trimmed.split(sep)
+    for i, part in enumerate(split_parts):
+        part = part.strip()
+        if not part:
+            continue
+
+        # 检查是否包含特殊前缀，如果有则合并剩余部分
+        if any(prefix in part for prefix in ["regex:", "cmd:", "shell:"]):
+            parts.append(sep.join(split_parts[i:]).strip())
+            break
+        parts.append(part)
+
+    return parts
+
+
+class Config(object):
+    """
+    Configuration class for DDNS.
+    This class is used to load and manage configuration settings.
+    """
+
+    def __init__(self, cli_config=None, json_config=None, env_config=None):
+        # type: (dict | None, dict | None, dict | None) -> None
+        """
+        Initialize the Config object.
+        """
+        self._cli_config = cli_config or {}
+        self._json_config = json_config or {}
+        self._env_config = env_config or {}
+
+        # Known configuration keys that should not go into extra
+        self._known_keys = {
+            "dns",
+            "id",
+            "token",
+            "endpoint",
+            "index4",
+            "index6",
+            "ipv4",
+            "ipv6",
+            "ttl",
+            "line",
+            "proxy",
+            "cache",
+            "ssl",
+            "log_level",
+            "log_format",
+            "log_file",
+            "log_datefmt",
+            "extra",
+            "debug",
+            "config",
+            "command",
+        }
+
+        # dns related configurations
+        self.dns = self._get("dns", "")  # type: str
+        self.id = self._get("id", "")  # type: str
+        self.token = self._get("token", "")  # type: str
+        self.endpoint = self._get("endpoint")  # type: str | None
+        self.index4 = self._get("index4", ["default"])  # type: list[str]|Literal[False]
+        self.index6 = self._get("index6", ["default"])  # type: list[str]|Literal[False]
+        self.ipv4 = self._get("ipv4", [])  # type: list[str]
+        self.ipv6 = self._get("ipv6", [])  # type: list[str]
+        ttl = self._get("ttl", None)  # type: int | str | None
+        self.ttl = int(ttl) if isinstance(ttl, (str, bytes)) else ttl  # type: int | None
+        self.line = self._get("line", None)  # type: str | None
+        self.proxy = self._get("proxy", [])  # type: list[str] | None
+        # cache and SSL settings
+        self.cache = str_bool(self._get("cache", True))
+        self.ssl = str_bool(self._get("ssl", "auto"))
+
+        log_level = self._get("log_level", "INFO")
+        if isinstance(log_level, (str, bytes)):
+            log_level = get_log_level(log_level)
+        self.log_level = log_level  # type: int  # type: ignore[assignment]
+        self.log_format = self._get("log_format", None)  # type: str | None
+        self.log_file = self._get("log_file", None)  # type: str | None
+        self.log_datefmt = self._get("log_datefmt", "%Y-%m-%dT%H:%M:%S")  # type: str | None
+
+        # Collect extra fields from all config sources
+        self.extra = self._collect_extra()  # type: dict
+
+    def _get(self, key, default=None):
+        # type: (str, Any) -> Any
+        """
+        Get a configuration value by key.
+        """
+        value = self._cli_config.get(key)
+        if isinstance(value, list) and len(value) == 1:
+            # 如果是单个元素的列表，取出第一个元素, 这样可以避免在 CLI 配置中使用单个值时仍然得到一个列表
+            value = value[0]
+        if value is None:
+            value = self._json_config.get(key, self._env_config.get(key, default))
+        if is_false(value):
+            return False
+        # 处理数组参数
+        if key in SIMPLE_ARRAY_PARAMS:
+            return split_array_string(value)
+        return value
+
+    def _collect_extra(self):
+        # type: () -> dict
+        """
+        Collect all extra fields from CLI, JSON, and ENV configs that are not known keys.
+        Priority: CLI > JSON > ENV
+        """
+        extra = {}  # type: dict
+
+        # Collect from env config first (lowest priority)
+        for key, value in self._env_config.items():
+            if key.startswith("extra_"):
+                extra_key = key[6:]  # Remove "extra_" prefix
+                extra[extra_key] = value
+            elif key == "extra" and isinstance(value, dict):
+                extra.update(value)
+            elif key not in self._known_keys:
+                extra[key] = value
+
+        # Collect from JSON config (medium priority)
+        for key, value in self._json_config.items():
+            if key == "extra" and isinstance(value, dict):
+                extra.update(value)
+            elif key not in self._known_keys:
+                extra[key] = value
+
+        # Collect from CLI config (highest priority)
+        for key, value in self._cli_config.items():
+            if key.startswith("extra_"):
+                extra_key = key[6:]  # Remove "extra_" prefix
+                extra[extra_key] = value
+            elif key not in self._known_keys:
+                extra[key] = value
+
+        return extra
+
+    def md5(self):
+        # type: () -> str
+        """
+        Generate hash based on all merged configurations.
+
+        Returns:
+            str: Hash value based on configuration attributes.
+        """
+        dict_var = {
+            "dns": self.dns,
+            "id": self.id,
+            "token": self.token,
+            "endpoint": self.endpoint,
+            "index4": self.index4,
+            "index6": self.index6,
+            "ipv4": self.ipv4,
+            "ipv6": self.ipv6,
+            "line": self.line,
+            "ttl": self.ttl,
+            # System settings
+            "cache": self.cache,
+            "proxy": self.proxy,
+            "ssl": self.ssl,
+            # Logging settings
+            "log_level": self.log_level,
+            "log_format": self.log_format,
+            "log_file": self.log_file,
+            "log_datefmt": self.log_datefmt,
+            # Extra fields
+            "extra": self.extra,
+        }
+        return md5(str(dict_var).encode("utf-8")).hexdigest()

ddns/config/env.py

@@ -0,0 +1,77 @@
+# -*- coding:utf-8 -*-
+"""
+Configuration loader for DDNS environment variables.
+@author: NewFuture
+"""
+
+from ast import literal_eval
+from os import environ
+from sys import stderr
+
+__all__ = ["load_config"]
+
+
+def _try_parse_array(value, key=None):
+    # type: (str, str|None) -> Any
+    """解析数组值[], 非数组返回元素字符串（去除前后空格）"""
+    if not value:
+        return value
+
+    value = value.strip()
+    # 尝试解析 JSON
+    # if (value.startswith("{'") and value.endswith("'}")) or (value.startswith('{"') and value.endswith('"}')):
+    #     try:
+    #         return json_decode(value)
+    #     except Exception:
+    #         logging.warning("Failed to parse JSON from value: %s", value)
+    if value.startswith("[") and value.endswith("]"):
+        # or (value.startswith("{") and value.endswith("}"))
+        try:
+            return literal_eval(value)
+        except Exception:
+            stderr.write("Failed to parse JSON array from value: {}={}\n".format(key, value))
+            pass
+    # 返回去除前后空格的字符串
+    return value
+
+
+def load_config(prefix="DDNS_"):
+    # type: (str) -> dict
+    """
+    从环境变量加载配置并返回配置字典。
+
+    支持以下转换：
+    1. 对于特定的数组参数（index4, index6, ipv4, ipv6, proxy），转换为数组
+    2. 对于 JSON 格式的数组 [item1,item2]，转换为数组
+    3. 键名转换：点号转下划线，支持大小写变体
+    4. 自动检测标准 Python 环境变量：
+       - SSL 验证：PYTHONHTTPSVERIFY
+    5. 支持 extra 字段：DDNS_EXTRA_XXX 会被转换为 extra_xxx
+    6. 其他所有值保持原始字符串格式，去除前后空格
+
+    Args:
+        prefix (str): 环境变量前缀，默认为 "DDNS_"
+
+    Returns:
+        dict: 从环境变量解析的配置字典
+    """
+    env_vars = {}  # type: dict[str, str | list]
+
+    # 标准环境变量映射
+    alias_mappings = {"pythonhttpsverify": "ssl"}
+
+    for key, value in environ.items():
+        lower_key = key.lower()
+        config_key = None
+
+        if lower_key in alias_mappings:
+            config_key = alias_mappings[lower_key]
+            if config_key in env_vars:
+                continue  # DDNS变量优先级更高
+        elif lower_key.startswith(prefix.lower()):
+            config_key = lower_key[len(prefix) :].replace(".", "_")  # noqa: E203
+
+        if config_key:
+            env_vars[config_key] = _try_parse_array(value, key=key)
+
+    return env_vars

ddns/config/file.py

@@ -0,0 +1,169 @@
+# -*- coding:utf-8 -*-
+"""
+Configuration file loader for DDNS. supports both JSON and AST parsing.
+@author: NewFuture
+"""
+
+from ast import literal_eval
+from json import loads as json_decode, dumps as json_encode
+from sys import stderr, stdout
+from ..util.comment import remove_comment
+from ..util.http import request
+from ..util.fileio import read_file, write_file
+
+
+def _process_multi_providers(config):
+    # type: (dict) -> list[dict]
+    """Process v4.1 providers format and return list of configs."""
+    result = []
+
+    # 提取全局配置（除providers之外的所有配置）
+    global_config = _flatten_single_config(config, exclude_keys=["providers"])
+
+    # 检查providers和dns字段不能同时使用
+    if global_config.get("dns"):
+        stderr.write("Error: 'providers' and 'dns' fields cannot be used simultaneously in config file!\n")
+        raise ValueError("providers and dns fields conflict")
+
+    # 为每个provider创建独立配置
+    for provider_config in config["providers"]:
+        # 验证provider必须有provider字段
+        if not provider_config.get("provider"):
+            stderr.write("Error: Each provider must have a 'provider' field!\n")
+            raise ValueError("provider missing provider field")
+
+        flat_config = global_config.copy()  # 从全局配置开始
+        provider_flat = _flatten_single_config(provider_config, exclude_keys=["provider"])
+        flat_config["dns"] = provider_config.get("provider")
+        flat_config.update(provider_flat)
+        result.append(flat_config)
+    return result
+
+
+def _flatten_single_config(config, exclude_keys=None):
+    # type: (dict, list[str]|None) -> dict
+    """Flatten a single config object with optional key exclusion."""
+    if exclude_keys is None:
+        exclude_keys = []
+    flat_config = {}
+    for k, v in config.items():
+        if k in exclude_keys:
+            continue
+        if isinstance(v, dict):
+            for subk, subv in v.items():
+                flat_config["{}_{}".format(k, subk)] = subv
+        else:
+            flat_config[k] = v
+    return flat_config
+
+
+def load_config(config_path, proxy=None, ssl="auto"):
+    # type: (str, list[str] | None, bool | str) -> dict|list[dict]
+    """
+    加载配置文件并返回配置字典或配置字典数组。
+    支持本地文件和远程HTTP(S) URL。
+    对于单个对象返回dict，对于数组返回list[dict]。
+    优先尝试JSON解析，失败后尝试AST解析。
+
+    Args:
+        config_path (str): 配置文件路径或HTTP(S) URL
+        proxy (list[str] | None): 代理列表，仅用于HTTP或HTTPS请求
+        ssl (bool | str): SSL验证配置，仅用于HTTPS请求
+
+    Returns:
+        dict|list[dict]: 配置字典或配置字典数组
+
+    Raises:
+        Exception: 当配置文件加载失败时抛出异常
+    """
+    try:
+        # 检查是否为远程URL
+        if "://" in config_path:
+            # 使用HTTP请求获取远程配置
+            response = request("GET", config_path, proxies=proxy, verify=ssl, retries=3)
+            if (response.status not in (200, None)) or not response.body:
+                stderr.write("Failed to load {}: HTTP {} {}\n".format(config_path, response.status, response.reason))
+                stderr.write("Response body: %s\n" % response.body)
+                raise Exception("HTTP {}: {}".format(response.status, response.reason))
+            content = response.body
+        else:
+            # 本地文件加载
+            content = read_file(config_path)
+
+        # 移除注释后尝试JSON解析
+        content_without_comments = remove_comment(content)
+        try:
+            config = json_decode(content_without_comments)
+        except (ValueError, SyntaxError) as json_error:
+            # JSON解析失败，尝试AST解析
+            try:
+                config = literal_eval(content)
+                stdout.write("Successfully loaded config file with AST parser: %s\n" % config_path)
+            except (ValueError, SyntaxError) as ast_error:
+                if config_path.endswith(".json"):
+                    stderr.write("JSON parsing failed for %s\n" % (config_path))
+                    raise json_error
+
+                stderr.write(
+                    "Both JSON and AST parsing failed for %s\nJSON Error: %s\nAST Error: %s\n"
+                    % (config_path, json_error, ast_error)
+                )
+                raise ast_error
+    except Exception as e:
+        stderr.write("Failed to load config file `%s`: %s\n" % (config_path, e))
+        raise
+
+    # 处理配置格式：v4.1 providers格式或单个对象
+    if "providers" in config and isinstance(config["providers"], list):
+        return _process_multi_providers(config)
+    else:
+        return _flatten_single_config(config)
+
+
+def save_config(config_path, config):
+    # type: (str, dict) -> bool
+    """
+    保存配置到文件。
+
+    Args:
+        config_path (str): 配置文件路径
+        config (dict): 配置字典
+
+    Returns:
+        bool: 保存成功返回True
+
+    Raises:
+        Exception: 保存失败时抛出异常
+    """
+    # 补全默认配置
+    config = {
+        "$schema": "https://ddns.newfuture.cc/schema/v4.1.json",
+        "dns": config.get("dns", "debug"),
+        "id": config.get("id", "YOUR ID or EMAIL for DNS Provider"),
+        "token": config.get("token", "YOUR TOKEN or KEY for DNS Provider"),
+        "ipv4": config.get("ipv4", ["ddns.newfuture.cc"]),
+        "index4": config.get("index4", ["default"]),
+        "ipv6": config.get("ipv6", []),
+        "index6": config.get("index6", []),
+        "ttl": config.get("ttl", 600),
+        "line": config.get("line"),
+        "proxy": config.get("proxy", []),
+        "cache": config.get("cache", True),
+        "ssl": config.get("ssl", "auto"),
+        "log": {
+            "file": config.get("log_file"),
+            "level": config.get("log_level", "INFO"),
+            "format": config.get("log_format"),
+            "datefmt": config.get("log_datefmt"),
+        },
+    }
+    try:
+        content = json_encode(config, indent=2, ensure_ascii=False)
+        # Python 2 兼容性：检查是否需要解码
+        if hasattr(content, "decode"):
+            content = content.decode("utf-8")  # type: ignore
+        write_file(config_path, content)
+        return True
+    except Exception:
+        stderr.write("Cannot open config file to write: `%s`!\n" % config_path)
+        raise

ddns/provider/cloudflare.py

@@ -49,14 +49,33 @@ class CloudflareProvider(BaseProvider):
 
     def _query_record(self, zone_id, subdomain, main_domain, record_type, line, extra):
         # type: (str, str, str, str, str | None, dict) -> dict | None
-        """https://developers.cloudflare.com/api/resources/dns/subresources/records/methods/list/"""
+        """
+        查询DNS记录，优先使用extra filter匹配，匹配不到则fallback到不带extra的结果
+
+        Query DNS records, prioritize extra filters, fallback to query without extra if no match found.
+        https://developers.cloudflare.com/api/resources/dns/subresources/records/methods/list/
+        """
         # cloudflare的域名查询需要完整域名
         name = join_domain(subdomain, main_domain)
         query = {"name.exact": name}  # type: dict[str, str|None]
-        if extra:
-            query["proxied"] = extra.get("proxied", None)  # 代理状态
+
+        # 添加extra filter到查询参数，将布尔值转换为小写字符串
+        proxied = extra.get("proxied") if extra else None
+        if proxied is not None:
+            query["proxied"] = str(proxied).lower()  # True -> "true", False -> "false"
+
+        # 先使用extra filter查询
         data = self._request("GET", "/{}/dns_records".format(zone_id), type=record_type, per_page=10000, **query)
         record = next((r for r in data if r.get("name") == name and r.get("type") == record_type), None)
+
+        # 如果使用了extra filter但没找到记录，尝试不带extra filter查询
+        if not record and proxied is not None:
+            self.logger.debug("No record found with extra filters, retrying without extra filters")
+            data = self._request(
+                "GET", "/{}/dns_records".format(zone_id), type=record_type, per_page=10000, **{"name.exact": name}
+            )
+            record = next((r for r in data if r.get("name") == name and r.get("type") == record_type), None)
+
         self.logger.debug("Record queried: %s", record)
         if record:
             return record
@@ -81,9 +100,9 @@ class CloudflareProvider(BaseProvider):
         # type: (str, dict, str, str, int | str | None, str | None, dict) -> bool
         """https://developers.cloudflare.com/api/resources/dns/subresources/records/methods/edit/"""
         extra["comment"] = extra.get("comment", self.remark)  # 注释
-        extra["proxied"] = old_record.get("proxied", extra.get("proxied"))  # 保持原有的代理状态
-        extra["tags"] = old_record.get("tags", extra.get("tags"))  # 保持原有的标签
-        extra["settings"] = old_record.get("settings", extra.get("settings"))  # 保持原有的设置
+        extra["proxied"] = extra.get("proxied", old_record.get("proxied"))  # extra优先，保持原有的代理状态作为默认值
+        extra["tags"] = extra.get("tags", old_record.get("tags"))  # extra优先，保持原有的标签作为默认值
+        extra["settings"] = extra.get("settings", old_record.get("settings"))  # extra优先，保持原有的设置作为默认值
         data = self._request(
             "PUT",
             "/{}/dns_records/{}".format(zone_id, old_record["id"]),

ddns/scheduler/__init__.py

@@ -0,0 +1,72 @@
+# -*- coding:utf-8 -*-
+"""
+Task scheduler management
+Provides factory functions and public API for task scheduling
+@author: NewFuture
+"""
+
+import os
+import platform
+
+from ddns.util.fileio import read_file_safely
+
+from ..util.try_run import try_run
+
+# Import all scheduler classes
+from ._base import BaseScheduler
+from .cron import CronScheduler
+from .launchd import LaunchdScheduler
+from .schtasks import SchtasksScheduler
+from .systemd import SystemdScheduler
+
+
+def get_scheduler(scheduler=None):
+    # type: (str | None) -> BaseScheduler
+    """
+    Factory function to get appropriate scheduler based on platform or user preference
+
+    Args:
+        scheduler: Scheduler type. Can be:
+                  - None or "auto": Auto-detect based on platform
+                  - "systemd": Use systemd timer (Linux)
+                  - "cron": Use cron jobs (Unix/Linux)
+                  - "launchd": Use launchd (macOS)
+                  - "schtasks": Use Windows Task Scheduler
+
+    Returns:
+        Appropriate scheduler instance
+
+    Raises:
+        ValueError: If invalid scheduler specified
+        NotImplementedError: If scheduler not available on current platform
+    """
+    # Auto-detect if not specified
+    if scheduler is None or scheduler == "auto":
+        system = platform.system().lower()
+        if system == "windows":
+            return SchtasksScheduler()
+        elif system == "darwin":  # macOS
+            # Check if launchd directories exist
+            launchd_dirs = ["/Library/LaunchDaemons", "/System/Library/LaunchDaemons"]
+            if any(os.path.isdir(d) for d in launchd_dirs):
+                return LaunchdScheduler()
+        elif system == "linux" and (
+            (read_file_safely("/proc/1/comm", default="").strip().lower() == "systemd")
+            or (try_run(["systemctl", "--version"]) is not None)
+        ):  # Linux with systemd available
+            return SystemdScheduler()
+        return CronScheduler()  # Other Unix-like systems, use cron
+    elif scheduler == "systemd":
+        return SystemdScheduler()
+    elif scheduler == "cron":
+        return CronScheduler()
+    elif scheduler == "launchd" or scheduler == "mac":
+        return LaunchdScheduler()
+    elif scheduler == "schtasks" or scheduler == "windows":
+        return SchtasksScheduler()
+    else:
+        raise ValueError("Invalid scheduler: {}. ".format(scheduler))
+
+
+# Export public API
+__all__ = ["get_scheduler", "BaseScheduler"]

ddns/scheduler/_base.py

@@ -0,0 +1,80 @@
+# -*- coding:utf-8 -*-
+"""
+Base scheduler class for DDNS task management
+@author: NewFuture
+"""
+
+import sys
+from datetime import datetime
+from logging import Logger, getLogger  # noqa: F401
+
+from .. import __version__ as version
+
+
+class BaseScheduler(object):
+    """Base class for all task schedulers"""
+
+    def __init__(self, logger=None):  # type: (Logger | None) -> None
+        self.logger = (logger or getLogger()).getChild("task")
+
+    def _get_ddns_cmd(self):  # type: () -> list[str]
+        """Get DDNS command for scheduled execution as array"""
+        if hasattr(sys.modules["__main__"], "__compiled__"):
+            return [sys.argv[0]]
+        else:
+            return [sys.executable, "-m", "ddns"]
+
+    def _build_ddns_command(self, ddns_args=None):  # type: (dict | None) -> list[str]
+        """Build DDNS command with arguments as array"""
+        # Get base command as array
+        cmd_parts = self._get_ddns_cmd()
+
+        if not ddns_args:
+            return cmd_parts
+
+        # Filter out debug=False to reduce noise
+        args = {k: v for k, v in ddns_args.items() if not (k == "debug" and not v)}
+
+        for key, value in args.items():
+            if isinstance(value, bool):
+                cmd_parts.extend(["--{}".format(key), str(value).lower()])
+            elif isinstance(value, list):
+                for item in value:
+                    cmd_parts.extend(["--{}".format(key), str(item)])
+            else:
+                cmd_parts.extend(["--{}".format(key), str(value)])
+
+        return cmd_parts
+
+    def _quote_command_array(self, cmd_array):  # type: (list[str]) -> str
+        """Convert command array to properly quoted command string"""
+        return " ".join('"{}"'.format(arg) if " " in arg else arg for arg in cmd_array)
+
+    def _get_description(self):  # type: () -> str
+        """Generate standard description/comment for DDNS installation"""
+        date = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        return "auto-update v{} installed on {}".format(version, date)
+
+    def is_installed(self):  # type: () -> bool
+        """Check if DDNS task is installed"""
+        raise NotImplementedError
+
+    def get_status(self):  # type: () -> dict
+        """Get detailed status information"""
+        raise NotImplementedError
+
+    def install(self, interval, ddns_args=None):  # type: (int, dict | None) -> bool
+        """Install DDNS scheduled task"""
+        raise NotImplementedError
+
+    def uninstall(self):  # type: () -> bool
+        """Uninstall DDNS scheduled task"""
+        raise NotImplementedError
+
+    def enable(self):  # type: () -> bool
+        """Enable DDNS scheduled task"""
+        raise NotImplementedError
+
+    def disable(self):  # type: () -> bool
+        """Disable DDNS scheduled task"""
+        raise NotImplementedError