ddns 4.1.0b3__py2.py3-none-any.whl → 4.1.1b1__py2.py3-none-any.whl

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

ddns/scheduler/cron.py

@@ -0,0 +1,111 @@
+# -*- coding:utf-8 -*-
+"""
+Cron-based task scheduler for Unix-like systems
+@author: NewFuture
+"""
+
+import os
+import subprocess
+import tempfile
+
+from ..util.fileio import write_file
+from ..util.try_run import try_run
+from ._base import BaseScheduler
+
+
+class CronScheduler(BaseScheduler):
+    """Cron-based task scheduler for Unix-like systems"""
+
+    SCHEDULER_NAME = "cron"
+
+    KEY = "# DDNS:"
+
+    def _update_crontab(self, lines):  # type: (list[str]) -> bool
+        """Update crontab with new content"""
+        try:
+            temp_path = tempfile.mktemp(suffix=".cron")
+            write_file(temp_path, u"\n".join(lines) + u"\n")  # fmt: skip
+            subprocess.check_call(["crontab", temp_path])
+            os.unlink(temp_path)
+            return True
+        except Exception as e:
+            self.logger.error("Failed to update crontab: %s", e)
+            return False
+
+    def is_installed(self, crontab_content=None):  # type: (str | None) -> bool
+        result = crontab_content or try_run(["crontab", "-l"], logger=self.logger) or ""
+        return self.KEY in result
+
+    def get_status(self):
+        status = {"scheduler": "cron", "installed": False}  # type: dict[str, str | bool | int | None]
+        # Get crontab content once and reuse it for all checks
+        crontab_content = try_run(["crontab", "-l"], logger=self.logger) or ""
+        lines = crontab_content.splitlines()
+        line = next((i for i in lines if self.KEY in i), "").strip()
+
+        if line:  # Task is installed
+            status["installed"] = True
+            status["enabled"] = bool(line and not line.startswith("#"))
+        else:  # Task not installed
+            status["enabled"] = False
+
+        cmd_groups = line.split(self.KEY, 1) if line else ["", ""]
+        parts = cmd_groups[0].strip(" #\t").split() if cmd_groups[0] else []
+        status["interval"] = int(parts[0][2:]) if len(parts) >= 5 and parts[0].startswith("*/") else None
+        status["command"] = " ".join(parts[5:]) if len(parts) >= 6 else None
+        status["description"] = cmd_groups[1].strip() if len(cmd_groups) > 1 else None
+
+        return status
+
+    def install(self, interval, ddns_args=None):
+        ddns_commands = self._build_ddns_command(ddns_args)
+        # Convert array to properly quoted command string for cron
+        ddns_command = self._quote_command_array(ddns_commands)
+        description = self._get_description()
+        cron_entry = '*/{} * * * * cd "{}" && {} # DDNS: {}'.format(interval, os.getcwd(), ddns_command, description)
+
+        crontext = try_run(["crontab", "-l"], logger=self.logger) or ""
+        lines = [line for line in crontext.splitlines() if self.KEY not in line]
+        lines.append(cron_entry)
+
+        if self._update_crontab(lines):
+            return True
+        else:
+            self.logger.error("Failed to install DDNS cron job")
+            return False
+
+    def uninstall(self):
+        return self._modify_cron_lines("uninstall")
+
+    def enable(self):
+        return self._modify_cron_lines("enable")
+
+    def disable(self):
+        return self._modify_cron_lines("disable")
+
+    def _modify_cron_lines(self, action):  # type: (str) -> bool
+        """Helper to enable, disable, or uninstall cron lines"""
+        crontext = try_run(["crontab", "-l"], logger=self.logger)
+        if not crontext or self.KEY not in crontext:
+            self.logger.info("No crontab found")
+            return False
+
+        modified_lines = []
+        for line in crontext.rstrip("\n").splitlines():
+            if self.KEY not in line:
+                modified_lines.append(line)
+            elif action == "uninstall":
+                continue  # Skip DDNS lines (remove them)
+            elif action == "enable" and line.strip().startswith("#"):
+                uncommented = line.lstrip(" #\t").lstrip()  # Enable: uncomment the line
+                modified_lines.append(uncommented if uncommented else line)
+            elif action == "disable" and not line.strip().startswith("#"):
+                modified_lines.append("# " + line)  # Disable: comment the line
+            else:
+                raise ValueError("Invalid action: {}".format(action))
+
+        if self._update_crontab(modified_lines):
+            return True
+        else:
+            self.logger.error("Failed to %s DDNS cron job", action)
+            return False

