Introduction of the --dns-delay arg and logic.

Indeed, before this patch, user couldn't define the delay they want to
apply between each DNS queries.

Author: funilrys

PyFunceble/cli/entry_points/pyfunceble/argsparser.py

@@ -83,6 +83,9 @@ def parse_args(
         ):
             raise self.error("--max-workers must be a positive digit.")
 
+        if namespace.dns__delay is not None and namespace.dns__delay < 0:
+            raise self.error("--dns-delay must be zero or a positive digit.")
+
         if namespace.cli_decoding__adblock and namespace.cli_decoding__wildcard:
             raise self.error("--adblock and --wildcard are incompatible.")
 

PyFunceble/cli/entry_points/pyfunceble/cli.py

@@ -536,6 +536,17 @@ def get_dns_control_group_data() -> List[Tuple[List[str], dict]]:
                 % get_configured_value("dns.trust_server"),
             },
         ),
+        (
+            [
+                "--dns-delay",
+            ],
+            {
+                "dest": "dns.delay",
+                "type": float,
+                "help": "Sets the delay (in seconds) to apply between each DNS\n "
+                "queries.\n %s" % get_configured_value("dns.delay"),
+            },
+        ),
     ]
 
 

PyFunceble/data/infrastructure/.PyFunceble_production.yaml

@@ -243,6 +243,11 @@ dns:
   # Available: UDP | TCP | HTTPS | TLS
   protocol: UDP
 
+  # Sets the delay (seconds) to apply between each queries.
+  # When a value > 0.00000 is given, we will wait for the given amount of
+  # seconds between each queries.
+  delay: 0.0
+
 # Not Implemented yet. Reserved for future usage and implementation.
 share_logs: False
 

PyFunceble/query/dns/query_tool.py

@@ -83,9 +83,9 @@ class DNSQueryTool:
     STD_TIMEOUT: float = 5.0
     STD_FOLLOW_NAMESERVER_ORDER: bool = True
     STD_TRUST_SERVER: bool = False
+    STD_DELAY: float = 0.0
 
     SUPPORTED_PROTOCOL: List[str] = ["TCP", "UDP", "HTTPS", "TLS"]
