redis-benchmarks-specification 0.1.331__tar.gz → 0.1.333__tar.gz

{redis_benchmarks_specification-0.1.331 → redis_benchmarks_specification-0.1.333}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: redis-benchmarks-specification
-Version: 0.1.331
+Version: 0.1.333
 Summary: The Redis benchmarks specification describes the cross-language/tools requirements and expectations to foster performance and observability standards around redis related technologies. Members from both industry and academia, including organizations and individuals are encouraged to contribute.
 Author: filipecosta90
 Author-email: filipecosta.90@gmail.com

{redis_benchmarks_specification-0.1.331 → redis_benchmarks_specification-0.1.333}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "redis-benchmarks-specification"
-version = "0.1.331"
+version = "0.1.333"
 description = "The Redis benchmarks specification describes the cross-language/tools requirements and expectations to foster performance and observability standards around redis related technologies. Members from both industry and academia, including organizations and individuals are encouraged to contribute."
 authors = ["filipecosta90 <filipecosta.90@gmail.com>","Redis Performance Group <performance@redis.com>"]
 readme = "Readme.md"

{redis_benchmarks_specification-0.1.331 → redis_benchmarks_specification-0.1.333}/redis_benchmarks_specification/__self_contained_coordinator__/self_contained_coordinator.py

@@ -122,6 +122,7 @@ _reset_queue_requested = False
 _exclusive_hardware = False
 _http_auth_username = None
 _http_auth_password = None
+_flush_timestamp = None
 
 
 class CoordinatorHTTPHandler(BaseHTTPRequestHandler):
@@ -203,7 +204,7 @@ class CoordinatorHTTPHandler(BaseHTTPRequestHandler):
             self._send_auth_required()
             return
 
-        global _reset_queue_requested
+        global _reset_queue_requested, _flush_timestamp
 
         parsed_path = urlparse(self.path)
 
@@ -240,12 +241,86 @@ class CoordinatorHTTPHandler(BaseHTTPRequestHandler):
                 self.send_header("Content-type", "application/json")
                 self.end_headers()
                 self.wfile.write(json.dumps({"error": str(e)}).encode())
+
+        elif parsed_path.path == "/flush":
+            try:
+                # Read request body (optional)
+                content_length = int(self.headers.get("Content-Length", 0))
+                if content_length > 0:
+                    post_data = self.rfile.read(content_length)
+                    try:
+                        request_data = json.loads(post_data.decode())
+                    except json.JSONDecodeError:
+                        request_data = {}
+                else:
+                    request_data = {}
+
+                # Record flush timestamp
+                flush_time = datetime.datetime.utcnow()
+                _flush_timestamp = flush_time
+
+                logging.info("Flush requested via HTTP endpoint - stopping all containers and processes")
+
+                # Perform flush cleanup
+                self._perform_flush_cleanup()
+
+                self.send_response(200)
+                self.send_header("Content-type", "application/json")
+                self.end_headers()
+                response = {
+                    "status": "success",
+                    "message": "Flush completed - all containers stopped and processes killed",
+                    "flush_timestamp": flush_time.isoformat(),
+                    "timestamp": datetime.datetime.utcnow().isoformat()
+                }
+                self.wfile.write(json.dumps(response).encode())
+
+            except Exception as e:
+                logging.error(f"Error during flush operation: {e}")
+                self.send_response(500)
+                self.send_header("Content-type", "application/json")
+                self.end_headers()
+                response = {
+                    "status": "error",
+                    "message": f"Flush failed: {str(e)}",
+                    "timestamp": datetime.datetime.utcnow().isoformat()
+                }
+                self.wfile.write(json.dumps(response).encode())
+
         else:
             self.send_response(404)
             self.send_header("Content-type", "application/json")
             self.end_headers()
             self.wfile.write(json.dumps({"error": "Not found"}).encode())
 