ddns/scheduler/launchd.py

@@ -0,0 +1,130 @@
+# -*- coding:utf-8 -*-
+"""
+macOS launchd-based task scheduler
+@author: NewFuture
+"""
+
+import os
+import re
+
+from ..util.fileio import read_file_safely, write_file
+from ..util.try_run import try_run
+from ._base import BaseScheduler
+
+
+class LaunchdScheduler(BaseScheduler):
+    """macOS launchd-based task scheduler"""
+
+    LABEL = "cc.newfuture.ddns"
+
+    def _get_plist_path(self):
+        return os.path.expanduser("~/Library/LaunchAgents/{}.plist".format(self.LABEL))
+
+    def is_installed(self):
+        return os.path.exists(self._get_plist_path())
+
+    def get_status(self):
+        # Read plist content once and use it to determine installation status
+        content = read_file_safely(self._get_plist_path())
+        status = {"scheduler": "launchd", "installed": bool(content)}
+        if not content:
+            return status
+
+        # For launchd, check if service is actually loaded/enabled
+        result = try_run(["launchctl", "list"], logger=self.logger)
+        status["enabled"] = bool(result) and self.LABEL in result
+
+        # Get interval
+        interval_match = re.search(r"<key>StartInterval</key>\s*<integer>(\d+)</integer>", content)
+        status["interval"] = int(interval_match.group(1)) // 60 if interval_match else None
+
+        # Get command
+        program_match = re.search(r"<key>Program</key>\s*<string>([^<]+)</string>", content)
+        if program_match:
+            status["command"] = program_match.group(1)
+        else:
+            args_section = re.search(r"<key>ProgramArguments</key>\s*<array>(.*?)</array>", content, re.DOTALL)
+            if args_section:
+                strings = re.findall(r"<string>([^<]+)</string>", args_section.group(1))
+                if strings:
+                    status["command"] = " ".join(strings)
+
+        # Get comments
+        desc_match = re.search(r"<key>Description</key>\s*<string>([^<]+)</string>", content)
+        status["description"] = desc_match.group(1) if desc_match else None
+
+        return status
+
+    def install(self, interval, ddns_args=None):
+        plist_path = self._get_plist_path()
+        program_args = self._build_ddns_command(ddns_args)
+
+        # Create comment with version and install date (consistent with Windows)
+        comment = self._get_description()
+
+        # Generate plist XML using template string for proper macOS plist format
+        program_args_xml = "".join("        <string>{}</string>\n".format(arg) for arg in program_args)
+
+        plist_content = """<?xml version="1.0" encoding="UTF-8"?>
+<plist version="1.0">
+<dict>
+    <key>Label</key>
+    <string>{label}</string>
+    <key>Description</key>
+    <string>{description}</string>
+    <key>ProgramArguments</key>
+    <array>{program}</array>
+    <key>StartInterval</key>
+    <integer>{interval}</integer>
+    <key>RunAtLoad</key>
+    <true/>
+    <key>WorkingDirectory</key>
+    <string>{dir}</string>
+</dict>
+</plist>""".format(
+            label=self.LABEL, description=comment, program=program_args_xml, interval=interval * 60, dir=os.getcwd()
+        )
+
+        write_file(plist_path, plist_content)
+        result = try_run(["launchctl", "load", plist_path], logger=self.logger)
+        if result is not None:
+            self.logger.info("DDNS launchd service installed successfully")
+            return True
+        else:
+            self.logger.error("Failed to load launchd service")
+            return False
+
+    def uninstall(self):
+        plist_path = self._get_plist_path()
+        try_run(["launchctl", "unload", plist_path], logger=self.logger)  # Ignore errors
+        try:
+            os.remove(plist_path)
+        except OSError:
+            pass
+
+        self.logger.info("DDNS launchd service uninstalled successfully")
+        return True
+
+    def enable(self):
+        plist_path = self._get_plist_path()
+        if not os.path.exists(plist_path):
+            self.logger.error("DDNS launchd service not found")
+            return False
+
+        result = try_run(["launchctl", "load", plist_path], logger=self.logger)
+        if result is not None:
+            self.logger.info("DDNS launchd service enabled successfully")
+            return True
+        else:
+            self.logger.error("Failed to enable launchd service")
+            return False
+
+    def disable(self):
+        plist_path = self._get_plist_path()
+        result = try_run(["launchctl", "unload", plist_path], logger=self.logger)
+        if result is not None:
+            self.logger.info("DDNS launchd service disabled successfully")
+            return True
+        else:
+            self.logger.error("Failed to disable launchd service")
+            return False

