benchmark-runner 1.0.803__py3-none-any.whl → 1.0.805__py3-none-any.whl

benchmark_runner/common/oc/oc.py

@@ -1289,9 +1289,27 @@ class OC(SSH):
         else:
             return self.run(ssh_vm_cmd)
 
-    def get_virtctl_vm_status(self, vm_name: str = '', namespace: str = environment_variables.environment_variables_dict['namespace']):
+    def wait_for_vm_access(self, vm_name: str = '', namespace: str = environment_variables.environment_variables_dict['namespace'],
+                        timeout: int = SHORT_TIMEOUT):
+        """
+        This method waits for VM to be accessible via virtctl ssh
+        :param vm_name:
+        :param timeout:
+        :return:
+        """
+        current_wait_time = 0
+        while timeout <= 0 or current_wait_time <= timeout:
+            check_virtctl_vm_cmd = f"virtctl ssh --local-ssh=true --local-ssh-opts='-o BatchMode=yes' --local-ssh-opts='-o PasswordAuthentication=no' --local-ssh-opts='-o ConnectTimeout=2' root@{vm_name} -n {namespace} 2>&1 |egrep 'denied|verification failed'  && echo 'True' || echo 'False'"
+            if 'True' in self.run(check_virtctl_vm_cmd):
+                return 'True'
+            # sleep for x seconds
+            time.sleep(OC.SLEEP_TIME)
+            current_wait_time += OC.SLEEP_TIME
+        raise VMStateTimeout(vm_name=vm_name, state='virtctl')
+
+    def get_vm_access(self, vm_name: str = '', namespace: str = environment_variables.environment_variables_dict['namespace']):
         """
-        This method returns True when the VM is active and an error message when it is not, using virtctl protocol
+        This method returns True when the VM is access and an error message when it is not, using virtctl protocol
         :param vm_name:
         :param namespace:
         :return: virtctl_status 'True' if successful, or an error message if it fails.
@@ -1312,7 +1330,7 @@ class OC(SSH):
         :return:
         """
         namespace = f'-n {namespace}' if namespace else ''
-        command = f"{self._cli} get vmi {vm_name} {namespace} -o jsonpath={{.metadata.labels.'kubevirt\\.io/nodeName'}}"
+        command = f"{self._cli} get vmi {vm_name} {namespace} -o jsonpath=\"{{.status.nodeName}}\""
 
         try:
             result = self.run(command)

benchmark_runner/workloads/bootstorm_vm.py

@@ -66,6 +66,19 @@ class BootstormVM(WorkloadsOperations):
         """
         self._bootstorm_start_time[vm_name] = time.time()
 
+    @logger_time_stamp
+    def _wait_vm_access(self, vm_name: str):
+        """
+        This method verifies virtctl into VM and return vm node in success or False if failed
+        @return:
+        """
+        if self._oc.get_vm_node(vm_name=vm_name):
+            vm_node = self._oc.get_vm_node(vm_name=vm_name)
+            if self._oc.wait_for_vm_access(vm_name=vm_name):
+                logger.info(f"Successfully virtctl into VM: '{vm_name}' in node {vm_node} ")
+            return vm_node
+        return False
+
     @logger_time_stamp
     def _wait_ssh_vm(self, vm_name: str):
         """
@@ -92,7 +105,7 @@ class BootstormVM(WorkloadsOperations):
         """
         if vm_node:
             delta = round((time.time() - self._bootstorm_start_time[vm_name]) * self.MILLISECONDS, 3)
-            data = {'vm_name': vm_name, 'node': vm_node, 'bootstorm_time': delta, 'vm_ssh': int(bool(vm_node)),}
+            data = {'vm_name': vm_name, 'node': vm_node, 'bootstorm_time': delta, 'access_vm': int(bool(vm_node)),}
             logger.info(data)
             return data
         return {}
@@ -123,15 +136,15 @@ class BootstormVM(WorkloadsOperations):
                 self._data_dict.update(self._prometheus_result)
             total_run_time = self._get_bootstorm_vm_total_run_time()
             self._data_dict.update({'total_run_time': total_run_time})
-            # Google drive run_artifacts_url folder path
-            if self._google_drive_path and self.get_run_artifacts_google_drive():
-                self._data_dict.update({'run_artifacts_url': self.get_run_artifacts_google_drive()})
-            if self._es_host:
-                # upload several run results
-                self._upload_to_elasticsearch(index=self._es_index, kind=self._kind, status=self._status,
-                                              result=self._data_dict)
-                # verify that data upload to elastic search according to unique uuid
-                self._verify_elasticsearch_data_uploaded(index=self._es_index, uuid=self._uuid)
+        # Google drive run_artifacts_url folder path
+        if self._google_drive_path and self.get_run_artifacts_google_drive():
+            self._data_dict.update({'run_artifacts_url': self.get_run_artifacts_google_drive()})
+        if self._es_host:
+            # upload several run results
+            self._upload_to_elasticsearch(index=self._es_index, kind=self._kind, status=self._status,
+                                          result=self._data_dict)
+            # verify that data upload to elastic search according to unique uuid
+            self._verify_elasticsearch_data_uploaded(index=self._es_index, uuid=self._uuid)
 
     def _run_vm(self):
         """