-    BREAKOFF: float = 0.2
 
     value2rdata_type: Dict[int, str] = {
         x.value: x.name for x in dns.rdatatype.RdataType
@@ -102,6 +102,7 @@ class DNSQueryTool:
     _preferred_protocol: str = "UDP"
     _query_timeout: float = 5.0
     _trust_server: bool = False
+    _delay: float = 0.0
 
     dns_name: Optional[str] = None
 
@@ -115,6 +116,7 @@ def __init__(
         follow_nameserver_order: Optional[bool] = None,
         preferred_protocol: Optional[str] = None,
         trust_server: Optional[bool] = None,
+        delay: Optional[bool] = None,
     ) -> None:
         if nameservers is not None:
             self.nameservers.set_nameservers(nameservers)
@@ -136,6 +138,11 @@ def __init__(
         else:
             self.guess_and_set_trust_server()
 
+        if delay is not None:
+            self.delay = delay
+        else:
+            self.guess_and_set_delay()
+
     def prepare_query(func):  # pylint: disable=no-self-argument
         """
         Prepare the query after running the decorated method.
@@ -562,6 +569,50 @@ def set_preferred_protocol(self, value: str) -> "DNSQueryTool":
 
         return self
 
+    @property
+    def delay(self) -> float:
+        """
+        Provides the current state of the :code:`_delay` attribute.
+        """
+
+        return self._delay
+
+    @delay.setter
+    @update_lookup_record
+    def delay(self, value: Union[int, float]) -> None:
+        """
+        Sets the delay to apply.
+
+        :param value:
+            The delay to apply.
+
+        :raise TypeError:
+            When the given :code:`value` is not a :py:class:`float`
+            nor :py:class.`int`.
+        :raise ValueError:
+            When the given :code:`value` is not a positive.
+        """
+
+        if not isinstance(value, (float, int)):
+            raise TypeError(f"<value> should be {float} or {int}, {type(value)} given.")
+
+        if value < 0:
+            raise ValueError(f"<value> should be positive, {value} given.")
+
+        self._delay = float(value)
+
+    def set_delay(self, value: Union[int, float]) -> "DNSQueryTool":
+        """
+        Sets the delay to apply.
+
+        :param value:
+            The delay to apply.
+        """
+
+        self.delay = value
+
+        return self
+
     def guess_and_set_preferred_protocol(self) -> "DNSQueryTool":
         """
         Try to guess and set the preferred procol.
@@ -612,6 +663,19 @@ def guess_and_set_trust_server(self) -> "DNSQueryTool":
 
         return self
 
+    def guess_and_set_delay(self) -> "DNSQueryTool":
+        """
+        Try to guess and set the delay to apply.
+        """
+
+        if PyFunceble.facility.ConfigLoader.is_already_loaded():
+            if PyFunceble.storage.CONFIGURATION.dns.delay:
+                self.delay = PyFunceble.storage.CONFIGURATION.dns.delay
+            else:
+                self.delay = self.STD_DELAY
+        else:
+            self.delay = self.STD_DELAY
+
     def guess_all_settings(
         self,
     ) -> "DNSQueryTool":  # pragma: no cover ## Method themselves are more important
@@ -750,10 +814,10 @@ def tcp(
                 "Unsuccessfully queried information of %r from %r. Sleeping %fs.",
                 self.subject,
                 nameserver,
-                self.BREAKOFF,
+                self.delay,
             )
 
-            time.sleep(self.BREAKOFF)
+            time.sleep(self.delay)
 
         return ListHelper(result).remove_duplicates().subject
 
@@ -822,10 +886,10 @@ def udp(
                 "Unsuccessfully queried information of %r from %r. Sleeping %fs.",
                 self.subject,
                 nameserver,
-                self.BREAKOFF,
+                self.delay,
             )
 
-            time.sleep(self.BREAKOFF)
+            time.sleep(self.delay)
 
         return ListHelper(result).remove_duplicates().subject
 
@@ -888,10 +952,10 @@ def https(
                 "Unsuccessfully queried information of %r from %r. Sleeping %fs.",
                 self.subject,
                 nameserver,
-                self.BREAKOFF,
+                self.delay,
             )
 
-            time.sleep(self.BREAKOFF)
+            time.sleep(self.delay)
 
         return ListHelper(result).remove_duplicates().subject
 
@@ -965,10 +1029,10 @@ def tls(
                 "Unsuccessfully queried information of %r from %r. Sleeping %fs.",
                 self.subject,
                 nameserver,
-                self.BREAKOFF,
+                self.delay,
             )
 
-            time.sleep(self.BREAKOFF)
+            time.sleep(self.delay)
 
         return ListHelper(result).remove_duplicates().subject
 

docs/configuration/dns.rst

@@ -71,3 +71,12 @@
     Otherwise, when the trust mode is disabled, when the first read DNS server
     gives us a negative response (without any error), we still ask all other
     DNS servers that were given or found.
+
+:code:`dns[delay]`
+""""""""""""""""""
+
+    **Type:** :code:`float`
+
+    **Default value:** :code:`0.0`
+
+    **Description:** Sets the delay to apply between each DNS query.

docs/usage/terminal.rst

@@ -46,7 +46,7 @@ Test sources
 
 This argument takes one or more values separated by spaces.
 
-Test one or more :code:`$DOMAIN`s, 
+Test one or more :code:`$DOMAIN`s,
 
 .. code-block:: console
 
@@ -634,6 +634,25 @@ Activates or disable the trust mode.
     a negative response - without error - we still consolidate by
     checking all given/found server.
 
+------
+
+
+.. _dns-delay:
+
+:code:`--dns-delay`
+"""""""""""""""""""
+
+.. versionadded:: 4.0.0
+
+Sets the delay to apply between each DNS query.
+
+**Default value:** :code:`0.0`
+
+.. note::
+    When greater that :code:`0.0`, a delay will be applied between each DNS
+    query.
+
+    Otherwise, if equal to `0.0`, no delay will be applied.
 
 ------
 
@@ -1468,6 +1487,11 @@ Global overview
                                 checking all given/found server.
 
                                 Configured value: False
+        --dns-delay DNS__DELAY
+                                Sets the delay (in seconds) to apply between each DNS
+                                queries.
+
+                                Configured value: 0.0
 
     Databases:
         --inactive-db         Activates or disables the usage of a 'database' to

tests/query/dnss/test_query_tool.py

@@ -692,6 +692,97 @@ def test_guess_and_set_preferred_protocol_none(self) -> None:
 
         self.assertEqual(expected, actual)
 
+    def test_set_delay(self) -> None:
+        """
+        Tests the method which let us set the delay.
+        """
+
+        given = 0.48
+        expected = 0.48
+
+        self.query_tool.set_delay(given)
+        actual = self.query_tool.delay
+
+        self.assertEqual(expected, actual)
+
+    def test_set_delay_through_init(self) -> None:
+        """
+        Tests the method which let us set the delay.
+
+        In this test we check that the transfert of the delay
+        through the constructor is working.
+        """
+
+        given = 0.55
+
+        query_tool = DNSQueryTool(delay=given)
+
+        expected = 0.55
+        actual = query_tool.delay
+
+        self.assertEqual(expected, actual)
+
+    def test_set_delay_not_float(self) -> None:
+        """
+        Tests the method which let us set the delay for the case
+        that the given delay is not a float or int.
+        """
+
+        given = ["Hello", "World"]
+
+        self.assertRaises(TypeError, lambda: self.query_tool.set_delay(given))
+
+    def test_guess_and_set_delay(self) -> None:
+        """
+        Tests the method which let us guess and set the delay between each
+        queries.
+
+        In this test, we check the case that the given delay is set to a value
+        greater than 0.
+        """
+
+        config_loader = ConfigLoader()
+        config_loader.set_custom_config({"dns": {"delay": 0.45}}).start()
+
+        self.query_tool.guess_and_set_delay()
+
+        expected = 0.45
+        actual = self.query_tool.delay
+
+        self.assertEqual(expected, actual)
+
+    def test_guess_and_set_delay_less_than_zero(self) -> None:
+        """
+        Tests the method which let us guess and set the delay between each
+        queries.
+
+        In this test, we check the case that the given delay is set to a value
+        less than 0.
+        """
+
+        config_loader = ConfigLoader()
+        config_loader.set_custom_config({"dns": {"delay": -3.0}}).start()
+
+        self.assertRaises(ValueError, lambda: self.query_tool.guess_and_set_delay())
+
+    def test_guess_and_set_delay_none(self) -> None:
+        """
+        Tests the method which let us guess and set the delay between each
+        queries.
+
+        In this test, we check the case that the given delay is set to None.
+        """
+
+        config_loader = ConfigLoader()
+        config_loader.set_custom_config({"dns": {"delay": None}}).start()
+
+        self.query_tool.guess_and_set_delay()
+
+        expected = self.query_tool.STD_DELAY
+        actual = self.query_tool.delay
+
+        self.assertEqual(expected, actual)
+
     def test_get_lookup_record(self) -> None:
         """
         Tests the method which let us get the lookup record.