ddns/scheduler/schtasks.py

@@ -0,0 +1,120 @@
+# -*- coding:utf-8 -*-
+"""
+schtasks-based task scheduler
+@author: NewFuture
+"""
+
+import os
+import re
+import tempfile
+
+from ..util.try_run import try_run
+from ._base import BaseScheduler
+
+
+class SchtasksScheduler(BaseScheduler):
+    """schtasks-based task scheduler"""
+
+    NAME = "DDNS"
+
+    def _schtasks(self, *args):
+        """Helper to run schtasks commands with consistent error handling"""
+        result = try_run(["schtasks"] + list(args), logger=self.logger)
+        return result is not None
+
+    def _extract_xml(self, xml_text, tag_name):
+        """Extract XML tag content using regex for better performance and flexibility"""
+        pattern = r"<{0}[^>]*>(.*?)</{0}>".format(re.escape(tag_name))
+        match = re.search(pattern, xml_text, re.DOTALL)
+        return match.group(1).strip() if match else None
+
+    def is_installed(self):
+        result = try_run(["schtasks", "/query", "/tn", self.NAME], logger=self.logger) or ""
+        return self.NAME in result
+
+    def get_status(self):
+        # Use XML format for language-independent parsing
+        task_xml = try_run(["schtasks", "/query", "/tn", self.NAME, "/xml"], logger=self.logger)
+        status = {"scheduler": "schtasks", "installed": bool(task_xml)}
+
+        if not task_xml:
+            return status  # Task not installed, return minimal status
+
+        status["enabled"] = self._extract_xml(task_xml, "Enabled") != "false"
+        command = self._extract_xml(task_xml, "Command")
+        arguments = self._extract_xml(task_xml, "Arguments")
+        status["command"] = "{} {}".format(command, arguments) if command and arguments else command
+
+        # Parse interval: PT10M -> 10, fallback to original string
+        interval_str = self._extract_xml(task_xml, "Interval")
+        interval_match = re.search(r"PT(\d+)M", interval_str) if interval_str else None
+        status["interval"] = int(interval_match.group(1)) if interval_match else interval_str
+
+        # Show description if exists, otherwise show installation date
+        description = self._extract_xml(task_xml, "Description") or self._extract_xml(task_xml, "Date")
+        if description:
+            status["description"] = description
+        return status
+
+    def install(self, interval, ddns_args=None):
+        # Build command line as array: prefer pythonw for script mode, or compiled exe directly
+        cmd_array = self._build_ddns_command(ddns_args)
+        workdir = os.getcwd()
+
+        # Split array into executable and arguments for schtasks XML format
+        # For Windows scheduler, prefer pythonw.exe to avoid console window
+        executable = cmd_array[0].replace("python.exe", "pythonw.exe")
+        arguments = self._quote_command_array(cmd_array[1:]) if len(cmd_array) > 1 else ""
+
+        # Create XML task definition with working directory support
+        description = self._get_description()
+
+        # Use template string to generate Windows Task Scheduler XML
+        xml_content = """<?xml version="1.0" encoding="UTF-16"?>
+<Task version="1.2" xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task">
+  <RegistrationInfo>
+    <Description>{description}</Description>
+  </RegistrationInfo>
+  <Triggers>
+    <TimeTrigger>
+      <StartBoundary>1900-01-01T00:00:00</StartBoundary>
+      <Repetition>
+        <Interval>PT{interval}M</Interval>
+      </Repetition>
+      <Enabled>true</Enabled>
+    </TimeTrigger>
+  </Triggers>
+  <Actions>
+    <Exec>
+      <Command>{exe}</Command>
+      <Arguments>{arguments}</Arguments>
+      <WorkingDirectory>{dir}</WorkingDirectory>
+    </Exec>
+  </Actions>
+  <Settings>
+    <MultipleInstancesPolicy>IgnoreNew</MultipleInstancesPolicy>
+    <DisallowStartIfOnBatteries>false</DisallowStartIfOnBatteries>
+    <StopIfGoingOnBatteries>false</StopIfGoingOnBatteries>
+  </Settings>
+</Task>""".format(description=description, interval=interval, exe=executable, arguments=arguments, dir=workdir)
+
+        # Write XML to temp file and use it to create task
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".xml", delete=False) as f:
+            f.write(xml_content)
+            xml_file = f.name
+
+        try:
+            success = self._schtasks("/Create", "/XML", xml_file, "/TN", self.NAME, "/F")
+            return success
+        finally:
+            os.unlink(xml_file)
+
+    def uninstall(self):
+        success = self._schtasks("/Delete", "/TN", self.NAME, "/F")
+        return success
+
+    def enable(self):
+        return self._schtasks("/Change", "/TN", self.NAME, "/Enable")
+
+    def disable(self):
+        return self._schtasks("/Change", "/TN", self.NAME, "/Disable")

