Merge pull request #644 from mplsgrant/2024-10-podstatus-run-debug

fix run --debug issue for service accounts

Author: pinheadmz

resources/charts/namespaces/values.yaml

@@ -19,22 +19,25 @@ roles:
         resources: ["persistentvolumeclaims", "namespaces"]
         verbs: ["get", "list"]
       - apiGroups: [""]
-        resources: ["events"]
+        resources: ["events", "pods/status"]
         verbs: ["get"]
   - name: pod-manager
     rules:
       - apiGroups: [""]
         resources: ["pods", "services"]
         verbs: ["get", "list", "watch", "create", "delete", "update"]
+      - apiGroups: [""]
+        resources: ["pods"]
+        verbs: ["get", "list", "watch", "create", "delete", "update", "patch"]
       - apiGroups: [""]
         resources: ["pods/log", "pods/exec", "pods/attach", "pods/portforward"]
         verbs: ["get", "create"]
       - apiGroups: [""]
         resources: ["configmaps", "secrets"]
-        verbs: ["get", "list", "create"]
+        verbs: ["get", "list", "create", "update"]
       - apiGroups: [""]
         resources: ["persistentvolumeclaims", "namespaces"]
         verbs: ["get", "list"]
       - apiGroups: [""]
-        resources: ["events"]
-        verbs: ["get"]
+        resources: ["events", "pods/status"]
+        verbs: ["get"]

resources/scenarios/test_scenarios/p2p_interface.py

@@ -49,7 +49,7 @@ def run_test(self):
         good_getdata = msg_getdata()
         good_getdata.inv.append(CInv(t=2, h=best_block))
         p2p_block_store.send_and_ping(good_getdata)
-        p2p_block_store.wait_until(lambda: p2p_block_store.blocks[best_block] == 1)
+        p2p_block_store.wait_until(lambda: p2p_block_store.blocks[best_block] >= 1)
 
 
 def main():

test/data/admin/networks/6_node_bitcoin/network.yaml

@@ -4,6 +4,7 @@
 from pathlib import Path
 from typing import Callable, Optional
 
+from scenarios_test import ScenariosTest
 from test_base import TestBase
 
 from warnet.constants import KUBECONFIG, WARGAMES_NAMESPACE_PREFIX
@@ -17,32 +18,41 @@
 from warnet.process import run_command
 
 
-class NamespaceAdminTest(TestBase):
+class NamespaceAdminTest(ScenariosTest, TestBase):
     def __init__(self):
         super().__init__()
+
         self.namespace_dir = (
             Path(os.path.dirname(__file__))
             / "data"
             / "admin"
             / "namespaces"
             / "two_namespaces_two_users"
         )
-        self.network_dir = (
-            Path(os.path.dirname(__file__)) / "data" / "admin" / "networks" / "6_node_bitcoin"
-        )
+
+        self.initial_context = None
+        self.current_context = None
+        self.bob_user = "bob-warnettest"
+        self.bob_auth_file = "bob-warnettest-wargames-red-team-warnettest-kubeconfig"
+        self.bob_context = "bob-warnettest-wargames-red-team-warnettest"
+
+        self.blue_namespace = "wargames-blue-team-warnettest"
+        self.red_namespace = "wargames-red-team-warnettest"
+        self.blue_users = ["carol-warnettest", "default", "mallory-warnettest"]
+        self.red_users = ["alice-warnettest", self.bob_user, "default"]
 
     def run_test(self):
         try:
             os.chdir(self.tmpdir)
             self.log.info(f"Running test in: {self.tmpdir}")
             self.establish_initial_context()
-            self.establish_names()
             self.setup_namespaces()
             self.setup_service_accounts()
-            self.deploy_network_in_team_namespaces()
+            self.setup_network()
             self.authenticate_and_become_bob()
-            self.return_to_intial_context()
+            self.bob_runs_scenario_tests()
         finally:
+            self.return_to_initial_context()
             try:
                 self.cleanup_kubeconfig()
             except K8sError as e:
@@ -52,27 +62,8 @@ def run_test(self):
     def establish_initial_context(self):
         self.initial_context = get_kubeconfig_value("{.current-context}")
         self.log.info(f"Initial context: {self.initial_context}")
-
-    def establish_names(self):
-        self.bob_user = "bob-warnettest"
-        self.bob_auth_file = "bob-warnettest-wargames-red-team-warnettest-kubeconfig"
-        self.bob_context = "bob-warnettest-wargames-red-team-warnettest"
-
-        self.blue_namespace = "wargames-blue-team-warnettest"
-        self.red_namespace = "wargames-red-team-warnettest"
-        self.blue_users = ["carol-warnettest", "default", "mallory-warnettest"]
-        self.red_users = ["alice-warnettest", self.bob_user, "default"]
-
-    def return_to_intial_context(self):
-        cmd = f"kubectl config use-context {self.initial_context}"
-        self.log.info(run_command(cmd))
-        self.wait_for_predicate(self.this_is_the_current_context(self.initial_context))
-
-    def this_is_the_current_context(self, context: str) -> Callable[[], bool]:
-        cmd = "kubectl config current-context"
-        current_context = run_command(cmd).strip()
-        self.log.info(f"Current context: {current_context} {context == current_context}")
-        return lambda: current_context == context
+        self.current_context = self.initial_context
+        self.log.info(f"Current context: {self.current_context}")
 
     def setup_namespaces(self):
         self.log.info("Setting up the namespaces")