@@ -143,7 +156,7 @@ class BootstormVM(WorkloadsOperations):
         self._set_bootstorm_vm_first_run_time()
         self._set_bootstorm_vm_start_time(vm_name=self._vm_name)
         self._virtctl.start_vm_sync(vm_name=self._vm_name)
-        self.vm_node = self._wait_ssh_vm(vm_name=self._vm_name)
+        self.vm_node = self._wait_vm_access(vm_name=self._vm_name)
         self._data_dict = self._get_bootstorm_vm_elapsed_time(vm_name=self._vm_name, vm_node=self.vm_node)
         self._data_dict['run_artifacts_url'] = os.path.join(self._run_artifacts_url,
                                                             f'{self._get_run_artifacts_hierarchy(workload_name=self._workload_name, is_file=True)}-{self._time_stamp_format}.tar.gz')
@@ -158,16 +171,16 @@ class BootstormVM(WorkloadsOperations):
         :param vm_name: The name of the VM to verify.
         :param retries: Number of retry attempts.
         :param delay: Time to wait (in seconds) between retries.
-        @return: virtctl_status 'True' if successful, or an error message if it fails
+        @return: access_status 'True' if successful, or an error message if it fails
         """
-        virtctl_status = None
+        access_status = None
         for attempt in range(retries):
             try:
-                virtctl_status = self._oc.get_virtctl_vm_status(vm_name)
+                access_status = self._oc.get_vm_access(vm_name)
 
-                if str(virtctl_status).lower() == "true":
+                if str(access_status).lower() == "true":
                     # Log success and store relevant data
-                    logger.info(f"VM {vm_name} verified successfully (virtctl SSH status: { virtctl_status}).")
+                    logger.info(f"VM {vm_name} verified successfully (virtctl SSH status: {access_status}).")
                     break  # Exit loop on success
                 else:
                     logger.info(f"Attempt {attempt + 1}/{retries}: VM {vm_name} not reachable via Virtctl SSH. Retrying...")
@@ -185,8 +198,8 @@ class BootstormVM(WorkloadsOperations):
         self._data_dict = {
             'vm_name': vm_name,
             'node': vm_node,
-            'virtctl_vm': 1 if str(virtctl_status).lower() == "true" else 0, # int value for Grafana
-            'virtctl_status': virtctl_status,
+            'access_vm': 1 if str(access_status).lower() == "true" else 0, # int value for Grafana
+            'access_status': access_status,
             'test_name': self._test_name,
             'run_artifacts_url': os.path.join(
                 self._run_artifacts_url,
@@ -194,13 +207,13 @@ class BootstormVM(WorkloadsOperations):
             )
         }
 
-        if str(virtctl_status).lower() != "true":
+        if str(access_status).lower() != "true":
             logger.info(
-                f"All attempts failed for VM {vm_name}. Final SSH status: {self._data_dict.get('virtctl_status', 'No status available')}")
+                f"All attempts failed for VM {vm_name}. Final SSH status: {self._data_dict.get('access_status', 'No status available')}")
             error_log_path = f"{self._run_artifacts_path}/{vm_name}_error.log"
 
             # Retrieve the status or use a default message
-            status_message = self._data_dict.get('virtctl_status') or "No status available"
+            status_message = self._data_dict.get('access_status') or "No status available"
 
             try:
                 with open(error_log_path, "w") as error_log_file:
@@ -209,7 +222,7 @@ class BootstormVM(WorkloadsOperations):
                 logger.error(f"Failed to write error log for {vm_name}: {write_err}")
 
         self._finalize_vm()
-        return virtctl_status
+        return access_status
 
     def _verify_single_vm_wrapper(self, vm_name, return_dict):
         """
