Windows server MSSQL 2022 hammerdb workload (#1162)

Author: ebattat

MANIFEST.in

@@ -20,6 +20,9 @@ include benchmark_runner/common/template_operations/templates/bootstorm/*.yaml
 include benchmark_runner/common/template_operations/templates/bootstorm/internal_data/*.yaml
 include benchmark_runner/common/template_operations/templates/windows/*.yaml
 include benchmark_runner/common/template_operations/templates/windows/internal_data/*.yaml
+include benchmark_runner/common/template_operations/templates/winmssql/*.yaml
+include benchmark_runner/common/template_operations/templates/winmssql/internal_data/*.yaml
+include benchmark_runner/common/template_operations/templates/winmssql/windows_benchmark_runner/*
 
 # ocp resource
 include benchmark_runner/common/ocp_resources/lso/template/*.sh

README.md

@@ -65,9 +65,12 @@ The following options may be passed via command line flags or set in the environ
 
 Choose one from the following list:
 
-`['stressng_pod', 'stressng_vm', 'stressng_kata', 'uperf_pod', 'uperf_vm', 'uperf_kata', 'hammerdb_pod_mariadb', 'hammerdb_vm_mariadb', 'hammerdb_kata_mariadb', 'hammerdb_pod_mariadb_lso', 'hammerdb_vm_mariadb_lso', 'hammerdb_kata_mariadb_lso', 'hammerdb_pod_postgres', 'hammerdb_vm_postgres', 'hammerdb_kata_postgres', 'hammerdb_pod_postgres_lso', 'hammerdb_vm_postgres_lso', 'hammerdb_kata_postgres_lso', 'hammerdb_pod_mssql', 'hammerdb_vm_mssql', 'hammerdb_kata_mssql', 'hammerdb_pod_mssql_lso', 'hammerdb_vm_mssql_lso', 'hammerdb_kata_mssql_lso', 'vdbench_pod', 'vdbench_kata', 'vdbench_vm', 'clusterbuster', 'bootstorm_vm']`
+`['stressng_pod', 'stressng_vm', 'stressng_kata', 'uperf_pod', 'uperf_vm', 'uperf_kata', 'hammerdb_pod_mariadb', 'hammerdb_vm_mariadb', 'hammerdb_kata_mariadb', 'hammerdb_pod_mariadb_lso', 'hammerdb_vm_mariadb_lso', 'hammerdb_kata_mariadb_lso', 'hammerdb_pod_postgres', 'hammerdb_vm_postgres', 'hammerdb_kata_postgres', 'hammerdb_pod_postgres_lso', 'hammerdb_vm_postgres_lso', 'hammerdb_kata_postgres_lso', 'hammerdb_pod_mssql', 'hammerdb_vm_mssql', 'hammerdb_kata_mssql', 'hammerdb_pod_mssql_lso', 'hammerdb_vm_mssql_lso', 'hammerdb_kata_mssql_lso', 'vdbench_pod', 'vdbench_kata', 'vdbench_vm', 'clusterbuster', 'bootstorm_vm', 'windows_vm', 'winmssql_vm' ]`
 
 ** clusterbuster workloads: cpusoaker, files, fio, uperf. for more details [see](https://github.com/RobertKrawitz/OpenShift4-tools)
+** For windows workloads: need to share windows qcow2 image by nginx
+** For hammerdb mssql must run only once [permission](https://github.com/redhat-performance/benchmark-runner/blob/main/benchmark_runner/common/ocp_resources/custom/template/02_mssql_patch_template.sh)
+** winmssql_vm: will run hammerdb inside windows server mssql 2022: for more details [see](benchmark_runner/common/template_operations/templates/winmssql/windows_benchmark_runner/readme)
 
 Not mandatory:
 
@@ -103,6 +106,8 @@ Not mandatory:
 
 **optional:** WORKER_DISK_IDS=$WORKER_DISK_IDS [WORKER_DISK_IDS For ODF/LSO workloads hammerdb/vdbench]
 
+**optional:** WINDOWS_URL=$WINDOWS_URL [WINDOWS_URL for qcow2 image that can be shared by Nginx]
+
 For example:
 
 ```sh
@@ -175,3 +180,7 @@ name of the promdb snapshot.
 ## How to develop in benchmark-runner
 
 see [HOW_TO.md](HOW_TO.md)
+
+## benchmark-runner blog
+
+open [link](https://developers.redhat.com/articles/2025/11/18/how-run-performance-tests-using-benchmark-runner)

benchmark_runner/common/elasticsearch/elasticsearch_exceptions.py

@@ -10,3 +10,9 @@ class ElasticSearchDataNotUploaded(ElasticSearchError):
     def __init__(self):
         self.message = f'Data did not upload to elastic search'
         super(ElasticSearchDataNotUploaded, self).__init__(self.message)
+
+class ElasticSearchDataNotFound(ElasticSearchError):
+    """This exception return elastic search not uploaded error"""
+    def __init__(self):
+        self.message = f'Data did not found to elastic search'
+        super(ElasticSearchDataNotFound, self).__init__(self.message)

benchmark_runner/common/elasticsearch/elasticsearch_operations.py

@@ -6,9 +6,9 @@
 from elasticsearch import Elasticsearch
 from elasticsearch.connection import create_ssl_context
 from elasticsearch_dsl import Search
-from datetime import datetime, timezone
+from datetime import datetime, timezone, timedelta
 
-from benchmark_runner.common.elasticsearch.elasticsearch_exceptions import ElasticSearchDataNotUploaded
+from benchmark_runner.common.elasticsearch.elasticsearch_exceptions import ElasticSearchDataNotUploaded, ElasticSearchDataNotFound
 from benchmark_runner.common.logger.logger_time_stamp import logger_time_stamp, logger
 
 
@@ -154,11 +154,12 @@ def verify_elasticsearch_data_uploaded(self, index: str, uuid: str = '', workloa
             raise ElasticSearchDataNotUploaded
 
     @typechecked()
-    def upload_to_elasticsearch(self, index: str, data: dict, doc_type: str = '_doc', es_add_items: dict = None, **kwargs):
+    def upload_to_elasticsearch(self, index: str, data: dict, doc_type: str = '_doc', timestamp: datetime = None, es_add_items: dict = None, **kwargs):
         """
         This method uploads json data into elasticsearch
         :param index: index name to be stored in elasticsearch
         :param data: data must be in dictionary i.e. {'key': 'value'}
+        :param timestamp:
         :param doc_type:
         :param es_add_items:
         :return:
@@ -169,7 +170,10 @@ def upload_to_elasticsearch(self, index: str, data: dict, doc_type: str = '_doc'
                 data.update(es_add_items)
 
             # utcnow - solve timestamp issue
-            data['timestamp'] = datetime.now(timezone.utc)  # datetime.utcnow() or datetime.now()
+            if timestamp:
+                data['timestamp'] = timestamp
+            else:
+                data['timestamp'] = datetime.now(timezone.utc)  # datetime.utcnow() or datetime.now()
 
             # Uploads data to elasticsearch server
             try:
@@ -229,32 +233,48 @@ def delete_elasticsearch_index_by_id(self, index: str, id: str):
 
     @typechecked()
     @logger_time_stamp
-    def get_query_data_between_dates(self, start_datetime: datetime, end_datetime: datetime):
+    def get_query_data_between_dates(self, start_datetime: datetime, end_datetime: datetime, sort_order: str = "desc") -> dict:
         """
-        This method returns the query for fetching data between dates
-        @param start_datetime:
-        @param end_datetime:
-        @return:
+        Returns an Elasticsearch query for fetching data between UTC-aware datetime ranges.
+
+        :param start_datetime: datetime, start of the range (UTC-aware)
+        :param end_datetime: datetime, end of the range (UTC-aware)
+        :param sort_order: desc or asc
+        :return: dict, Elasticsearch query
         """
-        if start_datetime and end_datetime:
-            if end_datetime < start_datetime:
-                start_datetime = end_datetime
-            query = {
-                    "bool": {
-                        "filter": {
-                            "range": {
-                                "timestamp": {
-                                    "format": "yyyy-MM-dd HH:mm:ss"
-                                }
+        if not start_datetime:
+            raise ValueError('Empty parameters: start_datetime')
+        if not end_datetime:
+            raise ValueError('Empty parameters: end_datetime')
+
+        # Ensure start_datetime <= end_datetime
+        if end_datetime < start_datetime:
+            start_datetime, end_datetime = end_datetime, start_datetime
+
+        # Convert to ISO 8601 with Z
+        start_iso = start_datetime.replace(microsecond=0).isoformat() + "Z"
+        end_iso = end_datetime.replace(microsecond=0).isoformat() + "Z"
+
+        # Build Elasticsearch query
+        query = {
+            "query": {
+                "bool": {
+                    "filter": {
+                        "range": {
+                            "timestamp": {
+                                "gte": start_iso,
+                                "lte": end_iso
                             }
                         }
                     }
-            }
-            query['bool']['filter']['range']['timestamp']['lte'] = str(end_datetime.replace(microsecond=0))
-            query['bool']['filter']['range']['timestamp']['gte'] = str(start_datetime.replace(microsecond=0))
-            return query
-        else:
-            raise Exception('Empty parameters: start_datetime/ end_datetime')
+                }
+            },
+            "sort": [
+                {"timestamp": {"order": sort_order}}
+            ]
+        }
+
+        return query
 
     @typechecked()
     @logger_time_stamp
@@ -271,7 +291,7 @@ def get_index_data_between_dates(self, index: str, start_datetime: datetime = No
         if index and start_datetime and end_datetime:
             es_data = []
             query = self.get_query_data_between_dates(start_datetime, end_datetime)
-            response = self.__es.search(index=index, query=query, size=number_of_documents, scroll=scroll_duration)
+            response = self.__es.search(index=index, body=query, size=number_of_documents, scroll=scroll_duration)
             scroll_id = response.get('_scroll_id')
             if response.get('hits').get('hits'):
                 es_data.extend(response.get('hits').get('hits'))
@@ -285,6 +305,63 @@ def get_index_data_between_dates(self, index: str, start_datetime: datetime = No
         else:
             raise Exception('Empty parameters: index/ start_datetime/ end_datetime')
 
+    @typechecked()
+    @logger_time_stamp
+    def get_latest_resource_with_key(
+            self,
+            index: str,
+            key: str,
+            start_datetime: datetime = None,
+            end_datetime: datetime = None
+    ) -> dict:
+        """
+        Returns the _source of the most recent document (latest first)
+        that contains the given key.
+        If none found, returns an empty dict.
+        """
+        if not end_datetime:
+            end_datetime = datetime.now(timezone.utc)
+        if not start_datetime:
+            start_datetime = end_datetime - timedelta(minutes=60)
+
+        docs = self.get_index_data_between_dates(
+            index,
+            start_datetime=start_datetime,
+            end_datetime=end_datetime
+        )
+
+        if not docs:
+            return {}
+
+        # Latest → oldest
+        for doc in docs:
+            source = doc.get('_source', {})
+            if key in source:
+                return source
+
+        return {}
+
+    @typechecked()
+    @logger_time_stamp
+    def get_uuid_for_ids(self, index: str, ids: list[str]) -> dict:
+        """
+        Return a mapping of doc_id -> uuid (or None if missing)
+        """
+        if not ids:
+            # Nothing to fetch, avoid _mget with empty list
+            return {}
+        docs = self.__es.mget(
+            index=index,
+            body={"ids": ids}
+        )
+        result = {}
+        for doc in docs["docs"]:
+            if doc.get("found"):
+                result[doc["_id"]] = doc["_source"].get("uuid")
+            else:
+                result[doc["_id"]] = None
+        return result
+
     @typechecked()
     @logger_time_stamp
     def get_index_ids_between_dates(self, index: str, start_datetime: datetime = None, end_datetime: datetime = None):

benchmark_runner/common/template_operations/template_operations.py

@@ -166,7 +166,7 @@ def __generate_yamls_internal(self, scale: str = None, scale_num: str = None, sc
             if os.path.isfile(os.path.join(self.__dir_path, f'namespace_template.yaml')):
                 answer['namespace.yaml'] = render_yaml_file(dir_path=self.__dir_path, yaml_file='namespace_template.yaml', environment_variable_dict=self.__environment_variables_dict)
             # windows workload
-            if 'windows' in self.__workload_name:
+            if 'win' in self.__workload_name:
                 answer['windows_dv.yaml'] = render_yaml_file(dir_path=os.path.join(workload_dir_path, 'internal_data'), yaml_file='windows_dv_template.yaml', environment_variable_dict=render_data)
             # vdbench scale
             if scale and redis and 'vdbench' in self.__workload_name: