DAOS-13700 test: use self.random in most cases

Use self.random in nearly all cases so it can be seeded for reproducibility.
Test-tag: BoundaryTest DfuseFind DiskFailureTest HarnessConfigTest NvmePoolExclude OSAOfflineDrain OSAOfflineParallelTest OSAOfflineReintegration OSAOnlineParallelTest OSAOnlineReintegration PoolCreateAllVmTests PoolManagementRace ReplayTests EcodRunIoConf DaosRunIoConf soak_smoke security RebuildMdtest
Skip-unit-tests: true
Skip-fault-injection-test: true

Signed-off-by: Dalton Bohning <[email protected]>

src/tests/ftest/container/boundary.py

@@ -1,11 +1,11 @@
 """
   (C) Copyright 2022-2023 Intel Corporation.
+  (C) Copyright 2025 Hewlett Packard Enterprise Development LP
 
   SPDX-License-Identifier: BSD-2-Clause-Patent
 """
 
 import itertools
-import random
 import time
 
 from apricot import TestWithServers
@@ -108,7 +108,7 @@ def create_pools(self, num_pools, num_containers):
         container_manager = ThreadManager(
             self.create_container_and_test, self.get_remaining_time() - 30)
         all_pool_cont_args = list(itertools.product(self.pool, range(num_containers)))
-        random.shuffle(all_pool_cont_args)
+        self.random.shuffle(all_pool_cont_args)
         for pool, cont_num in all_pool_cont_args:
             container_manager.add(pool=pool, cont_num=cont_num)
         self.log.info('Creating %d containers for each pool', num_containers)

src/tests/ftest/deployment/disk_failure.py

@@ -1,9 +1,9 @@
 """
   (C) Copyright 2022-2024 Intel Corporation.
+  (C) Copyright 2025 Hewlett Packard Enterprise Development LP
 
   SPDX-License-Identifier: BSD-2-Clause-Patent
 """
-import random
 import threading
 import time
 
@@ -64,7 +64,7 @@ def verify_disk_failure(self, num_pool):
                 time.sleep(5)
 
             # Evict a random target from the system