@@ -251,7 +264,7 @@ class BootstormVM(WorkloadsOperations):
                 failure_vms.append(vm_name)
         return failure_vms
 
-    def _verify_virtctl_vms(self, delay=10):
+    def _verify_vms_access(self, delay=10):
             """
             This method verifies the virtctl SSH login for each VM, either during the upgrade or once for each VM.
             It prepares the data for ElasticSearch, generates a must-gather in case of an error, and uploads it to Google Drive.
@@ -292,19 +305,19 @@ class BootstormVM(WorkloadsOperations):
                                                       odf_version=self._odf_version)
                     # Error log with details of failed VM, for catching all vm errors
                     logger.error(f"Failed to verify virtctl SSH login for the following VMs: {', '.join(failure_vms)}")
-                # Upload artifacts
-                if self._google_drive_shared_drive_id:
-                    self.upload_run_artifacts_to_google_drive()
-                elif self._endpoint_url and not self._google_drive_shared_drive_id:
-                    self.upload_run_artifacts_to_s3()
-                else:
-                    self._save_artifacts_local = True
-                if self._es_host:
-                    self._data_dict.update({'run_artifacts_url': self.get_run_artifacts_google_drive()})
-                    # upload several run results
-                    self._upload_to_elasticsearch(index=self._es_index, kind=self._kind, status=self._status,result=self._data_dict)
-                    # verify that data upload to elastic search according to unique uuid
-                    self._verify_elasticsearch_data_uploaded(index=self._es_index, uuid=self._uuid)
+                    # Upload artifacts
+                    if self._google_drive_shared_drive_id:
+                        self.upload_run_artifacts_to_google_drive()
+                    elif self._endpoint_url:
+                        self.upload_run_artifacts_to_s3()
+                    else:
+                        self._save_artifacts_local = True
+                    if self._es_host:
+                        self._data_dict.update({'run_artifacts_url': self.get_run_artifacts_google_drive(), 'failure_vms': failure_vms, 'verification_failure': True})
+                        # upload several run results
+                        self._upload_to_elasticsearch(index=self._es_index, kind=self._kind, status=self._status,result=self._data_dict)
+                        # verify that data upload to elastic search according to unique uuid
+                        self._verify_elasticsearch_data_uploaded(index=self._es_index, uuid=self._uuid)
 
             except Exception as err:
                 # Save run artifacts logs
@@ -322,7 +335,7 @@ class BootstormVM(WorkloadsOperations):
             if not self._run_strategy:
                 self._virtctl.start_vm_async(vm_name=f'{self._workload_name}-{self._trunc_uuid}-{vm_num}')
             self._virtctl.wait_for_vm_status(vm_name=vm_name, status=VMStatus.Running)
-            vm_node = self._wait_ssh_vm(vm_name)
+            vm_node = self._wait_vm_access(vm_name)
             self._data_dict = self._get_bootstorm_vm_elapsed_time(vm_name=vm_name, vm_node=vm_node)
             self._data_dict['run_artifacts_url'] = os.path.join(self._run_artifacts_url, f'{self._get_run_artifacts_hierarchy(workload_name=self._workload_name, is_file=True)}-scale-{self._time_stamp_format}.tar.gz')
             self._finalize_vm()
@@ -394,7 +407,7 @@ class BootstormVM(WorkloadsOperations):
     def run_vm_workload(self):
         # verification only w/o running or deleting any resource
         if self._verification_only:
-            self._verify_virtctl_vms()
+            self._verify_vms_access()
         else:
             if not self._scale:
                 self._run_vm()

{benchmark_runner-1.0.803.dist-info → benchmark_runner-1.0.805.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: benchmark-runner
-Version: 1.0.803
+Version: 1.0.805
 Summary: Benchmark Runner Tool
 Home-page: https://github.com/redhat-performance/benchmark-runner
 Author: Red Hat

{benchmark_runner-1.0.803.dist-info → benchmark_runner-1.0.805.dist-info}/RECORD

@@ -46,7 +46,7 @@ benchmark_runner/common/logger/init_logger.py,sha256=ERa-gNqrl2pZybj7v3csvmao7Mv
 benchmark_runner/common/logger/logger_exceptions.py,sha256=rivdlRm_jIsKQ53rP_-HX8emdtOmQNO4JuIkg8fnBoc,454
 benchmark_runner/common/logger/logger_time_stamp.py,sha256=2JgugN9LpXF4Ijx0wPRzz3DAGJB8eJpM5g1qPvbWbV8,1479
 benchmark_runner/common/oc/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-benchmark_runner/common/oc/oc.py,sha256=m0fUSau6RhZlKLT8HY2D-RpH1Q2GVFzuXsMNW98AjTI,69552
+benchmark_runner/common/oc/oc.py,sha256=iCsh3eBrhRta2qn7h97vhy-jWQ_fKlC9HTi_Cg2fYZQ,70518
 benchmark_runner/common/oc/oc_exceptions.py,sha256=XfKUzeK3Ors_Y2csQEoGqrlsZlYvq6OXLkFh9s_mQRM,6311
 benchmark_runner/common/oc/singleton_oc_login.py,sha256=OISe7GxN-povQBk1GYVwkdcuEvIbDQP5QImYbNvhX5Y,2395
 benchmark_runner/common/ocp_resources/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -166,15 +166,15 @@ benchmark_runner/main/environment_variables_exceptions.py,sha256=UR0Ith0P0oshsDZ
 benchmark_runner/main/main.py,sha256=A744O550wQh37hhk10H0HlT28LZ_2EOaRlJyWG6Pras,14083
 benchmark_runner/main/temporary_environment_variables.py,sha256=ODSHkfhgvdr_b2e3XyvykW21MVjSdyqimREyMc2klRE,957
 benchmark_runner/workloads/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-benchmark_runner/workloads/bootstorm_vm.py,sha256=zhjl0pchl--H9SD6yxNIDKhDvFyL2-WVZZtdBaddGdE,20636
+benchmark_runner/workloads/bootstorm_vm.py,sha256=1nugd-X-8ZX2-inIiHMxQnPDfUlmCm7OKKW6_EinwBc,21168
 benchmark_runner/workloads/vdbench_pod.py,sha256=feu3lvNumfBCD-An6__xS5Kt9nA50A_-0FmqTXuU9iw,10011
 benchmark_runner/workloads/vdbench_vm.py,sha256=4rRbE-jAbmNrhP-k8F_OREkJ59VfQ7wLrfRQPwDneJg,9786
 benchmark_runner/workloads/windows_vm.py,sha256=qFVD3qBFMnVpYXnrpam-7H5-0Yzvx6qtaEEZx4T-ex4,2415
 benchmark_runner/workloads/workloads.py,sha256=F9fnk4h715tq7ANSCbDH0jktB8fpr_u3YG61Kdi5_os,1422
 benchmark_runner/workloads/workloads_exceptions.py,sha256=u7VII95iPRF_YhfpGH1U1RmgiIYESMOtbSF1dz7_ToE,1858
 benchmark_runner/workloads/workloads_operations.py,sha256=cuhGZA1n1Ing0amC-f9Y4MYtwQrFGyaoZUNkpZObKX4,26432
-benchmark_runner-1.0.803.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-benchmark_runner-1.0.803.dist-info/METADATA,sha256=g7Ax2U9tG1LhMfzOZ2MeQqnftfAn6NB0MyfqQ4ay1bY,11520
-benchmark_runner-1.0.803.dist-info/WHEEL,sha256=0CuiUZ_p9E4cD6NyLD6UG80LBXYyiSYZOKDm5lp32xk,91
-benchmark_runner-1.0.803.dist-info/top_level.txt,sha256=MP7UbTCzu59D53uKCZl5VsQeM_vheyMc7FmryczJQbk,17
-benchmark_runner-1.0.803.dist-info/RECORD,,
+benchmark_runner-1.0.805.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+benchmark_runner-1.0.805.dist-info/METADATA,sha256=-5DyHf3RX4fcO6nj6tTrIgFH6Akj8omUOlzFCop-pcs,11520
+benchmark_runner-1.0.805.dist-info/WHEEL,sha256=DnLRTWE75wApRYVsjgc6wsVswC54sMSJhAEd4xhDpBk,91
+benchmark_runner-1.0.805.dist-info/top_level.txt,sha256=MP7UbTCzu59D53uKCZl5VsQeM_vheyMc7FmryczJQbk,17
+benchmark_runner-1.0.805.dist-info/RECORD,,

{benchmark_runner-1.0.803.dist-info → benchmark_runner-1.0.805.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.3.1)
+Generator: setuptools (80.4.0)
 Root-Is-Purelib: true
 Tag: py3-none-any