ddns 4.1.0b1__py2.py3-none-any.whl → 4.1.0b2__py2.py3-none-any.whl

ddns/provider/aliesa.py

@@ -0,0 +1,129 @@
+# coding=utf-8
+"""
+AliESA API
+阿里云边缘安全加速(ESA) DNS 解析操作库
+@author: NewFuture, GitHub Copilot
+"""
+
+from .alidns import AliBaseProvider
+from ._base import join_domain, TYPE_JSON
+from time import strftime
+
+
+class AliesaProvider(AliBaseProvider):
+    """阿里云边缘安全加速(ESA) DNS Provider"""
+
+    endpoint = "https://esa.cn-hangzhou.aliyuncs.com"
+    api_version = "2024-09-10"  # ESA API版本
+    content_type = TYPE_JSON
+    remark = "Managed by DDNS %s" % strftime("%Y-%m-%d %H:%M:%S")
+
+    def _query_zone_id(self, domain):
+        # type: (str) -> str | None
+        """
+        查询站点ID
+        https://help.aliyun.com/zh/edge-security-acceleration/esa/api-esa-2024-09-10-listsites
+        """
+        res = self._request(method="GET", action="ListSites", SiteName=domain, PageSize=500)
+        sites = res.get("Sites", [])
+
+        for site in sites:
+            if site.get("SiteName") == domain:
+                site_id = site.get("SiteId")
+                self.logger.debug("Found site ID %s for domain %s", site_id, domain)
+                return site_id
+
+        self.logger.error("Site not found for domain: %s", domain)
+        return None
+
+    def _query_record(self, zone_id, subdomain, main_domain, record_type, line, extra):
+        # type: (str, str, str, str, str | None, dict) -> dict | None
+        """
+        查询DNS记录
+        https://help.aliyun.com/zh/edge-security-acceleration/esa/api-esa-2024-09-10-listrecords
+        """
+        full_domain = join_domain(subdomain, main_domain)
+        res = self._request(
+            method="GET",
+            action="ListRecords",
+            SiteId=int(zone_id),
+            RecordName=full_domain,
+            Type=self._get_type(record_type),
+            RecordMatchType="exact",  # 精确匹配
+            PageSize=100,
+        )
+
+        records = res.get("Records", [])
+        if len(records) == 0:
+            self.logger.warning("No records found for [%s] with %s <%s>", zone_id, full_domain, record_type)
+            return None
+
+        # 返回第一个匹配的记录
+        record = records[0]
+        self.logger.debug("Found record: %s", record)
+        return record
+
+    def _create_record(self, zone_id, subdomain, main_domain, value, record_type, ttl, line, extra):
+        # type: (str, str, str, str, str, int | str | None, str | None, dict) -> bool
+        """
+        创建DNS记录
+        https://help.aliyun.com/zh/edge-security-acceleration/esa/api-esa-2024-09-10-createrecord
+        """
+        full_domain = join_domain(subdomain, main_domain)
+        extra["Comment"] = extra.get("Comment", self.remark)
+        extra["BizName"] = extra.get("BizName", "web")
+        extra["Proxied"] = extra.get("Proxied", True)
+        data = self._request(
+            method="POST",
+            action="CreateRecord",
+            SiteId=int(zone_id),
+            RecordName=full_domain,
+            Type=self._get_type(record_type),
+            Data={"Value": value},
+            Ttl=ttl or 1,
+            **extra
+        )
+
+        if data and data.get("RecordId"):
+            self.logger.info("Record created: %s", data)
+            return True
+
+        self.logger.error("Failed to create record: %s", data)
+        return False
+
+    def _update_record(self, zone_id, old_record, value, record_type, ttl, line, extra):
+        # type: (str, dict, str, str, int | str | None, str | None, dict) -> bool
+        """
+        更新DNS记录
+        https://help.aliyun.com/zh/edge-security-acceleration/esa/api-esa-2024-09-10-updaterecord
+        """
+        # 检查是否需要更新
+        if (
+            old_record.get("Data", {}).get("Value") == value
+            and old_record.get("RecordType") == self._get_type(record_type)
+            and (not ttl or old_record.get("Ttl") == ttl)
+        ):
+            self.logger.warning("No changes detected, skipping update for record: %s", old_record.get("RecordName"))
+            return True
+
+        extra["Comment"] = extra.get("Comment", self.remark)
+        extra["Proxied"] = extra.get("Proxied", old_record.get("Proxied"))
+        data = self._request(
+            method="POST",
+            action="UpdateRecord",
+            RecordId=old_record.get("RecordId"),
+            Data={"Value": value},
+            Ttl=ttl,
+            **extra
+        )
+
+        if data and data.get("RecordId"):
+            self.logger.info("Record updated: %s", data)
+            return True
+
+        self.logger.error("Failed to update record: %s", data)
+        return False
+
+    def _get_type(self, record_type):
+        # type: (str) -> str
+        return "A/AAAA" if record_type in ("A", "AAAA") else record_type