-            evict_device = random.choice(device_info)  # nosec
+            evict_device = self.random.choice(device_info)
             self.log.info("Evicting random target: %s", evict_device["uuid"])
             try:
                 get_dmg_response(self.dmg_command.storage_set_faulty,

src/tests/ftest/dfuse/find.py

@@ -1,10 +1,10 @@
 """
   (C) Copyright 2021-2024 Intel Corporation.
+  (C) Copyright 2025 Hewlett Packard Enterprise Development LP
 
   SPDX-License-Identifier: BSD-2-Clause-Patent
 """
 import os
-import random
 import string
 
 from apricot import TestWithServers
@@ -52,7 +52,6 @@ def test_dfuse_find_perf(self):
             challenger performance.
 
         :avocado: tags=all,manual
-        :avocado: tags=hw,medium
         :avocado: tags=DfuseFind,test_dfuse_find_perf
         """
         # Number of repetitions each test will run.
@@ -180,12 +179,12 @@ def _search_needles(file_name, sample_tag, expected_res):
         for sample_num in range(1, samples + 1):
             self.log.info("Running sample number %d of %d", sample_num, samples)
 
-            prefix = random.randrange(containers - 1)  # nosec
-            suffix = random.randrange(needles - 1)  # nosec
+            prefix = self.random.randrange(containers - 1)
+            suffix = self.random.randrange(needles - 1)
             file_name = "t{:05d}_*_{:05d}.needle".format(prefix, suffix)
             _search_needles(file_name, "unique_file", 1)
 
-            number = random.randrange(needles - 1)  # nosec
+            number = self.random.randrange(needles - 1)
             file_name = "*_{:05d}.needle".format(number)
             _search_needles(file_name, "same_suffix", containers)
 
@@ -255,14 +254,13 @@ def _setup_challenger(self, test_path, directories):
 
         return challenger_dirs
 
-    @classmethod
-    def _generate_temp_path_name(cls, root, prefix):
+    def _generate_temp_path_name(self, root, prefix):
         """
         Creates path that can be used to create temporary files or directories.
         The return value is concatenation of root and a random string prefixed
         with the prefix value.
         """
         letters = string.ascii_lowercase + string.digits
-        random_name = "".join(random.choice(letters) for _ in range(8))  # nosec
+        random_name = "".join(self.random.choice(letters) for _ in range(8))
 
         return os.path.join(root, "{}{}".format(prefix, random_name))

src/tests/ftest/harness/config.py

@@ -1,5 +1,6 @@
 """
 (C) Copyright 2021-2024 Intel Corporation.
+(C) Copyright 2025 Hewlett Packard Enterprise Development LP
 
 SPDX-License-Identifier: BSD-2-Clause-Patent
 """
@@ -79,3 +80,7 @@ def test_harness_config(self):
         with open(self.agent_managers[0].manager.job.temporary_file, 'r') as yaml_file:
             daos_agent_yaml = yaml.safe_load(yaml_file.read())
         self.assertEqual(daos_agent_yaml['exclude_fabric_ifaces'], expected)
+
+        self.log.info('Verify rand_seed set from yaml')
+        rand_seed = self.params.get("rand_seed", "/run/setup/*")
+        self.assertEqual(self.rand_seed, rand_seed)

src/tests/ftest/harness/config.yaml

@@ -4,6 +4,7 @@ hosts:
 timeout: 60
 setup:
   mgmt_svc_replicas_suffix: .wolf.hpdd.intel.com
+  rand_seed: 7
 server_config:
   name: daos_server
   engines_per_host: 1

src/tests/ftest/nvme/pool_exclude.py

@@ -1,9 +1,9 @@
 """
   (C) Copyright 2020-2023 Intel Corporation.
+  (C) Copyright 2025 Hewlett Packard Enterprise Development LP
 
   SPDX-License-Identifier: BSD-2-Clause-Patent
 """
-import random
 import re
 import threading
 import time
@@ -115,9 +115,9 @@ def run_nvme_pool_exclude(self, num_pool, oclass=None):
                 self.pool.display_pool_daos_space("Pool space: Before Exclude")
                 pver_begin = self.pool.get_version(True)
 
-                index = random.randint(1, len(rank_list))  # nosec
+                index = self.random.randint(1, len(rank_list))
                 rank = rank_list.pop(index - 1)
-                tgt_exclude = random.randint(1, 6)  # nosec
+                tgt_exclude = self.random.randint(1, 6)
                 self.log.info("Removing rank %d, target %d", rank, tgt_exclude)
 
                 self.log.info("Pool Version at the beginning %s", pver_begin)

src/tests/ftest/osa/offline_drain.py

@@ -1,10 +1,9 @@
 """
   (C) Copyright 2020-2023 Intel Corporation.
+  (C) Copyright 2025 Hewlett Packard Enterprise Development LP
 
   SPDX-License-Identifier: BSD-2-Clause-Patent
 """
-import random
-
 from nvme_utils import ServerFillUp
 from osa_utils import OSAUtils
 from test_utils_pool import add_pool
@@ -48,7 +47,7 @@ def run_offline_drain_test(self, num_pool, data=False, oclass=None, pool_fillup=
             oclass = self.ior_cmd.dfs_oclass.value
 
         # Exclude target : random two targets  (target idx : 0-7)
-        exc = random.randint(0, 6)  # nosec
+        exc = self.random.randint(0, 6)
         target_list.append(exc)
         target_list.append(exc + 1)
         t_string = "{},{}".format(target_list[0], target_list[1])

src/tests/ftest/osa/offline_parallel_test.py

@@ -1,11 +1,11 @@
 """
   (C) Copyright 2020-2023 Intel Corporation.
+  (C) Copyright 2025 Hewlett Packard Enterprise Development LP
 
   SPDX-License-Identifier: BSD-2-Clause-Patent
 """
 import copy
 import queue
-import random
 import threading
 import time
 
@@ -83,7 +83,7 @@ def run_offline_parallel_test(self, num_pool, data=False, oclass=None):
             oclass = self.ior_cmd.dfs_oclass.value
 
         # Exclude target : random two targets (target idx : 0-7)
-        exc = random.randint(0, 6)  # nosec
+        exc = self.random.randint(0, 6)
         target_list.append(exc)
         target_list.append(exc + 1)
         t_string = "{},{}".format(target_list[0], target_list[1])

src/tests/ftest/osa/offline_reintegration.py

@@ -1,10 +1,9 @@
 """
   (C) Copyright 2020-2023 Intel Corporation.
+  (C) Copyright 2025 Hewlett Packard Enterprise Development LP
 
   SPDX-License-Identifier: BSD-2-Clause-Patent
 """
-import random
-
 from nvme_utils import ServerFillUp
 from osa_utils import OSAUtils
 from test_utils_pool import add_pool
@@ -83,7 +82,7 @@ def run_offline_reintegration_test(self, num_pool, data=False, server_boot=False
 
         # Exclude ranks 0 and 3 from a random pool
         ranks = [0, 3]
-        self.pool = random.choice(pools)  # nosec
+        self.pool = self.random.choice(pools)
         for loop in range(0, self.loop_test_cnt):
             self.log.info(
                 "==> (Loop %s/%s) Excluding ranks %s from %s",

src/tests/ftest/osa/online_parallel_test.py

@@ -1,11 +1,11 @@
 """
   (C) Copyright 2020-2023 Intel Corporation.
+  (C) Copyright 2025 Hewlett Packard Enterprise Development LP
 
   SPDX-License-Identifier: BSD-2-Clause-Patent
 """
 import copy
 import queue
-import random
 import threading
 import time
 from itertools import product
@@ -93,7 +93,7 @@ def run_online_parallel_test(self, num_pool, racer=False):
         target_list = []
 
         # Exclude target : random two targets  (target idx : 0-7)
-        exc = random.randint(0, 6)  # nosec
+        exc = self.random.randint(0, 6)
         target_list.append(exc)
         target_list.append(exc + 1)
         t_string = "{},{}".format(target_list[0], target_list[1])

src/tests/ftest/osa/online_reintegration.py

@@ -1,10 +1,10 @@
 """
   (C) Copyright 2020-2023 Intel Corporation.
+  (C) Copyright 2025 Hewlett Packard Enterprise Development LP
 
   SPDX-License-Identifier: BSD-2-Clause-Patent
 """
 import queue
-import random
 import threading
 import time
 
@@ -61,7 +61,7 @@ def run_online_reintegration_test(self, num_pool, racer=False, server_boot=False
         exclude_servers = (len(self.hostlist_servers) * 2) - 1
 
         # Exclude one rank : other than rank 0.
-        rank = random.randint(1, exclude_servers)  # nosec
+        rank = self.random.randint(1, exclude_servers)
 
         # Start the daos_racer thread
         if racer is True:

src/tests/ftest/pool/create_all_vm.py

@@ -1,10 +1,9 @@
 """
 (C) Copyright 2022-2023 Intel Corporation.
+(C) Copyright 2025 Hewlett Packard Enterprise Development LP
 
 SPDX-License-Identifier: BSD-2-Clause-Patent
 """
-import random
-
 from general_utils import bytes_to_human
 from pool_create_all_base import PoolCreateAllTestBase
 
@@ -71,7 +70,7 @@ def test_rank_filter(self):
         :avocado: tags=PoolCreateAllVmTests,test_rank_filter
         """
         ranks = list(range(self.engines_count))
-        random.shuffle(ranks)
+        self.random.shuffle(ranks)
         ranks = ranks[(len(ranks) // 2):]
         delta_bytes = self.params.get("delta", "/run/test_rank_filter/*", 0)
         self.log.info("Test ranks filtered pool creation with full storage")

src/tests/ftest/pool/management_race.py

@@ -1,9 +1,9 @@
 """
   (C) Copyright 2022-2023 Intel Corporation.
+  (C) Copyright 2025 Hewlett Packard Enterprise Development LP
 
   SPDX-License-Identifier: BSD-2-Clause-Patent
 """
-import random
 import time
 
 from apricot import TestWithServers
@@ -45,7 +45,7 @@ def del_recreate_query_and_list_pools(
                 self.log.info("--(%d.3.%s.%d)Pool %s recreated.\n",
                               thread_num, pool_id, test_num, pool_id)
                 # pool stays with a random time before destroy
-                pool_stay_time = random.randint(1, 3)  # nosec
+                pool_stay_time = self.random.randint(1, 3)
                 time.sleep(pool_stay_time)
             else:
                 completed = False
@@ -102,7 +102,7 @@ def test_pool_management_race(self):
             self.log.info("==(1.%d) pool created, %s.", pool_number, self.pool[-1].identifier)
 
         # Randomly select a pool for delete, recreate and query
-        pool_number = random.randint(0, len(self.pool) - 1)  # nosec
+        pool_number = self.random.randint(0, len(self.pool) - 1)
 
         # Setup the thread manager for del_and_recreate_pool
         thread_manager = ThreadManager(self.del_recreate_query_and_list_pools, self.timeout - 30)

src/tests/ftest/rebuild/mdtest.py

@@ -73,7 +73,7 @@ def test_rebuild_mdtest(self):
 
         self.log_step("Kill 1 random rank")
         times["kill_rank"] = datetime.now()
-        self.server_managers[0].stop_random_rank(force=True)
+        self.server_managers[0].stop_random_rank(self.random, force=True)
 
         self.log_step("Wait for rebuild to start")
         self.pool.wait_for_rebuild_to_start(interval=rebuild_check_inverval)

src/tests/ftest/server/replay.py

@@ -1,9 +1,9 @@
 """
   (C) Copyright 2023 Intel Corporation.
+  (C) Copyright 2025 Hewlett Packard Enterprise Development LP
 
   SPDX-License-Identifier: BSD-2-Clause-Patent
 """
-import random
 import time
 
 from apricot import TestWithServers
@@ -251,13 +251,13 @@ def test_replay_attributes(self):
         for container in containers:
             for index, item in enumerate((container.pool, container)):
                 # Modify a random pool/container property value
-                name = random.choice(list(modify_attributes[index].keys()))  # nosec
+                name = self.random.choice(list(modify_attributes[index].keys()))
                 modified = False
                 for entry in expected[item.identifier]:
                     if entry['name'] == name:
                         original = entry['value']
                         while entry['value'] == original:
-                            entry['value'] = random.choice(modify_attributes[index][name])  # nosec
+                            entry['value'] = self.random.choice(modify_attributes[index][name])
                         self.log.info(
                             'Modifying %s property: %s -> %s',
                             item.identifier, entry['name'], entry['value'])

src/tests/ftest/util/apricot/apricot/test.py

@@ -157,16 +157,16 @@ def setUp(self):
         super().setUp()
 
         # Random generator that could be seeded for reproducibility
-        env_seed = os.environ.get("DAOS_TEST_RANDOM_SEED", None)
-        if env_seed is None:
+        self.rand_seed = os.environ.get("DAOS_TEST_RANDOM_SEED", None)
+        if self.rand_seed is None:
+            self.rand_seed = self.params.get("rand_seed", "/run/setup/*", None)
+        if self.rand_seed is None:
             self.rand_seed = int.from_bytes(os.urandom(8), byteorder='little')
         else:
             try:
-                self.rand_seed = int(env_seed)
+                self.rand_seed = int(self.rand_seed)
             except ValueError:
-                self.fail(
-                    "ERROR: The env variable DAOS_TEST_RANDOM_SEED "
-                    "does not define a valid integer: got='{}'".format(env_seed))
+                self.fail(f"rand_seed is not an integer: {self.rand_seed}")
         self.log.info("Test.random seed = %d", self.rand_seed)
         self.random = random.Random(self.rand_seed)     # nosec
 

src/tests/ftest/util/daos_io_conf.py

@@ -1,10 +1,10 @@
 """
   (C) Copyright 2020-2023 Intel Corporation.
+  (C) Copyright 2025 Hewlett Packard Enterprise Development LP
 
   SPDX-License-Identifier: BSD-2-Clause-Patent
 """
 import os
-import random
 
 from apricot import TestWithServers
 from command_utils import ExecutableCommand
@@ -94,14 +94,15 @@ def run_conf(self, dmg_config_file):
         return True
 
 
-def gen_unaligned_io_conf(record_size, filename="testfile"):
+def gen_unaligned_io_conf(test, record_size, filename="testfile"):
     """Generate the data-set file based on record size.
 
     Args:
-        record_size(Number): Record Size to fill the data.
+        test (Test): test object
+        record_size (Number): Record Size to fill the data.
         filename (string): Filename (with/without path) for creating the data set.
     """
-    rand_ofs_end = random.randint(1, record_size - 1)  # nosec
+    rand_ofs_end = test.random.randint(1, record_size - 1)
     rand_ofs_start = rand_ofs_end - 1
     file_data = (
         "test_lvl daos",
@@ -172,7 +173,7 @@ def unaligned_io(self):
         for record_size in total_sizes:
             print("Start test for record size = {}".format(record_size))
             # Create unaligned test data set
-            gen_unaligned_io_conf(record_size, self.testfile)
+            gen_unaligned_io_conf(self, record_size, self.testfile)
             # Run test file using daos_run_io_conf
             if not io_conf.run_conf(self.dmg_config_file):
                 self.fail("daos_run_io_conf failed")