+    def _perform_flush_cleanup(self):
+        """Perform flush cleanup: stop all containers and kill memtier processes"""
+        import subprocess
+
+        # Kill all memtier processes
+        try:
+            logging.info("Killing all memtier_benchmark processes")
+            subprocess.run(["pkill", "-f", "memtier_benchmark"], check=False)
+            subprocess.run(["pkill", "-f", "memtier"], check=False)
+        except Exception as e:
+            logging.warning(f"Error killing memtier processes: {e}")
+
+        # Stop all Docker containers
+        try:
+            logging.info("Stopping all Docker containers")
+            client = docker.from_env()
+            containers = client.containers.list()
+            for container in containers:
+                try:
+                    logging.info(f"Stopping container: {container.name} ({container.id[:12]})")
+                    container.stop(timeout=5)
+                except Exception as e:
+                    logging.warning(f"Error stopping container {container.name}: {e}")
+        except Exception as e:
+            logging.warning(f"Error accessing Docker client: {e}")
+
+        logging.info("Flush cleanup completed")
+
 
 def start_http_server(port=8080):
     """Start the HTTP server in a separate thread"""
@@ -259,6 +334,9 @@ def start_http_server(port=8080):
             logging.info(
                 f"  POST /reset-queue - Reset pending streams and skip running tests"
             )
+            logging.info(
+                f"  POST /flush - Stop all containers and processes, ignore work before flush time"
+            )
             server.serve_forever()
         except Exception as e:
             logging.error(f"HTTP server error: {e}")
@@ -784,6 +862,19 @@ def process_self_contained_coordinator_stream(
                 git_timestamp_ms,
                 run_arch,
             ) = extract_build_info_from_streamdata(testDetails)
+
+            # Check if this work should be ignored due to flush
+            global _flush_timestamp
+            if _flush_timestamp is not None and use_git_timestamp and git_timestamp_ms is not None:
+                # Convert flush timestamp to milliseconds for comparison
+                flush_timestamp_ms = int(_flush_timestamp.timestamp() * 1000)
+                if git_timestamp_ms < flush_timestamp_ms:
+                    logging.info(
+                        f"Ignoring work with git_timestamp_ms {git_timestamp_ms} "
+                        f"(before flush timestamp {flush_timestamp_ms}). Stream id: {stream_id}"
+                    )
+                    return stream_id, False, 0
+
             tf_github_org = default_github_org
             if b"github_org" in testDetails:
                 tf_github_org = testDetails[b"github_org"].decode()
@@ -954,6 +1045,12 @@ def process_self_contained_coordinator_stream(
                     command_regexp,
                 )
 
+                logging.info(f"Adding {len(filtered_test_files)} tests to pending test list")
+
+                # Use pipeline for efficient bulk operations
+                pipeline = github_event_conn.pipeline()
+                test_names_added = []
+
                 for test_file in filtered_test_files:
                     with open(test_file, "r") as stream:
                         (
@@ -961,14 +1058,18 @@ def process_self_contained_coordinator_stream(
                             benchmark_config,
                             test_name,
                         ) = get_final_benchmark_config(None, None, stream, "")
-                    github_event_conn.lpush(stream_test_list_pending, test_name)
-                    github_event_conn.expire(
-                        stream_test_list_pending, REDIS_BINS_EXPIRE_SECS
-                    )
+                    pipeline.lpush(stream_test_list_pending, test_name)
+                    test_names_added.append(test_name)
                     logging.debug(
-                        f"Added test named {test_name} to the pending test list in key {stream_test_list_pending}"
+                        f"Queued test named {test_name} for addition to pending test list"
                     )
 
+                # Set expiration and execute pipeline
+                pipeline.expire(stream_test_list_pending, REDIS_BINS_EXPIRE_SECS)
+                pipeline.execute()
+
+                logging.info(f"Successfully added {len(test_names_added)} tests to pending test list in key {stream_test_list_pending}")
+
                 pending_tests = len(filtered_test_files)
                 failed_tests = 0
                 benchmark_suite_start_datetime = datetime.datetime.utcnow()