fix edge of provider record changing without client changing.

Author: mitjohnson

src/pyddns/config.py

@@ -79,6 +79,4 @@ def get(self, section: str, option: str) -> str:
         if self.config.has_option(section, option):
             return self.config.get(section, option)
 
-        else:
-
-            raise KeyError(f"Option '{option}' not found in section '{section}'.")
+        raise KeyError(f"Option '{option}' not found in section '{section}'.")

src/pyddns/services/cloudflare_service.py

@@ -6,6 +6,7 @@
 the current IP address, leveraging the Cloudflare API.
 """
 import logging
+import socket
 from typing import Callable, Optional, Any, Tuple
 from datetime import datetime
 
@@ -90,6 +91,7 @@ def _obtain_record(self, record_name: str) -> Optional[Tuple[str, datetime, Opti
             record.name or 'domain': record for record in result
             }
 
+
         domain_record = records.get(record_name)
 
         if domain_record is None:
@@ -103,46 +105,120 @@ def _obtain_record(self, record_name: str) -> Optional[Tuple[str, datetime, Opti
         return self.storage.retrieve_record(record_name)
 
     @cf_error_handler
-    def update_dns(self, ip_address: str, record_name: Optional[str] = None) -> None:
+    def check_cloudflare_ip(self, record_name: str) -> Optional[str]:
+        """
+        Checks the A record IP address in cloudflare utilizing the API
 
-        """ 
-        Updates IP address for specified record 
+        This is recomended if you have a proxied connection.
+        """
 
-        Automatically infers record_name if it is defined in the ddns.ini file.
+        if record_name is None:
+            logging.error("CloudFlare DNS: In _obtain_record: Record_name not provided.")
+            raise ValueError("CloudFlare DNS: Record name cannot be None")
+
+        response = self.storage.retrieve_record(record_name)
+
+        if not response:
+            response = self._obtain_record(record_name)
+
+        record_id = response[2]
+        api_res = self.cf_client.dns.records.get(zone_id=self.zone_id, dns_record_id=record_id)
+
+        if not api_res:
+            logging.error("Cloudflare DNS: API call failed.")
+            return None
+
+        return api_res.content
+
+    def cloudflare_dns_lookup(self, record_name: str) -> str:
+        """
+        Performs a DNS lookup for the record name for Cloudflare.
+
+        This will not return the correct IP if you have a proxied connection.
         """
-        record_name = record_name or self.config.get(self.service_name,'record_name')
+        logging.debug("CloudFlare DNS: Performing DNS lookup for %s", record_name)
+        return socket.gethostbyname(record_name)
+
+    def check_and_update_dns(self, record_name: Optional[str] = None) -> None:
+        """
+        Compares the actual Cloudflare A record with the local database record. 
+        If they are different, updates Cloudflare with the current IP address.
+        """
+        record_name = record_name or self.config.get(self.service_name, 'record_name')
 
         if not record_name:
             raise ValueError("CloudFlare DNS: Record name cannot be None")
 
-        logging.debug("CloudFlare DNS: Preparing to uppdate %s with IP:", record_name)
+        logging.debug("CloudFlare DNS: Checking current IP for %s", record_name)
+        cloudflare_ip = self.check_cloudflare_ip(record_name)
+        logging.debug("CloudFlare DNS: Current IP for %s is %s", record_name, cloudflare_ip)
 
         record: Optional[Tuple[str, datetime, str]] = self._obtain_record(record_name)
 
         if not record:
             logging.error("CloudFlare DNS: No record found for %s.", record_name)
             return
 
-        current_ip: str = record[0]
-        record_id: str = record[2]
+        current_ip = self.get_ipv4()
+        db_ip = record[0]
+        logging.debug("CloudFlare DNS: IP from database is %s", db_ip)
 
-        if current_ip == ip_address:
+        if current_ip != db_ip:
             logging.info(
-                "CloudFlare DNS: No update needed for %s - IP is already %s.",
-                record_name, ip_address
+                "CloudFlare DNS: Local IP has changed from %s to %s, updating Cloudflare.",
+                db_ip, current_ip
             )
+            self.update_dns(current_ip, record_name)
             return
 
+        if db_ip != cloudflare_ip:
+            logging.info(
+                "CloudFlare DNS: A record has changed from %s to %s for %s, updating Cloudflare",
+                db_ip, cloudflare_ip, record_name
+            )
+            self.update_dns(current_ip, record_name)
+            return
+
+        logging.info(
+            "CloudFlare DNS: No update needed for %s - IP is still %s",
+            record_name, db_ip
+        )
+        return
+
+    @cf_error_handler
+    def update_dns(self, ip_address: str, record_name: Optional[str] = None) -> None:
+        """ 
+        Updates IP address for specified record 
+        Automatically infers record_name if it is defined in the ddns.ini file.
+        """
+        record_name = record_name or self.config.get(self.service_name, 'record_name')
+
+        if not record_name:
+            raise ValueError("CloudFlare DNS: Record name cannot be None")
+
+        logging.info("CloudFlare DNS: Preparing to update %s with IP: %s", record_name, ip_address)
+
+        record: Optional[Tuple[str, datetime, str]] = self._obtain_record(record_name)
+
+        if not record:
+            logging.error("CloudFlare DNS: No record found for %s.", record_name)
+            return
+
+        record_id: str = record[2]
+
+        comment = f"Updated on {datetime.now()} by py_ddns."
         response = self.cf_client.dns.records.update(
-            content = ip_address,
-            zone_id = self.zone_id,
-            name = record_name or NOT_GIVEN,
-            dns_record_id = record_id,
-            comment= f"Updated on {datetime.now()} by py_ddns.",
+            content=ip_address,
+            zone_id=self.zone_id,
+            type="A",
+            proxied=True,
+            name=record_name or NOT_GIVEN,
+            dns_record_id=record_id,
+            comment=comment,
         )
 
         if response is None:
