vantage6-node 5.0.2rc2__tar.gz → 5.0.3__tar.gz

{vantage6_node-5.0.2rc2 → vantage6_node-5.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: vantage6-node
-Version: 5.0.2rc2
+Version: 5.0.3
 Summary: vantage6 node
 Author: Vantage6 Team
 Maintainer-email: Frank Martin <f.martin@iknl.nl>, Bart van Beusekom <b.vanbeusekom@iknl.nl>
@@ -14,11 +14,11 @@ Requires-Dist: kubernetes==36.0.2
 Requires-Dist: nvidia-ml-py==12.535.133
 Requires-Dist: parquet-tools==0.2.16
 Requires-Dist: psutil==7.0.0
-Requires-Dist: python-socketio==5.15.0
+Requires-Dist: python-socketio==5.16.2
 Requires-Dist: requests==2.33.1
-Requires-Dist: vantage6-client==5.0.2rc2
-Requires-Dist: vantage6-common==5.0.2rc2
-Requires-Dist: vantage6==5.0.2rc2
+Requires-Dist: vantage6-client==5.0.3
+Requires-Dist: vantage6-common==5.0.3
+Requires-Dist: vantage6==5.0.3
 Provides-Extra: dev
 Requires-Dist: black; extra == 'dev'
 Requires-Dist: coverage==7.10.2; extra == 'dev'

{vantage6_node-5.0.2rc2 → vantage6_node-5.0.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "vantage6-node"
-version = "5.0.2rc2"
+version = "5.0.3"
 description = "vantage6 node"
 readme = "README.md"
 license = {text = "MIT"}
@@ -25,11 +25,11 @@ dependencies = [
     "nvidia-ml-py==12.535.133",
     "parquet-tools==0.2.16",
     "psutil==7.0.0",
-    "python-socketio==5.15.0",
+    "python-socketio==5.16.2",
     "requests==2.33.1",
-    "vantage6==5.0.2rc2",
-    "vantage6-client==5.0.2rc2",
-    "vantage6-common==5.0.2rc2",
+    "vantage6==5.0.3",
+    "vantage6-client==5.0.3",
+    "vantage6-common==5.0.3",
 ]
 
 [project.optional-dependencies]

vantage6_node-5.0.3/tests_node/test_container_manager.py

@@ -0,0 +1,219 @@
+import logging
+import os
+import unittest
+from unittest.mock import MagicMock, patch
+
+from vantage6.common.globals import NodePolicy
+
+from vantage6.node.k8s.container_manager import ContainerManager
+
+
+def _get_null_logger(name="null_logger_container_manager"):
+    logger = logging.getLogger(name)
+    logger.addHandler(logging.NullHandler())
+    logger.propagate = False
+    return logger
+
+
+class TestIsImageAllowed(unittest.TestCase):
+    """
+    Tests for ContainerManager.is_image_allowed().
+
+    ContainerManager.__init__ talks to the Kubernetes API, so these tests bypass it
+    (via __new__) and set up only the attributes is_image_allowed() actually reads:
+    `_policies`, `client` and `log`. This keeps `_is_regex_pattern` (a real
+    staticmethod on the class) working, unlike a fully mocked `self` would.
+    """
+
+    def setUp(self):
+        self.manager = ContainerManager.__new__(ContainerManager)
+        self.manager.log = _get_null_logger()
+        self.manager.client = MagicMock()
+        self.manager._policies = {}
+
+    @staticmethod
+    def _task_info(store_id: int | None = None) -> dict:
+        task_info = {"init_org": {"id": 1}, "init_user": {"id": 1}}
+        if store_id is not None:
+            task_info["algorithm_store"] = {"id": store_id}
+        return task_info
+
+    def test_allowed_algorithms_exact_match(self):
+        """Baseline regression check for the (unchanged) allowed_algorithms policy."""
+        self.manager._policies = {
+            NodePolicy.ALLOWED_ALGORITHMS.value: ["some/image:tag"]
+        }
+
+        self.assertTrue(
+            self.manager.is_image_allowed("some/image:tag", self._task_info())
+        )
+        self.assertFalse(
+            self.manager.is_image_allowed("some/other-image:tag", self._task_info())
+        )
+
+    def test_allowed_algorithm_stores_verified(self):
+        """
+        The store URL is whitelisted and the store itself confirms the image is a
+        registered, approved algorithm there - the image is allowed.
+        """
+        self.manager._policies = {
+            NodePolicy.ALLOWED_ALGORITHM_STORES.value: ["https://store.example"]
+        }
+        self.manager.client.algorithm_store.get.return_value = {
+            "url": "https://store.example",
+            "api_path": "/api",
+        }
+        self.manager.client.algorithm_store.get_algorithm.return_value = {
+            "image": "some/image:tag",
+            "digest": "abc123",
+        }
+
+        self.assertTrue(
+            self.manager.is_image_allowed("some/image:tag", self._task_info(store_id=1))
+        )
+        self.manager.client.algorithm_store.get_algorithm.assert_called_once_with(
+            "some/image:tag"
+        )
+
+    def test_allowed_algorithm_stores_not_confirmed_by_store(self):
+        """
+        The store URL is whitelisted, but the store does not confirm the image is
+        registered/approved there (e.g. it genuinely isn't, the store hasn't been
+        upgraded to support node requests, or it could not be reached) - the image
+        is denied. This is the fix for GHSA-j43v-wwjr-9grj: previously the store URL
+        match alone was enough.
+        """
+        self.manager._policies = {
+            NodePolicy.ALLOWED_ALGORITHM_STORES.value: ["https://store.example"]
+        }
+        self.manager.client.algorithm_store.get.return_value = {
+            "url": "https://store.example",
+            "api_path": "/api",
+        }
+        self.manager.client.algorithm_store.get_algorithm.return_value = None
+
+        self.assertFalse(
+            self.manager.is_image_allowed("some/image:tag", self._task_info(store_id=1))
+        )
+
+    def test_allowed_algorithm_stores_url_not_whitelisted(self):
+        """
+        The store's URL isn't on the whitelist at all - the image is denied without
+        even asking the store to verify the image (no wasted network call).
+        """
+        self.manager._policies = {
+            NodePolicy.ALLOWED_ALGORITHM_STORES.value: ["https://trusted.example"]
+        }
+        self.manager.client.algorithm_store.get.return_value = {
+            "url": "https://untrusted.example",
+            "api_path": "/api",
+        }
+
+        self.assertFalse(
+            self.manager.is_image_allowed("some/image:tag", self._task_info(store_id=1))
+        )
+        self.manager.client.algorithm_store.get_algorithm.assert_not_called()
+
+    def test_allowed_algorithm_stores_localhost_translated_in_k8s(self):
+        """
+        A store registered under a `localhost` URL (e.g. running on the same local
+        dev machine as the node) is translated to an address reachable from inside
+        the node's pod before the live verification call, when V6_K8S_NODE_NAME
+        indicates a local k8s dev deployment.
+        """
+        self.manager._policies = {
+            NodePolicy.ALLOWED_ALGORITHM_STORES.value: ["http://localhost:7601"]
+        }
+        self.manager.client.algorithm_store.get.return_value = {
+            "url": "http://localhost:7601",
+            "api_path": "/api",
+        }
+        self.manager.client.algorithm_store.get_algorithm.return_value = {
+            "image": "some/image:tag",
+            "digest": "abc123",
+        }
+
+        with patch.dict(os.environ, {"V6_K8S_NODE_NAME": "docker-desktop"}):
+            self.assertTrue(
+                self.manager.is_image_allowed(
+                    "some/image:tag", self._task_info(store_id=1)
+                )
+            )
+
+        self.assertEqual(
+            self.manager.client.algorithm_store.url,
+            "http://host.docker.internal:7601/api",
+        )
+
+    def test_allowed_algorithm_stores_localhost_unchanged_without_k8s_node(self):
+        """
+        Without V6_K8S_NODE_NAME set (the default outside local dev deployments), a
+        `localhost` store URL is used as-is - a real deployment never has the node
+        and the store on the same machine, so there is nothing to translate.
+        """
+        self.manager._policies = {
+            NodePolicy.ALLOWED_ALGORITHM_STORES.value: ["http://localhost:7601"]
+        }
+        self.manager.client.algorithm_store.get.return_value = {
+            "url": "http://localhost:7601",
+            "api_path": "/api",
+        }
+        self.manager.client.algorithm_store.get_algorithm.return_value = {
+            "image": "some/image:tag",
+            "digest": "abc123",
+        }
+
+        with patch.dict(os.environ, {}, clear=False):
+            os.environ.pop("V6_K8S_NODE_NAME", None)
+            self.manager.is_image_allowed("some/image:tag", self._task_info(store_id=1))
+
+        self.assertEqual(
+            self.manager.client.algorithm_store.url, "http://localhost:7601/api"
+        )
+
+    def test_allow_either_whitelist_or_store(self):
+        """
+        Baseline regression check: with allow_either_whitelist_or_store, an image
+        that fails the allowed_algorithms whitelist but is confirmed by the
+        (whitelisted) store is still allowed.
+        """
+        self.manager._policies = {
+            NodePolicy.ALLOWED_ALGORITHMS.value: ["some/other-image:tag"],
+            NodePolicy.ALLOWED_ALGORITHM_STORES.value: ["https://store.example"],
+            "allow_either_whitelist_or_store": True,
+        }
+        self.manager.client.algorithm_store.get.return_value = {
+            "url": "https://store.example",
+            "api_path": "/api",
+        }
+        self.manager.client.algorithm_store.get_algorithm.return_value = {
+            "image": "some/image:tag",
+            "digest": "abc123",
+        }
+
+        self.assertTrue(
+            self.manager.is_image_allowed("some/image:tag", self._task_info(store_id=1))
+        )
+
+
+class TestGetImagePullPolicy:
+    def _manager_with_policies(self, policies: dict) -> ContainerManager:
+        manager = ContainerManager.__new__(ContainerManager)
+        manager._policies = policies
+        return manager
+
+    def test_require_algorithm_pull_false_means_if_not_present(self):
+        manager = self._manager_with_policies({"require_algorithm_pull": False})
+        assert manager._get_image_pull_policy() == "IfNotPresent"
+
+    def test_require_algorithm_pull_true_means_always(self):
+        manager = self._manager_with_policies({"require_algorithm_pull": True})
+        assert manager._get_image_pull_policy() == "Always"
+
+    def test_require_algorithm_pull_absent_defaults_to_always(self):
+        manager = self._manager_with_policies({})
+        assert manager._get_image_pull_policy() == "Always"
+
+
+if __name__ == "__main__":
+    unittest.main()

vantage6_node-5.0.3/tests_node/test_network_isolation.py

@@ -0,0 +1,124 @@
+from unittest.mock import MagicMock, patch
+
+import pytest
+from kubernetes import client as k8s_client
+
+from vantage6.node import Node
+from vantage6.node.k8s.network_isolation import (
+    _probe_pod_reached_target,
+    validate_algorithm_isolation,
+)
+
+
+class TestProbePodReachedTarget:
+    def _pod_with_exit_code(self, exit_code: int) -> k8s_client.V1Pod:
+        return k8s_client.V1Pod(
+            status=k8s_client.V1PodStatus(
+                container_statuses=[
+                    k8s_client.V1ContainerStatus(
+                        name="probe",
+                        image="curlimages/curl:latest",
+                        image_id="curlimages/curl@sha256:abc",
+                        ready=False,
+                        restart_count=0,
+                        state=k8s_client.V1ContainerState(
+                            terminated=k8s_client.V1ContainerStateTerminated(
+                                exit_code=exit_code
+                            )
+                        ),
+                    )
+                ]
+            )
+        )
+
+    def test_exit_code_zero_means_not_isolated(self):
+        assert _probe_pod_reached_target(self._pod_with_exit_code(0)) is True
+
+    def test_non_zero_exit_code_means_isolated(self):
+        assert _probe_pod_reached_target(self._pod_with_exit_code(28)) is False
+
+
+class TestValidateAlgorithmIsolation:
+    @patch("vantage6.node.k8s.network_isolation._wait_for_probe_pod")
+    def test_reachable_target_returns_not_isolated(self, mock_wait):
+        mock_wait.return_value = TestProbePodReachedTarget()._pod_with_exit_code(0)
+        core_api = MagicMock()
+
+        isolated, message = validate_algorithm_isolation(
+            core_api=core_api,
+            task_namespace="vantage6-tasks",
+            log=MagicMock(),
+        )
+
+        assert isolated is False
+        assert "example.com" in message
+        core_api.delete_namespaced_pod.assert_called_once()
+
+    @patch("vantage6.node.k8s.network_isolation._wait_for_probe_pod")
+    def test_blocked_target_returns_isolated(self, mock_wait):
+        mock_wait.return_value = TestProbePodReachedTarget()._pod_with_exit_code(28)
+        core_api = MagicMock()
+
+        isolated, message = validate_algorithm_isolation(
+            core_api=core_api,
+            task_namespace="vantage6-tasks",
+            log=MagicMock(),
+        )
+
+        assert isolated is True
+        assert "verified" in message
+
+
+class TestNodeProductionGating:
+    def test_production_true_exits_on_isolation_failure(self):
+        ctx = MagicMock()
+        ctx.config = {"production": True}
+
+        with (
+            patch("vantage6.node.validate_required_env_vars"),
+            patch("vantage6.node.ContainerManager") as mock_cm_cls,
+        ):
+            mock_cm = mock_cm_cls.return_value
+            mock_cm.ensure_task_namespace.return_value = True
+            mock_cm.validate_algorithm_isolation.return_value = (
+                False,
+                "probe failed",
+            )
+            with patch("vantage6.node.exit", side_effect=SystemExit(1)) as mock_exit:
+                with (
+                    patch.object(Node, "_setup_node_client", return_value=MagicMock()),
+                    pytest.raises(SystemExit),
+                ):
+                    Node(ctx)
+                mock_exit.assert_called_once_with(1)
+
+    def test_production_false_warns_on_isolation_failure(self, caplog):
+        ctx = MagicMock()
+        ctx.config = {"production": False, "debug": {}}
+
+        def _connect_socket(self):
+            self.socketIO = MagicMock()
+
+        with (
+            patch("vantage6.node.validate_required_env_vars"),
+            patch("vantage6.node.ContainerManager") as mock_cm_cls,
+        ):
+            mock_cm = mock_cm_cls.return_value
+            mock_cm.ensure_task_namespace.return_value = True
+            mock_cm.validate_algorithm_isolation.return_value = (
+                False,
+                "probe failed",
+            )
+            with patch("vantage6.node.exit") as mock_exit:
+                with (
+                    patch.object(Node, "_setup_node_client", return_value=MagicMock()),
+                    patch.object(Node, "authenticate"),
+                    patch.object(Node, "setup_encryption"),
+                    patch.object(Node, "connect_to_socket", _connect_socket),
+                    patch.object(Node, "start_processing_threads"),
+                    patch("vantage6.node.Thread"),
+                    caplog.at_level("WARNING"),
+                ):
+                    Node(ctx)
+                mock_exit.assert_not_called()
+        assert "probe failed" in caplog.text

{vantage6_node-5.0.2rc2 → vantage6_node-5.0.3}/tests_node/test_pod_status_mapping.py

@@ -63,7 +63,6 @@ class TestPodStatus(unittest.TestCase):
         )
 
         self.mock_pod = V1Pod(metadata={"name": ""}, status=self.mock_pod_status)
-        pass
 
     def test_running_job_pod(self):
         self.mock_pod.status.phase = "Running"

vantage6_node-5.0.3/tests_node/test_share_algorithm_logs.py

@@ -0,0 +1,141 @@
+import unittest
+from unittest.mock import Mock, patch
+
+from vantage6.common.enum import RunStatus
+
+from vantage6.node import Node
+from vantage6.node.k8s.container_manager import ContainerManager
+from vantage6.node.k8s.data_classes import KilledRun, Result
+
+
+class TestContainerManagerLogSharing(unittest.TestCase):
+    def _make_manager(self, share_algorithm_logs: bool) -> ContainerManager:
+        manager = ContainerManager.__new__(ContainerManager)
+        manager.log = Mock()
+        manager.share_algorithm_logs = share_algorithm_logs
+        manager.socket_io = Mock()
+        manager.client = Mock()
+        manager.client.collaboration_id = 7
+        manager.task_namespace = "test-namespace"
+        manager.core_api = Mock()
+        pod = Mock()
+        pod.metadata = Mock()
+        pod.metadata.name = "pod-1"
+        manager.core_api.list_namespaced_pod.return_value.items = [pod]
+        return manager
+
+    def test_log_stream_does_not_emit_when_sharing_disabled(self):
+        manager = self._make_manager(False)
+        run_io = Mock(run_id=42, container_name="algo-container")
+        fake_watch = Mock()
+        fake_watch.stream.return_value = ["hello from algorithm"]
+
+        with patch(
+            "vantage6.node.k8s.container_manager.watch.Watch", return_value=fake_watch
+        ):
+            manager._ContainerManager__log_stream(run_io=run_io, task_id=99)
+
+        manager.socket_io.emit.assert_not_called()
+
+    def test_log_stream_emits_when_sharing_enabled(self):
+        manager = self._make_manager(True)
+        run_io = Mock(run_id=42, container_name="algo-container")
+        fake_watch = Mock()
+        fake_watch.stream.return_value = ["hello from algorithm"]
+
+        with patch(
+            "vantage6.node.k8s.container_manager.watch.Watch", return_value=fake_watch
+        ):
+            manager._ContainerManager__log_stream(run_io=run_io, task_id=99)
+
+        manager.socket_io.emit.assert_called_once_with(
+            "algorithm_log",
+            {
+                "collaboration_id": 7,
+                "run_id": 42,
+                "task_id": 99,
+                "log": "hello from algorithm",
+            },
+            namespace="/tasks",
+        )
+
+
+class TestFinishedTaskLogSharing(unittest.TestCase):
+    def _make_node(self, share_algorithm_logs: bool) -> Node:
+        node = Node.__new__(Node)
+        node.log = Mock()
+        node.config = {"share_algorithm_logs": share_algorithm_logs}
+        node.k8s_container_manager = Mock()
+        node.k8s_container_manager.process_next_completed_run.return_value = Result(
+            run_id=1,
+            task_id=2,
+            logs="sensitive algorithm logs",
+            data="output-data",
+            status=RunStatus.COMPLETED,
+            parent_id=None,
+            init_org_id=5,
+        )
+        node.client = Mock()
+        node.client.whoami = Mock(id_=1, organization_id=1)
+        node.client.collaboration_id = 1
+        node.socketIO = Mock()
+        return node
+
+    def _run_one_iteration(self, node: Node) -> None:
+        # __send_updates_finished_tasks loops forever with a trailing
+        # time.sleep(1); make sleep raise so the loop stops after one pass.
+        with (
+            patch("vantage6.node.time.sleep", side_effect=InterruptedError),
+            self.assertRaises(InterruptedError),
+        ):
+            node._Node__send_updates_finished_tasks()
+
+    def test_logs_redacted_when_sharing_disabled(self):
+        node = self._make_node(share_algorithm_logs=False)
+        self._run_one_iteration(node)
+
+        patch_call = node.client.run.patch.call_args
+        self.assertEqual(
+            patch_call.kwargs["data"]["log"],
+            "Node does not allow sharing algorithm logs",
+        )
+
+    def test_logs_shared_when_sharing_enabled(self):
+        node = self._make_node(share_algorithm_logs=True)
+        self._run_one_iteration(node)
+
+        patch_call = node.client.run.patch.call_args
+        self.assertEqual(patch_call.kwargs["data"]["log"], "sensitive algorithm logs")
+
+
+class TestKillContainersLogSharing(unittest.TestCase):
+    def _make_node(self, share_algorithm_logs: bool) -> Node:
+        node = Node.__new__(Node)
+        node.log = Mock()
+        node.config = {"share_algorithm_logs": share_algorithm_logs}
+        node.client = Mock()
+        node.client.collaboration_id = 7
+        node.client.whoami = Mock(id_=1)
+        node.k8s_container_manager = Mock()
+        node.k8s_container_manager.kill_algorithm_runs.return_value = [
+            KilledRun(run_id=1, task_id=2, parent_id=None, logs="sensitive kill logs")
+        ]
+        return node
+
+    def test_kill_logs_not_sent_when_sharing_disabled(self):
+        node = self._make_node(share_algorithm_logs=False)
+        node.kill_containers({"collaboration_id": 7})
+
+        node.client.run.patch.assert_not_called()
+
+    def test_kill_logs_sent_when_sharing_enabled(self):
+        node = self._make_node(share_algorithm_logs=True)
+        node.kill_containers({"collaboration_id": 7})
+
+        node.client.run.patch.assert_called_once_with(
+            id_=1, data={"log": "sensitive kill logs"}
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()