ddns/provider/callback.py

@@ -16,7 +16,7 @@ class CallbackProvider(SimpleProvider):
     Generic custom callback provider, supports GET/POST arbitrary API.
     """
 
-    API = ""  # CallbackProvider uses auth_id as URL, no fixed API endpoint
+    endpoint = ""  # CallbackProvider uses id as URL, no fixed API endpoint
     content_type = TYPE_JSON
     decode_response = False  # Callback response is not JSON, it's a custom response
 
@@ -26,9 +26,8 @@ class CallbackProvider(SimpleProvider):
         Send custom callback request, support GET/POST
         """
         self.logger.info("%s => %s(%s)", domain, value, record_type)
-        url = self.auth_id  # 直接用 auth_id 作为 url
-        token = self.auth_token  # auth_token 作为 POST 参数
-        headers = {"User-Agent": "DDNS/{0} (ddns@newfuture.cc)".format(self.version)}
+        url = self.id  # 直接用 id 作为 url
+        token = self.token  # token 作为 POST 参数
         extra.update(
             {
                 "__DOMAIN__": domain,
@@ -51,7 +50,7 @@ class CallbackProvider(SimpleProvider):
                     params[k] = self._replace_vars(v, extra)
 
         try:
-            res = self._http(method, url, body=params, headers=headers)
+            res = self._http(method, url, body=params)
             if res is not None:
                 self.logger.info("Callback result: %s", res)
                 return True
@@ -72,8 +71,8 @@ class CallbackProvider(SimpleProvider):
         return string
 
     def _validate(self):
-        # CallbackProvider uses auth_id as URL, not as regular ID
-        if not self.auth_id or "://" not in self.auth_id:
-            self.logger.critical("callback ID 参数[%s] 必须是有效的URL", self.auth_id)
-            raise ValueError("id must be configured with URL")
-        # CallbackProvider doesn't need auth_token validation (it can be empty)
+        # CallbackProvider uses id as URL, not as regular ID
+        if self.endpoint or (not self.id or "://" not in self.id):
+            # 如果 endpoint 已经设置，或者 id 不是有效的 URL，则抛出异常
+            self.logger.critical("endpoint [%s] or id [%s] 必须是有效的URL", self.endpoint, self.id)
+            raise ValueError("endpoint or id must be configured with URL")

ddns/provider/cloudflare.py

@@ -8,26 +8,26 @@ from ._base import BaseProvider, TYPE_JSON, join_domain
 
 
 class CloudflareProvider(BaseProvider):
-    API = "https://api.cloudflare.com"
+    endpoint = "https://api.cloudflare.com"
     content_type = TYPE_JSON
 
     def _validate(self):
-        if not self.auth_token:
+        if not self.token:
             raise ValueError("token must be configured")
-        if self.auth_id:
+        if self.id:
             # must be email for Cloudflare API v4
-            if "@" not in self.auth_id:
+            if "@" not in self.id:
                 self.logger.critical("ID 必须为空或有效的邮箱地址")
                 raise ValueError("ID must be a valid email or Empty for Cloudflare API v4")
 
     def _request(self, method, action, **params):
         """发送请求数据"""
         headers = {}
-        if self.auth_id:
-            headers["X-Auth-Email"] = self.auth_id
-            headers["X-Auth-Key"] = self.auth_token
+        if self.id:
+            headers["X-Auth-Email"] = self.id
+            headers["X-Auth-Key"] = self.token
         else:
-            headers["Authorization"] = "Bearer " + self.auth_token
+            headers["Authorization"] = "Bearer " + self.token
 
         params = {k: v for k, v in params.items() if v is not None}  # 过滤掉None参数
         data = self._http(method, "/client/v4/zones" + action, headers=headers, params=params)

ddns/provider/dnscom.py

@@ -5,7 +5,7 @@ www.51dns.com (原dns.com)
 @author: Bigjin<i@bigjin.com>, NewFuture
 """
 
-from ._base import BaseProvider, TYPE_FORM
+from ._base import BaseProvider, TYPE_FORM, encode_params
 from hashlib import md5
 from time import time
 
@@ -16,7 +16,7 @@ class DnscomProvider(BaseProvider):
     https://www.51dns.com/document/api/index.html
     """
 
-    API = "https://www.51dns.com"
+    endpoint = "https://www.51dns.com"
     content_type = TYPE_FORM
 
     def _validate(self):
@@ -31,12 +31,12 @@ class DnscomProvider(BaseProvider):
         params = {k: v for k, v in params.items() if v is not None}
         params.update(
             {
-                "apiKey": self.auth_id,
+                "apiKey": self.id,
                 "timestamp": time(),  # 时间戳
             }
         )
-        query = self._encode(sorted(params.items()))
-        sign = md5((query + self.auth_token).encode("utf-8")).hexdigest()
+        query = encode_params(params)
+        sign = md5((query + self.token).encode("utf-8")).hexdigest()
         params["hash"] = sign
         return params
 

ddns/provider/dnspod.py

@@ -14,7 +14,7 @@ class DnspodProvider(BaseProvider):
     DNSPOD 接口解析操作库
     """
 
-    API = "https://dnsapi.cn"
+    endpoint = "https://dnsapi.cn"
     content_type = TYPE_FORM
 
     DefaultLine = "默认"
@@ -36,9 +36,8 @@ class DnspodProvider(BaseProvider):
         if extra:
             params.update(extra)
         params = {k: v for k, v in params.items() if v is not None}
-        params.update({"login_token": "{0},{1}".format(self.auth_id, self.auth_token), "format": "json"})
-        headers = {"User-Agent": "DDNS/{0} (ddns@newfuture.cc)".format(self.version)}
-        data = self._http("POST", "/" + action, headers=headers, body=params)
+        params.update({"login_token": "{0},{1}".format(self.id, self.token), "format": "json"})
+        data = self._http("POST", "/" + action, body=params)
         if data and data.get("status", {}).get("code") == "1":  # 请求成功
             return data
         else:  # 请求失败

ddns/provider/dnspod_com.py

@@ -14,5 +14,5 @@ class DnspodComProvider(DnspodProvider):
     This class extends the DnspodProvider to use the global DNSPOD API.
     """
 
-    API = "https://api.dnspod.com"
+    endpoint = "https://api.dnspod.com"
     DefaultLine = "default"

ddns/provider/edgeone.py

@@ -0,0 +1,82 @@
+# coding=utf-8
+"""
+Tencent Cloud EdgeOne API
+腾讯云 EdgeOne (边缘安全速平台) API
+API Documentation: https://cloud.tencent.com/document/api/1552/80731
+@author: NewFuture
+"""
+from ddns.provider._base import join_domain
+from .tencentcloud import TencentCloudProvider
+
+
+class EdgeOneProvider(TencentCloudProvider):
+    """
+    腾讯云 EdgeOne API 提供商
+    Tencent Cloud EdgeOne API Provider
+    """
+
+    endpoint = "https://teo.tencentcloudapi.com"
+    # 腾讯云 EdgeOne API 配置
+    service = "teo"
+    version_date = "2022-09-01"
+
+    def _query_zone_id(self, domain):
+        # type: (str) -> str | None
+        """查询域名的加速域名信息获取 ZoneId https://cloud.tencent.com/document/api/1552/80713"""
+        # 首先尝试直接查找域名
+        filters = [{"Name": "zone-name", "Values": [domain], "Fuzzy": False}]  # type: Any
+        response = self._request("DescribeZones", Filters=filters)
+
+        if response and "Zones" in response:
+            for zone in response.get("Zones", []):
+                if zone.get("ZoneName") == domain:
+                    zone_id = zone.get("ZoneId")
+                    if zone_id:
+                        self.logger.debug("Found acceleration domain %s with Zone ID: %s", domain, zone_id)
+                        return zone_id
+
+        self.logger.debug("Acceleration domain not found for: %s", domain)
+        return None
+
+    def _query_record(self, zone_id, subdomain, main_domain, record_type, line, extra):
+        # type: (str, str, str, str, str | None, dict) -> dict | None
+        """查询加速域名信息 https://cloud.tencent.com/document/api/1552/86336"""
+        domain = join_domain(subdomain, main_domain)
+        filters = [{"Name": "domain-name", "Values": [domain], "Fuzzy": False}]  # type: Any
+        response = self._request("DescribeAccelerationDomains", ZoneId=zone_id, Filters=filters)
+
+        if response and "AccelerationDomains" in response:
+            for domain_info in response.get("AccelerationDomains", []):
+                if domain_info.get("DomainName") == domain:
+                    self.logger.debug("Found acceleration domain: %s", domain_info)
+                    return domain_info
+
+        self.logger.warning("No acceleration domain found for: %s, response: %s", domain, response)
+        return None
+
+    def _create_record(self, zone_id, subdomain, main_domain, value, record_type, ttl, line, extra):
+        # type: (str, str, str, str, str, int, str | None, dict) -> bool
+        """创建新的加速域名记录 https://cloud.tencent.com/document/api/1552/86338"""
+        domain = join_domain(subdomain, main_domain)
+        origin = {"OriginType": "IP_DOMAIN", "Origin": value}  # type: Any
+        res = self._request("CreateAccelerationDomain", ZoneId=zone_id, DomainName=domain, OriginInfo=origin, **extra)
+        if res:
+            self.logger.info("Acceleration domain created (%s)", res.get("RequestId"))
+            return True
+
+        self.logger.error("Failed to create acceleration domain, response: %s", res)
+        return False
+
+    def _update_record(self, zone_id, old_record, value, record_type, ttl, line, extra):
+        """更新加速域名的源站 IP 地址 https://cloud.tencent.com/document/api/1552/86335"""
+        domain = old_record.get("DomainName")
+        # 构建源站信息
+        backup = old_record.get("OriginDetail", {}).get("BackupOrigin", "")
+        origin = {"OriginType": "IP_DOMAIN", "Origin": value, "BackupOrigin": backup}  # type: Any
+        response = self._request("ModifyAccelerationDomain", ZoneId=zone_id, DomainName=domain, OriginInfo=origin)
+
+        if response:
+            self.logger.info("Acceleration domain updated (%s)", response.get("RequestId"))
+            return True
+        self.logger.error("Failed to update acceleration domain origin, response: %s", response)
+        return False

ddns/provider/he.py

@@ -8,7 +8,7 @@ from ._base import SimpleProvider, TYPE_FORM
 
 
 class HeProvider(SimpleProvider):
-    API = "https://dyn.dns.he.net"
+    endpoint = "https://dyn.dns.he.net"
     content_type = TYPE_FORM
     accept = None  # he.net does not require a specific Accept header
     decode_response = False  # he.net response is plain text, not JSON
@@ -18,9 +18,9 @@ class HeProvider(SimpleProvider):
             "HE.net 缺少充分的真实环境测试，请及时在 GitHub Issues 中反馈: %s",
             "https://github.com/NewFuture/DDNS/issues",
         )
-        if self.auth_id:
+        if self.id:
             raise ValueError("Hurricane Electric (he.net) does not use `id`, use `token(password)` only.")
-        if not self.auth_token:
+        if not self.token:
             raise ValueError("Hurricane Electric (he.net) requires `token(password)`.")
 
     def set_record(self, domain, value, record_type="A", ttl=None, line=None, **extra):
@@ -32,7 +32,7 @@ class HeProvider(SimpleProvider):
         params = {
             "hostname": domain,  # he.net requires full domain name
             "myip": value,  # IP address to update
-            "password": self.auth_token,  # Use auth_token as password
+            "password": self.token,  # Use token as password
         }
         try:
             res = self._http("POST", "/nic/update", body=params)

ddns/provider/huaweidns.py

@@ -5,13 +5,13 @@ HuaweiDNS API
 @author: NewFuture
 """
 
-from ._base import BaseProvider, TYPE_JSON, hmac_sha256_authorization, sha256_hash, join_domain
-from json import dumps as jsonencode
+from ._base import BaseProvider, TYPE_JSON, join_domain, encode_params
+from ._signature import hmac_sha256_authorization, sha256_hash
 from time import strftime, gmtime
 
 
 class HuaweiDNSProvider(BaseProvider):
-    API = "https://dns.myhuaweicloud.com"
+    endpoint = "https://dns.myhuaweicloud.com"
     content_type = TYPE_JSON
     algorithm = "SDK-HMAC-SHA256"
 
@@ -32,16 +32,16 @@ class HuaweiDNSProvider(BaseProvider):
         # type: (str, str, **Any) -> dict
         params = {k: v for k, v in params.items() if v is not None}
         if method.upper() == "GET" or method.upper() == "DELETE":
-            query = self._encode(sorted(params.items()))
+            query = encode_params(params)
             body = ""
         else:
             query = ""
-            body = jsonencode(params)
+            body = self._encode_body(params)
 
         now = strftime("%Y%m%dT%H%M%SZ", gmtime())
         headers = {
             "content-type": self.content_type,
-            "host": self.API.split("://", 1)[1].strip("/"),
+            "host": self.endpoint.split("://", 1)[1].strip("/"),
             "X-Sdk-Date": now,
         }
 
@@ -51,10 +51,10 @@ class HuaweiDNSProvider(BaseProvider):
         sign_path = path if path.endswith("/") else path + "/"
         authorization_format = "%s Access=%s, SignedHeaders={SignedHeaders}, Signature={Signature}" % (
             self.algorithm,
-            self.auth_id,
+            self.id,
         )
         authorization = hmac_sha256_authorization(
-            secret_key=self.auth_token,
+            secret_key=self.token,
             method=method,
             path=sign_path,
             query=query,

ddns/provider/namesilo.py

@@ -0,0 +1,159 @@
+# coding=utf-8
+"""
+NameSilo API Provider
+DNS provider implementation for NameSilo domain registrar
+@doc: https://www.namesilo.com/api-reference
+@author: NewFuture & Copilot
+"""
+
+from ._base import BaseProvider, TYPE_JSON
+
+
+class NamesiloProvider(BaseProvider):
+    """
+    NameSilo DNS API Provider
+
+    Supports DNS record management through NameSilo's API including:
+    - Domain information retrieval
+    - DNS record listing
+    - DNS record creation
+    - DNS record updating
+    """
+
+    endpoint = "https://www.namesilo.com"
+    content_type = TYPE_JSON
+
+    def _validate(self):
+        """Validate authentication credentials"""
+        # NameSilo only requires API key (token), not ID
+        if not self.token:
+            raise ValueError("API key (token) must be configured for NameSilo")
+        if not self.endpoint:
+            raise ValueError("API endpoint must be defined in {}".format(self.__class__.__name__))
+
+        # Warn if ID is configured since NameSilo doesn't need it
+        if self.id:
+            self.logger.warning("NameSilo does not require 'id' configuration - only API key (token) is needed")
+
+        # Show pending verification warning
+        self.logger.warning("NameSilo provider implementation is pending verification - please test thoroughly")
+
+    def _request(self, operation, **params):
+        # type: (str, **(str | int | bytes | bool | None)) -> dict|None
+        """
+        Send request to NameSilo API
+
+        Args:
+            operation (str): API operation name
+            params: API parameters
+
+        Returns:
+            dict: API response data
+        """
+        # Filter out None parameters
+        params = {k: v for k, v in params.items() if v is not None}
+
+        # Add required authentication and format parameters
+        params.update({"version": "1", "type": "json", "key": self.token})
+
+        # Make API request
+        response = self._http("GET", "/api/" + operation, queries=params)
+
+        # Parse response
+        if response and isinstance(response, dict):
+            reply = response.get("reply", {})
+
+            # Check for successful response
+            if reply.get("code") == "300":  # NameSilo success code
+                return reply
+            else:
+                # Log error details
+                error_msg = reply.get("detail", "Unknown error")
+                self.logger.warning("NameSilo API error [%s]: %s", reply.get("code", "unknown"), error_msg)
+
+        return None
+
+    def _query_zone_id(self, domain):
+        # type: (str) -> str | None
+        """
+        Query domain information to get domain as zone identifier
+        @doc: https://www.namesilo.com/api-reference#domains/get-domain-info
+        """
+        response = self._request("getDomainInfo", domain=domain)
+
+        if response:
+            # Domain exists, return the domain name as zone_id
+            domain_info = response.get("domain", {})
+            if domain_info:
+                self.logger.debug("Domain found: %s", domain)
+                return domain
+
+        self.logger.warning("Domain not found or not accessible: %s", domain)
+        return None
+
+    def _query_record(self, zone_id, subdomain, main_domain, record_type, line, extra):
+        # type: (str, str, str, str, str | None, dict) -> dict | None
+        """
+        Query existing DNS record
+        @doc: https://www.namesilo.com/api-reference#dns/list-dns-records
+        """
+        response = self._request("dnsListRecords", domain=main_domain)
+
+        if response:
+            records = response.get("resource_record", [])
+
+            # Find matching record
+            for record in records:
+                if record.get("host") == subdomain and record.get("type") == record_type:
+                    self.logger.debug("Found existing record: %s", record)
+                    return record
+
+        self.logger.debug("No matching record found for %s.%s (%s)", subdomain, main_domain, record_type)
+        return None
+
+    def _create_record(self, zone_id, subdomain, main_domain, value, record_type, ttl, line, extra):
+        # type: (str, str, str, str, str, int | str | None, str | None, dict) -> bool
+        """
+        Create new DNS record
+        @doc: https://www.namesilo.com/api-reference#dns/add-dns-record
+        """
+        response = self._request(
+            "dnsAddRecord", domain=main_domain, rrtype=record_type, rrhost=subdomain, rrvalue=value, rrttl=ttl
+        )
+
+        if response:
+            record_id = response.get("record_id")
+            self.logger.info("DNS record created successfully: %s", record_id)
+            return True
+        else:
+            self.logger.error("Failed to create DNS record")
+            return False
+
+    def _update_record(self, zone_id, old_record, value, record_type, ttl, line, extra):
+        # type: (str, dict, str, str, int | str | None, str | None, dict) -> bool
+        """
+        Update existing DNS record
+        @doc: https://www.namesilo.com/api-reference#dns/update-dns-record
+        """
+        record_id = old_record.get("record_id")
+        if not record_id:
+            self.logger.error("No record_id found in old_record: %s", old_record)
+            return False
+
+        # In NameSilo, zone_id is the main domain name
+        response = self._request(
+            "dnsUpdateRecord",
+            rrid=record_id,
+            domain=zone_id,  # zone_id is main_domain in NameSilo
+            rrhost=old_record.get("host"),  # host field contains subdomain
+            rrvalue=value,
+            rrtype=record_type,
+            rrttl=ttl or old_record.get("ttl"),
+        )
+
+        if response:
+            self.logger.info("DNS record updated successfully: %s", record_id)
+            return True
+        else:
+            self.logger.error("Failed to update DNS record")
+            return False