ddns/scheduler/systemd.py

@@ -0,0 +1,139 @@
+# -*- coding:utf-8 -*-
+"""
+Systemd timer-based task scheduler for Linux
+@author: NewFuture
+"""
+
+import os
+import re
+
+from ..util.fileio import read_file_safely, write_file
+from ..util.try_run import try_run
+from ._base import BaseScheduler
+
+try:  # python 3
+    PermissionError  # type: ignore
+except NameError:  # python 2 doesn't have PermissionError, use OSError instead
+    PermissionError = IOError
+
+
+class SystemdScheduler(BaseScheduler):
+    """Systemd timer-based task scheduler for Linux"""
+
+    SERVICE_NAME = "ddns.service"
+    TIMER_NAME = "ddns.timer"
+    SERVICE_PATH = "/etc/systemd/system/ddns.service"
+    TIMER_PATH = "/etc/systemd/system/ddns.timer"
+
+    def _systemctl(self, *args):
+        """Run systemctl command and return success status"""
+        result = try_run(["systemctl"] + list(args), logger=self.logger)
+        return result is not None
+
+    def is_installed(self):
+        """Check if systemd timer files exist"""
+        return os.path.exists(self.SERVICE_PATH) and os.path.exists(self.TIMER_PATH)
+
+    def get_status(self):
+        """Get comprehensive status information"""
+        installed = self.is_installed()
+        status = {"scheduler": "systemd", "installed": installed}
+        if not installed:
+            return status
+
+        # Check if timer is enabled
+        result = try_run(["systemctl", "is-enabled", self.TIMER_NAME], logger=self.logger)
+        status["enabled"] = bool(result and result.strip() == "enabled")
+
+        # Extract interval from timer file
+        timer_content = read_file_safely(self.TIMER_PATH) or ""
+        match = re.search(r"OnUnitActiveSec=(\d+)m", timer_content)
+        status["interval"] = int(match.group(1)) if match else None
+
+        # Extract command and description from service file
+        service_content = read_file_safely(self.SERVICE_PATH) or ""
+        match = re.search(r"ExecStart=(.+)", service_content)
+        status["command"] = match.group(1).strip() if match else None
+        desc_match = re.search(r"Description=(.+)", service_content)
+        status["description"] = desc_match.group(1).strip() if desc_match else None
+
+        return status
+
+    def install(self, interval, ddns_args=None):
+        """Install systemd timer with specified interval"""
+        ddns_commands = self._build_ddns_command(ddns_args)
+        # Convert array to properly quoted command string for ExecStart
+        ddns_command = self._quote_command_array(ddns_commands)
+        work_dir = os.getcwd()
+        description = self._get_description()
+
+        # Create service file content
+        service_content = u"""[Unit]
+Description={}
+After=network.target
+
+[Service]
+Type=oneshot
+WorkingDirectory={}
+ExecStart={}
+""".format(description, work_dir, ddns_command)  # fmt: skip
+
+        # Create timer file content
+        timer_content = u"""[Unit]
+Description=DDNS automatic IP update timer
+Requires={}
+
+[Timer]
+OnUnitActiveSec={}m
+Unit={}
+
+[Install]
+WantedBy=multi-user.target
+""".format(self.SERVICE_NAME, interval, self.SERVICE_NAME)  # fmt: skip
+
+        try:
+            # Write service and timer files
+            write_file(self.SERVICE_PATH, service_content)
+            write_file(self.TIMER_PATH, timer_content)
+        except PermissionError as e:
+            self.logger.debug("Permission denied when writing systemd files: %s", e)
+            print("Permission denied. Please run as root or use sudo.")
+            print("or use cron scheduler (with --scheduler=cron) instead.")
+            return False
+        except Exception as e:
+            self.logger.error("Failed to write systemd files: %s", e)
+            return False
+
+        if self._systemctl("daemon-reload") and self._systemctl("enable", self.TIMER_NAME):
+            self._systemctl("start", self.TIMER_NAME)
+            return True
+        else:
+            self.logger.error("Failed to enable/start systemd timer")
+            return False
+
+    def uninstall(self):
+        """Uninstall systemd timer and service"""
+        self.disable()  # Stop and disable timer
+        # Remove systemd files
+        try:
+            os.remove(self.SERVICE_PATH)
+            os.remove(self.TIMER_PATH)
+            self._systemctl("daemon-reload")  # Reload systemd configuration
+            return True
+
+        except PermissionError as e:
+            self.logger.debug("Permission denied when removing systemd files: %s", e)
+            print("Permission denied. Please run as root or use sudo.")
+            return False
+        except Exception as e:
+            self.logger.error("Failed to remove systemd files: %s", e)
+            return False
+
+    def enable(self):
+        """Enable and start systemd timer"""
+        return self._systemctl("enable", self.TIMER_NAME) and self._systemctl("start", self.TIMER_NAME)
+
+    def disable(self):
+        """Disable and stop systemd timer"""
+        self._systemctl("stop", self.TIMER_NAME)
+        return self._systemctl("disable", self.TIMER_NAME)

