Add ability to delay preload after usage

In case of making quick bursts that do not exceed the maximum number of
preloaded disposables, it is faster to not preload in the meantime.
These are the behaviors:

- "-1": preload after X seconds only if list is empty;
-   "": use global value, and if it is not set, use default;
-  "0": preload instantaneously; and
-  "1": preload after X seconds.

For: QubesOS/qubes-issues#10230
For: QubesOS/qubes-issues#1512

Author: ben-grande

qubes/tests/vm/adminvm.py

@@ -290,3 +290,14 @@ def test_802_preload_set_threshold(self):
         for value in cases_valid:
             with self.subTest(value=value):
                 self.vm.features["preload-dispvm-threshold"] = value
+
+    def test_803_preload_set_delay(self):
+        cases_valid = ["", "0", "1", "-1", "3.14"]
+        cases_invalid = ["a", ".2.", "1 1"]
+        for value in cases_invalid:
+            with self.subTest(value=value):
+                with self.assertRaises(qubes.exc.QubesValueError):
+                    self.vm.features["preload-dispvm-delay"] = value
+        for value in cases_valid:
+            with self.subTest(value=value):
+                self.vm.features["preload-dispvm-delay"] = value

qubes/tests/vm/mix/dvmtemplate.py

@@ -119,6 +119,29 @@ def cleanup_dispvm(self):
     async def mock_coro(self, *args, **kwargs):
         pass
 
+    def test_010_dvm_preload_get_delay(self):
+        cases = [
+            (None, 0),
+            (False, 0),
+            ("0", 0),
+            ("2", 2),
+            ("10000", 10000),
+            ("-1", -1),
+            ("-3.14", -3.14),
+        ]
+        self.assertEqual(self.appvm.get_feat_preload_max(), 0)
+        for value, expected_value in cases:
+            with self.subTest(value=value, expected_value=expected_value):
+                self.appvm.features["preload-dispvm-delay"] = value
+                self.assertEqual(
+                    self.appvm.get_feat_preload_delay(), expected_value
+                )
+        cases_invalid = ["a", ".2.", "1 1"]
+        for value in cases_invalid:
+            with self.subTest(value=value):
+                with self.assertRaises(qubes.exc.QubesValueError):
+                    self.appvm.features["preload-dispvm-delay"] = value
+
     def test_010_dvm_preload_get_max(self):
         cases = [
             (None, 0),

qubes/vm/adminvm.py

@@ -378,6 +378,30 @@ def on_feature_pre_set_preload_dispvm_threshold(
                 "Invalid preload-dispvm-threshold value: not a digit"
             )
 
+    @qubes.events.handler("domain-feature-pre-set:preload-dispvm-delay")
+    def on_feature_pre_set_preload_dispvm_delay(
+        self, event, feature, value, oldvalue=None
+    ):
+        """
+        Before accepting the ``preload-dispvm-delay`` feature, validate it.
+
+        :param str event: Event which was fired.
+        :param str feature: Feature name.
+        :param int value: New value of the feature.
+        :param int oldvalue: Old value of the feature.
+        """
+        # pylint: disable=unused-argument
+        if value == oldvalue:
+            return
+        if not value:
+            value = "0"
+        try:
+            float(value)
+        except ValueError:
+            raise qubes.exc.QubesValueError(
+                "Invalid preload-dispvm-delay value: not an integer or float"
+            )
+
     @qubes.events.handler("domain-feature-delete:preload-dispvm-max")
     def on_feature_delete_preload_dispvm_max(self, event, feature):
         """

qubes/vm/dispvm.py

@@ -733,13 +733,17 @@ async def from_appvm(
         if not preload and appvm.can_preload():
             # Not necessary to await for this event as its intent is to fill
             # gaps and not relevant for this run. Delay to not affect this run.
-            asyncio.ensure_future(
-                appvm.fire_event_async(
-                    "domain-preload-dispvm-start",
-                    reason="there is a gap",
-                    delay=5,
+            delay = appvm.get_feat_preload_delay()
+            if delay == -1 and appvm.get_feat_preload():
+                pass
+            else:
+                asyncio.ensure_future(
+                    appvm.fire_event_async(
+                        "domain-preload-dispvm-start",
+                        reason="there is a gap",
+                        delay=max(5, delay),
+                    )
                 )
-            )
 
         if not preload and (preload_dispvm := appvm.get_feat_preload()):
             dispvm = None
@@ -850,8 +854,13 @@ async def use_preload(self) -> None:
             )
             self.features["preload-dispvm-in-progress"] = False
         self.app.save()
+        delay = appvm.get_feat_preload_delay()
+        if delay == -1 and appvm.get_feat_preload():
+            return
         asyncio.ensure_future(
-            appvm.fire_event_async("domain-preload-dispvm-used", dispvm=self)
+            appvm.fire_event_async(
+                "domain-preload-dispvm-used", dispvm=self, delay=delay
+            )
         )
 
     def _preload_cleanup(self) -> None:

qubes/vm/mix/dvmtemplate.py

@@ -150,6 +150,30 @@ async def on_dvmtemplate_domain_shutdown(self, _event, **_kwargs) -> None:
         """
         await self.refresh_preload()
 
+    @qubes.events.handler("domain-feature-pre-set:preload-dispvm-delay")
+    def on_feature_pre_set_preload_dispvm_delay(
+        self, event, feature, value, oldvalue=None
+    ):
+        """
+        Before accepting the ``preload-dispvm-delay`` feature, validate it.
+
+        :param str event: Event which was fired.
+        :param str feature: Feature name.
+        :param int value: New value of the feature.
+        :param int oldvalue: Old value of the feature.
+        """
+        # pylint: disable=unused-argument
+        if value == oldvalue:
+            return
+        if not value:
+            value = "0"
+        try:
+            float(value)
+        except ValueError:
+            raise qubes.exc.QubesValueError(
+                "Invalid preload-dispvm-delay value: not an integer or float"
+            )
+
     @qubes.events.handler("domain-feature-delete:preload-dispvm-max")
     def on_feature_delete_preload_dispvm_max(self, event, feature) -> None:
         """
@@ -502,6 +526,26 @@ async def on_domain_preload_dispvm_used(
             ]
         )
 
+    def get_feat_preload_delay(self) -> int:
+        """
+        Get the ``preload-dispvm-delay`` feature as float.
+
+        :rtype: int
+        """
+        assert isinstance(self, qubes.vm.BaseVM)
+        feature = "preload-dispvm-delay"
+        default = 5
+        global_features = self.app.domains["dom0"].features
+        global_value = global_features.get(feature)
+        value = self.features.get(feature)
+        if value is None:
+            if global_value is None:
+                value = default
+            else:
+                value = global_value
+        value = float(value or 0)
+        return value
+
     def get_feat_preload_threshold(self) -> int:
         """
         Get the ``preload-dispvm-threshold`` feature as int (bytes unit).