-            logging.error("CloudFlare DNS: No response recienved from cloudflare.")
+            logging.error("CloudFlare DNS: No response received from Cloudflare.")
             return
 
         self.storage.update_ip(self.service_name, record_name, response.content)

src/pyddns/services/duckdns_service.py

@@ -74,8 +74,8 @@ def _parse_domain_name(self, record_name: str) -> str:
 
         if record_name.endswith('.duckdns.org'):
             return record_name[:-len('.duckdns.org')]
-        else:
-            return record_name
+
+        return record_name
 
     def _parse_api_response(self, response: str) -> Tuple[str, Optional[str], Optional[str], str]:
         """
@@ -96,58 +96,79 @@ def _parse_api_response(self, response: str) -> Tuple[str, Optional[str], Option
 
     def check_duckdns_ip(self, record_name: str) -> str:
         """
-        Checks the current IP address for DuckDNS
+        Performs a DNS lookup for record name for DuckDNS
         """
         logging.debug("DuckDNS: Performing DNS lookup for %s", record_name)
         return socket.gethostbyname(f"{self._parse_domain_name(record_name)}.duckdns.org")
 
-    def update_dns(self, ip_address: str, record_name: Optional[str] = None) -> None:
+    def check_and_update_dns(self, record_name: Optional[str] = None) -> None:
         """
-        Updates the IP address for DuckDNS, and then updates the IP adress in the database.
+        Compares the actual DuckDNS A record with the local database record. 
+        If they are different, updates DuckDNS with the current IP address.
         """
-
         record_name = record_name or self.config.get(self.service_name, 'domains')
         record_name = self._parse_domain_name(record_name)
 
         if not record_name:
             raise ValueError("DuckDNS: Record name cannot be None")
 
-        logging.debug(
-            "DuckDNS: Preparing to update DuckDNS for %s.duckdns.org with IP: %s",
-            record_name, ip_address
-        )
+        logging.debug("DuckDNS: Checking current IP for %s", record_name)
+        duck_ip = self.check_duckdns_ip(record_name)
+        logging.debug("DuckDNS: Current IP for %s is %s", record_name, duck_ip)
+
         record = self._obtain_record(record_name)
 
         if not record:
             logging.error("DuckDNS: No record found for %s.", record_name)
             return
 
-        current_ip = record[0]
+        current_ip = self.get_ipv4()
+        db_ip = record[0]
+        logging.debug("DuckDNS: IP from database is %s", db_ip)
+
+        if current_ip != db_ip:
+            logging.info("IP has changed from %s to %s, updating DuckDNS.", current_ip, db_ip)
+            self.update_dns(current_ip, record_name)
+            return
 
-        if current_ip == ip_address:
+        if db_ip != duck_ip:
             logging.info(
-                "DuckDNS: No update needed for %s.duckdns.org - Current IP is already %s.",
-                record_name, ip_address
+                "DuckDNS: A record has changed from %s to %s for %s, updating DuckDNS",
+                db_ip, duck_ip, record_name
             )
+            self.update_dns(current_ip, record_name)
             return
 
+        logging.info("DuckDNS: No update needed for %s - IP is still %s", record_name, db_ip)
+
+    def update_dns(self, ip_address: str, record_name: Optional[str] = None) -> None:
+        """
+        Updates the IP address for DuckDNS in the database.
+        This method assumes that the IP address has already been verified to be different.
+        """
+        record_name = record_name or self.config.get(self.service_name, 'domains')
+        record_name = self._parse_domain_name(record_name)
+
+        if not record_name:
+            raise ValueError("DuckDNS: Record name cannot be None")
+
         payload = {
             "domains": f"{record_name}.duckdns.org",
             "token": self.token,
             "ip": ip_address,
             "verbose": 'true'
         }
-        try:
 
+        try:
             logging.debug("DuckDNS: Making API call to %s with parameters %s", self.url, payload)
-            response = requests.get(self.url, params = payload, timeout=10)
+            response = requests.get(self.url, params=payload, timeout=10)
             response.raise_for_status()
 
             ipv4 = self._parse_api_response(response.text)[1]
-            logging.debug("DuckDNS: Recieved %s from DuckDNS API.", response.text)
+            logging.debug("DuckDNS: Received %s from DuckDNS API.", response.text)
 
             self.storage.update_ip(self.service_name, self._parse_domain_name(record_name), ipv4)
-            logging.info("DuckDNS:  Updated %s to %s.", ip_address, ipv4)
+            logging.info("DuckDNS: Updated %s to %s.", ip_address, ipv4)
 
         except requests.HTTPError as err:
             logging.error("DuckDNS: API Call %s", err)
@@ -158,4 +179,3 @@ def update_dns(self, ip_address: str, record_name: Optional[str] = None) -> None
         except Exception as err:
             logging.error("DuckDNS: API Call %s", err)
             raise
-