ddns/util/fileio.py

@@ -23,7 +23,7 @@ def _ensure_directory_exists(file_path):  # type: (str) -> None
         os.makedirs(directory)
 
 
-def read_file_safely(file_path, encoding="utf-8", default=None):  # type: (str, str, str|None) -> str | None
+def read_file_safely(file_path, encoding="utf-8", default=None):  # type: (str, str, str|None) -> str
     """
     Safely read file content with UTF-8 encoding, return None if file doesn't exist or can't be read
 
@@ -37,7 +37,7 @@ def read_file_safely(file_path, encoding="utf-8", default=None):  # type: (str,
     try:
         return read_file(file_path, encoding)
     except Exception:
-        return default
+        return default  # type: ignore
 
 
 def write_file_safely(file_path, content, encoding="utf-8"):  # type: (str, str, str) -> bool

ddns/util/try_run.py

@@ -0,0 +1,37 @@
+# -*- coding:utf-8 -*-
+"""
+Utility: Safe command execution wrapper used across the project.
+Provides a single try_run function with consistent behavior.
+"""
+
+import subprocess
+import sys
+
+
+def try_run(command, logger=None, **kwargs):
+    # type: (list, object, **object) -> str | None
+    """Safely run a subprocess command and return decoded output or None on failure.
+
+    Args:
+        command (list): Command array to execute
+        logger (object, optional): Logger instance for debug output
+        **kwargs: Additional arguments passed to subprocess.check_output
+
+    Returns:
+        str or None: Command output as string, or None if command failed
+
+    - Adds a default timeout=60s on Python 3 to avoid hangs
+    - Decodes output as text via universal_newlines=True
+    - Logs at debug level when logger is provided
+    """
+    try:
+        if sys.version_info[0] >= 3 and "timeout" not in kwargs:
+            kwargs["timeout"] = 60
+        return subprocess.check_output(command, universal_newlines=True, **kwargs)  # type: ignore
+    except Exception as e:  # noqa: BLE001 - broad for subprocess safety
+        if logger is not None:
+            try:
+                logger.debug("Command failed: %s", e)  # type: ignore
+            except Exception:
+                pass
+        return None

{ddns-4.1.0b3.dist-info → ddns-4.1.1b1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ddns
-Version: 4.1.0b3
+Version: 4.1.1b1
 Summary: Dynamic DNS client for multiple providers, supporting IPv4 and IPv6.
 Author-email: NewFuture <python@newfuture.cc>
 License-Expression: MIT
@@ -138,7 +138,7 @@ Dynamic: license-file
   也可使用一键安装脚本自动下载并安装对应平台的二进制：
 
   ```bash
-  curl -fSL https://ddns.newfuture.cc/install.sh | sh
+  curl -#fSL https://ddns.newfuture.cc/install.sh | sh
   ```
   提示：安装到系统目录（如 /usr/local/bin）可能需要 root 或 sudo 权限；若权限不足，可改为 `sudo sh` 运行。