@@ -86,18 +77,28 @@ def setup_service_accounts(self):
         self.wait_for_predicate(self.service_accounts_are_validated)
         self.log.info("Service accounts have been set up and validated")
 
-    def deploy_network_in_team_namespaces(self):
-        self.log.info("Deploy networks to team namespaces")
-        self.log.info(self.warnet(f"deploy {self.network_dir} --to-all-users"))
+    def setup_network(self):
+        if self.current_context == self.bob_context:
+            self.log.info(f"Allowing {self.current_context} to update the network...")
+            assert self.this_is_the_current_context(self.bob_context)
+            self.warnet(f"deploy {self.network_dir}")
+        else:
+            self.log.info("Deploy networks to team namespaces")
+            assert self.this_is_the_current_context(self.initial_context)
+            self.log.info(self.warnet(f"deploy {self.network_dir} --to-all-users"))
         self.wait_for_all_tanks_status()
         self.log.info("Waiting for all edges")
         self.wait_for_all_edges()
 
     def authenticate_and_become_bob(self):
         self.log.info("Authenticating and becoming bob...")
+        self.log.info(f"Current context: {self.current_context}")
+        assert self.initial_context == self.current_context
         assert get_kubeconfig_value("{.current-context}") == self.initial_context
         self.warnet(f"auth kubeconfigs/{self.bob_auth_file}")
-        assert get_kubeconfig_value("{.current-context}") == self.bob_context
+        self.current_context = self.bob_context
+        assert get_kubeconfig_value("{.current-context}") == self.current_context
+        self.log.info(f"Current context: {self.current_context}")
 
     def service_accounts_are_validated(self) -> bool:
         self.log.info("Checking service accounts")
@@ -145,6 +146,17 @@ def two_namespaces_are_validated(self) -> bool:
             return False
         return self.red_namespace in maybe_namespaces
 
+    def return_to_initial_context(self):
+        cmd = f"kubectl config use-context {self.initial_context}"
+        self.log.info(run_command(cmd))
+        self.wait_for_predicate(self.this_is_the_current_context(self.initial_context))
+
+    def this_is_the_current_context(self, context: str) -> Callable[[], bool]:
+        cmd = "kubectl config current-context"
+        current_context = run_command(cmd).strip()
+        self.log.info(f"Current context: {current_context} {context == current_context}")
+        return lambda: current_context == context
+
     def cleanup_kubeconfig(self):
         try:
             kubeconfig_data = open_kubeconfig(KUBECONFIG)
@@ -159,6 +171,11 @@ def cleanup_kubeconfig(self):
         except Exception as e:
             raise K8sError(f"Could not write to KUBECONFIG: {KUBECONFIG}") from e
 
+    def bob_runs_scenario_tests(self):
+        assert self.this_is_the_current_context(self.bob_context)
+        super().run_test()
+        assert self.this_is_the_current_context(self.bob_context)
+
 
 def remove_user(kubeconfig_data: dict, username: str) -> dict:
     kubeconfig_data["users"] = [

test/data/admin/networks/6_node_bitcoin/node-defaults.yaml

@@ -1,6 +1,7 @@
 #!/usr/bin/env python3
 
 import os
+import re
 from pathlib import Path
 
 from test_base import TestBase
@@ -21,6 +22,7 @@ def run_test(self):
             self.setup_network()
             self.run_and_check_miner_scenario_from_file()
             self.run_and_check_scenario_from_file()
+            self.run_and_check_scenario_from_file_debug()
             self.check_regtest_recon()
             self.check_active_count()
         finally:
@@ -82,6 +84,12 @@ def run_and_check_miner_scenario_from_file(self):
         assert "Active Scenarios: 1" in table
         self.stop_scenario()
 
+    def run_and_check_scenario_from_file_debug(self):
+        scenario_file = self.scen_dir / "test_scenarios" / "p2p_interface.py"
+        self.log.info(f"Running scenario from: {scenario_file}")
+        output = self.warnet(f"run {scenario_file} --source_dir={self.scen_dir} --debug")
+        self.check_for_pod_deletion_message(output)
+
     def run_and_check_scenario_from_file(self):
         scenario_file = self.scen_dir / "test_scenarios" / "p2p_interface.py"
         self.log.info(f"Running scenario from: {scenario_file}")
@@ -109,6 +117,12 @@ def two_pass_one_fail():
         table = self.warnet("status")
         assert "Active Scenarios: 0" in table
 
+    def check_for_pod_deletion_message(self, input):
+        message = "Deleting pod..."
+        self.log.info(f"Checking for message: '{message}'")
+        assert re.search(re.escape(message), input, flags=re.MULTILINE)
+        self.log.info(f"Found message: '{message}'")
+
 
 if __name__ == "__main__":
     test = ScenariosTest()