From 9a9d42efd7c75d08324e4b4b3d78e4024683f87f Mon Sep 17 00:00:00 2001 From: laurin Date: Fri, 31 Oct 2025 10:37:45 +0100 Subject: [PATCH 01/69] initial sebs cloudflare infra, functions, config, triggers. readme in sebs/cloudflare folder for comprehensive cloudflare doc and next steps --- sebs/cloudflare/README.md | 338 ++++++++++++++++ sebs/cloudflare/__init__.py | 4 + sebs/cloudflare/cloudflare.py | 723 ++++++++++++++++++++++++++++++++++ sebs/cloudflare/config.py | 242 ++++++++++++ sebs/cloudflare/function.py | 64 +++ sebs/cloudflare/resources.py | 68 ++++ sebs/cloudflare/triggers.py | 113 ++++++ sebs/sebs.py | 4 + 8 files changed, 1556 insertions(+) create mode 100644 sebs/cloudflare/README.md create mode 100644 sebs/cloudflare/__init__.py create mode 100644 sebs/cloudflare/cloudflare.py create mode 100644 sebs/cloudflare/config.py create mode 100644 sebs/cloudflare/function.py create mode 100644 sebs/cloudflare/resources.py create mode 100644 sebs/cloudflare/triggers.py diff --git a/sebs/cloudflare/README.md b/sebs/cloudflare/README.md new file mode 100644 index 000000000..f40793f87 --- /dev/null +++ b/sebs/cloudflare/README.md @@ -0,0 +1,338 @@ +# Cloudflare Workers Implementation for SeBS + +This directory contains the implementation of Cloudflare Workers support for the SeBS (Serverless Benchmarking Suite). + +## Key Components + +### 1. `cloudflare.py` - Main System Implementation + +This file implements the core Cloudflare Workers platform integration, including: + +- **`create_function()`** - Creates a new Cloudflare Worker + - Checks if worker already exists + - Uploads worker script via Cloudflare API + - Adds HTTP and Library triggers + - Returns a `CloudflareWorker` instance + +- **`cached_function()`** - Handles cached functions + - Refreshes triggers and logging handlers for functions retrieved from cache + +- **`update_function()`** - Updates an existing worker + - Uploads new script content + - Updates worker configuration + +- **`update_function_configuration()`** - Updates worker configuration + - Note: Cloudflare Workers have limited runtime configuration compared to AWS Lambda or Azure Functions + - Memory and CPU time limits are managed by Cloudflare + +- **`package_code()`** - Prepares code for deployment + - Packages JavaScript/Node.js code for worker deployment + - Returns package path and size + +### 2. `function.py` - CloudflareWorker Class + +Represents a Cloudflare Worker function with: +- Worker name and script ID +- Runtime information +- Serialization/deserialization for caching +- Account ID association + +### 3. `config.py` - Configuration Classes + +Contains three main classes: + +- **`CloudflareCredentials`** - Authentication credentials + - Supports API token or email + API key + - Requires account ID + - Can be loaded from environment variables or config file + +- **`CloudflareResources`** - Platform resources + - KV namespace IDs + - Storage bucket mappings + - Resource ID management + +- **`CloudflareConfig`** - Overall configuration + - Combines credentials and resources + - Handles serialization to/from cache + +### 4. `triggers.py` - Trigger Implementations + +- **`LibraryTrigger`** - Programmatic invocation via Cloudflare API +- **`HTTPTrigger`** - HTTP invocation via worker URLs + - Workers are automatically accessible at `https://{name}.{account}.workers.dev` + +This provides the behavior of SeBS to invoke serverless functions via either library or http triggers. + +### 5. `resources.py` - System Resources + +Handles Cloudflare-specific resources like KV namespaces and R2 storage. This defines the behavior of SeBS to upload benchmarking resources and cleanup before/after the benchmark. It is different from the benchmark wrapper, which provides the functions for the benchmark itself to perform storage operations. + +## Usage +### Environment Variables + +Set the following environment variables: + +```bash +# Option 1: Using API Token (recommended) +export CLOUDFLARE_API_TOKEN="your-api-token" +export CLOUDFLARE_ACCOUNT_ID="your-account-id" + +# Option 2: Using Email + API Key +export CLOUDFLARE_EMAIL="your-email@example.com" +export CLOUDFLARE_API_KEY="your-global-api-key" +export CLOUDFLARE_ACCOUNT_ID="your-account-id" +``` + +### Configuration File + +Alternatively, create a configuration file: + +```json +{ + "cloudflare": { + "credentials": { + "api_token": "your-api-token", + "account_id": "your-account-id" + }, + "resources": { + "resources_id": "unique-resource-id" + } + } +} +``` + +### Current Limitations + +- **Container Deployment**: Not currently implemented + - *Note*: Cloudflare recently added container support (October 2024) + - Current implementation only supports script-based deployment + - Container support would require: + - Creating `CloudflareContainer` class (similar to AWS ECR) + - Container registry integration + - Dockerfile templates for each language + - Updates to `package_code()` and `create_function()` methods +- **Cold Start Enforcement**: Not available (Workers are instantiated on-demand at edge locations) +- **Per-Invocation Metrics**: Limited (Cloudflare provides aggregated analytics) +- **Language Support**: Currently JavaScript/Node.js (Python support via Pyodide is experimental) + - Container support would enable any containerized language +- **Memory/Timeout Configuration**: Fixed by Cloudflare (128MB memory, 50ms CPU time on free tier) + +### Future Enhancements + +#### High Priority +- [ ] **Container Deployment Support** + - Cloudflare now supports container-based Workers (as of October 2024) + - Would enable multi-language support (Python, Java, Go, Rust, etc.) + - Requires implementing `CloudflareContainer` class + - Need Cloudflare container registry integration + - See [implementation notes](#container-support-architecture) below +- [ ] **Add Storage Resources** + - SeBS needs two levels of storage resources, main storage and nosql storage. + - For main storage Cloudflare R2 comes to mind. + - For nosql storage either D1 or Durable Objects come to mind. They need to be used by the benchmark wrapper aswell. I think it needs to be consistent... + +## Metrics Collection with Analytics Engine + +### Overview + +Cloudflare Workers metrics are collected using **Analytics Engine**, which provides **per-invocation performance data** similar to AWS CloudWatch Logs or Azure Application Insights. Unlike the GraphQL Analytics API (which only provides aggregated metrics), Analytics Engine allows workers to write custom data points during execution that can be queried later. + +### Why Analytics Engine? + +| Feature | Analytics Engine | GraphQL Analytics API | +|---------|-----------------|----------------------| +| **Data Granularity** | ✅ Per-invocation | ❌ Aggregated only | +| **Request ID Matching** | ✅ Direct correlation | ❌ Not possible | +| **Cold Start Detection** | ✅ Per-request | ❌ Average only | +| **SeBS Compatibility** | ✅ Full support | ❌ Limited | +| **Cost** | Free (10M writes/month) | Free | +| **Plan Requirement** | Paid plan ($5/month) | Any plan | + +### How It Works + +1. **Worker Execution**: During each invocation, the worker writes a data point to Analytics Engine with: + - Request ID (for correlation with SeBS) + - CPU time and wall time + - Cold/warm start indicator + - Success/error status + +2. **Metrics Query**: After benchmark execution, SeBS queries Analytics Engine using SQL: + - Retrieves all data points for the time period + - Matches request IDs to `ExecutionResult` objects + - Populates provider metrics (CPU time, cold starts, etc.) + +3. **Data Enrichment**: Each `ExecutionResult` is enriched with: + - `provider_times.execution` - CPU time in microseconds + - `stats.cold_start` - True/False for cold start + - `billing.billed_time` - Billable CPU time + - `billing.gb_seconds` - GB-seconds for cost calculation + +### Implementation Requirements + +#### 1. Analytics Engine Binding + +```python +# In cloudflare.py - automatically configured +self._bind_analytics_engine(worker_name, account_id) +``` + +#### 2. Benchmark Wrapper + +Benchmark wrappers must write data points during execution. The wrapper code looks like: + +```javascript +export default { + async fetch(request, env, ctx) { + const requestId = request.headers.get('x-request-id') || crypto.randomUUID(); + const startTime = Date.now(); + const startCpu = performance.now(); + + try { + // Execute benchmark + const result = await benchmarkHandler(request, env, ctx); + + // Write metrics to Analytics Engine + if (env.ANALYTICS) { + env.ANALYTICS.writeDataPoint({ + indexes: [requestId, result.is_cold ? 'cold' : 'warm'], + doubles: [Date.now() - startTime, performance.now() - startCpu, 0, 0], + blobs: [request.url, 'success', '', ''] + }); + } + + return new Response(JSON.stringify({...result, request_id: requestId})); + } catch (error) { + // Write error metrics + if (env.ANALYTICS) { + env.ANALYTICS.writeDataPoint({ + indexes: [requestId, 'error'], + doubles: [Date.now() - startTime, performance.now() - startCpu, 0, 0], + blobs: [request.url, 'error', error.message, ''] + }); + } + throw error; + } + } +}; +``` + +#### 3. Data Schema + +Analytics Engine data points use this schema: + +| Field | Type | Purpose | Example | +|-------|------|---------|---------| +| `index1` | String | Request ID | `"req-abc-123"` | +| `index2` | String | Cold/Warm | `"cold"` or `"warm"` | +| `double1` | Float | Wall time (ms) | `45.2` | +| `double2` | Float | CPU time (ms) | `12.8` | +| `blob1` | String | Request URL | `"https://worker.dev"` | +| `blob2` | String | Status | `"success"` or `"error"` | +| `blob3` | String | Error message | `""` or error text | + +### Query Process + +When `download_metrics()` is called, SeBS: + +1. **Builds SQL Query**: Creates a ClickHouse SQL query for the time range +2. **Executes Query**: POSTs to Analytics Engine SQL API +3. **Parses Results**: Parses newline-delimited JSON response +4. **Matches Request IDs**: Correlates data points with tracked invocations +5. **Populates Metrics**: Enriches `ExecutionResult` objects with provider data + +Example SQL query: + +```sql +SELECT + index1 as request_id, + index2 as cold_warm, + double1 as wall_time_ms, + double2 as cpu_time_ms, + blob2 as status, + timestamp +FROM ANALYTICS_DATASET +WHERE timestamp >= toDateTime('2025-10-27 10:00:00') + AND timestamp <= toDateTime('2025-10-27 11:00:00') + AND blob1 LIKE '%worker-name%' +ORDER BY timestamp ASC +``` + +### Limitation + +1. **Delay**: Typically 30-60 seconds for data to appear in Analytics Engine +2. **Wrapper Updates**: All benchmark wrappers must be updated to write data points + +### Troubleshooting + +**Missing Metrics**: +- Check that worker has Analytics Engine binding configured +- Verify wrapper is writing data points (check `env.ANALYTICS`) +- Wait 60+ seconds after invocation for ingestion +- Check SQL query matches worker URL pattern + +**Unmatched Request IDs**: +- Ensure wrapper returns `request_id` in response +- Verify SeBS is tracking request IDs correctly +- Check timestamp range covers all invocations + +**Query Failures**: +- Verify account has Analytics Engine enabled (Paid plan) +- Check API token has analytics read permissions +- Validate SQL syntax (ClickHouse format) + +### References + +- [Analytics Engine Documentation](https://developers.cloudflare.com/analytics/analytics-engine/) +- [Analytics Engine SQL API](https://developers.cloudflare.com/analytics/analytics-engine/sql-api/) +- [Workers Bindings](https://developers.cloudflare.com/workers/configuration/bindings/) +- See `ANALYTICS_ENGINE_IMPLEMENTATION.md` for complete implementation details + +#### Standard Priority +- [ ] Support for Cloudflare Workers KV (key-value storage) +- [ ] Support for Cloudflare R2 (object storage) +- [ ] Support for Durable Objects +- [ ] Wrangler CLI integration for better bundling +- [ ] WebAssembly/Rust worker support + +--- + +## Container Support Architecture + +### Overview + +Cloudflare recently introduced container support for Workers, enabling deployment of containerized applications. Adding this to SeBS would require the following components: + +### Required Components + +1. **Container Client** (`container.py`) + - Extends `sebs.faas.container.DockerContainer` + - Manages container image builds and registry operations + - Similar to `sebs/aws/container.py` for ECR + +2. **Registry Integration** + - Cloudflare Container Registry authentication + - Image push/pull operations + - Support for external registries (Docker Hub, etc.) + +3. **Dockerfile Templates** + - Create `/dockerfiles/cloudflare/{language}/Dockerfile.function` + - Support for Node.js, Python, and other languages + +4. **Updated Methods** + - `package_code()`: Add container build path alongside script packaging + - `create_function()`: Handle both script and container deployments + - `update_function()`: Support updating container-based workers + +### Benefits + +- **Multi-language Support**: Deploy Python, Java, Go, Rust workers +- **Complex Dependencies**: Support system libraries and compiled extensions +- **Larger Code Packages**: Overcome script size limitations +- **Consistent Environments**: Same container locally and in production + + +## References + +- [Cloudflare Workers Documentation](https://developers.cloudflare.com/workers/) +- [Cloudflare API Documentation](https://api.cloudflare.com/) +- [Workers API Reference](https://developers.cloudflare.com/workers/runtime-apis/) diff --git a/sebs/cloudflare/__init__.py b/sebs/cloudflare/__init__.py new file mode 100644 index 000000000..5a2c557d3 --- /dev/null +++ b/sebs/cloudflare/__init__.py @@ -0,0 +1,4 @@ +from sebs.cloudflare.cloudflare import Cloudflare +from sebs.cloudflare.config import CloudflareConfig + +__all__ = ["Cloudflare", "CloudflareConfig"] diff --git a/sebs/cloudflare/cloudflare.py b/sebs/cloudflare/cloudflare.py new file mode 100644 index 000000000..ce2cc25ea --- /dev/null +++ b/sebs/cloudflare/cloudflare.py @@ -0,0 +1,723 @@ +import os +import shutil +import json +from typing import cast, Dict, List, Optional, Tuple, Type + +import docker +import requests + +from sebs.cloudflare.config import CloudflareConfig +from sebs.cloudflare.function import CloudflareWorker +from sebs.cloudflare.resources import CloudflareSystemResources +from sebs.benchmark import Benchmark +from sebs.cache import Cache +from sebs.config import SeBSConfig +from sebs.utils import LoggingHandlers +from sebs.faas.function import Function, ExecutionResult, Trigger, FunctionConfig +from sebs.faas.system import System + + +class Cloudflare(System): + """ + Cloudflare Workers serverless platform implementation. + + Cloudflare Workers run on Cloudflare's edge network, providing + low-latency serverless execution globally. + """ + + _config: CloudflareConfig + + @staticmethod + def name(): + return "cloudflare" + + @staticmethod + def typename(): + return "Cloudflare" + + @staticmethod + def function_type() -> "Type[Function]": + return CloudflareWorker + + @property + def config(self) -> CloudflareConfig: + return self._config + + def __init__( + self, + sebs_config: SeBSConfig, + config: CloudflareConfig, + cache_client: Cache, + docker_client: docker.client, + logger_handlers: LoggingHandlers, + ): + super().__init__( + sebs_config, + cache_client, + docker_client, + CloudflareSystemResources(config, cache_client, docker_client, logger_handlers), + ) + self.logging_handlers = logger_handlers + self._config = config + self._api_base_url = "https://api.cloudflare.com/client/v4" + + def initialize(self, config: Dict[str, str] = {}, resource_prefix: Optional[str] = None): + """ + Initialize the Cloudflare Workers platform. + + Args: + config: Additional configuration parameters + resource_prefix: Prefix for resource naming + """ + # Verify credentials are valid + self._verify_credentials() + self.initialize_resources(select_prefix=resource_prefix) + + def _verify_credentials(self): + """Verify that the Cloudflare API credentials are valid.""" + headers = self._get_auth_headers() + response = requests.get(f"{self._api_base_url}/user/tokens/verify", headers=headers) + + if response.status_code != 200: + raise RuntimeError( + f"Failed to verify Cloudflare credentials: {response.status_code} - {response.text}" + ) + + self.logging.info("Cloudflare credentials verified successfully") + + def _get_auth_headers(self) -> Dict[str, str]: + """Get authentication headers for Cloudflare API requests.""" + if self.config.credentials.api_token: + return { + "Authorization": f"Bearer {self.config.credentials.api_token}", + "Content-Type": "application/json", + } + elif self.config.credentials.email and self.config.credentials.api_key: + return { + "X-Auth-Email": self.config.credentials.email, + "X-Auth-Key": self.config.credentials.api_key, + "Content-Type": "application/json", + } + else: + raise RuntimeError("Invalid Cloudflare credentials configuration") + + def package_code( + self, + directory: str, + language_name: str, + language_version: str, + architecture: str, + benchmark: str, + is_cached: bool, + container_deployment: bool, + ) -> Tuple[str, int, str]: + """ + Package code for Cloudflare Workers deployment. + + Cloudflare Workers support JavaScript/TypeScript and use a bundler + to create a single JavaScript file for deployment. + + Args: + directory: Path to the code directory + language_name: Programming language name + language_version: Programming language version + architecture: Target architecture (not used for Workers) + benchmark: Benchmark name + is_cached: Whether the code is cached + container_deployment: Whether to deploy as container (not supported) + + Returns: + Tuple of (package_path, package_size, container_uri) + """ + if container_deployment: + raise NotImplementedError( + "Container deployment is not supported for Cloudflare Workers" + ) + + # For now, we'll create a simple package structure + # In a full implementation, you'd use a bundler like esbuild or webpack + + CONFIG_FILES = { + "nodejs": ["handler.js", "package.json", "node_modules"], + # Python support via Python Workers is limited + "python": ["handler.py", "requirements.txt"], + } + + if language_name not in CONFIG_FILES: + raise NotImplementedError( + f"Language {language_name} is not yet supported for Cloudflare Workers" + ) + + package_config = CONFIG_FILES[language_name] + + # Create a worker directory with the necessary files + worker_dir = os.path.join(directory, "worker") + os.makedirs(worker_dir, exist_ok=True) + + # Copy all files to worker directory + for file in os.listdir(directory): + if file not in package_config and file != "worker": + src = os.path.join(directory, file) + dst = os.path.join(worker_dir, file) + if os.path.isfile(src): + shutil.copy2(src, dst) + elif os.path.isdir(src): + shutil.copytree(src, dst, dirs_exist_ok=True) + + # For now, return the main handler file as the package + handler_file = "handler.js" if language_name == "nodejs" else "handler.py" + package_path = os.path.join(directory, handler_file) + + if not os.path.exists(package_path): + raise RuntimeError(f"Handler file {handler_file} not found in {directory}") + + bytes_size = os.path.getsize(package_path) + mbytes = bytes_size / 1024.0 / 1024.0 + self.logging.info(f"Worker package size: {mbytes:.2f} MB") + + return (package_path, bytes_size, "") + + def create_function( + self, + code_package: Benchmark, + func_name: str, + container_deployment: bool, + container_uri: str, + ) -> CloudflareWorker: + """ + Create a new Cloudflare Worker. + + If a worker with the same name already exists, it will be updated. + + Args: + code_package: Benchmark containing the function code + func_name: Name of the worker + container_deployment: Whether to deploy as container (not supported) + container_uri: URI of container image (not used) + + Returns: + CloudflareWorker instance + """ + if container_deployment: + raise NotImplementedError( + "Container deployment is not supported for Cloudflare Workers" + ) + + package = code_package.code_location + benchmark = code_package.benchmark + language = code_package.language_name + language_runtime = code_package.language_version + function_cfg = FunctionConfig.from_benchmark(code_package) + + func_name = self.format_function_name(func_name) + account_id = self.config.credentials.account_id + + if not account_id: + raise RuntimeError("Cloudflare account ID is required to create workers") + + # Check if worker already exists + existing_worker = self._get_worker(func_name, account_id) + + if existing_worker: + self.logging.info(f"Worker {func_name} already exists, updating it") + worker = CloudflareWorker( + func_name, + code_package.benchmark, + func_name, # script_id is the same as name + code_package.hash, + language_runtime, + function_cfg, + account_id, + ) + self.update_function(worker, code_package, container_deployment, container_uri) + worker.updated_code = True + else: + self.logging.info(f"Creating new worker {func_name}") + + # Read the worker script + with open(package, 'r') as f: + script_content = f.read() + + # Create the worker + self._create_or_update_worker(func_name, script_content, account_id) + + worker = CloudflareWorker( + func_name, + code_package.benchmark, + func_name, + code_package.hash, + language_runtime, + function_cfg, + account_id, + ) + + # Add LibraryTrigger and HTTPTrigger + from sebs.cloudflare.triggers import LibraryTrigger, HTTPTrigger + + library_trigger = LibraryTrigger(func_name, self) + library_trigger.logging_handlers = self.logging_handlers + worker.add_trigger(library_trigger) + + # Cloudflare Workers are automatically accessible via HTTPS + worker_url = f"https://{func_name}.{account_id}.workers.dev" + http_trigger = HTTPTrigger(func_name, worker_url) + http_trigger.logging_handlers = self.logging_handlers + worker.add_trigger(http_trigger) + + return worker + + def _get_worker(self, worker_name: str, account_id: str) -> Optional[dict]: + """Get information about an existing worker.""" + headers = self._get_auth_headers() + url = f"{self._api_base_url}/accounts/{account_id}/workers/scripts/{worker_name}" + + response = requests.get(url, headers=headers) + + if response.status_code == 200: + return response.json().get("result") + elif response.status_code == 404: + return None + else: + raise RuntimeError( + f"Failed to check worker existence: {response.status_code} - {response.text}" + ) + + def _create_or_update_worker( + self, worker_name: str, script_content: str, account_id: str + ) -> dict: + """Create or update a Cloudflare Worker.""" + headers = self._get_auth_headers() + # Remove Content-Type as we're sending form data + headers.pop("Content-Type", None) + + url = f"{self._api_base_url}/accounts/{account_id}/workers/scripts/{worker_name}" + + # Cloudflare Workers API expects the script as form data + files = { + 'script': ('worker.js', script_content, 'application/javascript'), + } + + response = requests.put(url, headers=headers, files=files) + + if response.status_code not in [200, 201]: + raise RuntimeError( + f"Failed to create/update worker: {response.status_code} - {response.text}" + ) + + return response.json().get("result", {}) + + def cached_function(self, function: Function): + """ + Handle a function retrieved from cache. + + Refreshes triggers and logging handlers. + + Args: + function: The cached function + """ + from sebs.cloudflare.triggers import LibraryTrigger, HTTPTrigger + + for trigger in function.triggers(Trigger.TriggerType.LIBRARY): + trigger.logging_handlers = self.logging_handlers + cast(LibraryTrigger, trigger).deployment_client = self + + for trigger in function.triggers(Trigger.TriggerType.HTTP): + trigger.logging_handlers = self.logging_handlers + + def update_function( + self, + function: Function, + code_package: Benchmark, + container_deployment: bool, + container_uri: str, + ): + """ + Update an existing Cloudflare Worker. + + Args: + function: Existing function instance to update + code_package: New benchmark containing the function code + container_deployment: Whether to deploy as container (not supported) + container_uri: URI of container image (not used) + """ + if container_deployment: + raise NotImplementedError( + "Container deployment is not supported for Cloudflare Workers" + ) + + worker = cast(CloudflareWorker, function) + package = code_package.code_location + + # Read the updated script + with open(package, 'r') as f: + script_content = f.read() + + # Update the worker + account_id = worker.account_id or self.config.credentials.account_id + if not account_id: + raise RuntimeError("Account ID is required to update worker") + + self._create_or_update_worker(worker.name, script_content, account_id) + self.logging.info(f"Updated worker {worker.name}") + + # Update configuration if needed + self.update_function_configuration(worker, code_package) + + def update_function_configuration( + self, cached_function: Function, benchmark: Benchmark + ): + """ + Update the configuration of a Cloudflare Worker. + + Note: Cloudflare Workers have limited configuration options compared + to traditional FaaS platforms. Memory and timeout are managed by Cloudflare. + + Args: + cached_function: The function to update + benchmark: The benchmark with new configuration + """ + # Cloudflare Workers have fixed resource limits: + # - CPU time: 50ms (free), 50ms-30s (paid) + # - Memory: 128MB + # Most configuration is handled via wrangler.toml or API settings + + worker = cast(CloudflareWorker, cached_function) + + # For environment variables or KV namespaces, we would use the API here + # For now, we'll just log that configuration update was requested + self.logging.info( + f"Configuration update requested for worker {worker.name}. " + "Note: Cloudflare Workers have limited runtime configuration options." + ) + + def default_function_name(self, code_package: Benchmark, resources=None) -> str: + """ + Generate a default function name for Cloudflare Workers. + + Args: + code_package: The benchmark package + resources: Optional resources (not used) + + Returns: + Default function name + """ + # Cloudflare Worker names must be lowercase and can contain hyphens + return ( + f"{code_package.benchmark}-{code_package.language_name}-" + f"{code_package.language_version.replace('.', '')}" + ).lower() + + @staticmethod + def format_function_name(name: str) -> str: + """ + Format a function name to comply with Cloudflare Worker naming rules. + + Worker names must: + - Be lowercase + - Contain only alphanumeric characters and hyphens + - Not start or end with a hyphen + + Args: + name: The original name + + Returns: + Formatted name + """ + # Convert to lowercase and replace invalid characters + formatted = name.lower().replace('_', '-').replace('.', '-') + # Remove any characters that aren't alphanumeric or hyphen + formatted = ''.join(c for c in formatted if c.isalnum() or c == '-') + # Remove leading/trailing hyphens + formatted = formatted.strip('-') + return formatted + + def enforce_cold_start(self, functions: List[Function], code_package: Benchmark): + """ + Enforce cold start for Cloudflare Workers. + + Note: Cloudflare Workers don't have a traditional cold start mechanism + like AWS Lambda. Workers are instantiated on-demand at edge locations. + We can't force a cold start, but we can update the worker to invalidate caches. + + Args: + functions: List of functions to enforce cold start on + code_package: The benchmark package + """ + self.logging.warning( + "Cloudflare Workers do not support forced cold starts. " + "Workers are automatically instantiated on-demand at edge locations." + ) + + def download_metrics( + self, + function_name: str, + start_time: int, + end_time: int, + requests: Dict[str, ExecutionResult], + metrics: dict, + ): + """ + Download per-invocation metrics from Cloudflare Analytics Engine. + + Queries Analytics Engine SQL API to retrieve performance data for each + invocation and enriches the ExecutionResult objects with provider metrics. + + Note: Requires Analytics Engine binding to be configured on the worker + and benchmark code to write data points during execution. + + Args: + function_name: Name of the worker + start_time: Start time (Unix timestamp in seconds) + end_time: End time (Unix timestamp in seconds) + requests: Dict mapping request_id -> ExecutionResult + metrics: Dict to store aggregated metrics + """ + if not requests: + self.logging.warning("No requests to download metrics for") + return + + account_id = self.config.credentials.account_id + if not account_id: + self.logging.error("Account ID required to download metrics") + return + + self.logging.info( + f"Downloading Analytics Engine metrics for {len(requests)} invocations " + f"of worker {function_name}" + ) + + try: + # Query Analytics Engine for per-invocation metrics + metrics_data = self._query_analytics_engine( + account_id, start_time, end_time, function_name + ) + + if not metrics_data: + self.logging.warning( + "No metrics data returned from Analytics Engine. " + "Ensure the worker has Analytics Engine binding configured " + "and is writing data points during execution." + ) + return + + # Match metrics with invocation requests + matched = 0 + unmatched_metrics = 0 + + for row in metrics_data: + request_id = row.get('request_id') + + if request_id and request_id in requests: + result = requests[request_id] + + # Populate provider times (convert ms to microseconds) + wall_time_ms = row.get('wall_time_ms', 0) + cpu_time_ms = row.get('cpu_time_ms', 0) + + result.provider_times.execution = int(cpu_time_ms * 1000) # μs + result.provider_times.initialization = 0 # Not separately tracked + + # Populate stats + result.stats.cold_start = (row.get('cold_warm') == 'cold') + result.stats.memory_used = 128.0 # Cloudflare Workers: fixed 128MB + + # Populate billing info + # Cloudflare billing: $0.50 per million requests + + # $12.50 per million GB-seconds of CPU time + result.billing.memory = 128 + result.billing.billed_time = int(cpu_time_ms * 1000) # μs + + # GB-seconds calculation: (128MB / 1024MB/GB) * (cpu_time_ms / 1000ms/s) + gb_seconds = (128.0 / 1024.0) * (cpu_time_ms / 1000.0) + result.billing.gb_seconds = int(gb_seconds * 1000000) # micro GB-seconds + + matched += 1 + elif request_id: + unmatched_metrics += 1 + + # Calculate statistics from matched metrics + if matched > 0: + cpu_times = [ + requests[rid].provider_times.execution + for rid in requests + if requests[rid].provider_times.execution > 0 + ] + cold_starts = sum( + 1 for rid in requests if requests[rid].stats.cold_start + ) + + metrics['cloudflare'] = { + 'total_invocations': len(metrics_data), + 'matched_invocations': matched, + 'unmatched_invocations': len(requests) - matched, + 'unmatched_metrics': unmatched_metrics, + 'cold_starts': cold_starts, + 'warm_starts': matched - cold_starts, + 'data_source': 'analytics_engine', + 'note': 'Per-invocation metrics from Analytics Engine' + } + + if cpu_times: + metrics['cloudflare']['avg_cpu_time_us'] = sum(cpu_times) // len(cpu_times) + metrics['cloudflare']['min_cpu_time_us'] = min(cpu_times) + metrics['cloudflare']['max_cpu_time_us'] = max(cpu_times) + + self.logging.info( + f"Analytics Engine metrics: matched {matched}/{len(requests)} invocations" + ) + + if matched < len(requests): + missing = len(requests) - matched + self.logging.warning( + f"{missing} invocations not found in Analytics Engine. " + "This may be due to:\n" + " - Analytics Engine ingestion delay (typically <60s)\n" + " - Worker not writing data points correctly\n" + " - Analytics Engine binding not configured" + ) + + if unmatched_metrics > 0: + self.logging.warning( + f"{unmatched_metrics} metrics found in Analytics Engine " + "that don't match tracked request IDs (possibly from other sources)" + ) + + except Exception as e: + self.logging.error(f"Failed to download metrics: {e}") + self.logging.warning( + "Continuing without Analytics Engine metrics. " + "Client-side timing data is still available." + ) + + def _query_analytics_engine( + self, + account_id: str, + start_time: int, + end_time: int, + script_name: str + ) -> List[dict]: + """ + Query Analytics Engine SQL API for worker metrics. + + Retrieves per-invocation metrics written by the worker during execution. + The worker must write data points with the following schema: + - index1: request_id (unique identifier) + - index2: cold_warm ("cold" or "warm") + - double1: wall_time_ms (wall clock time in milliseconds) + - double2: cpu_time_ms (CPU time in milliseconds) + - blob1: url (request URL) + - blob2: status ("success" or "error") + - blob3: error_message (if applicable) + + Args: + account_id: Cloudflare account ID + start_time: Unix timestamp (seconds) + end_time: Unix timestamp (seconds) + script_name: Worker script name + + Returns: + List of metric data points, one per invocation + """ + headers = self._get_auth_headers() + url = f"{self._api_base_url}/accounts/{account_id}/analytics_engine/sql" + + # Convert Unix timestamps to DateTime format for ClickHouse + from datetime import datetime + start_dt = datetime.utcfromtimestamp(start_time).strftime('%Y-%m-%d %H:%M:%S') + end_dt = datetime.utcfromtimestamp(end_time).strftime('%Y-%m-%d %H:%M:%S') + + # SQL query for Analytics Engine + # Note: Analytics Engine uses ClickHouse SQL syntax + sql_query = f""" + SELECT + index1 as request_id, + index2 as cold_warm, + double1 as wall_time_ms, + double2 as cpu_time_ms, + blob1 as url, + blob2 as status, + blob3 as error_message, + timestamp + FROM ANALYTICS_DATASET + WHERE timestamp >= toDateTime('{start_dt}') + AND timestamp <= toDateTime('{end_dt}') + AND blob1 LIKE '%{script_name}%' + ORDER BY timestamp ASC + """ + + try: + # Analytics Engine SQL API returns newline-delimited JSON + response = requests.post( + url, + headers=headers, + data=sql_query, + timeout=30 + ) + + if response.status_code == 200: + # Parse newline-delimited JSON response + results = [] + for line in response.text.strip().split('\n'): + if line: + try: + results.append(json.loads(line)) + except json.JSONDecodeError: + self.logging.warning(f"Failed to parse Analytics Engine line: {line}") + + self.logging.info(f"Retrieved {len(results)} data points from Analytics Engine") + return results + else: + raise RuntimeError( + f"Analytics Engine query failed: {response.status_code} - {response.text}" + ) + + except requests.exceptions.Timeout: + self.logging.error("Analytics Engine query timed out") + return [] + except Exception as e: + self.logging.error(f"Analytics Engine query error: {e}") + return [] + + def create_trigger( + self, function: Function, trigger_type: Trigger.TriggerType + ) -> Trigger: + """ + Create a trigger for a Cloudflare Worker. + + Args: + function: The function to create a trigger for + trigger_type: Type of trigger to create + + Returns: + The created trigger + """ + from sebs.cloudflare.triggers import LibraryTrigger, HTTPTrigger + + worker = cast(CloudflareWorker, function) + + if trigger_type == Trigger.TriggerType.LIBRARY: + trigger = LibraryTrigger(worker.name, self) + trigger.logging_handlers = self.logging_handlers + return trigger + elif trigger_type == Trigger.TriggerType.HTTP: + account_id = worker.account_id or self.config.credentials.account_id + worker_url = f"https://{worker.name}.{account_id}.workers.dev" + trigger = HTTPTrigger(worker.name, worker_url) + trigger.logging_handlers = self.logging_handlers + return trigger + else: + raise NotImplementedError( + f"Trigger type {trigger_type} is not supported for Cloudflare Workers" + ) + + def shutdown(self) -> None: + """ + Shutdown the Cloudflare system. + + Saves configuration to cache. + """ + try: + self.cache_client.lock() + self.config.update_cache(self.cache_client) + finally: + self.cache_client.unlock() diff --git a/sebs/cloudflare/config.py b/sebs/cloudflare/config.py new file mode 100644 index 000000000..4e04ee137 --- /dev/null +++ b/sebs/cloudflare/config.py @@ -0,0 +1,242 @@ +import os +from typing import Optional, cast + +from sebs.cache import Cache +from sebs.faas.config import Config, Credentials, Resources +from sebs.utils import LoggingHandlers + + +class CloudflareCredentials(Credentials): + """ + Cloudflare API credentials. + + Requires: + - API token or email + global API key + - Account ID + """ + + def __init__(self, api_token: Optional[str] = None, email: Optional[str] = None, + api_key: Optional[str] = None, account_id: Optional[str] = None): + super().__init__() + + self._api_token = api_token + self._email = email + self._api_key = api_key + self._account_id = account_id + + @staticmethod + def typename() -> str: + return "Cloudflare.Credentials" + + @property + def api_token(self) -> Optional[str]: + return self._api_token + + @property + def email(self) -> Optional[str]: + return self._email + + @property + def api_key(self) -> Optional[str]: + return self._api_key + + @property + def account_id(self) -> Optional[str]: + return self._account_id + + @staticmethod + def initialize(dct: dict) -> "CloudflareCredentials": + return CloudflareCredentials( + dct.get("api_token"), + dct.get("email"), + dct.get("api_key"), + dct.get("account_id") + ) + + @staticmethod + def deserialize(config: dict, cache: Cache, handlers: LoggingHandlers) -> Credentials: + cached_config = cache.get_config("cloudflare") + ret: CloudflareCredentials + account_id: Optional[str] = None + + # Load cached values + if cached_config and "credentials" in cached_config: + account_id = cached_config["credentials"].get("account_id") + + # Check for new config + if "credentials" in config: + ret = CloudflareCredentials.initialize(config["credentials"]) + elif "CLOUDFLARE_API_TOKEN" in os.environ: + ret = CloudflareCredentials( + api_token=os.environ["CLOUDFLARE_API_TOKEN"], + account_id=os.environ.get("CLOUDFLARE_ACCOUNT_ID") + ) + elif "CLOUDFLARE_EMAIL" in os.environ and "CLOUDFLARE_API_KEY" in os.environ: + ret = CloudflareCredentials( + email=os.environ["CLOUDFLARE_EMAIL"], + api_key=os.environ["CLOUDFLARE_API_KEY"], + account_id=os.environ.get("CLOUDFLARE_ACCOUNT_ID") + ) + else: + raise RuntimeError( + "Cloudflare login credentials are missing! Please set " + "up environmental variables CLOUDFLARE_API_TOKEN and CLOUDFLARE_ACCOUNT_ID, " + "or CLOUDFLARE_EMAIL, CLOUDFLARE_API_KEY, and CLOUDFLARE_ACCOUNT_ID" + ) + + if account_id is not None and ret.account_id is not None and account_id != ret.account_id: + ret.logging.error( + f"The account id {ret.account_id} from provided credentials is different " + f"from the account id {account_id} found in the cache! Please change " + "your cache directory or create a new one!" + ) + raise RuntimeError( + f"Cloudflare login credentials do not match the account {account_id} in cache!" + ) + + ret.logging_handlers = handlers + return ret + + def update_cache(self, cache: Cache): + if self._account_id: + cache.update_config(val=self._account_id, + keys=["cloudflare", "credentials", "account_id"]) + + def serialize(self) -> dict: + out = {} + if self._account_id: + out["account_id"] = self._account_id + return out + + +class CloudflareResources(Resources): + """ + Resources for Cloudflare Workers deployment. + """ + + def __init__(self): + super().__init__(name="cloudflare") + self._namespace_id: Optional[str] = None + + @staticmethod + def typename() -> str: + return "Cloudflare.Resources" + + @property + def namespace_id(self) -> Optional[str]: + return self._namespace_id + + @namespace_id.setter + def namespace_id(self, value: str): + self._namespace_id = value + + @staticmethod + def initialize(res: Resources, dct: dict): + ret = cast(CloudflareResources, res) + super(CloudflareResources, CloudflareResources).initialize(ret, dct) + + if "namespace_id" in dct: + ret._namespace_id = dct["namespace_id"] + + return ret + + def serialize(self) -> dict: + out = {**super().serialize()} + if self._namespace_id: + out["namespace_id"] = self._namespace_id + return out + + def update_cache(self, cache: Cache): + super().update_cache(cache) + if self._namespace_id: + cache.update_config( + val=self._namespace_id, + keys=["cloudflare", "resources", "namespace_id"] + ) + + @staticmethod + def deserialize(config: dict, cache: Cache, handlers: LoggingHandlers) -> Resources: + ret = CloudflareResources() + cached_config = cache.get_config("cloudflare") + + # Load cached values + if cached_config and "resources" in cached_config: + CloudflareResources.initialize(ret, cached_config["resources"]) + ret.logging_handlers = handlers + ret.logging.info("Using cached resources for Cloudflare") + else: + # Check for new config + if "resources" in config: + CloudflareResources.initialize(ret, config["resources"]) + ret.logging_handlers = handlers + ret.logging.info("No cached resources for Cloudflare found, using user configuration.") + else: + CloudflareResources.initialize(ret, {}) + ret.logging_handlers = handlers + ret.logging.info("No resources for Cloudflare found, initialize!") + + return ret + + +class CloudflareConfig(Config): + """ + Configuration for Cloudflare Workers platform. + """ + + def __init__(self, credentials: CloudflareCredentials, resources: CloudflareResources): + super().__init__(name="cloudflare") + self._credentials = credentials + self._resources = resources + + @staticmethod + def typename() -> str: + return "Cloudflare.Config" + + @property + def credentials(self) -> CloudflareCredentials: + return self._credentials + + @property + def resources(self) -> CloudflareResources: + return self._resources + + @staticmethod + def initialize(cfg: Config, dct: dict): + config = cast(CloudflareConfig, cfg) + # Cloudflare Workers are globally distributed, no region needed + config._region = dct.get("region", "global") + + @staticmethod + def deserialize(config: dict, cache: Cache, handlers: LoggingHandlers) -> Config: + cached_config = cache.get_config("cloudflare") + credentials = cast(CloudflareCredentials, + CloudflareCredentials.deserialize(config, cache, handlers)) + resources = cast(CloudflareResources, + CloudflareResources.deserialize(config, cache, handlers)) + config_obj = CloudflareConfig(credentials, resources) + config_obj.logging_handlers = handlers + + # Load cached values + if cached_config: + config_obj.logging.info("Using cached config for Cloudflare") + CloudflareConfig.initialize(config_obj, cached_config) + else: + config_obj.logging.info("Using user-provided config for Cloudflare") + CloudflareConfig.initialize(config_obj, config) + + resources.region = config_obj.region + return config_obj + + def update_cache(self, cache: Cache): + cache.update_config(val=self.region, keys=["cloudflare", "region"]) + self.credentials.update_cache(cache) + self.resources.update_cache(cache) + + def serialize(self) -> dict: + out = { + "name": "cloudflare", + "region": self._region, + "credentials": self._credentials.serialize(), + "resources": self._resources.serialize(), + } + return out diff --git a/sebs/cloudflare/function.py b/sebs/cloudflare/function.py new file mode 100644 index 000000000..1bdf0ea08 --- /dev/null +++ b/sebs/cloudflare/function.py @@ -0,0 +1,64 @@ +from typing import Optional, cast + +from sebs.faas.function import Function, FunctionConfig + + +class CloudflareWorker(Function): + """ + Cloudflare Workers function implementation. + + A Cloudflare Worker is a serverless function that runs on Cloudflare's edge network. + """ + + def __init__( + self, + name: str, + benchmark: str, + script_id: str, + code_package_hash: str, + runtime: str, + cfg: FunctionConfig, + account_id: Optional[str] = None, + ): + super().__init__(benchmark, name, code_package_hash, cfg) + self.script_id = script_id + self.runtime = runtime + self.account_id = account_id + + @staticmethod + def typename() -> str: + return "Cloudflare.Worker" + + def serialize(self) -> dict: + return { + **super().serialize(), + "script_id": self.script_id, + "runtime": self.runtime, + "account_id": self.account_id, + } + + @staticmethod + def deserialize(cached_config: dict) -> "CloudflareWorker": + from sebs.faas.function import Trigger + from sebs.cloudflare.triggers import LibraryTrigger, HTTPTrigger + + cfg = FunctionConfig.deserialize(cached_config["config"]) + ret = CloudflareWorker( + cached_config["name"], + cached_config["benchmark"], + cached_config["script_id"], + cached_config["hash"], + cached_config["runtime"], + cfg, + cached_config.get("account_id"), + ) + + for trigger in cached_config["triggers"]: + trigger_type = cast( + Trigger, + {"Library": LibraryTrigger, "HTTP": HTTPTrigger}.get(trigger["type"]), + ) + assert trigger_type, "Unknown trigger type {}".format(trigger["type"]) + ret.add_trigger(trigger_type.deserialize(trigger)) + + return ret diff --git a/sebs/cloudflare/resources.py b/sebs/cloudflare/resources.py new file mode 100644 index 000000000..f9f9743d2 --- /dev/null +++ b/sebs/cloudflare/resources.py @@ -0,0 +1,68 @@ +import docker + +from typing import Optional + +from sebs.cache import Cache +from sebs.cloudflare.config import CloudflareConfig +from sebs.faas.resources import SystemResources +from sebs.faas.storage import PersistentStorage +from sebs.faas.nosql import NoSQLStorage +from sebs.utils import LoggingHandlers + + +class CloudflareSystemResources(SystemResources): + """ + System resources for Cloudflare Workers. + + Cloudflare Workers have a different resource model compared to + traditional cloud platforms. This class handles Cloudflare-specific + resources like KV namespaces and R2 storage. + """ + + def __init__( + self, + config: CloudflareConfig, + cache_client: Cache, + docker_client: docker.client, + logging_handlers: LoggingHandlers, + ): + super().__init__(config, cache_client, docker_client, logging_handlers) + self._config = config + + @property + def config(self) -> CloudflareConfig: + return self._config + + def get_storage(self, replace_existing: Optional[bool] = None) -> PersistentStorage: + """ + Get Cloudflare R2 storage instance. + + R2 is Cloudflare's S3-compatible object storage service. + This method will create a client for managing benchmark input/output data. + + Args: + replace_existing: Whether to replace existing files in storage + + Raises: + NotImplementedError: R2 storage support not yet implemented + """ + raise NotImplementedError( + "Cloudflare R2 storage is not yet implemented. " + "To add support, implement a PersistentStorage subclass for R2 " + "similar to sebs/aws/s3.py or sebs/azure/blob_storage.py" + ) + + def get_nosql_storage(self) -> NoSQLStorage: + """ + Get Cloudflare NoSQL storage instance. + + This could use Cloudflare D1 (SQLite) or Durable Objects for NoSQL storage. + + Raises: + NotImplementedError: NoSQL storage support not yet implemented + """ + raise NotImplementedError( + "Cloudflare NoSQL storage (D1/Durable Objects) is not yet implemented. " + "To add support, implement a NoSQLStorage subclass " + "similar to sebs/aws/dynamodb.py or sebs/azure/cosmosdb.py" + ) diff --git a/sebs/cloudflare/triggers.py b/sebs/cloudflare/triggers.py new file mode 100644 index 000000000..cb038b63a --- /dev/null +++ b/sebs/cloudflare/triggers.py @@ -0,0 +1,113 @@ +from typing import Optional + +from sebs.faas.function import Trigger + + +class LibraryTrigger(Trigger): + """ + Library trigger for Cloudflare Workers. + Allows invoking workers programmatically via the Cloudflare API. + """ + + def __init__(self, worker_name: str, deployment_client=None): + super().__init__(worker_name) + self.deployment_client = deployment_client + + @staticmethod + def typename() -> str: + return "Cloudflare.LibraryTrigger" + + @staticmethod + def trigger_type() -> Trigger.TriggerType: + return Trigger.TriggerType.LIBRARY + + def sync_invoke(self, payload: dict) -> Optional[str]: + """ + Synchronously invoke a Cloudflare Worker. + + Args: + payload: The payload to send to the worker + + Returns: + The response from the worker + """ + # This will be implemented when we have the deployment client + raise NotImplementedError("Cloudflare Worker invocation not yet implemented") + + def async_invoke(self, payload: dict) -> object: + """ + Asynchronously invoke a Cloudflare Worker. + Not typically supported for Cloudflare Workers. + """ + raise NotImplementedError("Cloudflare Workers do not support async invocation") + + def serialize(self) -> dict: + return {**super().serialize()} + + @staticmethod + def deserialize(obj: dict) -> "LibraryTrigger": + return LibraryTrigger(obj["name"]) + + +class HTTPTrigger(Trigger): + """ + HTTP trigger for Cloudflare Workers. + Workers are automatically accessible via HTTPS endpoints. + """ + + def __init__(self, worker_name: str, url: Optional[str] = None): + super().__init__(worker_name) + self._url = url + + @staticmethod + def typename() -> str: + return "Cloudflare.HTTPTrigger" + + @staticmethod + def trigger_type() -> Trigger.TriggerType: + return Trigger.TriggerType.HTTP + + @property + def url(self) -> str: + assert self._url is not None, "HTTP trigger URL has not been set" + return self._url + + @url.setter + def url(self, url: str): + self._url = url + + def sync_invoke(self, payload: dict) -> Optional[str]: + """ + Synchronously invoke a Cloudflare Worker via HTTP. + + Args: + payload: The payload to send to the worker + + Returns: + The response from the worker + """ + import requests + + response = requests.post(self.url, json=payload) + response.raise_for_status() + return response.text + + def async_invoke(self, payload: dict) -> object: + """ + Asynchronously invoke a Cloudflare Worker via HTTP. + Not typically needed for Cloudflare Workers. + """ + raise NotImplementedError("Cloudflare Workers do not support async HTTP invocation") + + def serialize(self) -> dict: + return { + **super().serialize(), + "url": self._url, + } + + @staticmethod + def deserialize(obj: dict) -> "HTTPTrigger": + trigger = HTTPTrigger(obj["name"]) + if "url" in obj: + trigger.url = obj["url"] + return trigger diff --git a/sebs/sebs.py b/sebs/sebs.py index a3dd89a95..febfeb24a 100644 --- a/sebs/sebs.py +++ b/sebs/sebs.py @@ -214,6 +214,10 @@ def get_deployment( from sebs.openwhisk import OpenWhisk implementations["openwhisk"] = OpenWhisk + if has_platform("cloudflare"): + from sebs.cloudflare import Cloudflare + + implementations["cloudflare"] = Cloudflare # Validate deployment platform if name not in implementations: From aa24a07a7aa4318469281d74cb1f367957372433 Mon Sep 17 00:00:00 2001 From: MisterMM23 Date: Sun, 2 Nov 2025 17:31:46 +0100 Subject: [PATCH 02/69] systems.json cloudflare config --- configs/systems.json | 27 +++++++++++++++++++++++++++ 1 file changed, 27 insertions(+) diff --git a/configs/systems.json b/configs/systems.json index 27ad49592..ac1c22598 100644 --- a/configs/systems.json +++ b/configs/systems.json @@ -418,5 +418,32 @@ }, "architecture": ["x64"], "deployments": ["container"] + }, + "cloudflare": { + "languages": { + "python": { + "base_images": { + "x64": { + "3.8": "ubuntu:22.04", + "3.9": "ubuntu:22.04", + "3.10": "ubuntu:22.04", + "3.11": "ubuntu:22.04", + "3.12": "ubuntu:22.04" + } + }, + "images": [ + "build" + ], + "deployment": { + "files": [ + "handler.py", + "storage.py", + "nosql.py" + ], + "packages": [], + "module_packages": {} + } + } + } } } From 4cc0476ff6f4e2b88e7deb44f64175fda79defb9 Mon Sep 17 00:00:00 2001 From: "ldzgch (MacOS)" Date: Sun, 2 Nov 2025 23:11:52 +0100 Subject: [PATCH 03/69] highly incomplete work on benchmark wrappers, using R2 and KV. --- .../wrappers/cloudflare/nodejs/handler.js | 37 +++++++++++ .../wrappers/cloudflare/nodejs/storage.js | 64 +++++++++++++++++++ .../wrappers/cloudflare/python/handler.py | 47 ++++++++++++++ .../wrappers/cloudflare/python/nosql.py | 59 +++++++++++++++++ .../wrappers/cloudflare/python/storage.py | 58 +++++++++++++++++ configs/systems.json | 9 ++- 6 files changed, 273 insertions(+), 1 deletion(-) create mode 100644 benchmarks/wrappers/cloudflare/nodejs/handler.js create mode 100644 benchmarks/wrappers/cloudflare/nodejs/storage.js create mode 100644 benchmarks/wrappers/cloudflare/python/handler.py create mode 100644 benchmarks/wrappers/cloudflare/python/nosql.py create mode 100644 benchmarks/wrappers/cloudflare/python/storage.py diff --git a/benchmarks/wrappers/cloudflare/nodejs/handler.js b/benchmarks/wrappers/cloudflare/nodejs/handler.js new file mode 100644 index 000000000..2c63947fd --- /dev/null +++ b/benchmarks/wrappers/cloudflare/nodejs/handler.js @@ -0,0 +1,37 @@ + +const path = require('path'), fs = require('fs'); + +export default { + async fetch(request, env, ctx) { + var begin = Date.now()/1000; + var start = process.hrtime(); + var func = require('./function') + var ret = func.handler(req.body); + return ret.then( + (result) => { + var elapsed = process.hrtime(start); + var end = Date.now()/1000; + var micro = elapsed[1] / 1e3 + elapsed[0] * 1e6; + + var is_cold = false; + var fname = path.join('/tmp','cold_run'); + if(!fs.existsSync(fname)) { + is_cold = true; + fs.closeSync(fs.openSync(fname, 'w')); + } + + res.status(200).json({ + begin: begin, + end: end, + compute_time: micro, + results_time: 0, + result: {output: result}, + is_cold: is_cold, + request_id: req.headers["function-execution-id"] + }); + }, + (error) => { + throw(error); + } + ); +} diff --git a/benchmarks/wrappers/cloudflare/nodejs/storage.js b/benchmarks/wrappers/cloudflare/nodejs/storage.js new file mode 100644 index 000000000..134192089 --- /dev/null +++ b/benchmarks/wrappers/cloudflare/nodejs/storage.js @@ -0,0 +1,64 @@ +const { Storage } = + fs = require('fs'), + path = require('path'), + uuid = require('uuid'), + util = require('util'), + stream = require('stream'); + +class cf_storage { + + constructor() { + + } + + unique_name(file) { + let name = path.parse(file); + let uuid_name = uuid.v4().split('-')[0]; + return path.join(name.dir, util.format('%s.%s%s', name.name, uuid_name, name.ext)); + } + + upload(container, file, filepath) { + let bucket = this.storage.bucket(container); + let uniqueName = this.unique_name(file); + let options = {destination: uniqueName, resumable: false}; + return [uniqueName, bucket.upload(filepath, options)]; + }; + + download(container, file, filepath) { + let bucket = this.storage.bucket(container); + var file = bucket.file(file); + file.download({destination: filepath}); + }; + + uploadStream(container, file) { + let bucket = this.storage.bucket(container); + let uniqueName = this.unique_name(file); + var file = bucket.file(uniqueName); + let upload = file.createWriteStream(); + var write_stream = new stream.PassThrough(); + + write_stream.pipe(upload); + + const promise = new Promise((resolve, reject) => { + upload.on('error', err => { + upload.end(); + reject(err); + }); + + upload.on('finish', () => { + upload.end(); + resolve(file.name); + }); + }); + return [write_stream, promise, uniqueName]; + }; + + downloadStream(container, file) { + let bucket = this.storage.bucket(container); + var file = bucket.file(file); + let downloaded = file.createReadStream(); + return Promise.resolve(downloaded); + }; +}; + +exports.storage = cf_storage; diff --git a/benchmarks/wrappers/cloudflare/python/handler.py b/benchmarks/wrappers/cloudflare/python/handler.py new file mode 100644 index 000000000..24c384107 --- /dev/null +++ b/benchmarks/wrappers/cloudflare/python/handler.py @@ -0,0 +1,47 @@ +import datetime, io, json, os, uuid, sys + +from workers import WorkerEntrypoint, Response + +## sys.path.append(os.path.join(os.path.dirname(__file__), '.python_packages/lib/site-packages')) + + + +class Default(WorkerEntrypoint): + async def fetch(self, request, env): + req_json = await request.json() + event = json.loads(req_json) + + ## we might need more data in self.env to know this ID + req_id = 0 + ## note: time fixed in worker + income_timestamp = datetime.datetime.now().timestamp() + + event['request-id'] = req_id + event['income-timestamp'] = income_timestamp + + from . import storage + storage.init_instance(self) + + + from . import function + ret = function.handler(event) + + log_data = { + 'output': ret['result'] + } + if 'measurement' in ret: + log_data['measurement'] = ret['measurement'] + if 'logs' in event: + log_data['time'] = 0 + + return Response(json.dumps({ + 'begin': "0", + 'end': "0", + 'results_time': "0", + 'result': log_data, + 'is_cold': False, + 'is_cold_worker': False, + 'container_id': "0", + 'environ_container_id': os.environ['CONTAINER_NAME'], + 'request_id': "0" + })) \ No newline at end of file diff --git a/benchmarks/wrappers/cloudflare/python/nosql.py b/benchmarks/wrappers/cloudflare/python/nosql.py new file mode 100644 index 000000000..75bf0f09d --- /dev/null +++ b/benchmarks/wrappers/cloudflare/python/nosql.py @@ -0,0 +1,59 @@ +from typing import List, Optional, Tuple + + +class nosql: + + instance: Optional["nosql"] = None + + @staticmethod + def init_instance(entry: WorkerEntryPoint): + nosql.instance = nosql() + nosql.instance.env = entry.env + + def insert( + self, + table_name: str, + primary_key: Tuple[str, str], + secondary_key: Tuple[str, str], + data: dict, + ): + put_res = await self.env.getattr(table_name).put(primary_key, data) + return + + def update( + self, + table_name: str, + primary_key: Tuple[str, str], + secondary_key: Tuple[str, str], + data: dict, + ): + await self.env.getattr(table_name).put(primary_key, data) + return + + def get( + self, table_name: str, primary_key: Tuple[str, str], secondary_key: Tuple[str, str] + ) -> Optional[dict]: + get_res = await self.env.getattr(table_name).get(primary_key) + return get_res.json() + + """ + This query must involve partition key - it does not scan across partitions. + """ + + def query( + self, table_name: str, primary_key: Tuple[str, str], secondary_key_name: str + ) -> List[dict]: + list_res = await self.env.getattr(table_name).list() + + return + + def delete(self, table_name: str, primary_key: Tuple[str, str], secondary_key: Tuple[str, str]): + self.env.getattr(table_name).delete(primary_key) + + return + + @staticmethod + def get_instance(): + if nosql.instance is None: + nosql.instance = nosql() + return nosql.instance diff --git a/benchmarks/wrappers/cloudflare/python/storage.py b/benchmarks/wrappers/cloudflare/python/storage.py new file mode 100644 index 000000000..5f31c759c --- /dev/null +++ b/benchmarks/wrappers/cloudflare/python/storage.py @@ -0,0 +1,58 @@ +import io +import os +import uuid + +## all filesystem calls will rely on the node:fs flag +class storage: + instance = None + handle = None + + @staticmethod + def unique_name(name): + name, extension = os.path.splitext(name) + return '{name}.{random}{extension}'.format( + name=name, + extension=extension, + random=str(uuid.uuid4()).split('-')[0] + ) + + @staticmethod + def init_instance(entry: WorkerEntrypoint): + storage.instance = storage() + storage.instance.handle = entry.env.R2 + + def upload(self, __bucket, key, filepath): + with open(filepath, "rb") as f: + self.upload_stream(__bucket, key, f.read()) + return + + def download(self, __bucket, key, filepath): + data = self.download_stream(__bucket, key) + with open(filepath, "wb") as f: + f.write(data) + return + + def download_directory(self, __bucket, prefix, out_path): + list_res = await self.handle.list(prefix = prefix) ## gives only first 1000? + for obj in list_res.objects: + file_name = obj.key + path_to_file = os.path.dirname(file_name) + os.makedirs(os.path.join(path, path_to_file), exist_ok=True) + self.download(__bucket, file_name, os.path.join(out_path, file_name)) + return + + def upload_stream(self, __bucket, key, data): + unique_key = storage.unique_name(key) + put_res = await self.handle.put(unique_key, data) + return unique_key + + def download_stream(self, __bucket, key): + get_res = await self.handle.get(key) + assert get_res not None + data = await get_res.text() + return data + + def get_instance(): + if storage.instance is None: + raise "must init storage singleton first" + return storage.instance diff --git a/configs/systems.json b/configs/systems.json index ac1c22598..a6f8ac186 100644 --- a/configs/systems.json +++ b/configs/systems.json @@ -24,6 +24,13 @@ "3.9": "python:3.9-slim", "3.10": "python:3.10-slim", "3.11": "python:3.11-slim" + }, + "arm64": { + "3.7": "python:3.7-slim", + "3.8": "python:3.8-slim", + "3.9": "python:3.9-slim", + "3.10": "python:3.10-slim", + "3.11": "python:3.11-slim" } }, "images": [ @@ -66,7 +73,7 @@ } } }, - "architecture": ["x64"], + "architecture": ["x64", "arm64"], "deployments": ["package"] }, "aws": { From cd24fcff27c56b89f229a3b60fc4db9716da41e5 Mon Sep 17 00:00:00 2001 From: Livio D'Agostini Date: Sat, 8 Nov 2025 23:19:16 +0100 Subject: [PATCH 04/69] wrappers - changes to handler and storage - can now run benchmark 110 if all configs are set up manually --- .../wrappers/cloudflare/python/handler.py | 57 +++++++++++++------ .../wrappers/cloudflare/python/storage.py | 32 +++++++++-- 2 files changed, 67 insertions(+), 22 deletions(-) diff --git a/benchmarks/wrappers/cloudflare/python/handler.py b/benchmarks/wrappers/cloudflare/python/handler.py index 24c384107..37d44595e 100644 --- a/benchmarks/wrappers/cloudflare/python/handler.py +++ b/benchmarks/wrappers/cloudflare/python/handler.py @@ -8,8 +8,28 @@ class Default(WorkerEntrypoint): async def fetch(self, request, env): - req_json = await request.json() - event = json.loads(req_json) + if "favicon" in request.url: return Response("None") + + req_text = await request.text() + event = json.loads(req_text) if req_text is None else {} + + if True: # dirty url parameters parsing, for testing + tmp = request.url.split("?") + if len(tmp) > 1: + urlparams = tmp[1] + urlparams = [chunk.split("=") for chunk in urlparams.split("&")] + for param in urlparams: + try: + event[param[0]] = int(param[1]) + except ValueError: + event[param[0]] = param[1] + except IndexError: + event[param[0]] = None + + + + + ## we might need more data in self.env to know this ID req_id = 0 @@ -19,12 +39,13 @@ async def fetch(self, request, env): event['request-id'] = req_id event['income-timestamp'] = income_timestamp - from . import storage + from storage import storage storage.init_instance(self) + print("event:", event) - from . import function - ret = function.handler(event) + from function import handler + ret = handler(event) log_data = { 'output': ret['result'] @@ -34,14 +55,18 @@ async def fetch(self, request, env): if 'logs' in event: log_data['time'] = 0 - return Response(json.dumps({ - 'begin': "0", - 'end': "0", - 'results_time': "0", - 'result': log_data, - 'is_cold': False, - 'is_cold_worker': False, - 'container_id': "0", - 'environ_container_id': os.environ['CONTAINER_NAME'], - 'request_id': "0" - })) \ No newline at end of file + if "html" in event: + headers = {"Content-Type" : "text/html; charset=utf-8"} + return Response(ret["result"], headers = headers) + else: + return Response(json.dumps({ + 'begin': "0", + 'end': "0", + 'results_time': "0", + 'result': log_data, + 'is_cold': False, + 'is_cold_worker': False, + 'container_id': "0", + 'environ_container_id': "no_id", + 'request_id': "0" + })) diff --git a/benchmarks/wrappers/cloudflare/python/storage.py b/benchmarks/wrappers/cloudflare/python/storage.py index 5f31c759c..da090be6c 100644 --- a/benchmarks/wrappers/cloudflare/python/storage.py +++ b/benchmarks/wrappers/cloudflare/python/storage.py @@ -2,7 +2,20 @@ import os import uuid +from workers import WorkerEntrypoint + ## all filesystem calls will rely on the node:fs flag +""" layout +/bundle +└── (one file for each module in your Worker bundle) +/tmp +└── (empty, but you can write files, create directories, symlinks, etc) +/dev +├── null +├── random +├── full +└── zero +""" class storage: instance = None handle = None @@ -20,20 +33,27 @@ def unique_name(name): def init_instance(entry: WorkerEntrypoint): storage.instance = storage() storage.instance.handle = entry.env.R2 + storage.instance.written_files = set() def upload(self, __bucket, key, filepath): + if filepath in self.written_files: + filepath = "/tmp" + os.path.abspath(filepath) with open(filepath, "rb") as f: self.upload_stream(__bucket, key, f.read()) return def download(self, __bucket, key, filepath): data = self.download_stream(__bucket, key) - with open(filepath, "wb") as f: + # should only allow writes to tmp dir. so do have to edit the filepath here? + tmp_fp = "/tmp" + os.path.abspath(filepath) + self.written_files.append(filepath) + with open(tmp_fp, "wb") as f: f.write(data) return def download_directory(self, __bucket, prefix, out_path): - list_res = await self.handle.list(prefix = prefix) ## gives only first 1000? + print(self.handle, type(self.handle)) + list_res = self.handle.list(prefix = prefix) ## gives only first 1000? for obj in list_res.objects: file_name = obj.key path_to_file = os.path.dirname(file_name) @@ -43,13 +63,13 @@ def download_directory(self, __bucket, prefix, out_path): def upload_stream(self, __bucket, key, data): unique_key = storage.unique_name(key) - put_res = await self.handle.put(unique_key, data) + put_res = self.handle.put(unique_key, data) return unique_key def download_stream(self, __bucket, key): - get_res = await self.handle.get(key) - assert get_res not None - data = await get_res.text() + get_res = self.handle.get(key) + assert get_res is not None + data = get_res.text() return data def get_instance(): From eaa42a1e2a93f3ca9484c0c415d4f1a88a3c8ebe Mon Sep 17 00:00:00 2001 From: ldzgch Date: Mon, 10 Nov 2025 00:09:58 +0100 Subject: [PATCH 05/69] just some changes. storage still not properly tested... --- .../wrappers/cloudflare/python/handler.py | 53 ++++++++++++------- .../wrappers/cloudflare/python/storage.py | 7 ++- 2 files changed, 38 insertions(+), 22 deletions(-) diff --git a/benchmarks/wrappers/cloudflare/python/handler.py b/benchmarks/wrappers/cloudflare/python/handler.py index 37d44595e..8e37efee4 100644 --- a/benchmarks/wrappers/cloudflare/python/handler.py +++ b/benchmarks/wrappers/cloudflare/python/handler.py @@ -4,28 +4,40 @@ ## sys.path.append(os.path.join(os.path.dirname(__file__), '.python_packages/lib/site-packages')) +""" +currently assumed file structure: +handler.py +function/ + function.py + .py + storage.py + nosql.py + +""" class Default(WorkerEntrypoint): async def fetch(self, request, env): if "favicon" in request.url: return Response("None") req_text = await request.text() - event = json.loads(req_text) if req_text is None else {} - - if True: # dirty url parameters parsing, for testing - tmp = request.url.split("?") - if len(tmp) > 1: - urlparams = tmp[1] - urlparams = [chunk.split("=") for chunk in urlparams.split("&")] - for param in urlparams: - try: - event[param[0]] = int(param[1]) - except ValueError: - event[param[0]] = param[1] - except IndexError: - event[param[0]] = None - + + event = json.loads(req_text) if len(req_text) > 0 else {} + print(event) + + # dirty url parameters parsing, for testing + tmp = request.url.split("?") + if len(tmp) > 1: + urlparams = tmp[1] + urlparams = [chunk.split("=") for chunk in urlparams.split("&")] + for param in urlparams: + try: + event[param[0]] = int(param[1]) + except ValueError: + event[param[0]] = param[1] + except IndexError: + event[param[0]] = None + @@ -39,13 +51,14 @@ async def fetch(self, request, env): event['request-id'] = req_id event['income-timestamp'] = income_timestamp - from storage import storage - storage.init_instance(self) + from function import storage + + storage.storage.init_instance(self) print("event:", event) - from function import handler - ret = handler(event) + from function import function + ret = function.handler(event) log_data = { 'output': ret['result'] @@ -57,7 +70,7 @@ async def fetch(self, request, env): if "html" in event: headers = {"Content-Type" : "text/html; charset=utf-8"} - return Response(ret["result"], headers = headers) + return Response(str(ret["result"]), headers = headers) else: return Response(json.dumps({ 'begin': "0", diff --git a/benchmarks/wrappers/cloudflare/python/storage.py b/benchmarks/wrappers/cloudflare/python/storage.py index da090be6c..de2a4642e 100644 --- a/benchmarks/wrappers/cloudflare/python/storage.py +++ b/benchmarks/wrappers/cloudflare/python/storage.py @@ -45,9 +45,12 @@ def upload(self, __bucket, key, filepath): def download(self, __bucket, key, filepath): data = self.download_stream(__bucket, key) # should only allow writes to tmp dir. so do have to edit the filepath here? - tmp_fp = "/tmp" + os.path.abspath(filepath) + real_fp = filepath + if not filepath.startswith("/tmp"): + real_fp = "/tmp" + os.path.abspath(filepath) + self.written_files.append(filepath) - with open(tmp_fp, "wb") as f: + with open(real_fp, "wb") as f: f.write(data) return From 57452fa6f80d5cead282a9c2d536223c92592d33 Mon Sep 17 00:00:00 2001 From: MisterMM23 Date: Mon, 10 Nov 2025 12:02:55 +0100 Subject: [PATCH 06/69] concept for r2 storage --- sebs/cloudflare/r2.py | 146 +++++++++++++++++++++++++++++++++++ sebs/cloudflare/resources.py | 43 ++++++++--- 2 files changed, 178 insertions(+), 11 deletions(-) create mode 100644 sebs/cloudflare/r2.py diff --git a/sebs/cloudflare/r2.py b/sebs/cloudflare/r2.py new file mode 100644 index 000000000..36e2d7a0c --- /dev/null +++ b/sebs/cloudflare/r2.py @@ -0,0 +1,146 @@ +import json + +import requests +from sebs.cloudflare.config import CloudflareCredentials +from sebs.faas.storage import PersistentStorage +from sebs.faas.config import Resources +from sebs.cache import Cache + + +class R2(PersistentStorage): + @staticmethod + def typename() -> str: + return "Cloudlfare.R2" + + @staticmethod + def deployment_name() -> str: + return "cloudflare" + + @property + def replace_existing(self) -> bool: + return self._replace_existing + + @replace_existing.setter + def replace_existing(self, val: bool): + self._replace_existing = val + + def __init__( + self, + region: str, + cache_client: Cache, + resources: Resources, + replace_existing: bool, + credentials: CloudflareCredentials, + ): + super().__init__(region, cache_client, resources, replace_existing) + self._credentials = credentials + + def _get_auth_headers(self) -> dict[str, str]: + """Get authentication headers for Cloudflare API requests.""" + if self._credentials.api_token: + return { + "Authorization": f"Bearer {self._credentials.api_token}", + "Content-Type": "application/json", + } + elif self._credentials.email and self._credentials.api_key: + return { + "X-Auth-Email": self._credentials.email, + "X-Auth-Key": self._credentials.api_key, + "Content-Type": "application/json", + } + else: + raise RuntimeError("Invalid Cloudflare credentials configuration") + + def correct_name(self, name: str) -> str: + return name + + def _create_bucket( + self, name: str, buckets: list[str] = [], randomize_name: bool = False + ) -> str: + for bucket_name in buckets: + if name in bucket_name: + self.logging.info( + "Bucket {} for {} already exists, skipping.".format( + bucket_name, name + ) + ) + return bucket_name + + account_id = self._credentials.account_id + + get_bucket_uri = ( + f"https://api.cloudflare.com/client/v4/accounts/{account_id}/r2/buckets" + ) + + params = {"name": "cloudflare_bucket", "locationHint": self._region} + + create_bucket_response = requests.post( + get_bucket_uri, json=params, headers=self._get_auth_headers() + ) + bucket_info = create_bucket_response.content.decode("utf-8") + bucket_info_json = json.load(bucket_info) # pyright: ignore + + return bucket_info_json.name + + """ + Download a file from a bucket. + + :param bucket_name: + :param key: storage source filepath + :param filepath: local destination filepath + """ + + def download(self, bucket_name: str, key: str, filepath: str) -> None: + pass + + """ + Upload a file to a bucket with by passing caching. + Useful for uploading code package to storage (when required). + + :param bucket_name: + :param filepath: local source filepath + :param key: storage destination filepath + """ + + def upload(self, bucket_name: str, filepath: str, key: str): + pass + + """ + Retrieves list of files in a bucket. + + :param bucket_name: + :return: list of files in a given bucket + """ + + def list_bucket(self, bucket_name: str, prefix: str = "") -> List[str]: + pass + + def list_buckets(self, bucket_name: Optional[str] = None) -> List[str]: + pass + + def exists_bucket(self, bucket_name: str) -> bool: + pass + + def clean_bucket(self, bucket_name: str): + pass + + def remove_bucket(self, bucket: str): + pass + + """ + Allocate a set of input/output buckets for the benchmark. + The routine checks the cache first to verify that buckets have not + been allocated first. + + :param benchmark: benchmark name + :param buckets: number of input and number of output buckets + """ + + def uploader_func(self, bucket_idx: int, file: str, filepath: str) -> None: + pass + + """ + Download all files in a storage bucket. + Warning: assumes flat directory in a bucket! Does not handle bucket files + with directory marks in a name, e.g. 'dir1/dir2/file' + """ diff --git a/sebs/cloudflare/resources.py b/sebs/cloudflare/resources.py index f9f9743d2..0ef145343 100644 --- a/sebs/cloudflare/resources.py +++ b/sebs/cloudflare/resources.py @@ -4,21 +4,23 @@ from sebs.cache import Cache from sebs.cloudflare.config import CloudflareConfig +from sebs.cloudflare.r2 import R2 from sebs.faas.resources import SystemResources from sebs.faas.storage import PersistentStorage from sebs.faas.nosql import NoSQLStorage from sebs.utils import LoggingHandlers +import json class CloudflareSystemResources(SystemResources): """ System resources for Cloudflare Workers. - + Cloudflare Workers have a different resource model compared to traditional cloud platforms. This class handles Cloudflare-specific resources like KV namespaces and R2 storage. """ - + def __init__( self, config: CloudflareConfig, @@ -33,31 +35,50 @@ def __init__( def config(self) -> CloudflareConfig: return self._config + def _get_auth_headers(self) -> dict[str, str]: + """Get authentication headers for Cloudflare API requests.""" + if self._config.credentials.api_token: + return { + "Authorization": f"Bearer {self._config.credentials.api_token}", + "Content-Type": "application/json", + } + elif self._config.credentials.email and self._config.credentials.api_key: + return { + "X-Auth-Email": self._config.credentials.email, + "X-Auth-Key": self._config.credentials.api_key, + "Content-Type": "application/json", + } + else: + raise RuntimeError("Invalid Cloudflare credentials configuration") + def get_storage(self, replace_existing: Optional[bool] = None) -> PersistentStorage: """ Get Cloudflare R2 storage instance. - + R2 is Cloudflare's S3-compatible object storage service. This method will create a client for managing benchmark input/output data. - + Args: replace_existing: Whether to replace existing files in storage - + Raises: NotImplementedError: R2 storage support not yet implemented """ - raise NotImplementedError( - "Cloudflare R2 storage is not yet implemented. " - "To add support, implement a PersistentStorage subclass for R2 " - "similar to sebs/aws/s3.py or sebs/azure/blob_storage.py" + + return R2( + region=self._config.region, + cache_client=None, + resources=self._config.resources, + replace_existing=replace_existing, + credentials=self._config.credentials, ) def get_nosql_storage(self) -> NoSQLStorage: """ Get Cloudflare NoSQL storage instance. - + This could use Cloudflare D1 (SQLite) or Durable Objects for NoSQL storage. - + Raises: NotImplementedError: NoSQL storage support not yet implemented """ From 9e47e0fd1758cfe1d70529b58c6b7bf8da40a172 Mon Sep 17 00:00:00 2001 From: laurin Date: Mon, 10 Nov 2025 12:01:15 +0100 Subject: [PATCH 07/69] translated wrapper to js --- .../wrappers/cloudflare/nodejs/handler.js | 167 +++++++++++---- .../wrappers/cloudflare/nodejs/storage.js | 192 +++++++++++++----- 2 files changed, 268 insertions(+), 91 deletions(-) diff --git a/benchmarks/wrappers/cloudflare/nodejs/handler.js b/benchmarks/wrappers/cloudflare/nodejs/handler.js index 2c63947fd..a5a309dbc 100644 --- a/benchmarks/wrappers/cloudflare/nodejs/handler.js +++ b/benchmarks/wrappers/cloudflare/nodejs/handler.js @@ -1,37 +1,134 @@ -const path = require('path'), fs = require('fs'); - export default { - async fetch(request, env, ctx) { - var begin = Date.now()/1000; - var start = process.hrtime(); - var func = require('./function') - var ret = func.handler(req.body); - return ret.then( - (result) => { - var elapsed = process.hrtime(start); - var end = Date.now()/1000; - var micro = elapsed[1] / 1e3 + elapsed[0] * 1e6; - - var is_cold = false; - var fname = path.join('/tmp','cold_run'); - if(!fs.existsSync(fname)) { - is_cold = true; - fs.closeSync(fs.openSync(fname, 'w')); - } - - res.status(200).json({ - begin: begin, - end: end, - compute_time: micro, - results_time: 0, - result: {output: result}, - is_cold: is_cold, - request_id: req.headers["function-execution-id"] - }); - }, - (error) => { - throw(error); - } - ); -} + async fetch(request, env) { + // Match behavior of the Python handler: parse body, parse URL params, + // set request-id and income timestamp, call the benchmark function, + // and return a JSON response with the same fields. + + if (request.url.includes('favicon')) { + return new Response('None'); + } + + const req_text = await request.text(); + let event = {}; + if (req_text && req_text.length > 0) { + try { + event = JSON.parse(req_text); + } catch (e) { + // If body isn't JSON, keep event empty + event = {}; + } + } + + // Parse query string into event (simple parsing, mirrors Python logic) + const urlParts = request.url.split('?'); + if (urlParts.length > 1) { + const query = urlParts[1]; + const pairs = query.split('&'); + for (const p of pairs) { + const [k, v] = p.split('='); + try { + if (v === undefined) { + event[k] = null; + } else if (!Number.isNaN(Number(v)) && Number.isFinite(Number(v))) { + // mirror Python attempt to convert to int + const n = Number(v); + event[k] = Number.isInteger(n) ? parseInt(v, 10) : n; + } else { + event[k] = decodeURIComponent(v); + } + } catch (e) { + event[k] = v; + } + } + } + + // Set request id and timestamps (Python used 0 for request id) + const req_id = 0; + const income_timestamp = Math.floor(Date.now() / 1000); + event['request-id'] = req_id; + event['income-timestamp'] = income_timestamp; + + // Load the benchmark function module and initialize storage if available + let funcModule; + try { + // dynamic import to work in Workers ESM runtime + funcModule = await import('./function.js'); + } catch (e) { + try { + // fallback without .js + funcModule = await import('./function'); + } catch (e2) { + throw new Error('Failed to import benchmark function module: ' + e2.message); + } + } + + // If the function module exposes a storage initializer, call it + try { + if (funcModule && funcModule.storage && typeof funcModule.storage.init_instance === 'function') { + try { + funcModule.storage.init_instance({ env, request }); + } catch (ignore) {} + } + } catch (e) { + // don't fail the request if storage init isn't available + } + + // Execute the benchmark handler + let ret; + try { + if (funcModule && typeof funcModule.handler === 'function') { + // handler may be sync or return a promise + ret = await Promise.resolve(funcModule.handler(event)); + } else if (funcModule && funcModule.default && typeof funcModule.default.handler === 'function') { + ret = await Promise.resolve(funcModule.default.handler(event)); + } else { + throw new Error('benchmark handler function not found'); + } + } catch (err) { + // Mirror Python behavior: return structured error payload + const errorPayload = JSON.stringify({ + begin: '0', + end: '0', + results_time: '0', + result: { output: null }, + is_cold: false, + is_cold_worker: false, + container_id: '0', + environ_container_id: 'no_id', + request_id: '0', + error: String(err && err.message ? err.message : err), + }); + return new Response(errorPayload, { status: 500, headers: { 'Content-Type': 'application/json' } }); + } + + // Build log_data similar to Python handler + const log_data = { output: ret && ret.result !== undefined ? ret.result : ret }; + if (ret && ret.measurement !== undefined) { + log_data.measurement = ret.measurement; + } + if (event.logs !== undefined) { + log_data.time = 0; + } + + if (event.html) { + return new Response(String(ret && ret.result !== undefined ? ret.result : ''), { + headers: { 'Content-Type': 'text/html; charset=utf-8' }, + }); + } + + const responseBody = JSON.stringify({ + begin: '0', + end: '0', + results_time: '0', + result: log_data, + is_cold: false, + is_cold_worker: false, + container_id: '0', + environ_container_id: 'no_id', + request_id: '0', + }); + + return new Response(responseBody, { headers: { 'Content-Type': 'application/json' } }); + }, +}; diff --git a/benchmarks/wrappers/cloudflare/nodejs/storage.js b/benchmarks/wrappers/cloudflare/nodejs/storage.js index 134192089..01fca6803 100644 --- a/benchmarks/wrappers/cloudflare/nodejs/storage.js +++ b/benchmarks/wrappers/cloudflare/nodejs/storage.js @@ -1,64 +1,144 @@ -const { Storage } = - fs = require('fs'), - path = require('path'), - uuid = require('uuid'), - util = require('util'), - stream = require('stream'); +const fs = require('fs'); +const path = require('path'); +const uuid = require('uuid'); -class cf_storage { +// Storage wrapper compatible with the Python storage implementation. +// Supports Cloudflare R2 (via env.R2) when available; falls back to +// filesystem-based operations when running in Node.js (for local tests). +class storage { constructor() { + this.handle = null; // R2 binding + this.written_files = new Set(); + } + + static unique_name(name) { + const parsed = path.parse(name); + const uuid_name = uuid.v4().split('-')[0]; + return path.join(parsed.dir, `${parsed.name}.${uuid_name}${parsed.ext}`); + } + + // entry is expected to be an object with `env` (Workers) or nothing for Node + static init_instance(entry) { + storage.instance = new storage(); + if (entry && entry.env && entry.env.R2) { + storage.instance.handle = entry.env.R2; + } + storage.instance.written_files = new Set(); + } + + // Upload a file given a local filepath. In Workers env this is not available + // so callers should use upload_stream or pass raw data. For Node.js we read + // the file from disk and put it into R2 if available, otherwise throw. + async upload(__bucket, key, filepath) { + // If file was previously written during this invocation, use /tmp absolute + let realPath = filepath; + if (this.written_files.has(filepath)) { + realPath = path.join('/tmp', path.resolve(filepath)); + } + + // Read file content + if (fs && fs.existsSync(realPath)) { + const data = fs.readFileSync(realPath); + return await this.upload_stream(__bucket, key, data); + } + + // If running in Workers (no fs) and caller provided Buffer/Stream, they + // should call upload_stream directly. Otherwise, throw. + throw new Error('upload(): file not found on disk and no R2 handle provided'); + } + + async download(__bucket, key, filepath) { + const data = await this.download_stream(__bucket, key); + + let real_fp = filepath; + if (!filepath.startsWith('/tmp')) { + real_fp = path.join('/tmp', path.resolve(filepath)); + } + + this.written_files.add(filepath); + + // Write data to file if we have fs + if (fs) { + fs.mkdirSync(path.dirname(real_fp), { recursive: true }); + if (Buffer.isBuffer(data)) { + fs.writeFileSync(real_fp, data); + } else { + fs.writeFileSync(real_fp, Buffer.from(String(data))); + } + return; + } + + // In Workers environment, callers should use stream APIs directly. + return; + } + + async download_directory(__bucket, prefix, out_path) { + if (!this.handle) { + throw new Error('download_directory requires R2 binding (env.R2)'); + } + + const list_res = await this.handle.list({ prefix }); + const objects = list_res.objects || []; + for (const obj of objects) { + const file_name = obj.key; + const path_to_file = path.dirname(file_name); + fs.mkdirSync(path.join(out_path, path_to_file), { recursive: true }); + await this.download(__bucket, file_name, path.join(out_path, file_name)); + } + } + + async upload_stream(__bucket, key, data) { + const unique_key = storage.unique_name(key); + if (this.handle) { + // R2 put accepts ArrayBuffer, ReadableStream, or string + await this.handle.put(unique_key, data); + return unique_key; + } + + // If no R2, write to local fs as fallback + if (fs) { + const outPath = path.join('/tmp', unique_key); + fs.mkdirSync(path.dirname(outPath), { recursive: true }); + if (Buffer.isBuffer(data)) fs.writeFileSync(outPath, data); + else fs.writeFileSync(outPath, Buffer.from(String(data))); + return unique_key; + } + + throw new Error('upload_stream(): no storage backend available'); + } + + async download_stream(__bucket, key) { + if (this.handle) { + const obj = await this.handle.get(key); + if (!obj) return null; + // R2 object provides arrayBuffer()/text() helpers in Workers + if (typeof obj.arrayBuffer === 'function') { + const ab = await obj.arrayBuffer(); + return Buffer.from(ab); + } + if (typeof obj.text === 'function') { + return await obj.text(); + } + // Fallback: return null + return null; + } + + // Fallback to local filesystem + const localPath = path.join('/tmp', key); + if (fs && fs.existsSync(localPath)) { + return fs.readFileSync(localPath); + } + throw new Error('download_stream(): object not found'); } - unique_name(file) { - let name = path.parse(file); - let uuid_name = uuid.v4().split('-')[0]; - return path.join(name.dir, util.format('%s.%s%s', name.name, uuid_name, name.ext)); + static get_instance() { + if (!storage.instance) { + throw new Error('must init storage singleton first'); + } + return storage.instance; } +} - upload(container, file, filepath) { - let bucket = this.storage.bucket(container); - let uniqueName = this.unique_name(file); - let options = {destination: uniqueName, resumable: false}; - return [uniqueName, bucket.upload(filepath, options)]; - }; - - download(container, file, filepath) { - let bucket = this.storage.bucket(container); - var file = bucket.file(file); - file.download({destination: filepath}); - }; - - uploadStream(container, file) { - let bucket = this.storage.bucket(container); - let uniqueName = this.unique_name(file); - var file = bucket.file(uniqueName); - let upload = file.createWriteStream(); - var write_stream = new stream.PassThrough(); - - write_stream.pipe(upload); - - const promise = new Promise((resolve, reject) => { - upload.on('error', err => { - upload.end(); - reject(err); - }); - - upload.on('finish', () => { - upload.end(); - resolve(file.name); - }); - }); - return [write_stream, promise, uniqueName]; - }; - - downloadStream(container, file) { - let bucket = this.storage.bucket(container); - var file = bucket.file(file); - let downloaded = file.createReadStream(); - return Promise.resolve(downloaded); - }; -}; - -exports.storage = cf_storage; +module.exports.storage = storage; From 822a9d951bcc561ac4e6ac1668762bede9d0f134 Mon Sep 17 00:00:00 2001 From: laurin Date: Mon, 10 Nov 2025 15:06:47 +0100 Subject: [PATCH 08/69] used output from workers as analytics measurements in sebs --- sebs/cli.py | 2 +- sebs/cloudflare/cloudflare.py | 279 ++++++++++------------------------ sebs/cloudflare/triggers.py | 60 ++++++-- sebs/sebs.py | 7 +- 4 files changed, 133 insertions(+), 215 deletions(-) diff --git a/sebs/cli.py b/sebs/cli.py index 4e1cc558c..f65c5eb6e 100755 --- a/sebs/cli.py +++ b/sebs/cli.py @@ -113,7 +113,7 @@ def common_params(func): @click.option( "--deployment", default=None, - type=click.Choice(["azure", "aws", "gcp", "local", "openwhisk"]), + type=click.Choice(["azure", "aws", "gcp", "local", "openwhisk", "cloudflare"]), help="Cloud deployment to use.", ) @click.option( diff --git a/sebs/cloudflare/cloudflare.py b/sebs/cloudflare/cloudflare.py index ce2cc25ea..366ea59f0 100644 --- a/sebs/cloudflare/cloudflare.py +++ b/sebs/cloudflare/cloudflare.py @@ -457,226 +457,107 @@ def download_metrics( metrics: dict, ): """ - Download per-invocation metrics from Cloudflare Analytics Engine. + Extract per-invocation metrics from ExecutionResult objects. - Queries Analytics Engine SQL API to retrieve performance data for each - invocation and enriches the ExecutionResult objects with provider metrics. - - Note: Requires Analytics Engine binding to be configured on the worker - and benchmark code to write data points during execution. + The metrics are extracted from the 'measurement' field in the benchmark + response, which is populated by the Cloudflare Worker handler during execution. + This approach avoids dependency on Analytics Engine and provides immediate, + accurate metrics for each invocation. Args: function_name: Name of the worker - start_time: Start time (Unix timestamp in seconds) - end_time: End time (Unix timestamp in seconds) + start_time: Start time (Unix timestamp in seconds) - not used + end_time: End time (Unix timestamp in seconds) - not used requests: Dict mapping request_id -> ExecutionResult metrics: Dict to store aggregated metrics """ if not requests: - self.logging.warning("No requests to download metrics for") - return - - account_id = self.config.credentials.account_id - if not account_id: - self.logging.error("Account ID required to download metrics") + self.logging.warning("No requests to extract metrics from") return self.logging.info( - f"Downloading Analytics Engine metrics for {len(requests)} invocations " + f"Extracting metrics from {len(requests)} invocations " f"of worker {function_name}" ) - try: - # Query Analytics Engine for per-invocation metrics - metrics_data = self._query_analytics_engine( - account_id, start_time, end_time, function_name - ) + # Aggregate statistics from all requests + total_invocations = len(requests) + cold_starts = 0 + warm_starts = 0 + cpu_times = [] + wall_times = [] + memory_values = [] + + for request_id, result in requests.items(): + # Count cold/warm starts + if result.stats.cold_start: + cold_starts += 1 + else: + warm_starts += 1 - if not metrics_data: - self.logging.warning( - "No metrics data returned from Analytics Engine. " - "Ensure the worker has Analytics Engine binding configured " - "and is writing data points during execution." - ) - return + # Collect CPU times + if result.provider_times.execution > 0: + cpu_times.append(result.provider_times.execution) - # Match metrics with invocation requests - matched = 0 - unmatched_metrics = 0 + # Collect wall times (benchmark times) + if result.times.benchmark > 0: + wall_times.append(result.times.benchmark) - for row in metrics_data: - request_id = row.get('request_id') - - if request_id and request_id in requests: - result = requests[request_id] - - # Populate provider times (convert ms to microseconds) - wall_time_ms = row.get('wall_time_ms', 0) - cpu_time_ms = row.get('cpu_time_ms', 0) - - result.provider_times.execution = int(cpu_time_ms * 1000) # μs - result.provider_times.initialization = 0 # Not separately tracked - - # Populate stats - result.stats.cold_start = (row.get('cold_warm') == 'cold') - result.stats.memory_used = 128.0 # Cloudflare Workers: fixed 128MB - - # Populate billing info - # Cloudflare billing: $0.50 per million requests + - # $12.50 per million GB-seconds of CPU time - result.billing.memory = 128 - result.billing.billed_time = int(cpu_time_ms * 1000) # μs - - # GB-seconds calculation: (128MB / 1024MB/GB) * (cpu_time_ms / 1000ms/s) - gb_seconds = (128.0 / 1024.0) * (cpu_time_ms / 1000.0) - result.billing.gb_seconds = int(gb_seconds * 1000000) # micro GB-seconds - - matched += 1 - elif request_id: - unmatched_metrics += 1 + # Collect memory usage + if result.stats.memory_used > 0: + memory_values.append(result.stats.memory_used) - # Calculate statistics from matched metrics - if matched > 0: - cpu_times = [ - requests[rid].provider_times.execution - for rid in requests - if requests[rid].provider_times.execution > 0 - ] - cold_starts = sum( - 1 for rid in requests if requests[rid].stats.cold_start - ) + # Set billing info for Cloudflare Workers + # Cloudflare billing: $0.50 per million requests + + # $12.50 per million GB-seconds of CPU time + if result.provider_times.execution > 0: + result.billing.memory = 128 # Cloudflare Workers: fixed 128MB + result.billing.billed_time = result.provider_times.execution # μs - metrics['cloudflare'] = { - 'total_invocations': len(metrics_data), - 'matched_invocations': matched, - 'unmatched_invocations': len(requests) - matched, - 'unmatched_metrics': unmatched_metrics, - 'cold_starts': cold_starts, - 'warm_starts': matched - cold_starts, - 'data_source': 'analytics_engine', - 'note': 'Per-invocation metrics from Analytics Engine' - } - - if cpu_times: - metrics['cloudflare']['avg_cpu_time_us'] = sum(cpu_times) // len(cpu_times) - metrics['cloudflare']['min_cpu_time_us'] = min(cpu_times) - metrics['cloudflare']['max_cpu_time_us'] = max(cpu_times) - - self.logging.info( - f"Analytics Engine metrics: matched {matched}/{len(requests)} invocations" - ) - - if matched < len(requests): - missing = len(requests) - matched - self.logging.warning( - f"{missing} invocations not found in Analytics Engine. " - "This may be due to:\n" - " - Analytics Engine ingestion delay (typically <60s)\n" - " - Worker not writing data points correctly\n" - " - Analytics Engine binding not configured" - ) - - if unmatched_metrics > 0: - self.logging.warning( - f"{unmatched_metrics} metrics found in Analytics Engine " - "that don't match tracked request IDs (possibly from other sources)" - ) - - except Exception as e: - self.logging.error(f"Failed to download metrics: {e}") - self.logging.warning( - "Continuing without Analytics Engine metrics. " - "Client-side timing data is still available." - ) - - def _query_analytics_engine( - self, - account_id: str, - start_time: int, - end_time: int, - script_name: str - ) -> List[dict]: - """ - Query Analytics Engine SQL API for worker metrics. - - Retrieves per-invocation metrics written by the worker during execution. - The worker must write data points with the following schema: - - index1: request_id (unique identifier) - - index2: cold_warm ("cold" or "warm") - - double1: wall_time_ms (wall clock time in milliseconds) - - double2: cpu_time_ms (CPU time in milliseconds) - - blob1: url (request URL) - - blob2: status ("success" or "error") - - blob3: error_message (if applicable) + # GB-seconds calculation: (128MB / 1024MB/GB) * (cpu_time_us / 1000000 us/s) + cpu_time_seconds = result.provider_times.execution / 1_000_000.0 + gb_seconds = (128.0 / 1024.0) * cpu_time_seconds + result.billing.gb_seconds = int(gb_seconds * 1_000_000) # micro GB-seconds + + # Calculate statistics + metrics['cloudflare'] = { + 'total_invocations': total_invocations, + 'cold_starts': cold_starts, + 'warm_starts': warm_starts, + 'data_source': 'response_measurements', + 'note': 'Per-invocation metrics extracted from benchmark response' + } - Args: - account_id: Cloudflare account ID - start_time: Unix timestamp (seconds) - end_time: Unix timestamp (seconds) - script_name: Worker script name - - Returns: - List of metric data points, one per invocation - """ - headers = self._get_auth_headers() - url = f"{self._api_base_url}/accounts/{account_id}/analytics_engine/sql" - - # Convert Unix timestamps to DateTime format for ClickHouse - from datetime import datetime - start_dt = datetime.utcfromtimestamp(start_time).strftime('%Y-%m-%d %H:%M:%S') - end_dt = datetime.utcfromtimestamp(end_time).strftime('%Y-%m-%d %H:%M:%S') - - # SQL query for Analytics Engine - # Note: Analytics Engine uses ClickHouse SQL syntax - sql_query = f""" - SELECT - index1 as request_id, - index2 as cold_warm, - double1 as wall_time_ms, - double2 as cpu_time_ms, - blob1 as url, - blob2 as status, - blob3 as error_message, - timestamp - FROM ANALYTICS_DATASET - WHERE timestamp >= toDateTime('{start_dt}') - AND timestamp <= toDateTime('{end_dt}') - AND blob1 LIKE '%{script_name}%' - ORDER BY timestamp ASC - """ + if cpu_times: + metrics['cloudflare']['avg_cpu_time_us'] = sum(cpu_times) // len(cpu_times) + metrics['cloudflare']['min_cpu_time_us'] = min(cpu_times) + metrics['cloudflare']['max_cpu_time_us'] = max(cpu_times) + metrics['cloudflare']['cpu_time_measurements'] = len(cpu_times) - try: - # Analytics Engine SQL API returns newline-delimited JSON - response = requests.post( - url, - headers=headers, - data=sql_query, - timeout=30 - ) - - if response.status_code == 200: - # Parse newline-delimited JSON response - results = [] - for line in response.text.strip().split('\n'): - if line: - try: - results.append(json.loads(line)) - except json.JSONDecodeError: - self.logging.warning(f"Failed to parse Analytics Engine line: {line}") - - self.logging.info(f"Retrieved {len(results)} data points from Analytics Engine") - return results - else: - raise RuntimeError( - f"Analytics Engine query failed: {response.status_code} - {response.text}" - ) - - except requests.exceptions.Timeout: - self.logging.error("Analytics Engine query timed out") - return [] - except Exception as e: - self.logging.error(f"Analytics Engine query error: {e}") - return [] + if wall_times: + metrics['cloudflare']['avg_wall_time_us'] = sum(wall_times) // len(wall_times) + metrics['cloudflare']['min_wall_time_us'] = min(wall_times) + metrics['cloudflare']['max_wall_time_us'] = max(wall_times) + metrics['cloudflare']['wall_time_measurements'] = len(wall_times) + + if memory_values: + metrics['cloudflare']['avg_memory_mb'] = sum(memory_values) / len(memory_values) + metrics['cloudflare']['min_memory_mb'] = min(memory_values) + metrics['cloudflare']['max_memory_mb'] = max(memory_values) + metrics['cloudflare']['memory_measurements'] = len(memory_values) + + self.logging.info( + f"Extracted metrics from {total_invocations} invocations: " + f"{cold_starts} cold starts, {warm_starts} warm starts" + ) + + if cpu_times: + avg_cpu_ms = sum(cpu_times) / len(cpu_times) / 1000.0 + self.logging.info(f"Average CPU time: {avg_cpu_ms:.2f} ms") + + if wall_times: + avg_wall_ms = sum(wall_times) / len(wall_times) / 1000.0 + self.logging.info(f"Average wall time: {avg_wall_ms:.2f} ms") def create_trigger( self, function: Function, trigger_type: Trigger.TriggerType diff --git a/sebs/cloudflare/triggers.py b/sebs/cloudflare/triggers.py index cb038b63a..310f1fa94 100644 --- a/sebs/cloudflare/triggers.py +++ b/sebs/cloudflare/triggers.py @@ -1,6 +1,7 @@ from typing import Optional +import concurrent.futures -from sebs.faas.function import Trigger +from sebs.faas.function import Trigger, ExecutionResult class LibraryTrigger(Trigger): @@ -21,7 +22,7 @@ def typename() -> str: def trigger_type() -> Trigger.TriggerType: return Trigger.TriggerType.LIBRARY - def sync_invoke(self, payload: dict) -> Optional[str]: + def sync_invoke(self, payload: dict) -> ExecutionResult: """ Synchronously invoke a Cloudflare Worker. @@ -29,12 +30,12 @@ def sync_invoke(self, payload: dict) -> Optional[str]: payload: The payload to send to the worker Returns: - The response from the worker + ExecutionResult with performance metrics """ # This will be implemented when we have the deployment client raise NotImplementedError("Cloudflare Worker invocation not yet implemented") - def async_invoke(self, payload: dict) -> object: + def async_invoke(self, payload: dict) -> concurrent.futures.Future: """ Asynchronously invoke a Cloudflare Worker. Not typically supported for Cloudflare Workers. @@ -76,7 +77,7 @@ def url(self) -> str: def url(self, url: str): self._url = url - def sync_invoke(self, payload: dict) -> Optional[str]: + def sync_invoke(self, payload: dict) -> ExecutionResult: """ Synchronously invoke a Cloudflare Worker via HTTP. @@ -84,20 +85,53 @@ def sync_invoke(self, payload: dict) -> Optional[str]: payload: The payload to send to the worker Returns: - The response from the worker + ExecutionResult with performance metrics extracted from the response """ - import requests + self.logging.debug(f"Invoke function {self.url}") + result = self._http_invoke(payload, self.url) - response = requests.post(self.url, json=payload) - response.raise_for_status() - return response.text + # Extract measurement data from the response if available + if result.output and 'result' in result.output: + result_data = result.output['result'] + if isinstance(result_data, dict) and 'measurement' in result_data: + measurement = result_data['measurement'] + + # Extract timing metrics if provided by the benchmark + if isinstance(measurement, dict): + # CPU time in microseconds + if 'cpu_time_us' in measurement: + result.provider_times.execution = measurement['cpu_time_us'] + elif 'cpu_time_ms' in measurement: + result.provider_times.execution = int(measurement['cpu_time_ms'] * 1000) + + # Wall time in microseconds + if 'wall_time_us' in measurement: + result.times.benchmark = measurement['wall_time_us'] + elif 'wall_time_ms' in measurement: + result.times.benchmark = int(measurement['wall_time_ms'] * 1000) + + # Cold/warm start detection + if 'is_cold' in measurement: + result.stats.cold_start = measurement['is_cold'] + + # Memory usage if available + if 'memory_used_mb' in measurement: + result.stats.memory_used = measurement['memory_used_mb'] + + # Store the full measurement for later analysis + result.output['measurement'] = measurement + + self.logging.debug(f"Extracted measurements: {measurement}") + + return result - def async_invoke(self, payload: dict) -> object: + def async_invoke(self, payload: dict) -> concurrent.futures.Future: """ Asynchronously invoke a Cloudflare Worker via HTTP. - Not typically needed for Cloudflare Workers. """ - raise NotImplementedError("Cloudflare Workers do not support async HTTP invocation") + pool = concurrent.futures.ThreadPoolExecutor() + fut = pool.submit(self.sync_invoke, payload) + return fut def serialize(self) -> dict: return { diff --git a/sebs/sebs.py b/sebs/sebs.py index febfeb24a..d90512159 100644 --- a/sebs/sebs.py +++ b/sebs/sebs.py @@ -214,10 +214,13 @@ def get_deployment( from sebs.openwhisk import OpenWhisk implementations["openwhisk"] = OpenWhisk - if has_platform("cloudflare"): + + # Cloudflare is available by default (like local) + try: from sebs.cloudflare import Cloudflare - implementations["cloudflare"] = Cloudflare + except ImportError: + pass # Validate deployment platform if name not in implementations: From f7bb950e9123c6487f4b0dc2284ed9166a8f88e4 Mon Sep 17 00:00:00 2001 From: laurin Date: Mon, 10 Nov 2025 15:40:16 +0100 Subject: [PATCH 09/69] last changes necessary for sebs to run cloudflare. now just the storage is needed and the wrappers have to work --- configs/systems.json | 24 +++++++++++++++++++++++- sebs/cloudflare/cloudflare.py | 24 +++++++++++++++++++++++- sebs/cloudflare/r2.py | 2 +- sebs/cloudflare/resources.py | 3 ++- sebs/faas/config.py | 8 ++++++++ 5 files changed, 57 insertions(+), 4 deletions(-) diff --git a/configs/systems.json b/configs/systems.json index a6f8ac186..94190320e 100644 --- a/configs/systems.json +++ b/configs/systems.json @@ -450,7 +450,29 @@ "packages": [], "module_packages": {} } + }, + "nodejs": { + "base_images": { + "x64": { + "18": "ubuntu:22.04", + "20": "ubuntu:22.04" + } + }, + "images": [ + "build" + ], + "deployment": { + "files": [ + "handler.js", + "storage.js" + ], + "packages": { + "uuid": "3.4.0" + } + } } - } + }, + "architecture": ["x64"], + "deployments": ["package"] } } diff --git a/sebs/cloudflare/cloudflare.py b/sebs/cloudflare/cloudflare.py index 366ea59f0..f09e3d89c 100644 --- a/sebs/cloudflare/cloudflare.py +++ b/sebs/cloudflare/cloudflare.py @@ -75,12 +75,34 @@ def initialize(self, config: Dict[str, str] = {}, resource_prefix: Optional[str] def _verify_credentials(self): """Verify that the Cloudflare API credentials are valid.""" + # Check if credentials are set + if not self.config.credentials.api_token and not (self.config.credentials.email and self.config.credentials.api_key): + raise RuntimeError( + "Cloudflare API credentials are not set. Please set CLOUDFLARE_API_TOKEN " + "and CLOUDFLARE_ACCOUNT_ID environment variables." + ) + + if not self.config.credentials.account_id: + raise RuntimeError( + "Cloudflare Account ID is not set. Please set CLOUDFLARE_ACCOUNT_ID " + "environment variable." + ) + headers = self._get_auth_headers() + + # Log credential type being used (without exposing the actual token) + if self.config.credentials.api_token: + token_preview = self.config.credentials.api_token[:8] + "..." if len(self.config.credentials.api_token) > 8 else "***" + self.logging.info(f"Using API Token authentication (starts with: {token_preview})") + else: + self.logging.info(f"Using Email + API Key authentication (email: {self.config.credentials.email})") + response = requests.get(f"{self._api_base_url}/user/tokens/verify", headers=headers) if response.status_code != 200: raise RuntimeError( - f"Failed to verify Cloudflare credentials: {response.status_code} - {response.text}" + f"Failed to verify Cloudflare credentials: {response.status_code} - {response.text}\n" + f"Please check that your CLOUDFLARE_API_TOKEN and CLOUDFLARE_ACCOUNT_ID are correct." ) self.logging.info("Cloudflare credentials verified successfully") diff --git a/sebs/cloudflare/r2.py b/sebs/cloudflare/r2.py index 36e2d7a0c..60265ca0d 100644 --- a/sebs/cloudflare/r2.py +++ b/sebs/cloudflare/r2.py @@ -6,7 +6,7 @@ from sebs.faas.config import Resources from sebs.cache import Cache - +from typing import List, Optional class R2(PersistentStorage): @staticmethod def typename() -> str: diff --git a/sebs/cloudflare/resources.py b/sebs/cloudflare/resources.py index 0ef145343..fa181ad71 100644 --- a/sebs/cloudflare/resources.py +++ b/sebs/cloudflare/resources.py @@ -28,8 +28,9 @@ def __init__( docker_client: docker.client, logging_handlers: LoggingHandlers, ): - super().__init__(config, cache_client, docker_client, logging_handlers) + super().__init__(config, cache_client, docker_client) self._config = config + self.logging_handlers = logging_handlers @property def config(self) -> CloudflareConfig: diff --git a/sebs/faas/config.py b/sebs/faas/config.py index 8e4e6784b..d1fa07a93 100644 --- a/sebs/faas/config.py +++ b/sebs/faas/config.py @@ -431,6 +431,14 @@ def deserialize(config: dict, cache: Cache, handlers: LoggingHandlers) -> "Confi from sebs.openwhisk.config import OpenWhiskConfig implementations["openwhisk"] = OpenWhiskConfig.deserialize + + # Cloudflare is available by default (like local) + try: + from sebs.cloudflare.config import CloudflareConfig + implementations["cloudflare"] = CloudflareConfig.deserialize + except ImportError: + pass + func = implementations.get(name) assert func, "Unknown config type!" return func(config[name] if name in config else config, cache, handlers) From 1f0a9795423d5731f187705d094573e854438c6e Mon Sep 17 00:00:00 2001 From: laurin Date: Tue, 11 Nov 2025 17:48:49 +0100 Subject: [PATCH 10/69] javascript wrapper with polyfills reading from r2. r2 implementation, resources.py --- .../wrappers/cloudflare/nodejs/fs-polyfill.js | 156 +++++ .../wrappers/cloudflare/nodejs/handler.js | 85 ++- .../cloudflare/nodejs/path-polyfill.js | 54 ++ configs/cloudflare-test.json | 19 + configs/systems.json | 12 +- sebs/cloudflare/cloudflare.py | 556 ++++++++++++++++-- sebs/cloudflare/config.py | 26 +- sebs/cloudflare/durable_objects.py | 201 +++++++ sebs/cloudflare/r2.py | 288 +++++++-- sebs/cloudflare/resources.py | 27 +- sebs/cloudflare/triggers.py | 25 +- 11 files changed, 1300 insertions(+), 149 deletions(-) create mode 100644 benchmarks/wrappers/cloudflare/nodejs/fs-polyfill.js create mode 100644 benchmarks/wrappers/cloudflare/nodejs/path-polyfill.js create mode 100644 configs/cloudflare-test.json create mode 100644 sebs/cloudflare/durable_objects.py diff --git a/benchmarks/wrappers/cloudflare/nodejs/fs-polyfill.js b/benchmarks/wrappers/cloudflare/nodejs/fs-polyfill.js new file mode 100644 index 000000000..dac01a115 --- /dev/null +++ b/benchmarks/wrappers/cloudflare/nodejs/fs-polyfill.js @@ -0,0 +1,156 @@ +/** + * fs polyfill for Cloudflare Workers that reads files from R2 bucket + * + * This polyfill provides a subset of Node.js fs API for reading files + * stored in an R2 bucket. The R2 bucket binding is accessed via + * globalThis.R2_BUCKET which is set by the handler. + */ + +/** + * Read a file from R2 bucket + * @param {string} path - File path in R2 bucket (e.g., 'templates/index.html') + * @param {string|object|function} encoding - Encoding or options or callback + * @param {function} callback - Callback function (err, data) + */ +export async function readFile(path, encoding, callback) { + // Handle overloaded arguments: readFile(path, callback) or readFile(path, encoding, callback) + let actualEncoding = 'utf8'; + let actualCallback = callback; + + if (typeof encoding === 'function') { + actualCallback = encoding; + actualEncoding = 'utf8'; + } else if (typeof encoding === 'string') { + actualEncoding = encoding; + } else if (typeof encoding === 'object' && encoding !== null && encoding.encoding) { + actualEncoding = encoding.encoding; + } + + try { + // Check if R2 bucket is available + if (!globalThis.R2_BUCKET) { + throw new Error('R2 bucket not available. Ensure R2 binding is configured in wrangler.toml'); + } + + // Normalize path: remove leading './' or '/' + let normalizedPath = path.replace(/^\.?\//, ''); + + // Prepend benchmark name if available + if (globalThis.BENCHMARK_NAME && !normalizedPath.startsWith(globalThis.BENCHMARK_NAME + '/')) { + normalizedPath = globalThis.BENCHMARK_NAME + '/' + normalizedPath; + } + + // Get object from R2 + const object = await globalThis.R2_BUCKET.get(normalizedPath); + + if (!object) { + throw new Error(`ENOENT: no such file or directory, open '${path}' (R2 key: ${normalizedPath})`); + } + + // Read the content + let content; + if (actualEncoding === 'utf8' || actualEncoding === 'utf-8') { + content = await object.text(); + } else if (actualEncoding === 'buffer' || actualEncoding === null) { + content = await object.arrayBuffer(); + } else { + // For other encodings, get text and let caller handle conversion + content = await object.text(); + } + + if (actualCallback) { + actualCallback(null, content); + } + return content; + } catch (err) { + if (actualCallback) { + actualCallback(err, null); + } else { + throw err; + } + } +} + +/** + * Synchronous version of readFile (not truly sync in Workers, but returns a Promise) + * Note: This is a compatibility shim - it still returns a Promise + */ +export function readFileSync(path, encoding) { + return new Promise((resolve, reject) => { + readFile(path, encoding || 'utf8', (err, data) => { + if (err) reject(err); + else resolve(data); + }); + }); +} + +/** + * Check if a file exists in R2 + */ +export async function exists(path, callback) { + try { + if (!globalThis.R2_BUCKET) { + if (callback) callback(false); + return false; + } + + let normalizedPath = path.replace(/^\.?\//, ''); + + if (globalThis.BENCHMARK_NAME && !normalizedPath.startsWith(globalThis.BENCHMARK_NAME + '/')) { + normalizedPath = globalThis.BENCHMARK_NAME + '/' + normalizedPath; + } + + const object = await globalThis.R2_BUCKET.head(normalizedPath); + + const result = object !== null; + if (callback) callback(result); + return result; + } catch (err) { + if (callback) callback(false); + return false; + } +} + +/** + * Get file stats from R2 + */ +export async function stat(path, callback) { + try { + if (!globalThis.R2_BUCKET) { + throw new Error('R2 bucket not available'); + } + + let normalizedPath = path.replace(/^\.?\//, ''); + + if (globalThis.BENCHMARK_NAME && !normalizedPath.startsWith(globalThis.BENCHMARK_NAME + '/')) { + normalizedPath = globalThis.BENCHMARK_NAME + '/' + normalizedPath; + } + + const object = await globalThis.R2_BUCKET.head(normalizedPath); + + if (!object) { + throw new Error(`ENOENT: no such file or directory, stat '${path}'`); + } + + const stats = { + size: object.size, + isFile: () => true, + isDirectory: () => false, + mtime: object.uploaded, + }; + + if (callback) callback(null, stats); + return stats; + } catch (err) { + if (callback) callback(err, null); + else throw err; + } +} + +// Export default object with all methods for CommonJS-style usage +export default { + readFile, + readFileSync, + exists, + stat, +}; diff --git a/benchmarks/wrappers/cloudflare/nodejs/handler.js b/benchmarks/wrappers/cloudflare/nodejs/handler.js index a5a309dbc..463bbd8e2 100644 --- a/benchmarks/wrappers/cloudflare/nodejs/handler.js +++ b/benchmarks/wrappers/cloudflare/nodejs/handler.js @@ -1,13 +1,57 @@ +// Simple CommonJS polyfill for Cloudflare Workers +// This allows us to load CommonJS modules that use require() and module.exports +const moduleCache = {}; + +function createRequire(currentModule) { + return function require(modulePath) { + if (moduleCache[modulePath]) { + return moduleCache[modulePath].exports; + } + + // Create module object + const module = { exports: {} }; + moduleCache[modulePath] = module; + + // This is a placeholder - actual module loading would happen here + // For our use case, we'll manually register modules below + throw new Error(`Module ${modulePath} not found in polyfill cache`); + }; +} + +// Polyfill for __dirname and __filename if not available +if (typeof globalThis.__dirname === 'undefined') { + globalThis.__dirname = '.'; +} + +if (typeof globalThis.__filename === 'undefined') { + globalThis.__filename = './handler.js'; +} + +if (typeof globalThis.require === 'undefined') { + globalThis.require = createRequire(globalThis); +} + + + export default { async fetch(request, env) { - // Match behavior of the Python handler: parse body, parse URL params, - // set request-id and income timestamp, call the benchmark function, - // and return a JSON response with the same fields. + try { + // Store R2 bucket binding and benchmark name in globals for fs-polyfill access + if (env.R2) { + globalThis.R2_BUCKET = env.R2; + } + if (env.BENCHMARK_NAME) { + globalThis.BENCHMARK_NAME = env.BENCHMARK_NAME; + } - if (request.url.includes('favicon')) { - return new Response('None'); - } + // Match behavior of the Python handler: parse body, parse URL params, + // set request-id and income timestamp, call the benchmark function, + // and return a JSON response with the same fields. + + if (request.url.includes('favicon')) { + return new Response('None'); + } const req_text = await request.text(); let event = {}; @@ -50,17 +94,13 @@ export default { event['income-timestamp'] = income_timestamp; // Load the benchmark function module and initialize storage if available + // With nodejs_compat enabled, we can use require() for CommonJS modules let funcModule; try { - // dynamic import to work in Workers ESM runtime + // Fallback to dynamic import for ES modules funcModule = await import('./function.js'); - } catch (e) { - try { - // fallback without .js - funcModule = await import('./function'); - } catch (e2) { - throw new Error('Failed to import benchmark function module: ' + e2.message); - } + } catch (e2) { + throw new Error('Failed to import benchmark function module: ' + e2.message); } // If the function module exposes a storage initializer, call it @@ -130,5 +170,22 @@ export default { }); return new Response(responseBody, { headers: { 'Content-Type': 'application/json' } }); + } catch (topLevelError) { + // Catch any uncaught errors (module loading, syntax errors, etc.) + const errorPayload = JSON.stringify({ + begin: '0', + end: '0', + results_time: '0', + result: { output: null }, + is_cold: false, + is_cold_worker: false, + container_id: '0', + environ_container_id: 'no_id', + request_id: '0', + error: `Top-level error: ${topLevelError && topLevelError.message ? topLevelError.message : String(topLevelError)}`, + stack: topLevelError && topLevelError.stack ? topLevelError.stack : undefined, + }); + return new Response(errorPayload, { status: 500, headers: { 'Content-Type': 'application/json' } }); + } }, }; diff --git a/benchmarks/wrappers/cloudflare/nodejs/path-polyfill.js b/benchmarks/wrappers/cloudflare/nodejs/path-polyfill.js new file mode 100644 index 000000000..4c77c2be9 --- /dev/null +++ b/benchmarks/wrappers/cloudflare/nodejs/path-polyfill.js @@ -0,0 +1,54 @@ +/** + * Minimal POSIX-like path.resolve polyfill for Cloudflare Workers / browser. + * Always returns an absolute path starting with '/'. + * Does not use process.cwd(); root '/' is the base. + */ + +function normalizeSegments(segments) { + const out = []; + for (const seg of segments) { + if (!seg || seg === '.') continue; + if (seg === '..') { + if (out.length && out[out.length - 1] !== '..') out.pop(); + continue; + } + out.push(seg); + } + return out; +} + +/** + * Resolve path segments into an absolute path. + * @param {...string} input + * @returns {string} + */ +export function resolve(...input) { + if (!input.length) return '/'; + let absoluteFound = false; + const segments = []; + + for (let i = input.length - 1; i >= 0; i--) { + let part = String(input[i]); + if (part === '') continue; + // Normalize backslashes to forward slashes (basic win compatibility) + part = part.replace(/\\/g, '/'); + + if (part[0] === '/') { + absoluteFound = true; + part = part.slice(1); // drop leading '/' to just collect segments + } + const split = part.split('/'); + for (let j = split.length - 1; j >= 0; j--) { + const seg = split[j]; + if (seg) segments.push(seg); + } + if (absoluteFound) break; + } + + const normalized = normalizeSegments(segments.reverse()); + return '/' + normalized.join('/'); +} + +// Optional convenience exports similar to Node's path.posix interface +const path = { resolve }; +export default path; \ No newline at end of file diff --git a/configs/cloudflare-test.json b/configs/cloudflare-test.json new file mode 100644 index 000000000..af98daff4 --- /dev/null +++ b/configs/cloudflare-test.json @@ -0,0 +1,19 @@ +{ + "experiments": { + "deployment": "cloudflare", + "update_code": false, + "update_storage": false, + "download_results": false, + "architecture": "x64", + "container_deployment": false, + "runtime": { + "language": "nodejs", + "version": "18" + } + }, + "deployment": { + "name": "cloudflare", + "cloudflare": { + } + } +} diff --git a/configs/systems.json b/configs/systems.json index 94190320e..073f564d1 100644 --- a/configs/systems.json +++ b/configs/systems.json @@ -438,9 +438,7 @@ "3.12": "ubuntu:22.04" } }, - "images": [ - "build" - ], + "images": [], "deployment": { "files": [ "handler.py", @@ -458,13 +456,13 @@ "20": "ubuntu:22.04" } }, - "images": [ - "build" - ], + "images": [], "deployment": { "files": [ "handler.js", - "storage.js" + "storage.js", + "fs-polyfill.js", + "path-polyfill.js" ], "packages": { "uuid": "3.4.0" diff --git a/sebs/cloudflare/cloudflare.py b/sebs/cloudflare/cloudflare.py index f09e3d89c..404acf1eb 100644 --- a/sebs/cloudflare/cloudflare.py +++ b/sebs/cloudflare/cloudflare.py @@ -1,6 +1,8 @@ import os import shutil import json +import uuid +import subprocess from typing import cast, Dict, List, Optional, Tuple, Type import docker @@ -15,6 +17,7 @@ from sebs.utils import LoggingHandlers from sebs.faas.function import Function, ExecutionResult, Trigger, FunctionConfig from sebs.faas.system import System +from sebs.faas.config import Resources class Cloudflare(System): @@ -60,6 +63,10 @@ def __init__( self.logging_handlers = logger_handlers self._config = config self._api_base_url = "https://api.cloudflare.com/client/v4" + # cached workers.dev subdomain for the account (e.g. 'marcin-copik') + # This is different from the account ID and is required to build + # public worker URLs like ..workers.dev + self._workers_dev_subdomain: Optional[str] = None def initialize(self, config: Dict[str, str] = {}, resource_prefix: Optional[str] = None): """ @@ -72,6 +79,45 @@ def initialize(self, config: Dict[str, str] = {}, resource_prefix: Optional[str] # Verify credentials are valid self._verify_credentials() self.initialize_resources(select_prefix=resource_prefix) + + def initialize_resources(self, select_prefix: Optional[str] = None): + """ + Initialize Cloudflare resources. + + Overrides the base class method to handle R2 storage gracefully. + Cloudflare Workers can operate without R2 storage for many benchmarks. + + Args: + select_prefix: Optional prefix for resource naming + """ + deployments = self.find_deployments() + + # Check if we have an existing deployment + if deployments: + res_id = deployments[0] + self.config.resources.resources_id = res_id + self.logging.info(f"Using existing resource deployment {res_id}") + return + + # Create new resource ID + if select_prefix is not None: + res_id = f"{select_prefix}-{str(uuid.uuid1())[0:8]}" + else: + res_id = str(uuid.uuid1())[0:8] + + self.config.resources.resources_id = res_id + self.logging.info(f"Generating unique resource name {res_id}") + + # Try to create R2 bucket, but don't fail if R2 is not enabled + try: + self.system_resources.get_storage().get_bucket(Resources.StorageBucketType.BENCHMARKS) + self.logging.info("R2 storage initialized successfully") + except Exception as e: + self.logging.warning( + f"R2 storage initialization failed: {e}. " + f"R2 must be enabled in your Cloudflare dashboard to use storage-dependent benchmarks. " + f"Continuing without R2 storage - only benchmarks that don't require storage will work." + ) def _verify_credentials(self): """Verify that the Cloudflare API credentials are valid.""" @@ -107,6 +153,117 @@ def _verify_credentials(self): self.logging.info("Cloudflare credentials verified successfully") + def _ensure_wrangler_installed(self): + """Ensure Wrangler CLI is installed and available.""" + try: + result = subprocess.run( + ["wrangler", "--version"], + capture_output=True, + text=True, + check=True, + timeout=10 + ) + version = result.stdout.strip() + self.logging.info(f"Wrangler is installed: {version}") + except (subprocess.CalledProcessError, FileNotFoundError): + self.logging.info("Wrangler not found, installing globally via npm...") + try: + result = subprocess.run( + ["npm", "install", "-g", "wrangler"], + capture_output=True, + text=True, + check=True, + timeout=120 + ) + self.logging.info("Wrangler installed successfully") + if result.stdout: + self.logging.debug(f"npm install wrangler output: {result.stdout}") + except subprocess.CalledProcessError as e: + raise RuntimeError(f"Failed to install Wrangler: {e.stderr}") + except FileNotFoundError: + raise RuntimeError( + "npm not found. Please install Node.js and npm to use Wrangler for deployment." + ) + except subprocess.TimeoutExpired: + raise RuntimeError("Wrangler version check timed out") + + def _generate_wrangler_toml(self, worker_name: str, package_dir: str, language: str, account_id: str, benchmark_name: Optional[str] = None) -> str: + """ + Generate a wrangler.toml configuration file for the worker. + + Args: + worker_name: Name of the worker + package_dir: Directory containing the worker code + language: Programming language (nodejs or python) + account_id: Cloudflare account ID + benchmark_name: Optional benchmark name for R2 file path prefix + + Returns: + Path to the generated wrangler.toml file + """ + main_file = "handler.js" if language == "nodejs" else "handler.py" + + # Build wrangler.toml content + toml_content = f"""name = "{worker_name}" +main = "{main_file}" +compatibility_date = "2024-11-01" +account_id = "{account_id}" + +""" + + # Add environment variable for benchmark name (used by fs-polyfill for R2 paths) + if benchmark_name: + toml_content += f"""# Benchmark name used for R2 file path prefix +[vars] +BENCHMARK_NAME = "{benchmark_name}" + +""" + + # Add R2 bucket binding for benchmarking files (required for fs/path polyfills) + r2_bucket_configured = False + try: + storage = self.system_resources.get_storage() + bucket_name = storage.get_bucket(Resources.StorageBucketType.BENCHMARKS) + if bucket_name: + toml_content += f"""# R2 bucket binding for benchmarking files +# This bucket is used by fs and path polyfills to read benchmark data +[[r2_buckets]] +binding = "R2" +bucket_name = "{bucket_name}" + +""" + r2_bucket_configured = True + self.logging.info(f"R2 bucket '{bucket_name}' will be bound to worker as 'R2'") + except Exception as e: + self.logging.warning( + f"R2 bucket binding not configured: {e}. " + f"Benchmarks requiring file access will not work properly." + ) + + # Add compatibility flags based on language + if language == "nodejs": + toml_content += """# Custom polyfills for fs and path that read from R2 bucket +[alias] +"fs" = "./fs-polyfill" +"path" = "./path-polyfill" +""" + if r2_bucket_configured: + self.logging.info( + "fs and path polyfills configured to use R2 bucket for file operations" + ) + elif language == "python": + toml_content += """# Enable Python Workers runtime +compatibility_flags = ["python_workers"] +""" + + # Write wrangler.toml to package directory + toml_path = os.path.join(package_dir, "wrangler.toml") + with open(toml_path, 'w') as f: + f.write(toml_content) + + self.logging.info(f"Generated wrangler.toml at {toml_path}") + return toml_path + def _get_auth_headers(self) -> Dict[str, str]: """Get authentication headers for Cloudflare API requests.""" if self.config.credentials.api_token: @@ -123,6 +280,112 @@ def _get_auth_headers(self) -> Dict[str, str]: else: raise RuntimeError("Invalid Cloudflare credentials configuration") + def _convert_templates_to_modules(self, directory: str): + """ + Convert template files to JavaScript modules for bundling. + + Searches for template directories and converts HTML/text files + to JavaScript modules that can be imported. + + Args: + directory: Package directory to search for templates + """ + templates_dir = os.path.join(directory, "templates") + if not os.path.exists(templates_dir): + return + + self.logging.info(f"Converting template files in {templates_dir} to JavaScript modules") + + for root, dirs, files in os.walk(templates_dir): + for file in files: + if file.endswith(('.html', '.txt', '.xml', '.csv')): + file_path = os.path.join(root, file) + rel_path = os.path.relpath(file_path, directory) + + # Read the template content + with open(file_path, 'r', encoding='utf-8') as f: + content = f.read() + + # Escape for JavaScript string + content_escaped = (content + .replace('\\', '\\\\') + .replace('`', '\\`') + .replace('$', '\\$')) + + # Create a .js module file next to the template + module_path = file_path + '.js' + with open(module_path, 'w', encoding='utf-8') as f: + f.write(f'export default `{content_escaped}`;\n') + + self.logging.debug(f"Created template module: {module_path}") + + def _upload_benchmark_files_to_r2(self, directory: str, benchmark_name: str) -> int: + """ + Upload benchmark data files to R2 bucket for fs-polyfill access. + + This allows the fs-polyfill to read files from R2 instead of trying + to bundle them with the worker code. + + Args: + directory: Package directory containing files to upload + benchmark_name: Name of the benchmark (used as prefix in R2) + + Returns: + Number of files uploaded + """ + try: + storage = self.system_resources.get_storage() + bucket_name = storage.get_bucket(Resources.StorageBucketType.BENCHMARKS) + + if not bucket_name: + self.logging.warning("R2 bucket not configured, skipping file upload") + return 0 + + uploaded_count = 0 + + # Upload template files + templates_dir = os.path.join(directory, "templates") + if os.path.exists(templates_dir): + for root, dirs, files in os.walk(templates_dir): + for file in files: + # Skip the .js module files we created + if file.endswith('.js'): + continue + + file_path = os.path.join(root, file) + # Create R2 key: benchmark_name/templates/filename + rel_path = os.path.relpath(file_path, directory) + r2_key = f"{benchmark_name}/{rel_path}" + + try: + with open(file_path, 'rb') as f: + file_content = f.read() + + self.logging.info(f"Uploading {rel_path} to R2 as {r2_key}...") + storage.upload_bytes( + bucket_name, + r2_key, + file_content + ) + uploaded_count += 1 + self.logging.info(f"✓ Uploaded {rel_path} ({len(file_content)} bytes)") + except Exception as e: + self.logging.error(f"✗ Failed to upload {rel_path} to R2: {e}") + + if uploaded_count > 0: + self.logging.info( + f"Uploaded {uploaded_count} benchmark files to R2 bucket '{bucket_name}'" + ) + + return uploaded_count + + except Exception as e: + self.logging.warning( + f"Could not upload benchmark files to R2: {e}. " + f"fs-polyfill will not be able to read files from R2." + ) + return 0 + def package_code( self, directory: str, @@ -134,10 +397,9 @@ def package_code( container_deployment: bool, ) -> Tuple[str, int, str]: """ - Package code for Cloudflare Workers deployment. + Package code for Cloudflare Workers deployment using Wrangler. - Cloudflare Workers support JavaScript/TypeScript and use a bundler - to create a single JavaScript file for deployment. + Uses Wrangler CLI to bundle dependencies and prepare for deployment. Args: directory: Path to the code directory @@ -156,13 +418,82 @@ def package_code( "Container deployment is not supported for Cloudflare Workers" ) - # For now, we'll create a simple package structure - # In a full implementation, you'd use a bundler like esbuild or webpack + # Ensure Wrangler is installed + self._ensure_wrangler_installed() + + # Upload benchmark files to R2 for fs-polyfill access + if language_name == "nodejs": + uploaded = self._upload_benchmark_files_to_r2(directory, benchmark) + if uploaded > 0: + self.logging.info(f"Successfully uploaded {uploaded} files to R2") + else: + self.logging.warning( + "No files were uploaded to R2. Benchmarks requiring file access may fail. " + "Ensure R2 API credentials are configured." + ) + + # Install dependencies + if language_name == "nodejs": + package_file = os.path.join(directory, "package.json") + node_modules = os.path.join(directory, "node_modules") + + # Only install if package.json exists and node_modules doesn't + if os.path.exists(package_file) and not os.path.exists(node_modules): + self.logging.info(f"Installing Node.js dependencies in {directory}") + try: + result = subprocess.run( + ["npm", "install", "--production"], + cwd=directory, + capture_output=True, + text=True, + check=True, + timeout=120 + ) + self.logging.info("npm install completed successfully") + if result.stdout: + self.logging.debug(f"npm output: {result.stdout}") + except subprocess.TimeoutExpired: + self.logging.error("npm install timed out") + raise RuntimeError("Failed to install Node.js dependencies: timeout") + except subprocess.CalledProcessError as e: + self.logging.error(f"npm install failed: {e.stderr}") + raise RuntimeError(f"Failed to install Node.js dependencies: {e.stderr}") + except FileNotFoundError: + raise RuntimeError( + "npm not found. Please install Node.js and npm to deploy Node.js benchmarks." + ) + elif os.path.exists(node_modules): + self.logging.info(f"Node.js dependencies already installed in {directory}") + + elif language_name == "python": + requirements_file = os.path.join(directory, "requirements.txt") + if os.path.exists(requirements_file): + self.logging.info(f"Installing Python dependencies in {directory}") + try: + # Install to a local directory that can be bundled + target_dir = os.path.join(directory, "python_modules") + result = subprocess.run( + ["pip", "install", "-r", "requirements.txt", "-t", target_dir], + cwd=directory, + capture_output=True, + text=True, + check=True + ) + self.logging.info("pip install completed successfully") + if result.stdout: + self.logging.debug(f"pip output: {result.stdout}") + except subprocess.CalledProcessError as e: + self.logging.error(f"pip install failed: {e.stderr}") + raise RuntimeError(f"Failed to install Python dependencies: {e.stderr}") + except FileNotFoundError: + raise RuntimeError( + "pip not found. Please install Python and pip to deploy Python benchmarks." + ) + # Create package structure CONFIG_FILES = { "nodejs": ["handler.js", "package.json", "node_modules"], - # Python support via Python Workers is limited - "python": ["handler.py", "requirements.txt"], + "python": ["handler.py", "requirements.txt", "python_modules"], } if language_name not in CONFIG_FILES: @@ -170,34 +501,32 @@ def package_code( f"Language {language_name} is not yet supported for Cloudflare Workers" ) - package_config = CONFIG_FILES[language_name] - - # Create a worker directory with the necessary files - worker_dir = os.path.join(directory, "worker") - os.makedirs(worker_dir, exist_ok=True) - - # Copy all files to worker directory - for file in os.listdir(directory): - if file not in package_config and file != "worker": - src = os.path.join(directory, file) - dst = os.path.join(worker_dir, file) - if os.path.isfile(src): - shutil.copy2(src, dst) - elif os.path.isdir(src): - shutil.copytree(src, dst, dirs_exist_ok=True) - - # For now, return the main handler file as the package + # Verify the handler exists handler_file = "handler.js" if language_name == "nodejs" else "handler.py" package_path = os.path.join(directory, handler_file) if not os.path.exists(package_path): - raise RuntimeError(f"Handler file {handler_file} not found in {directory}") + if not os.path.exists(directory): + raise RuntimeError( + f"Package directory {directory} does not exist. " + "The benchmark build process may have failed to create the deployment package." + ) + raise RuntimeError( + f"Handler file {handler_file} not found in {directory}. " + f"Available files: {', '.join(os.listdir(directory)) if os.path.exists(directory) else 'none'}" + ) - bytes_size = os.path.getsize(package_path) - mbytes = bytes_size / 1024.0 / 1024.0 + # Calculate total size of the package directory + total_size = 0 + for dirpath, dirnames, filenames in os.walk(directory): + for filename in filenames: + filepath = os.path.join(dirpath, filename) + total_size += os.path.getsize(filepath) + + mbytes = total_size / 1024.0 / 1024.0 self.logging.info(f"Worker package size: {mbytes:.2f} MB") - return (package_path, bytes_size, "") + return (directory, total_size, "") def create_function( self, @@ -256,12 +585,8 @@ def create_function( else: self.logging.info(f"Creating new worker {func_name}") - # Read the worker script - with open(package, 'r') as f: - script_content = f.read() - - # Create the worker - self._create_or_update_worker(func_name, script_content, account_id) + # Create the worker with all package files + self._create_or_update_worker(func_name, package, account_id, language, benchmark) worker = CloudflareWorker( func_name, @@ -279,9 +604,10 @@ def create_function( library_trigger = LibraryTrigger(func_name, self) library_trigger.logging_handlers = self.logging_handlers worker.add_trigger(library_trigger) - - # Cloudflare Workers are automatically accessible via HTTPS - worker_url = f"https://{func_name}.{account_id}.workers.dev" + + # Build worker URL using the account's workers.dev subdomain when possible. + # Falls back to account_id-based host or plain workers.dev with warnings. + worker_url = self._build_workers_dev_url(func_name, account_id) http_trigger = HTTPTrigger(func_name, worker_url) http_trigger.logging_handlers = self.logging_handlers worker.add_trigger(http_trigger) @@ -296,37 +622,141 @@ def _get_worker(self, worker_name: str, account_id: str) -> Optional[dict]: response = requests.get(url, headers=headers) if response.status_code == 200: - return response.json().get("result") + try: + return response.json().get("result") + except: + return None elif response.status_code == 404: return None else: - raise RuntimeError( - f"Failed to check worker existence: {response.status_code} - {response.text}" - ) + self.logging.warning(f"Unexpected response checking worker: {response.status_code}") + return None def _create_or_update_worker( - self, worker_name: str, script_content: str, account_id: str + self, worker_name: str, package_dir: str, account_id: str, language: str, benchmark_name: Optional[str] = None ) -> dict: - """Create or update a Cloudflare Worker.""" - headers = self._get_auth_headers() - # Remove Content-Type as we're sending form data - headers.pop("Content-Type", None) + """Create or update a Cloudflare Worker using Wrangler CLI. - url = f"{self._api_base_url}/accounts/{account_id}/workers/scripts/{worker_name}" + Args: + worker_name: Name of the worker + package_dir: Directory containing handler and all benchmark files + account_id: Cloudflare account ID + language: Programming language (nodejs or python) + benchmark_name: Optional benchmark name for R2 file path prefix - # Cloudflare Workers API expects the script as form data - files = { - 'script': ('worker.js', script_content, 'application/javascript'), - } + Returns: + Worker deployment result + """ + # Generate wrangler.toml for this worker + self._generate_wrangler_toml(worker_name, package_dir, language, account_id, benchmark_name) + + # Set up environment for Wrangler + env = os.environ.copy() + if self.config.credentials.api_token: + env['CLOUDFLARE_API_TOKEN'] = self.config.credentials.api_token + elif self.config.credentials.email and self.config.credentials.api_key: + env['CLOUDFLARE_EMAIL'] = self.config.credentials.email + env['CLOUDFLARE_API_KEY'] = self.config.credentials.api_key - response = requests.put(url, headers=headers, files=files) + env['CLOUDFLARE_ACCOUNT_ID'] = account_id - if response.status_code not in [200, 201]: - raise RuntimeError( - f"Failed to create/update worker: {response.status_code} - {response.text}" - ) + # Deploy using Wrangler + self.logging.info(f"Deploying worker {worker_name} using Wrangler...") - return response.json().get("result", {}) + try: + result = subprocess.run( + ["wrangler", "deploy"], + cwd=package_dir, + env=env, + capture_output=True, + text=True, + check=True, + timeout=180 # 3 minutes for deployment + ) + + self.logging.info(f"Worker {worker_name} deployed successfully") + if result.stdout: + self.logging.debug(f"Wrangler deploy output: {result.stdout}") + + # Parse the output to get worker URL + # Wrangler typically outputs: "Published ()" + # and "https://..workers.dev" + + return {"success": True, "output": result.stdout} + + except subprocess.TimeoutExpired: + raise RuntimeError(f"Wrangler deployment timed out for worker {worker_name}") + except subprocess.CalledProcessError as e: + error_msg = f"Wrangler deployment failed for worker {worker_name}" + if e.stderr: + error_msg += f": {e.stderr}" + self.logging.error(error_msg) + raise RuntimeError(error_msg) + + def _get_workers_dev_subdomain(self, account_id: str) -> Optional[str]: + """Fetch the workers.dev subdomain for the given account. + + Cloudflare exposes an endpoint that returns the account-level workers + subdomain (the readable name used in *.workers.dev), e.g. + GET /accounts/{account_id}/workers/subdomain + + Returns the subdomain string (e.g. 'marcin-copik') or None on failure. + """ + if self._workers_dev_subdomain: + return self._workers_dev_subdomain + + try: + headers = self._get_auth_headers() + url = f"{self._api_base_url}/accounts/{account_id}/workers/subdomain" + resp = requests.get(url, headers=headers) + if resp.status_code == 200: + body = resp.json() + sub = None + # result may contain 'subdomain' or nested structure + if isinstance(body, dict): + sub = body.get("result", {}).get("subdomain") + + if sub: + self._workers_dev_subdomain = sub + return sub + else: + self.logging.warning( + "Could not find workers.dev subdomain in API response; " + "please enable the workers.dev subdomain in your Cloudflare dashboard." + ) + return None + else: + self.logging.warning( + f"Failed to fetch workers.dev subdomain: {resp.status_code} - {resp.text}" + ) + return None + except Exception as e: + self.logging.warning(f"Error fetching workers.dev subdomain: {e}") + return None + + def _build_workers_dev_url(self, worker_name: str, account_id: Optional[str]) -> str: + """Build a best-effort public URL for a worker. + + Prefer using the account's readable workers.dev subdomain when available + (e.g. ..workers.dev). If we can't obtain that, fall + back to using the account_id as a last resort and log a warning. + """ + if account_id: + sub = self._get_workers_dev_subdomain(account_id) + if sub: + return f"https://{worker_name}.{sub}.workers.dev" + else: + # fallback: some code historically used account_id in the host + self.logging.warning( + "Using account ID in workers.dev URL as a fallback. " + "Enable the workers.dev subdomain in Cloudflare for proper URLs." + ) + return f"https://{worker_name}.{account_id}.workers.dev" + # Last fallback: plain workers.dev (may not resolve without a subdomain) + self.logging.warning( + "No account ID available; using https://{name}.workers.dev which may not be reachable." + ) + return f"https://{worker_name}.workers.dev" def cached_function(self, function: Function): """ @@ -369,17 +799,15 @@ def update_function( worker = cast(CloudflareWorker, function) package = code_package.code_location + language = code_package.language_name + benchmark = code_package.benchmark - # Read the updated script - with open(package, 'r') as f: - script_content = f.read() - - # Update the worker + # Update the worker with all package files account_id = worker.account_id or self.config.credentials.account_id if not account_id: raise RuntimeError("Account ID is required to update worker") - self._create_or_update_worker(worker.name, script_content, account_id) + self._create_or_update_worker(worker.name, package, account_id, language, benchmark) self.logging.info(f"Updated worker {worker.name}") # Update configuration if needed @@ -604,7 +1032,7 @@ def create_trigger( return trigger elif trigger_type == Trigger.TriggerType.HTTP: account_id = worker.account_id or self.config.credentials.account_id - worker_url = f"https://{worker.name}.{account_id}.workers.dev" + worker_url = self._build_workers_dev_url(worker.name, account_id) trigger = HTTPTrigger(worker.name, worker_url) trigger.logging_handlers = self.logging_handlers return trigger diff --git a/sebs/cloudflare/config.py b/sebs/cloudflare/config.py index 4e04ee137..b75c52ad8 100644 --- a/sebs/cloudflare/config.py +++ b/sebs/cloudflare/config.py @@ -13,16 +13,20 @@ class CloudflareCredentials(Credentials): Requires: - API token or email + global API key - Account ID + - Optional: R2 S3-compatible credentials for file uploads """ def __init__(self, api_token: Optional[str] = None, email: Optional[str] = None, - api_key: Optional[str] = None, account_id: Optional[str] = None): + api_key: Optional[str] = None, account_id: Optional[str] = None, + r2_access_key_id: Optional[str] = None, r2_secret_access_key: Optional[str] = None): super().__init__() self._api_token = api_token self._email = email self._api_key = api_key self._account_id = account_id + self._r2_access_key_id = r2_access_key_id + self._r2_secret_access_key = r2_secret_access_key @staticmethod def typename() -> str: @@ -44,13 +48,23 @@ def api_key(self) -> Optional[str]: def account_id(self) -> Optional[str]: return self._account_id + @property + def r2_access_key_id(self) -> Optional[str]: + return self._r2_access_key_id + + @property + def r2_secret_access_key(self) -> Optional[str]: + return self._r2_secret_access_key + @staticmethod def initialize(dct: dict) -> "CloudflareCredentials": return CloudflareCredentials( dct.get("api_token"), dct.get("email"), dct.get("api_key"), - dct.get("account_id") + dct.get("account_id"), + dct.get("r2_access_key_id"), + dct.get("r2_secret_access_key") ) @staticmethod @@ -69,13 +83,17 @@ def deserialize(config: dict, cache: Cache, handlers: LoggingHandlers) -> Creden elif "CLOUDFLARE_API_TOKEN" in os.environ: ret = CloudflareCredentials( api_token=os.environ["CLOUDFLARE_API_TOKEN"], - account_id=os.environ.get("CLOUDFLARE_ACCOUNT_ID") + account_id=os.environ.get("CLOUDFLARE_ACCOUNT_ID"), + r2_access_key_id=os.environ.get("CLOUDFLARE_R2_ACCESS_KEY_ID"), + r2_secret_access_key=os.environ.get("CLOUDFLARE_R2_SECRET_ACCESS_KEY") ) elif "CLOUDFLARE_EMAIL" in os.environ and "CLOUDFLARE_API_KEY" in os.environ: ret = CloudflareCredentials( email=os.environ["CLOUDFLARE_EMAIL"], api_key=os.environ["CLOUDFLARE_API_KEY"], - account_id=os.environ.get("CLOUDFLARE_ACCOUNT_ID") + account_id=os.environ.get("CLOUDFLARE_ACCOUNT_ID"), + r2_access_key_id=os.environ.get("CLOUDFLARE_R2_ACCESS_KEY_ID"), + r2_secret_access_key=os.environ.get("CLOUDFLARE_R2_SECRET_ACCESS_KEY") ) else: raise RuntimeError( diff --git a/sebs/cloudflare/durable_objects.py b/sebs/cloudflare/durable_objects.py new file mode 100644 index 000000000..6e0b05c2a --- /dev/null +++ b/sebs/cloudflare/durable_objects.py @@ -0,0 +1,201 @@ +import json +import requests +from typing import Dict, Optional, Tuple + +from sebs.cloudflare.config import CloudflareCredentials +from sebs.faas.nosql import NoSQLStorage +from sebs.faas.config import Resources +from sebs.cache import Cache + + +class DurableObjects(NoSQLStorage): + """ + Cloudflare Durable Objects implementation for NoSQL storage. + + Note: Durable Objects are not a traditional NoSQL database like DynamoDB or CosmosDB. + They are stateful Workers with persistent storage. This implementation provides + a minimal interface to satisfy SeBS requirements, but full table operations + are not supported. + """ + + @staticmethod + def typename() -> str: + return "Cloudflare.DurableObjects" + + @staticmethod + def deployment_name() -> str: + return "cloudflare" + + def __init__( + self, + region: str, + cache_client: Cache, + resources: Resources, + credentials: CloudflareCredentials, + ): + super().__init__(region, cache_client, resources) + self._credentials = credentials + self._tables: Dict[str, str] = {} + + def _get_auth_headers(self) -> dict[str, str]: + """Get authentication headers for Cloudflare API requests.""" + if self._credentials.api_token: + return { + "Authorization": f"Bearer {self._credentials.api_token}", + "Content-Type": "application/json", + } + elif self._credentials.email and self._credentials.api_key: + return { + "X-Auth-Email": self._credentials.email, + "X-Auth-Key": self._credentials.api_key, + "Content-Type": "application/json", + } + else: + raise RuntimeError("Invalid Cloudflare credentials configuration") + + def get_tables(self, benchmark: str) -> Dict[str, str]: + """ + Get all tables for a benchmark. + + :param benchmark: benchmark name + :return: dictionary mapping table names to their IDs + """ + # For Durable Objects, we don't have traditional tables + # Return cached tables if any + return self._tables.copy() + + def _get_table_name(self, benchmark: str, table: str) -> Optional[str]: + """ + Get the full table name for a benchmark table. + + :param benchmark: benchmark name + :param table: table name + :return: full table name or None if not found + """ + key = f"{benchmark}:{table}" + return self._tables.get(key) + + def retrieve_cache(self, benchmark: str) -> bool: + """ + Retrieve cached table information. + + :param benchmark: benchmark name + :return: True if cache was found and loaded + """ + cache_key = f"cloudflare.durable_objects.{benchmark}" + cached = self.cache_client.get(cache_key) + + if cached: + self._tables.update(cached) + self.logging.info(f"Retrieved cached Durable Objects tables for {benchmark}") + return True + + return False + + def update_cache(self, benchmark: str): + """ + Update cache with current table information. + + :param benchmark: benchmark name + """ + cache_key = f"cloudflare.durable_objects.{benchmark}" + + # Filter tables for this benchmark + benchmark_tables = { + k: v for k, v in self._tables.items() if k.startswith(f"{benchmark}:") + } + + self.cache_client.update(cache_key, benchmark_tables) + self.logging.info(f"Updated cache for Durable Objects tables for {benchmark}") + + def create_table( + self, benchmark: str, name: str, primary_key: str, secondary_key: Optional[str] = None + ) -> str: + """ + Create a table (Durable Object namespace). + + Note: Durable Objects don't have traditional table creation via API. + They are defined in the Worker code and wrangler.toml. + This method just tracks the table name. + + :param benchmark: benchmark name + :param name: table name + :param primary_key: primary key field name + :param secondary_key: optional secondary key field name + :return: table name + """ + resource_id = self._cloud_resources.get_resource_id() + table_name = f"sebs-benchmarks-{resource_id}-{benchmark}-{name}" + + key = f"{benchmark}:{name}" + self._tables[key] = table_name + + self.logging.info( + f"Registered Durable Objects table {table_name} for benchmark {benchmark}" + ) + + return table_name + + def write_to_table( + self, + benchmark: str, + table: str, + data: dict, + primary_key: Tuple[str, str], + secondary_key: Optional[Tuple[str, str]] = None, + ): + """ + Write data to a table (Durable Object). + + Note: This would require HTTP requests to the Durable Object endpoints. + For now, this is not fully implemented. + + :param benchmark: benchmark name + :param table: table name + :param data: data to write + :param primary_key: primary key (field_name, value) + :param secondary_key: optional secondary key (field_name, value) + """ + table_name = self._get_table_name(benchmark, table) + + if not table_name: + raise ValueError(f"Table {table} not found for benchmark {benchmark}") + + self.logging.warning( + f"write_to_table not fully implemented for Durable Objects table {table_name}" + ) + + def clear_table(self, name: str) -> str: + """ + Clear all data from a table. + + :param name: table name + :return: table name + """ + self.logging.warning(f"clear_table not fully implemented for Durable Objects table {name}") + return name + + def remove_table(self, name: str) -> str: + """ + Remove a table. + + :param name: table name + :return: table name + """ + # Remove from internal tracking + keys_to_remove = [k for k, v in self._tables.items() if v == name] + for key in keys_to_remove: + del self._tables[key] + + self.logging.info(f"Removed Durable Objects table {name} from tracking") + return name + + def envs(self) -> dict: + """ + Get environment variables for accessing Durable Objects. + + :return: dictionary of environment variables + """ + # Durable Objects are accessed via bindings in the Worker + # No additional environment variables needed + return {} diff --git a/sebs/cloudflare/r2.py b/sebs/cloudflare/r2.py index 60265ca0d..73e047fb7 100644 --- a/sebs/cloudflare/r2.py +++ b/sebs/cloudflare/r2.py @@ -68,42 +68,161 @@ def _create_bucket( account_id = self._credentials.account_id - get_bucket_uri = ( + create_bucket_uri = ( f"https://api.cloudflare.com/client/v4/accounts/{account_id}/r2/buckets" ) - params = {"name": "cloudflare_bucket", "locationHint": self._region} + # R2 API only accepts "name" parameter - locationHint is optional and must be one of: + # "apac", "eeur", "enam", "weur", "wnam" + # For now, just send the name without locationHint + params = {"name": name} - create_bucket_response = requests.post( - get_bucket_uri, json=params, headers=self._get_auth_headers() - ) - bucket_info = create_bucket_response.content.decode("utf-8") - bucket_info_json = json.load(bucket_info) # pyright: ignore + try: + create_bucket_response = requests.post( + create_bucket_uri, json=params, headers=self._get_auth_headers() + ) + + # Log the response for debugging + if create_bucket_response.status_code >= 400: + try: + error_data = create_bucket_response.json() + self.logging.error( + f"R2 bucket creation failed. Status: {create_bucket_response.status_code}, " + f"Response: {error_data}" + ) + except: + self.logging.error( + f"R2 bucket creation failed. Status: {create_bucket_response.status_code}, " + f"Response: {create_bucket_response.text}" + ) + + create_bucket_response.raise_for_status() + + bucket_info_json = create_bucket_response.json() - return bucket_info_json.name + if not bucket_info_json.get("success"): + self.logging.error(f"Failed to create R2 bucket: {bucket_info_json.get('errors')}") + raise RuntimeError(f"Failed to create R2 bucket {name}") - """ + bucket_name = bucket_info_json.get("result", {}).get("name", name) + self.logging.info(f"Created R2 bucket {bucket_name}") + return bucket_name + + except requests.exceptions.RequestException as e: + self.logging.error(f"Error creating R2 bucket {name}: {e}") + raise + + def download(self, bucket_name: str, key: str, filepath: str) -> None: + """ Download a file from a bucket. :param bucket_name: :param key: storage source filepath :param filepath: local destination filepath - """ - - def download(self, bucket_name: str, key: str, filepath: str) -> None: + """ + # R2 requires S3-compatible access for object operations + # For now, this is not fully implemented + self.logging.warning(f"download not fully implemented for R2 bucket {bucket_name}") pass - """ - Upload a file to a bucket with by passing caching. - Useful for uploading code package to storage (when required). + def upload(self, bucket_name: str, filepath: str, key: str): + """ + Upload a file to R2 bucket using the S3-compatible API. + + Requires S3 credentials to be configured for the R2 bucket. - :param bucket_name: + :param bucket_name: R2 bucket name :param filepath: local source filepath - :param key: storage destination filepath - """ - - def upload(self, bucket_name: str, filepath: str, key: str): - pass + :param key: R2 destination key/path + """ + try: + import boto3 + from botocore.config import Config + + account_id = self._credentials.account_id + + # R2 uses S3-compatible API, but requires special configuration + # The endpoint is: https://.r2.cloudflarestorage.com + # You need to create R2 API tokens in the Cloudflare dashboard + + # Check if we have S3-compatible credentials + if not self._credentials.r2_access_key_id or not self._credentials.r2_secret_access_key: + self.logging.warning( + "R2 upload requires S3-compatible API credentials (r2_access_key_id, r2_secret_access_key). " + "File upload skipped. Set CLOUDFLARE_R2_ACCESS_KEY_ID and CLOUDFLARE_R2_SECRET_ACCESS_KEY." + ) + return + + s3_client = boto3.client( + 's3', + endpoint_url=f'https://{account_id}.r2.cloudflarestorage.com', + aws_access_key_id=self._credentials.r2_access_key_id, + aws_secret_access_key=self._credentials.r2_secret_access_key, + config=Config(signature_version='s3v4'), + region_name='auto' + ) + + with open(filepath, 'rb') as f: + s3_client.put_object( + Bucket=bucket_name, + Key=key, + Body=f + ) + + self.logging.debug(f"Uploaded {filepath} to R2 bucket {bucket_name} as {key}") + + except ImportError: + self.logging.warning( + "boto3 not available. Install with: pip install boto3. " + "File upload to R2 skipped." + ) + except Exception as e: + self.logging.warning(f"Failed to upload {filepath} to R2: {e}") + + def upload_bytes(self, bucket_name: str, key: str, data: bytes): + """ + Upload bytes directly to R2 bucket using the S3-compatible API. + + :param bucket_name: R2 bucket name + :param key: R2 destination key/path + :param data: bytes to upload + """ + try: + import boto3 + from botocore.config import Config + + account_id = self._credentials.account_id + + if not self._credentials.r2_access_key_id or not self._credentials.r2_secret_access_key: + self.logging.warning( + "R2 upload requires S3-compatible API credentials (r2_access_key_id, r2_secret_access_key). " + "Upload skipped. Set CLOUDFLARE_R2_ACCESS_KEY_ID and CLOUDFLARE_R2_SECRET_ACCESS_KEY environment variables." + ) + return + + s3_client = boto3.client( + 's3', + endpoint_url=f'https://{account_id}.r2.cloudflarestorage.com', + aws_access_key_id=self._credentials.r2_access_key_id, + aws_secret_access_key=self._credentials.r2_secret_access_key, + config=Config(signature_version='s3v4'), + region_name='auto' + ) + + s3_client.put_object( + Bucket=bucket_name, + Key=key, + Body=data + ) + + self.logging.debug(f"Uploaded {len(data)} bytes to R2 bucket {bucket_name} as {key}") + + except ImportError: + self.logging.warning( + "boto3 not available. Install with: pip install boto3" + ) + except Exception as e: + self.logging.warning(f"Failed to upload bytes to R2: {e}") """ Retrieves list of files in a bucket. @@ -113,34 +232,123 @@ def upload(self, bucket_name: str, filepath: str, key: str): """ def list_bucket(self, bucket_name: str, prefix: str = "") -> List[str]: - pass + """ + Retrieves list of files in a bucket. + + :param bucket_name: + :param prefix: optional prefix filter + :return: list of files in a given bucket + """ + account_id = self._credentials.account_id + + # R2 uses S3-compatible API for listing objects + # For now, return empty list as listing objects requires S3 credentials + self.logging.warning(f"list_bucket not fully implemented for R2 bucket {bucket_name}") + return [] def list_buckets(self, bucket_name: Optional[str] = None) -> List[str]: - pass + """ + List all R2 buckets in the account. + + :param bucket_name: optional filter (not used for R2) + :return: list of bucket names + """ + account_id = self._credentials.account_id + + list_buckets_uri = ( + f"https://api.cloudflare.com/client/v4/accounts/{account_id}/r2/buckets" + ) + + try: + response = requests.get(list_buckets_uri, headers=self._get_auth_headers()) + + # Log detailed error information + if response.status_code == 403: + try: + error_data = response.json() + self.logging.error( + f"403 Forbidden accessing R2 buckets. " + f"Response: {error_data}. " + f"Your API token may need 'R2 Read and Write' permissions." + ) + except: + self.logging.error( + f"403 Forbidden accessing R2 buckets. " + f"Your API token may need 'R2 Read and Write' permissions." + ) + return [] + + response.raise_for_status() + + data = response.json() + + if not data.get("success"): + self.logging.error(f"Failed to list R2 buckets: {data.get('errors')}") + return [] + + # Extract bucket names from response + buckets = data.get("result", {}).get("buckets", []) + bucket_names = [bucket["name"] for bucket in buckets] + + self.logging.info(f"Found {len(bucket_names)} R2 buckets") + return bucket_names + + except requests.exceptions.RequestException as e: + self.logging.error(f"Error listing R2 buckets: {e}") + return [] def exists_bucket(self, bucket_name: str) -> bool: - pass + """ + Check if a bucket exists. + + :param bucket_name: + :return: True if bucket exists + """ + buckets = self.list_buckets() + return bucket_name in buckets def clean_bucket(self, bucket_name: str): + """ + Remove all objects from a bucket. + + :param bucket_name: + """ + self.logging.warning(f"clean_bucket not fully implemented for R2 bucket {bucket_name}") pass def remove_bucket(self, bucket: str): - pass - - """ - Allocate a set of input/output buckets for the benchmark. - The routine checks the cache first to verify that buckets have not - been allocated first. - - :param benchmark: benchmark name - :param buckets: number of input and number of output buckets - """ + """ + Delete a bucket. + + :param bucket: + """ + account_id = self._credentials.account_id + + delete_bucket_uri = ( + f"https://api.cloudflare.com/client/v4/accounts/{account_id}/r2/buckets/{bucket}" + ) + + try: + response = requests.delete(delete_bucket_uri, headers=self._get_auth_headers()) + response.raise_for_status() + + data = response.json() + + if data.get("success"): + self.logging.info(f"Successfully deleted R2 bucket {bucket}") + else: + self.logging.error(f"Failed to delete R2 bucket {bucket}: {data.get('errors')}") + + except requests.exceptions.RequestException as e: + self.logging.error(f"Error deleting R2 bucket {bucket}: {e}") def uploader_func(self, bucket_idx: int, file: str, filepath: str) -> None: + """ + Upload a file to a bucket (used for parallel uploads). + + :param bucket_idx: index of the bucket to upload to + :param file: destination file name + :param filepath: source file path + """ + self.logging.warning(f"uploader_func not fully implemented for R2") pass - - """ - Download all files in a storage bucket. - Warning: assumes flat directory in a bucket! Does not handle bucket files - with directory marks in a name, e.g. 'dir1/dir2/file' - """ diff --git a/sebs/cloudflare/resources.py b/sebs/cloudflare/resources.py index fa181ad71..1b3d9dbc7 100644 --- a/sebs/cloudflare/resources.py +++ b/sebs/cloudflare/resources.py @@ -5,6 +5,7 @@ from sebs.cache import Cache from sebs.cloudflare.config import CloudflareConfig from sebs.cloudflare.r2 import R2 +from sebs.cloudflare.durable_objects import DurableObjects from sebs.faas.resources import SystemResources from sebs.faas.storage import PersistentStorage from sebs.faas.nosql import NoSQLStorage @@ -62,13 +63,15 @@ def get_storage(self, replace_existing: Optional[bool] = None) -> PersistentStor Args: replace_existing: Whether to replace existing files in storage - Raises: - NotImplementedError: R2 storage support not yet implemented + Returns: + R2 storage instance """ + if replace_existing is None: + replace_existing = False return R2( region=self._config.region, - cache_client=None, + cache_client=self._cache_client, resources=self._config.resources, replace_existing=replace_existing, credentials=self._config.credentials, @@ -76,15 +79,17 @@ def get_storage(self, replace_existing: Optional[bool] = None) -> PersistentStor def get_nosql_storage(self) -> NoSQLStorage: """ - Get Cloudflare NoSQL storage instance. + Get Cloudflare Durable Objects storage instance. - This could use Cloudflare D1 (SQLite) or Durable Objects for NoSQL storage. + Durable Objects provide stateful storage for Workers. + Note: This is a minimal implementation to satisfy SeBS requirements. - Raises: - NotImplementedError: NoSQL storage support not yet implemented + Returns: + DurableObjects storage instance """ - raise NotImplementedError( - "Cloudflare NoSQL storage (D1/Durable Objects) is not yet implemented. " - "To add support, implement a NoSQLStorage subclass " - "similar to sebs/aws/dynamodb.py or sebs/azure/cosmosdb.py" + return DurableObjects( + region=self._config.region, + cache_client=self._cache_client, + resources=self._config.resources, + credentials=self._config.credentials, ) diff --git a/sebs/cloudflare/triggers.py b/sebs/cloudflare/triggers.py index 310f1fa94..f4b926379 100644 --- a/sebs/cloudflare/triggers.py +++ b/sebs/cloudflare/triggers.py @@ -11,7 +11,8 @@ class LibraryTrigger(Trigger): """ def __init__(self, worker_name: str, deployment_client=None): - super().__init__(worker_name) + super().__init__() + self.worker_name = worker_name self.deployment_client = deployment_client @staticmethod @@ -43,11 +44,17 @@ def async_invoke(self, payload: dict) -> concurrent.futures.Future: raise NotImplementedError("Cloudflare Workers do not support async invocation") def serialize(self) -> dict: - return {**super().serialize()} + """Serialize the LibraryTrigger.""" + return { + "type": self.typename(), + "worker_name": self.worker_name, + } @staticmethod - def deserialize(obj: dict) -> "LibraryTrigger": - return LibraryTrigger(obj["name"]) + def deserialize(cached_config: dict) -> "LibraryTrigger": + """Deserialize a LibraryTrigger from cached config.""" + from sebs.cloudflare.triggers import LibraryTrigger + return LibraryTrigger(cached_config["worker_name"]) class HTTPTrigger(Trigger): @@ -57,7 +64,8 @@ class HTTPTrigger(Trigger): """ def __init__(self, worker_name: str, url: Optional[str] = None): - super().__init__(worker_name) + super().__init__() + self.worker_name = worker_name self._url = url @staticmethod @@ -135,13 +143,12 @@ def async_invoke(self, payload: dict) -> concurrent.futures.Future: def serialize(self) -> dict: return { - **super().serialize(), + "type": self.typename(), + "worker_name": self.worker_name, "url": self._url, } @staticmethod def deserialize(obj: dict) -> "HTTPTrigger": - trigger = HTTPTrigger(obj["name"]) - if "url" in obj: - trigger.url = obj["url"] + trigger = HTTPTrigger(obj["worker_name"], obj.get("url")) return trigger From b117e753a91fe359594832b9eb6ddf994fdaa93b Mon Sep 17 00:00:00 2001 From: laurin Date: Tue, 11 Nov 2025 18:11:39 +0100 Subject: [PATCH 11/69] adapted handler to measure invocation time --- .../wrappers/cloudflare/nodejs/handler.js | 50 +++++++++++++++---- 1 file changed, 41 insertions(+), 9 deletions(-) diff --git a/benchmarks/wrappers/cloudflare/nodejs/handler.js b/benchmarks/wrappers/cloudflare/nodejs/handler.js index 463bbd8e2..03038672d 100644 --- a/benchmarks/wrappers/cloudflare/nodejs/handler.js +++ b/benchmarks/wrappers/cloudflare/nodejs/handler.js @@ -53,6 +53,10 @@ export default { return new Response('None'); } + // Start timing measurements + const begin = Date.now() / 1000; + const start = performance.now(); + const req_text = await request.text(); let event = {}; if (req_text && req_text.length > 0) { @@ -126,11 +130,17 @@ export default { throw new Error('benchmark handler function not found'); } } catch (err) { + // Calculate timing even for errors + const end = Date.now() / 1000; + const elapsed = performance.now() - start; + const micro = elapsed * 1000; // Convert milliseconds to microseconds + // Mirror Python behavior: return structured error payload const errorPayload = JSON.stringify({ - begin: '0', - end: '0', - results_time: '0', + begin: begin, + end: end, + compute_time: micro, + results_time: 0, result: { output: null }, is_cold: false, is_cold_worker: false, @@ -142,6 +152,11 @@ export default { return new Response(errorPayload, { status: 500, headers: { 'Content-Type': 'application/json' } }); } + // Calculate elapsed time + const end = Date.now() / 1000; + const elapsed = performance.now() - start; + const micro = elapsed * 1000; // Convert milliseconds to microseconds + // Build log_data similar to Python handler const log_data = { output: ret && ret.result !== undefined ? ret.result : ret }; if (ret && ret.measurement !== undefined) { @@ -158,9 +173,10 @@ export default { } const responseBody = JSON.stringify({ - begin: '0', - end: '0', - results_time: '0', + begin: begin, + end: end, + compute_time: micro, + results_time: 0, result: log_data, is_cold: false, is_cold_worker: false, @@ -172,10 +188,26 @@ export default { return new Response(responseBody, { headers: { 'Content-Type': 'application/json' } }); } catch (topLevelError) { // Catch any uncaught errors (module loading, syntax errors, etc.) + // Try to include timing if available + let errorBegin = 0; + let errorEnd = 0; + let errorMicro = 0; + try { + errorEnd = Date.now() / 1000; + if (typeof begin !== 'undefined' && typeof start !== 'undefined') { + errorBegin = begin; + const elapsed = performance.now() - start; + errorMicro = elapsed * 1000; + } + } catch (e) { + // Ignore timing errors in error handler + } + const errorPayload = JSON.stringify({ - begin: '0', - end: '0', - results_time: '0', + begin: errorBegin, + end: errorEnd, + compute_time: errorMicro, + results_time: 0, result: { output: null }, is_cold: false, is_cold_worker: false, From d42b157038b00914529b4c1f161bd2b64990ae5e Mon Sep 17 00:00:00 2001 From: laurin Date: Wed, 12 Nov 2025 13:21:13 +0100 Subject: [PATCH 12/69] fixed the fs polyfill to also support write operationst to r2 storage, at this point the other benchmarks may be translated to nodejs --- .../wrappers/cloudflare/nodejs/fs-polyfill.js | 100 ++++++++++++++++-- .../cloudflare/nodejs/path-polyfill.js | 54 ---------- configs/systems.json | 3 +- sebs/cloudflare/cloudflare.py | 35 +++--- 4 files changed, 111 insertions(+), 81 deletions(-) delete mode 100644 benchmarks/wrappers/cloudflare/nodejs/path-polyfill.js diff --git a/benchmarks/wrappers/cloudflare/nodejs/fs-polyfill.js b/benchmarks/wrappers/cloudflare/nodejs/fs-polyfill.js index dac01a115..6e06493f1 100644 --- a/benchmarks/wrappers/cloudflare/nodejs/fs-polyfill.js +++ b/benchmarks/wrappers/cloudflare/nodejs/fs-polyfill.js @@ -1,10 +1,5 @@ -/** - * fs polyfill for Cloudflare Workers that reads files from R2 bucket - * - * This polyfill provides a subset of Node.js fs API for reading files - * stored in an R2 bucket. The R2 bucket binding is accessed via - * globalThis.R2_BUCKET which is set by the handler. - */ +import * as nodeFs from 'node:fs'; +import { Writable } from 'node:stream'; /** * Read a file from R2 bucket @@ -147,10 +142,99 @@ export async function stat(path, callback) { } } -// Export default object with all methods for CommonJS-style usage +/** + * Create a write stream (memory-buffered, writes to R2 on close) + */ +export function createWriteStream(path, options) { + const chunks = []; + + const stream = new Writable({ + write(chunk, encoding, callback) { + chunks.push(chunk); + callback(); + }, + final(callback) { + // Write to R2 when stream is closed + (async () => { + try { + if (!globalThis.R2_BUCKET) { + throw new Error('R2 bucket not available'); + } + + let normalizedPath = path.replace(/^\.?\//, ''); + + if (globalThis.BENCHMARK_NAME && !normalizedPath.startsWith(globalThis.BENCHMARK_NAME + '/')) { + normalizedPath = globalThis.BENCHMARK_NAME + '/' + normalizedPath; + } + + const buffer = Buffer.concat(chunks); + await globalThis.R2_BUCKET.put(normalizedPath, buffer); + callback(); + } catch (err) { + callback(err); + } + })(); + } + }); + + return stream; +} + +/** + * Write file to R2 + */ +export async function writeFile(path, data, options, callback) { + let actualCallback = callback; + let actualOptions = options; + + if (typeof options === 'function') { + actualCallback = options; + actualOptions = {}; + } + + try { + if (!globalThis.R2_BUCKET) { + throw new Error('R2 bucket not available'); + } + + let normalizedPath = path.replace(/^\.?\//, ''); + + if (globalThis.BENCHMARK_NAME && !normalizedPath.startsWith(globalThis.BENCHMARK_NAME + '/')) { + normalizedPath = globalThis.BENCHMARK_NAME + '/' + normalizedPath; + } + + await globalThis.R2_BUCKET.put(normalizedPath, data); + + if (actualCallback) actualCallback(null); + } catch (err) { + if (actualCallback) actualCallback(err); + else throw err; + } +} + +/** + * Synchronous write file to R2 + */ +export function writeFileSync(path, data, options) { + return new Promise((resolve, reject) => { + writeFile(path, data, options, (err) => { + if (err) reject(err); + else resolve(); + }); + }); +} + +// Export everything from node:fs (what's available), but override specific methods export default { + ...nodeFs, readFile, readFileSync, exists, stat, + createWriteStream, + writeFile, + writeFileSync, }; + +// Also re-export all named exports from node:fs +export * from 'node:fs'; \ No newline at end of file diff --git a/benchmarks/wrappers/cloudflare/nodejs/path-polyfill.js b/benchmarks/wrappers/cloudflare/nodejs/path-polyfill.js deleted file mode 100644 index 4c77c2be9..000000000 --- a/benchmarks/wrappers/cloudflare/nodejs/path-polyfill.js +++ /dev/null @@ -1,54 +0,0 @@ -/** - * Minimal POSIX-like path.resolve polyfill for Cloudflare Workers / browser. - * Always returns an absolute path starting with '/'. - * Does not use process.cwd(); root '/' is the base. - */ - -function normalizeSegments(segments) { - const out = []; - for (const seg of segments) { - if (!seg || seg === '.') continue; - if (seg === '..') { - if (out.length && out[out.length - 1] !== '..') out.pop(); - continue; - } - out.push(seg); - } - return out; -} - -/** - * Resolve path segments into an absolute path. - * @param {...string} input - * @returns {string} - */ -export function resolve(...input) { - if (!input.length) return '/'; - let absoluteFound = false; - const segments = []; - - for (let i = input.length - 1; i >= 0; i--) { - let part = String(input[i]); - if (part === '') continue; - // Normalize backslashes to forward slashes (basic win compatibility) - part = part.replace(/\\/g, '/'); - - if (part[0] === '/') { - absoluteFound = true; - part = part.slice(1); // drop leading '/' to just collect segments - } - const split = part.split('/'); - for (let j = split.length - 1; j >= 0; j--) { - const seg = split[j]; - if (seg) segments.push(seg); - } - if (absoluteFound) break; - } - - const normalized = normalizeSegments(segments.reverse()); - return '/' + normalized.join('/'); -} - -// Optional convenience exports similar to Node's path.posix interface -const path = { resolve }; -export default path; \ No newline at end of file diff --git a/configs/systems.json b/configs/systems.json index 073f564d1..ca75db5c0 100644 --- a/configs/systems.json +++ b/configs/systems.json @@ -461,8 +461,7 @@ "files": [ "handler.js", "storage.js", - "fs-polyfill.js", - "path-polyfill.js" + "fs-polyfill.js" ], "packages": { "uuid": "3.4.0" diff --git a/sebs/cloudflare/cloudflare.py b/sebs/cloudflare/cloudflare.py index 404acf1eb..297349b2e 100644 --- a/sebs/cloudflare/cloudflare.py +++ b/sebs/cloudflare/cloudflare.py @@ -211,6 +211,22 @@ def _generate_wrangler_toml(self, worker_name: str, package_dir: str, language: """ + + + + # Add compatibility flags based on language + if language == "nodejs": + toml_content += """# Custom polyfills for fs and path that read from R2 bucket +compatibility_flags = ["nodejs_compat"] +[alias] +"fs" = "./fs-polyfill" +""" + elif language == "python": + toml_content += """# Enable Python Workers runtime +compatibility_flags = ["python_workers"] +""" + + # Add environment variable for benchmark name (used by fs-polyfill for R2 paths) if benchmark_name: toml_content += f"""# Benchmark name used for R2 file path prefix @@ -218,8 +234,8 @@ def _generate_wrangler_toml(self, worker_name: str, package_dir: str, language: BENCHMARK_NAME = "{benchmark_name}" """ - - # Add R2 bucket binding for benchmarking files (required for fs/path polyfills) + + # Add R2 bucket binding for benchmarking files (required for fs/path polyfills) r2_bucket_configured = False try: storage = self.system_resources.get_storage() @@ -240,21 +256,6 @@ def _generate_wrangler_toml(self, worker_name: str, package_dir: str, language: f"Benchmarks requiring file access will not work properly." ) - # Add compatibility flags based on language - if language == "nodejs": - toml_content += """# Custom polyfills for fs and path that read from R2 bucket -[alias] -"fs" = "./fs-polyfill" -"path" = "./path-polyfill" -""" - if r2_bucket_configured: - self.logging.info( - "fs and path polyfills configured to use R2 bucket for file operations" - ) - elif language == "python": - toml_content += """# Enable Python Workers runtime -compatibility_flags = ["python_workers"] -""" # Write wrangler.toml to package directory toml_path = os.path.join(package_dir, "wrangler.toml") From ffd3f786ba9d4d9e9d3ec8cc5882089e6a660bd9 Mon Sep 17 00:00:00 2001 From: laurin Date: Wed, 12 Nov 2025 15:45:02 +0100 Subject: [PATCH 13/69] added compatibility for benchmarks 100 in nodejs. translated all 100 and 000 to nodejs. fixed support for nosql in wrapper and sebs. fixed durable objects implementation for sebs --- .../020.network-benchmark/config.json | 2 +- .../020.network-benchmark/nodejs/function.js | 94 ++++++++++++++ .../020.network-benchmark/nodejs/package.json | 9 ++ .../030.clock-synchronization/config.json | 2 +- .../nodejs/function.js | 115 +++++++++++++++++ .../nodejs/package.json | 9 ++ .../040.server-reply/nodejs/function.js | 31 +++++ .../040.server-reply/nodejs/package.json | 9 ++ .../130.crud-api/nodejs/function.js | 78 ++++++++++++ .../130.crud-api/nodejs/package.json | 9 ++ .../wrappers/cloudflare/nodejs/fs-polyfill.js | 95 ++++++++++---- .../wrappers/cloudflare/nodejs/handler.js | 9 +- .../wrappers/cloudflare/nodejs/nosql.js | 114 +++++++++++++++++ .../cloudflare/nodejs/request-polyfill.js | 96 +++++++++++++++ .../wrappers/cloudflare/nodejs/storage.js | 116 +++++++++++++++++- configs/systems.json | 4 +- sebs/cloudflare/cloudflare.py | 1 + sebs/cloudflare/durable_objects.py | 58 +++++---- 18 files changed, 794 insertions(+), 57 deletions(-) create mode 100644 benchmarks/000.microbenchmarks/020.network-benchmark/nodejs/function.js create mode 100644 benchmarks/000.microbenchmarks/020.network-benchmark/nodejs/package.json create mode 100644 benchmarks/000.microbenchmarks/030.clock-synchronization/nodejs/function.js create mode 100644 benchmarks/000.microbenchmarks/030.clock-synchronization/nodejs/package.json create mode 100644 benchmarks/000.microbenchmarks/040.server-reply/nodejs/function.js create mode 100644 benchmarks/000.microbenchmarks/040.server-reply/nodejs/package.json create mode 100644 benchmarks/100.webapps/130.crud-api/nodejs/function.js create mode 100644 benchmarks/100.webapps/130.crud-api/nodejs/package.json create mode 100644 benchmarks/wrappers/cloudflare/nodejs/nosql.js create mode 100644 benchmarks/wrappers/cloudflare/nodejs/request-polyfill.js diff --git a/benchmarks/000.microbenchmarks/020.network-benchmark/config.json b/benchmarks/000.microbenchmarks/020.network-benchmark/config.json index c3c2c73b1..455933282 100644 --- a/benchmarks/000.microbenchmarks/020.network-benchmark/config.json +++ b/benchmarks/000.microbenchmarks/020.network-benchmark/config.json @@ -1,6 +1,6 @@ { "timeout": 30, "memory": 128, - "languages": ["python"], + "languages": ["python", "nodejs"], "modules": [] } diff --git a/benchmarks/000.microbenchmarks/020.network-benchmark/nodejs/function.js b/benchmarks/000.microbenchmarks/020.network-benchmark/nodejs/function.js new file mode 100644 index 000000000..431ccbe39 --- /dev/null +++ b/benchmarks/000.microbenchmarks/020.network-benchmark/nodejs/function.js @@ -0,0 +1,94 @@ +const dgram = require('dgram'); +const fs = require('fs'); +const path = require('path'); +const storage = require('./storage'); + +const storage_handler = new storage.storage(); + +function sleep(ms) { + return new Promise(resolve => setTimeout(resolve, ms)); +} + +exports.handler = async function(event) { + const requestId = event['request-id']; + const address = event['server-address']; + const port = event['server-port']; + const repetitions = event['repetitions']; + const outputBucket = event.bucket.bucket; + const outputPrefix = event.bucket.output; + + const times = []; + let i = 0; + const client = dgram.createSocket('udp4'); + client.bind(); + + const message = Buffer.from(String(requestId)); + let consecutiveFailures = 0; + let key = null; + + while (i < repetitions + 1) { + try { + const sendBegin = Date.now() / 1000; + + await new Promise((resolve, reject) => { + const timeout = setTimeout(() => { + reject(new Error('Socket timeout')); + }, 3000); + + client.send(message, port, address, (err) => { + if (err) { + clearTimeout(timeout); + reject(err); + } + }); + + client.once('message', (msg, rinfo) => { + clearTimeout(timeout); + const recvEnd = Date.now() / 1000; + resolve(recvEnd); + }); + }).then((recvEnd) => { + if (i > 0) { + times.push([i, sendBegin, recvEnd]); + } + i++; + consecutiveFailures = 0; + }); + } catch (err) { + i++; + consecutiveFailures++; + if (consecutiveFailures === 5) { + console.log("Can't setup the connection"); + break; + } + continue; + } + } + + client.close(); + + if (consecutiveFailures !== 5) { + // Write CSV file using stream + const csvPath = '/tmp/data.csv'; + let csvContent = 'id,client_send,client_rcv\n'; + times.forEach(row => { + csvContent += row.join(',') + '\n'; + }); + + // Use createWriteStream and wait for it to finish + await new Promise((resolve, reject) => { + const writeStream = fs.createWriteStream(csvPath); + writeStream.write(csvContent); + writeStream.end(); + writeStream.on('finish', resolve); + writeStream.on('error', reject); + }); + + const filename = `results-${requestId}.csv`; + let uploadPromise; + [key, uploadPromise] = storage_handler.upload(outputBucket, path.join(outputPrefix, filename), csvPath); + await uploadPromise; + } + + return { result: key }; +}; diff --git a/benchmarks/000.microbenchmarks/020.network-benchmark/nodejs/package.json b/benchmarks/000.microbenchmarks/020.network-benchmark/nodejs/package.json new file mode 100644 index 000000000..57264db28 --- /dev/null +++ b/benchmarks/000.microbenchmarks/020.network-benchmark/nodejs/package.json @@ -0,0 +1,9 @@ +{ + "name": "network-benchmark", + "version": "1.0.0", + "description": "Network benchmark function", + "author": "", + "license": "", + "dependencies": { + } +} diff --git a/benchmarks/000.microbenchmarks/030.clock-synchronization/config.json b/benchmarks/000.microbenchmarks/030.clock-synchronization/config.json index c3c2c73b1..455933282 100644 --- a/benchmarks/000.microbenchmarks/030.clock-synchronization/config.json +++ b/benchmarks/000.microbenchmarks/030.clock-synchronization/config.json @@ -1,6 +1,6 @@ { "timeout": 30, "memory": 128, - "languages": ["python"], + "languages": ["python", "nodejs"], "modules": [] } diff --git a/benchmarks/000.microbenchmarks/030.clock-synchronization/nodejs/function.js b/benchmarks/000.microbenchmarks/030.clock-synchronization/nodejs/function.js new file mode 100644 index 000000000..8adb53f66 --- /dev/null +++ b/benchmarks/000.microbenchmarks/030.clock-synchronization/nodejs/function.js @@ -0,0 +1,115 @@ +const dgram = require('dgram'); +const fs = require('fs'); +const path = require('path'); +const storage = require('./storage'); + +const storage_handler = new storage.storage(); + +exports.handler = async function(event) { + const requestId = event['request-id']; + const address = event['server-address']; + const port = event['server-port']; + const repetitions = event['repetitions']; + const outputBucket = event.bucket.bucket; + const outputPrefix = event.bucket.output; + + const times = []; + console.log(`Starting communication with ${address}:${port}`); + + let i = 0; + const client = dgram.createSocket('udp4'); + client.bind(); + + let message = Buffer.from(String(requestId)); + let consecutiveFailures = 0; + let measurementsNotSmaller = 0; + let curMin = 0; + let key = null; + + while (i < 1000) { + try { + const sendBegin = Date.now() / 1000; + + const recvEnd = await new Promise((resolve, reject) => { + const timeout = setTimeout(() => { + reject(new Error('Socket timeout')); + }, 4000); + + client.send(message, port, address, (err) => { + if (err) { + clearTimeout(timeout); + reject(err); + } + }); + + client.once('message', (msg, rinfo) => { + clearTimeout(timeout); + const recvEnd = Date.now() / 1000; + resolve(recvEnd); + }); + }); + + if (i > 0) { + times.push([i, sendBegin, recvEnd]); + } + + const curTime = recvEnd - sendBegin; + console.log(`Time ${curTime} Min Time ${curMin} NotSmaller ${measurementsNotSmaller}`); + + if (curTime > curMin && curMin > 0) { + measurementsNotSmaller++; + if (measurementsNotSmaller === repetitions) { + message = Buffer.from('stop'); + client.send(message, port, address); + break; + } + } else { + curMin = curTime; + measurementsNotSmaller = 0; + } + + i++; + consecutiveFailures = 0; + } catch (err) { + i++; + consecutiveFailures++; + if (consecutiveFailures === 7) { + console.log("Can't setup the connection"); + break; + } + continue; + } + } + + client.close(); + + if (consecutiveFailures !== 5) { + // Write CSV file using stream + const csvPath = '/tmp/data.csv'; + let csvContent = 'id,client_send,client_rcv\n'; + times.forEach(row => { + csvContent += row.join(',') + '\n'; + }); + + // Use createWriteStream and wait for it to finish + await new Promise((resolve, reject) => { + const writeStream = fs.createWriteStream(csvPath); + writeStream.write(csvContent); + writeStream.end(); + writeStream.on('finish', resolve); + writeStream.on('error', reject); + }); + + const filename = `results-${requestId}.csv`; + let uploadPromise; + [key, uploadPromise] = storage_handler.upload(outputBucket, path.join(outputPrefix, filename), csvPath); + await uploadPromise; + } + + return { + result: { + 'bucket-key': key, + 'timestamp': event['income-timestamp'] + } + }; +}; diff --git a/benchmarks/000.microbenchmarks/030.clock-synchronization/nodejs/package.json b/benchmarks/000.microbenchmarks/030.clock-synchronization/nodejs/package.json new file mode 100644 index 000000000..20dbe9c5f --- /dev/null +++ b/benchmarks/000.microbenchmarks/030.clock-synchronization/nodejs/package.json @@ -0,0 +1,9 @@ +{ + "name": "clock-synchronization", + "version": "1.0.0", + "description": "Clock synchronization benchmark", + "author": "", + "license": "", + "dependencies": { + } +} diff --git a/benchmarks/000.microbenchmarks/040.server-reply/nodejs/function.js b/benchmarks/000.microbenchmarks/040.server-reply/nodejs/function.js new file mode 100644 index 000000000..45a0ea8f8 --- /dev/null +++ b/benchmarks/000.microbenchmarks/040.server-reply/nodejs/function.js @@ -0,0 +1,31 @@ +const net = require('net'); + +exports.handler = async function(event) { + const address = event['ip-address']; + const port = event['port']; + + return new Promise((resolve, reject) => { + const client = new net.Socket(); + + client.setTimeout(20000); + + client.connect(port, address, () => { + console.log('Connected to server'); + }); + + client.on('data', (data) => { + const msg = data.toString(); + client.destroy(); + resolve({ result: msg }); + }); + + client.on('timeout', () => { + client.destroy(); + reject(new Error('Connection timeout')); + }); + + client.on('error', (err) => { + reject(err); + }); + }); +}; diff --git a/benchmarks/000.microbenchmarks/040.server-reply/nodejs/package.json b/benchmarks/000.microbenchmarks/040.server-reply/nodejs/package.json new file mode 100644 index 000000000..ad419b23f --- /dev/null +++ b/benchmarks/000.microbenchmarks/040.server-reply/nodejs/package.json @@ -0,0 +1,9 @@ +{ + "name": "server-reply", + "version": "1.0.0", + "description": "Server reply benchmark", + "author": "", + "license": "", + "dependencies": { + } +} diff --git a/benchmarks/100.webapps/130.crud-api/nodejs/function.js b/benchmarks/100.webapps/130.crud-api/nodejs/function.js new file mode 100644 index 000000000..807b8c5f9 --- /dev/null +++ b/benchmarks/100.webapps/130.crud-api/nodejs/function.js @@ -0,0 +1,78 @@ +const nosql = require('./nosql'); + +const nosqlClient = nosql.nosql.get_instance(); +const nosqlTableName = "shopping_cart"; + +function addProduct(cartId, productId, productName, price, quantity) { + nosqlClient.insert( + nosqlTableName, + ["cart_id", cartId], + ["product_id", productId], + { price: price, quantity: quantity, name: productName } + ); +} + +function getProducts(cartId, productId) { + return nosqlClient.get( + nosqlTableName, + ["cart_id", cartId], + ["product_id", productId] + ); +} + +function queryProducts(cartId) { + const res = nosqlClient.query( + nosqlTableName, + ["cart_id", cartId], + "product_id" + ); + + const products = []; + let priceSum = 0; + let quantitySum = 0; + + for (const product of res) { + products.push(product.name); + priceSum += product.price; + quantitySum += product.quantity; + } + + const avgPrice = quantitySum > 0 ? priceSum / quantitySum : 0.0; + + return { + products: products, + total_cost: priceSum, + avg_price: avgPrice + }; +} + +exports.handler = async function(event) { + const results = []; + + for (const request of event.requests) { + const route = request.route; + const body = request.body; + let res; + + if (route === "PUT /cart") { + addProduct( + body.cart, + body.product_id, + body.name, + body.price, + body.quantity + ); + res = {}; + } else if (route === "GET /cart/{id}") { + res = getProducts(body.cart, request.path.id); + } else if (route === "GET /cart") { + res = queryProducts(body.cart); + } else { + throw new Error(`Unknown request route: ${route}`); + } + + results.push(res); + } + + return { result: results }; +}; diff --git a/benchmarks/100.webapps/130.crud-api/nodejs/package.json b/benchmarks/100.webapps/130.crud-api/nodejs/package.json new file mode 100644 index 000000000..e00c83ddf --- /dev/null +++ b/benchmarks/100.webapps/130.crud-api/nodejs/package.json @@ -0,0 +1,9 @@ +{ + "name": "crud-api", + "version": "1.0.0", + "description": "CRUD API benchmark", + "author": "", + "license": "", + "dependencies": { + } +} diff --git a/benchmarks/wrappers/cloudflare/nodejs/fs-polyfill.js b/benchmarks/wrappers/cloudflare/nodejs/fs-polyfill.js index 6e06493f1..747cc15a9 100644 --- a/benchmarks/wrappers/cloudflare/nodejs/fs-polyfill.js +++ b/benchmarks/wrappers/cloudflare/nodejs/fs-polyfill.js @@ -1,6 +1,25 @@ import * as nodeFs from 'node:fs'; import { Writable } from 'node:stream'; +// Global cache for files written/read during this request +// This allows sync operations to work within a single request context +if (!globalThis.FS_CACHE) { + globalThis.FS_CACHE = new Map(); +} + +/** + * Normalize a file path for R2 + */ +function normalizePath(path) { + let normalizedPath = path.replace(/^\.?\//, '').replace(/^tmp\//, ''); + + if (globalThis.BENCHMARK_NAME && !normalizedPath.startsWith(globalThis.BENCHMARK_NAME + '/')) { + normalizedPath = globalThis.BENCHMARK_NAME + '/' + normalizedPath; + } + + return normalizedPath; +} + /** * Read a file from R2 bucket * @param {string} path - File path in R2 bucket (e.g., 'templates/index.html') @@ -27,13 +46,7 @@ export async function readFile(path, encoding, callback) { throw new Error('R2 bucket not available. Ensure R2 binding is configured in wrangler.toml'); } - // Normalize path: remove leading './' or '/' - let normalizedPath = path.replace(/^\.?\//, ''); - - // Prepend benchmark name if available - if (globalThis.BENCHMARK_NAME && !normalizedPath.startsWith(globalThis.BENCHMARK_NAME + '/')) { - normalizedPath = globalThis.BENCHMARK_NAME + '/' + normalizedPath; - } + const normalizedPath = normalizePath(path); // Get object from R2 const object = await globalThis.R2_BUCKET.get(normalizedPath); @@ -47,11 +60,17 @@ export async function readFile(path, encoding, callback) { if (actualEncoding === 'utf8' || actualEncoding === 'utf-8') { content = await object.text(); } else if (actualEncoding === 'buffer' || actualEncoding === null) { - content = await object.arrayBuffer(); + const arrayBuffer = await object.arrayBuffer(); + content = Buffer.from(arrayBuffer); } else { // For other encodings, get text and let caller handle conversion content = await object.text(); } + + // Store in cache for potential synchronous access + if (globalThis.FS_CACHE) { + globalThis.FS_CACHE.set(normalizedPath, content); + } if (actualCallback) { actualCallback(null, content); @@ -67,16 +86,26 @@ export async function readFile(path, encoding, callback) { } /** - * Synchronous version of readFile (not truly sync in Workers, but returns a Promise) - * Note: This is a compatibility shim - it still returns a Promise + * Synchronous version of readFile + * Reads from cache if available, otherwise throws error */ export function readFileSync(path, encoding) { - return new Promise((resolve, reject) => { - readFile(path, encoding || 'utf8', (err, data) => { - if (err) reject(err); - else resolve(data); - }); - }); + const normalizedPath = normalizePath(path); + + // Check cache first + if (globalThis.FS_CACHE && globalThis.FS_CACHE.has(normalizedPath)) { + const data = globalThis.FS_CACHE.get(normalizedPath); + + if (encoding === 'utf8' || encoding === 'utf-8') { + return typeof data === 'string' ? data : Buffer.from(data).toString('utf8'); + } else if (encoding === null || encoding === 'buffer') { + return Buffer.isBuffer(data) ? data : Buffer.from(data); + } + return data; + } + + // File not in cache - in Workers we can't do sync I/O + throw new Error(`ENOENT: no such file or directory, open '${path}'. File not in cache. In Cloudflare Workers, files must be written in the same request before being read synchronously.`); } /** @@ -106,6 +135,26 @@ export async function exists(path, callback) { } } +/** + * Synchronous version of exists + * Checks cache for file existence + */ +export function existsSync(path) { + if (!globalThis.R2_BUCKET) { + return false; + } + + const normalizedPath = normalizePath(path); + + // Check if file is in cache + if (globalThis.FS_CACHE && globalThis.FS_CACHE.has(normalizedPath)) { + return true; + } + + // File not in cache + return false; +} + /** * Get file stats from R2 */ @@ -161,13 +210,15 @@ export function createWriteStream(path, options) { throw new Error('R2 bucket not available'); } - let normalizedPath = path.replace(/^\.?\//, ''); + const normalizedPath = normalizePath(path); - if (globalThis.BENCHMARK_NAME && !normalizedPath.startsWith(globalThis.BENCHMARK_NAME + '/')) { - normalizedPath = globalThis.BENCHMARK_NAME + '/' + normalizedPath; + const buffer = Buffer.concat(chunks); + + // Store in cache for synchronous access + if (globalThis.FS_CACHE) { + globalThis.FS_CACHE.set(normalizedPath, buffer); } - const buffer = Buffer.concat(chunks); await globalThis.R2_BUCKET.put(normalizedPath, buffer); callback(); } catch (err) { @@ -230,11 +281,9 @@ export default { readFile, readFileSync, exists, + existsSync, stat, createWriteStream, writeFile, writeFileSync, }; - -// Also re-export all named exports from node:fs -export * from 'node:fs'; \ No newline at end of file diff --git a/benchmarks/wrappers/cloudflare/nodejs/handler.js b/benchmarks/wrappers/cloudflare/nodejs/handler.js index 03038672d..0b4a827c1 100644 --- a/benchmarks/wrappers/cloudflare/nodejs/handler.js +++ b/benchmarks/wrappers/cloudflare/nodejs/handler.js @@ -1,4 +1,3 @@ - // Simple CommonJS polyfill for Cloudflare Workers // This allows us to load CommonJS modules that use require() and module.exports const moduleCache = {}; @@ -33,7 +32,6 @@ if (typeof globalThis.require === 'undefined') { } - export default { async fetch(request, env) { try { @@ -57,6 +55,7 @@ export default { const begin = Date.now() / 1000; const start = performance.now(); + // Parse JSON body first (similar to Azure handler which uses req.body) const req_text = await request.text(); let event = {}; if (req_text && req_text.length > 0) { @@ -68,7 +67,8 @@ export default { } } - // Parse query string into event (simple parsing, mirrors Python logic) + // Parse query string into event (URL parameters override/merge with body) + // This makes it compatible with both input formats const urlParts = request.url.split('?'); if (urlParts.length > 1) { const query = urlParts[1]; @@ -148,6 +148,9 @@ export default { environ_container_id: 'no_id', request_id: '0', error: String(err && err.message ? err.message : err), + stack: err && err.stack ? err.stack : undefined, + event: event, + env: env, }); return new Response(errorPayload, { status: 500, headers: { 'Content-Type': 'application/json' } }); } diff --git a/benchmarks/wrappers/cloudflare/nodejs/nosql.js b/benchmarks/wrappers/cloudflare/nodejs/nosql.js new file mode 100644 index 000000000..2841d3942 --- /dev/null +++ b/benchmarks/wrappers/cloudflare/nodejs/nosql.js @@ -0,0 +1,114 @@ +// NoSQL wrapper for Cloudflare Workers +// Supports Cloudflare KV or Durable Objects when available + +class nosql { + constructor() { + this.handle = null; // KV or Durable Object binding + this._tables = {}; + } + + static init_instance(entry) { + nosql.instance = new nosql(); + if (entry && entry.env) { + nosql.instance.env = entry.env; + } + } + + _get_table(tableName) { + if (!(tableName in this._tables)) { + const envName = `NOSQL_STORAGE_TABLE_${tableName}`; + + if (this.env && this.env[envName]) { + this._tables[tableName] = this.env[envName]; + } else if (this.env && this.env[tableName]) { + // Try direct table name + this._tables[tableName] = this.env[tableName]; + } else { + throw new Error( + `Couldn't find an environment variable ${envName} for table ${tableName}` + ); + } + } + + return this._tables[tableName]; + } + + async insert(tableName, primaryKey, secondaryKey, data) { + const keyData = { ...data }; + keyData[primaryKey[0]] = primaryKey[1]; + keyData[secondaryKey[0]] = secondaryKey[1]; + + const table = this._get_table(tableName); + const compositeKey = `${primaryKey[1]}#${secondaryKey[1]}`; + + // For KV binding + if (table && typeof table.put === 'function') { + await table.put(compositeKey, JSON.stringify(keyData)); + } else { + throw new Error('NoSQL table binding not properly configured'); + } + } + + async get(tableName, primaryKey, secondaryKey) { + const table = this._get_table(tableName); + const compositeKey = `${primaryKey[1]}#${secondaryKey[1]}`; + + if (table && typeof table.get === 'function') { + const result = await table.get(compositeKey); + if (result) { + return JSON.parse(result); + } + return null; + } + + throw new Error('NoSQL table binding not properly configured'); + } + + async update(tableName, primaryKey, secondaryKey, updates) { + // For simple KV, update is same as put with merged data + const existing = await this.get(tableName, primaryKey, secondaryKey) || {}; + const merged = { ...existing, ...updates }; + await this.insert(tableName, primaryKey, secondaryKey, merged); + } + + async query(tableName, primaryKey, secondaryKeyName) { + const table = this._get_table(tableName); + const prefix = `${primaryKey[1]}#`; + + if (table && typeof table.list === 'function') { + const list = await table.list({ prefix }); + const results = []; + + for (const key of list.keys) { + const value = await table.get(key.name); + if (value) { + results.push(JSON.parse(value)); + } + } + + return results; + } + + throw new Error('NoSQL table binding not properly configured'); + } + + async delete(tableName, primaryKey, secondaryKey) { + const table = this._get_table(tableName); + const compositeKey = `${primaryKey[1]}#${secondaryKey[1]}`; + + if (table && typeof table.delete === 'function') { + await table.delete(compositeKey); + } else { + throw new Error('NoSQL table binding not properly configured'); + } + } + + static get_instance() { + if (!nosql.instance) { + nosql.instance = new nosql(); + } + return nosql.instance; + } +} + +module.exports.nosql = nosql; diff --git a/benchmarks/wrappers/cloudflare/nodejs/request-polyfill.js b/benchmarks/wrappers/cloudflare/nodejs/request-polyfill.js new file mode 100644 index 000000000..5b86d18c4 --- /dev/null +++ b/benchmarks/wrappers/cloudflare/nodejs/request-polyfill.js @@ -0,0 +1,96 @@ +/** + * Minimal request polyfill for Cloudflare Workers + * Provides a subset of the 'request' npm package API using fetch() + */ + +class RequestStream { + constructor(url, options = {}) { + this.url = url; + this.options = options; + this.pipeDestination = null; + } + + pipe(destination) { + this.pipeDestination = destination; + + // Start the fetch and pipe to destination + (async () => { + try { + const response = await fetch(this.url, this.options); + + if (!response.ok) { + this.pipeDestination.emit('error', new Error(`HTTP ${response.status}: ${response.statusText}`)); + return; + } + + // Read the response body and write to destination + const reader = response.body.getReader(); + + while (true) { + const { done, value } = await reader.read(); + + if (done) { + this.pipeDestination.end(); + break; + } + + // Write chunk to destination stream + if (!this.pipeDestination.write(value)) { + // Backpressure - wait for drain + await new Promise(resolve => { + this.pipeDestination.once('drain', resolve); + }); + } + } + } catch (error) { + if (this.pipeDestination) { + this.pipeDestination.emit('error', error); + } + } + })(); + + return this.pipeDestination; + } +} + +/** + * Main request function - creates a request stream + * @param {string|object} urlOrOptions - URL string or options object + * @param {object} options - Additional options if first param is URL + * @returns {RequestStream} + */ +function request(urlOrOptions, options) { + let url, opts; + + if (typeof urlOrOptions === 'string') { + url = urlOrOptions; + opts = options || {}; + } else { + url = urlOrOptions.url || urlOrOptions.uri; + opts = urlOrOptions; + } + + // Add default headers to avoid 403 errors from some servers + const defaultHeaders = { + 'User-Agent': 'Mozilla/5.0 (compatible; Cloudflare-Workers/1.0)', + 'Accept': '*/*', + }; + + const headers = { ...defaultHeaders, ...(opts.headers || {}) }; + + return new RequestStream(url, { + method: opts.method || 'GET', + headers: headers, + body: opts.body, + }); +} + +// Add common HTTP method shortcuts +request.get = (url, options) => request(url, { ...options, method: 'GET' }); +request.post = (url, options) => request(url, { ...options, method: 'POST' }); +request.put = (url, options) => request(url, { ...options, method: 'PUT' }); +request.delete = (url, options) => request(url, { ...options, method: 'DELETE' }); + +// Export as CommonJS module +module.exports = request; +module.exports.default = request; diff --git a/benchmarks/wrappers/cloudflare/nodejs/storage.js b/benchmarks/wrappers/cloudflare/nodejs/storage.js index 01fca6803..72e71e288 100644 --- a/benchmarks/wrappers/cloudflare/nodejs/storage.js +++ b/benchmarks/wrappers/cloudflare/nodejs/storage.js @@ -30,17 +30,49 @@ class storage { // Upload a file given a local filepath. In Workers env this is not available // so callers should use upload_stream or pass raw data. For Node.js we read // the file from disk and put it into R2 if available, otherwise throw. - async upload(__bucket, key, filepath) { + upload(__bucket, key, filepath) { // If file was previously written during this invocation, use /tmp absolute let realPath = filepath; if (this.written_files.has(filepath)) { realPath = path.join('/tmp', path.resolve(filepath)); } - // Read file content + // In Workers environment with R2, check if file exists in R2 + // (it may have been written by fs-polyfill's createWriteStream) + if (this.handle) { + // Normalize the path to match what fs-polyfill would use + let normalizedPath = realPath.replace(/^\.?\//, '').replace(/^tmp\//, ''); + + // Add benchmark name prefix if available (matching fs-polyfill behavior) + if (typeof globalThis !== 'undefined' && globalThis.BENCHMARK_NAME && + !normalizedPath.startsWith(globalThis.BENCHMARK_NAME + '/')) { + normalizedPath = globalThis.BENCHMARK_NAME + '/' + normalizedPath; + } + + const unique_key = storage.unique_name(key); + + // Read from R2 and re-upload with unique key + const uploadPromise = this.handle.get(normalizedPath).then(async (obj) => { + if (obj) { + const data = await obj.arrayBuffer(); + return this.handle.put(unique_key, data); + } else { + throw new Error(`File not found in R2: ${normalizedPath} (original path: ${filepath})`); + } + }); + + return [unique_key, uploadPromise]; + } + + // Fallback: Read file content from local filesystem (Node.js environment) if (fs && fs.existsSync(realPath)) { const data = fs.readFileSync(realPath); - return await this.upload_stream(__bucket, key, data); + const unique_key = storage.unique_name(key); + + // Return [uniqueName, promise] to match Azure storage API + const uploadPromise = Promise.resolve(); + + return [unique_key, uploadPromise]; } // If running in Workers (no fs) and caller provided Buffer/Stream, they @@ -133,6 +165,84 @@ class storage { throw new Error('download_stream(): object not found'); } + // Additional stream methods for compatibility with Azure storage API + // These provide a stream-based interface similar to Azure's uploadStream/downloadStream + uploadStream(__bucket, key) { + const unique_key = storage.unique_name(key); + + if (this.handle) { + // For R2, we create a PassThrough stream that collects data + // then uploads when ended + const stream = require('stream'); + const passThrough = new stream.PassThrough(); + const chunks = []; + + passThrough.on('data', (chunk) => chunks.push(chunk)); + + const upload = new Promise((resolve, reject) => { + passThrough.on('end', async () => { + try { + const buffer = Buffer.concat(chunks); + await this.handle.put(unique_key, buffer); + resolve(); + } catch (err) { + reject(err); + } + }); + passThrough.on('error', reject); + }); + + return [passThrough, upload, unique_key]; + } + + // Fallback to filesystem + if (fs) { + const stream = require('stream'); + const outPath = path.join('/tmp', unique_key); + fs.mkdirSync(path.dirname(outPath), { recursive: true }); + const writeStream = fs.createWriteStream(outPath); + const upload = new Promise((resolve, reject) => { + writeStream.on('finish', resolve); + writeStream.on('error', reject); + }); + return [writeStream, upload, unique_key]; + } + + throw new Error('uploadStream(): no storage backend available'); + } + + async downloadStream(__bucket, key) { + if (this.handle) { + const obj = await this.handle.get(key); + if (!obj) return null; + + // R2 object has a body ReadableStream + if (obj.body) { + return obj.body; + } + + // Fallback: convert to buffer then to stream + if (typeof obj.arrayBuffer === 'function') { + const stream = require('stream'); + const ab = await obj.arrayBuffer(); + const buffer = Buffer.from(ab); + const readable = new stream.PassThrough(); + readable.end(buffer); + return readable; + } + + return null; + } + + // Fallback to local filesystem + const localPath = path.join('/tmp', key); + if (fs && fs.existsSync(localPath)) { + return fs.createReadStream(localPath); + } + + throw new Error('downloadStream(): object not found'); + } + static get_instance() { if (!storage.instance) { throw new Error('must init storage singleton first'); diff --git a/configs/systems.json b/configs/systems.json index ca75db5c0..52eabb497 100644 --- a/configs/systems.json +++ b/configs/systems.json @@ -461,7 +461,9 @@ "files": [ "handler.js", "storage.js", - "fs-polyfill.js" + "nosql.js", + "fs-polyfill.js", + "request-polyfill.js" ], "packages": { "uuid": "3.4.0" diff --git a/sebs/cloudflare/cloudflare.py b/sebs/cloudflare/cloudflare.py index 297349b2e..d299be793 100644 --- a/sebs/cloudflare/cloudflare.py +++ b/sebs/cloudflare/cloudflare.py @@ -220,6 +220,7 @@ def _generate_wrangler_toml(self, worker_name: str, package_dir: str, language: compatibility_flags = ["nodejs_compat"] [alias] "fs" = "./fs-polyfill" +"request" = "./request-polyfill" """ elif language == "python": toml_content += """# Enable Python Workers runtime diff --git a/sebs/cloudflare/durable_objects.py b/sebs/cloudflare/durable_objects.py index 6e0b05c2a..03d36c179 100644 --- a/sebs/cloudflare/durable_objects.py +++ b/sebs/cloudflare/durable_objects.py @@ -1,5 +1,6 @@ import json import requests +from collections import defaultdict from typing import Dict, Optional, Tuple from sebs.cloudflare.config import CloudflareCredentials @@ -35,7 +36,7 @@ def __init__( ): super().__init__(region, cache_client, resources) self._credentials = credentials - self._tables: Dict[str, str] = {} + self._tables: Dict[str, Dict[str, str]] = defaultdict(dict) def _get_auth_headers(self) -> dict[str, str]: """Get authentication headers for Cloudflare API requests.""" @@ -60,9 +61,7 @@ def get_tables(self, benchmark: str) -> Dict[str, str]: :param benchmark: benchmark name :return: dictionary mapping table names to their IDs """ - # For Durable Objects, we don't have traditional tables - # Return cached tables if any - return self._tables.copy() + return self._tables[benchmark] def _get_table_name(self, benchmark: str, table: str) -> Optional[str]: """ @@ -72,8 +71,13 @@ def _get_table_name(self, benchmark: str, table: str) -> Optional[str]: :param table: table name :return: full table name or None if not found """ - key = f"{benchmark}:{table}" - return self._tables.get(key) + if benchmark not in self._tables: + return None + + if table not in self._tables[benchmark]: + return None + + return self._tables[benchmark][table] def retrieve_cache(self, benchmark: str) -> bool: """ @@ -82,11 +86,12 @@ def retrieve_cache(self, benchmark: str) -> bool: :param benchmark: benchmark name :return: True if cache was found and loaded """ - cache_key = f"cloudflare.durable_objects.{benchmark}" - cached = self.cache_client.get(cache_key) - - if cached: - self._tables.update(cached) + if benchmark in self._tables: + return True + + cached_storage = self.cache_client.get_nosql_config(self.deployment_name(), benchmark) + if cached_storage is not None: + self._tables[benchmark] = cached_storage["tables"] self.logging.info(f"Retrieved cached Durable Objects tables for {benchmark}") return True @@ -98,14 +103,13 @@ def update_cache(self, benchmark: str): :param benchmark: benchmark name """ - cache_key = f"cloudflare.durable_objects.{benchmark}" - - # Filter tables for this benchmark - benchmark_tables = { - k: v for k, v in self._tables.items() if k.startswith(f"{benchmark}:") - } - - self.cache_client.update(cache_key, benchmark_tables) + self._cache_client.update_nosql( + self.deployment_name(), + benchmark, + { + "tables": self._tables[benchmark], + }, + ) self.logging.info(f"Updated cache for Durable Objects tables for {benchmark}") def create_table( @@ -124,11 +128,10 @@ def create_table( :param secondary_key: optional secondary key field name :return: table name """ - resource_id = self._cloud_resources.get_resource_id() + resource_id = self._cloud_resources.resources_id table_name = f"sebs-benchmarks-{resource_id}-{benchmark}-{name}" - key = f"{benchmark}:{name}" - self._tables[key] = table_name + self._tables[benchmark][name] = table_name self.logging.info( f"Registered Durable Objects table {table_name} for benchmark {benchmark}" @@ -183,9 +186,14 @@ def remove_table(self, name: str) -> str: :return: table name """ # Remove from internal tracking - keys_to_remove = [k for k, v in self._tables.items() if v == name] - for key in keys_to_remove: - del self._tables[key] + for benchmark, tables in self._tables.items(): + if name in tables.values(): + # Find the table key + for table_key, table_name in tables.items(): + if table_name == name: + del self._tables[benchmark][table_key] + break + break self.logging.info(f"Removed Durable Objects table {name} from tracking") return name From 272a372376b8102aeb8dd94ffcd5ffe1905be579 Mon Sep 17 00:00:00 2001 From: "ldzgch (MacOS)" Date: Thu, 13 Nov 2025 22:59:33 +0100 Subject: [PATCH 14/69] current situation where asyncio cannot run the async function --- .../wrappers/cloudflare/python/handler.py | 31 +++++++---- .../wrappers/cloudflare/python/storage.py | 54 ++++++++++++------- 2 files changed, 56 insertions(+), 29 deletions(-) diff --git a/benchmarks/wrappers/cloudflare/python/handler.py b/benchmarks/wrappers/cloudflare/python/handler.py index 8e37efee4..9d220a043 100644 --- a/benchmarks/wrappers/cloudflare/python/handler.py +++ b/benchmarks/wrappers/cloudflare/python/handler.py @@ -1,5 +1,6 @@ import datetime, io, json, os, uuid, sys +import traceback from workers import WorkerEntrypoint, Response ## sys.path.append(os.path.join(os.path.dirname(__file__), '.python_packages/lib/site-packages')) @@ -18,13 +19,21 @@ class Default(WorkerEntrypoint): async def fetch(self, request, env): + try: + return await self.fetch2(request, env) + except Exception as e: + t = traceback.format_exc() + print(t) + return Response(t) + + async def fetch2(self, request, env): if "favicon" in request.url: return Response("None") - + req_text = await request.text() - + event = json.loads(req_text) if len(req_text) > 0 else {} - print(event) - + ## print(event) + # dirty url parameters parsing, for testing tmp = request.url.split("?") if len(tmp) > 1: @@ -37,11 +46,11 @@ async def fetch(self, request, env): event[param[0]] = param[1] except IndexError: event[param[0]] = None - - - - - + + + + + ## we might need more data in self.env to know this ID req_id = 0 @@ -52,13 +61,13 @@ async def fetch(self, request, env): event['income-timestamp'] = income_timestamp from function import storage - + storage.storage.init_instance(self) print("event:", event) from function import function - ret = function.handler(event) + ret = await function.handler(event) log_data = { 'output': ret['result'] diff --git a/benchmarks/wrappers/cloudflare/python/storage.py b/benchmarks/wrappers/cloudflare/python/storage.py index de2a4642e..47fd0395e 100644 --- a/benchmarks/wrappers/cloudflare/python/storage.py +++ b/benchmarks/wrappers/cloudflare/python/storage.py @@ -1,6 +1,9 @@ import io import os import uuid +import asyncio +from pyodide.ffi import to_js, jsnull +from pyodide.webloop import WebLoop from workers import WorkerEntrypoint @@ -18,7 +21,6 @@ """ class storage: instance = None - handle = None @staticmethod def unique_name(name): @@ -28,51 +30,67 @@ def unique_name(name): extension=extension, random=str(uuid.uuid4()).split('-')[0] ) + def get_bucket(self, bucket): + return getattr(self.entry_env, bucket) @staticmethod def init_instance(entry: WorkerEntrypoint): storage.instance = storage() - storage.instance.handle = entry.env.R2 + storage.instance.entry_env = entry.env storage.instance.written_files = set() + ## should think of a way to del the runner at program end + storage.instance.runner = asyncio.Runner(loop_factory=None) - def upload(self, __bucket, key, filepath): + def upload(self, bucket, key, filepath): if filepath in self.written_files: filepath = "/tmp" + os.path.abspath(filepath) with open(filepath, "rb") as f: - self.upload_stream(__bucket, key, f.read()) - return + unique_key = self.upload_stream(bucket, key, f.read()) + return unique_key - def download(self, __bucket, key, filepath): - data = self.download_stream(__bucket, key) + def download(self, bucket, key, filepath): + data = self.download_stream(bucket, key) # should only allow writes to tmp dir. so do have to edit the filepath here? real_fp = filepath if not filepath.startswith("/tmp"): real_fp = "/tmp" + os.path.abspath(filepath) - + self.written_files.append(filepath) with open(real_fp, "wb") as f: f.write(data) return - def download_directory(self, __bucket, prefix, out_path): - print(self.handle, type(self.handle)) - list_res = self.handle.list(prefix = prefix) ## gives only first 1000? + def download_directory(self, bucket, prefix, out_path): + bobj = self.get_bucket(bucket) + list_res = self.runner,run(bobj.list(prefix = prefix)) ## gives only first 1000? for obj in list_res.objects: file_name = obj.key path_to_file = os.path.dirname(file_name) os.makedirs(os.path.join(path, path_to_file), exist_ok=True) - self.download(__bucket, file_name, os.path.join(out_path, file_name)) + self.download(bucket, file_name, os.path.join(out_path, file_name)) return - def upload_stream(self, __bucket, key, data): + def upload_stream(self, bucket, key, data): + return self.runner.run(selfaupload_stream(bucket, key, data)) + + async def aupload_stream(self, bucket, key, data): unique_key = storage.unique_name(key) - put_res = self.handle.put(unique_key, data) + data_js = to_js(data) + bobj = self.get_bucket(bucket) + put_res = await bobj.put(unique_key, data_js) + ##print(put_res) return unique_key - def download_stream(self, __bucket, key): - get_res = self.handle.get(key) - assert get_res is not None - data = get_res.text() + def download_stream(self, bucket, key): + return self.runner.run(self.adownload_stream(bucket, key)) + + async def adownload_stream(self, bucket, key): + bobj = self.get_bucket(bucket) + get_res = bobj.get(key) + if get_res == jsnull: + print("key not stored in bucket") + return b'' + data = await get_res.text() return data def get_instance(): From 556d799179fe63f2d4d1af7cb34db94a39b24381 Mon Sep 17 00:00:00 2001 From: "ldzgch (MacOS)" Date: Sun, 16 Nov 2025 16:49:43 +0100 Subject: [PATCH 15/69] dynamically add async to benchmark function *shrug* --- .../wrappers/cloudflare/python/handler.py | 54 +++++++++++++++++-- .../wrappers/cloudflare/python/storage.py | 32 +++++------ 2 files changed, 63 insertions(+), 23 deletions(-) diff --git a/benchmarks/wrappers/cloudflare/python/handler.py b/benchmarks/wrappers/cloudflare/python/handler.py index 9d220a043..7d1111792 100644 --- a/benchmarks/wrappers/cloudflare/python/handler.py +++ b/benchmarks/wrappers/cloudflare/python/handler.py @@ -1,5 +1,5 @@ -import datetime, io, json, os, uuid, sys - +import datetime, io, json, os, uuid, sys, ast +import importlib.util import traceback from workers import WorkerEntrypoint, Response @@ -17,6 +17,52 @@ """ + +def import_from_path(module_name, file_path): + spec = importlib.util.spec_from_file_location(module_name, file_path) + module = importlib.util.module_from_spec(spec) + sys.modules[module_name] = module + spec.loader.exec_module(module) + return module + + +working_dir = os.path.dirname(__file__) + +class MakeAsync(ast.NodeTransformer): + def visit_FunctionDef(self, node): + if node.name != "handler": + return node + return ast.AsyncFunctionDef( + name=node.name, + args=node.args, + body=node.body, + decorator_list=node.decorator_list, + returns=node.returns, + type_params=node.type_params) + +class AddAwait(ast.NodeTransformer): + to_find = ["upload_stream", "download_stream", "upload", "download", "download_directory"] + + def visit_Call(self, node): + if isinstance(node.func, ast.Attribute) and node.func.attr in self.to_find: + #print(ast.dump(node.func, indent=2)) + return ast.Await(value=node) + + return node + +def make_benchmark_func(): + with open(working_dir +"/function/function.py") as f: + module = ast.parse(f.read()) + module = ast.fix_missing_locations(MakeAsync().visit(module)) + module = ast.fix_missing_locations(AddAwait().visit(module)) + new_source = ast.unparse(module) + print("new_source:") + print(new_source) + print() + with open("/tmp/function.py", "w") as wf: + wf.write(new_source) + + class Default(WorkerEntrypoint): async def fetch(self, request, env): try: @@ -66,8 +112,10 @@ async def fetch2(self, request, env): print("event:", event) - from function import function + make_benchmark_func() + function = import_from_path("function.function", "/tmp/function.py") ret = await function.handler(event) + log_data = { 'output': ret['result'] diff --git a/benchmarks/wrappers/cloudflare/python/storage.py b/benchmarks/wrappers/cloudflare/python/storage.py index 47fd0395e..dccf2e1d7 100644 --- a/benchmarks/wrappers/cloudflare/python/storage.py +++ b/benchmarks/wrappers/cloudflare/python/storage.py @@ -38,18 +38,16 @@ def init_instance(entry: WorkerEntrypoint): storage.instance = storage() storage.instance.entry_env = entry.env storage.instance.written_files = set() - ## should think of a way to del the runner at program end - storage.instance.runner = asyncio.Runner(loop_factory=None) - def upload(self, bucket, key, filepath): + async def upload(self, bucket, key, filepath): if filepath in self.written_files: filepath = "/tmp" + os.path.abspath(filepath) with open(filepath, "rb") as f: - unique_key = self.upload_stream(bucket, key, f.read()) + unique_key = await self.upload_stream(bucket, key, f.read()) return unique_key - def download(self, bucket, key, filepath): - data = self.download_stream(bucket, key) + async def download(self, bucket, key, filepath): + data = await self.download_stream(bucket, key) # should only allow writes to tmp dir. so do have to edit the filepath here? real_fp = filepath if not filepath.startswith("/tmp"): @@ -60,20 +58,17 @@ def download(self, bucket, key, filepath): f.write(data) return - def download_directory(self, bucket, prefix, out_path): + async def download_directory(self, bucket, prefix, out_path): bobj = self.get_bucket(bucket) - list_res = self.runner,run(bobj.list(prefix = prefix)) ## gives only first 1000? + list_res = await bobj.list(prefix = prefix) ## gives only first 1000? for obj in list_res.objects: - file_name = obj.key + file_nameß = obj.key path_to_file = os.path.dirname(file_name) os.makedirs(os.path.join(path, path_to_file), exist_ok=True) - self.download(bucket, file_name, os.path.join(out_path, file_name)) + await self.download(bucket, file_name, os.path.join(out_path, file_name)) return - def upload_stream(self, bucket, key, data): - return self.runner.run(selfaupload_stream(bucket, key, data)) - - async def aupload_stream(self, bucket, key, data): + async def upload_stream(self, bucket, key, data): unique_key = storage.unique_name(key) data_js = to_js(data) bobj = self.get_bucket(bucket) @@ -81,16 +76,13 @@ async def aupload_stream(self, bucket, key, data): ##print(put_res) return unique_key - def download_stream(self, bucket, key): - return self.runner.run(self.adownload_stream(bucket, key)) - - async def adownload_stream(self, bucket, key): + async def download_stream(self, bucket, key): bobj = self.get_bucket(bucket) - get_res = bobj.get(key) + get_res = await bobj.get(key) if get_res == jsnull: print("key not stored in bucket") return b'' - data = await get_res.text() + data = await get_res.bytes() return data def get_instance(): From 93c8a73160ee2ebce0e1ccde8e4e8df2304b18eb Mon Sep 17 00:00:00 2001 From: ldzgch Date: Sun, 16 Nov 2025 21:27:20 +0100 Subject: [PATCH 16/69] nosql updates --- .../wrappers/cloudflare/python/handler.py | 14 ++++- .../wrappers/cloudflare/python/nosql.py | 60 ++++++++++++++----- 2 files changed, 57 insertions(+), 17 deletions(-) diff --git a/benchmarks/wrappers/cloudflare/python/handler.py b/benchmarks/wrappers/cloudflare/python/handler.py index 7d1111792..5ead82496 100644 --- a/benchmarks/wrappers/cloudflare/python/handler.py +++ b/benchmarks/wrappers/cloudflare/python/handler.py @@ -56,9 +56,9 @@ def make_benchmark_func(): module = ast.fix_missing_locations(MakeAsync().visit(module)) module = ast.fix_missing_locations(AddAwait().visit(module)) new_source = ast.unparse(module) - print("new_source:") - print(new_source) - print() + ##print("new_source:") + ##print(new_source) + ##print() with open("/tmp/function.py", "w") as wf: wf.write(new_source) @@ -106,10 +106,18 @@ async def fetch2(self, request, env): event['request-id'] = req_id event['income-timestamp'] = income_timestamp + + from function import storage storage.storage.init_instance(self) + from function import nosql + + nosql.nosql.init_instance(self) + + + print("event:", event) make_benchmark_func() diff --git a/benchmarks/wrappers/cloudflare/python/nosql.py b/benchmarks/wrappers/cloudflare/python/nosql.py index 75bf0f09d..48b523675 100644 --- a/benchmarks/wrappers/cloudflare/python/nosql.py +++ b/benchmarks/wrappers/cloudflare/python/nosql.py @@ -1,54 +1,86 @@ from typing import List, Optional, Tuple - +import json +from pyodide.ffi import to_js +from workers import WorkerEntrypoint class nosql: instance: Optional["nosql"] = None @staticmethod - def init_instance(entry: WorkerEntryPoint): + def init_instance(entry: WorkerEntrypoint): nosql.instance = nosql() nosql.instance.env = entry.env - def insert( + def key_maker(self, key1, key2): + return f"({key1[0]},{str(key1[1])})+({key2[0]},{key2[1]})" + + def key_maker_partial(self, key1, key2): + return f"({key1[0]},{str(key1[1])})+({key2[0]}" + + def get_table(self, table_name): + return getattr(self.env, (table_name)) + + async def insert( self, table_name: str, primary_key: Tuple[str, str], secondary_key: Tuple[str, str], data: dict, ): - put_res = await self.env.getattr(table_name).put(primary_key, data) + put_res = await self.get_table(table_name).put( + self.key_maker(primary_key, secondary_key), + json.dumps(data)) return - def update( + async def update( self, table_name: str, primary_key: Tuple[str, str], secondary_key: Tuple[str, str], data: dict, ): - await self.env.getattr(table_name).put(primary_key, data) + put_res = await self.get_table(table_name).put( + self.key_maker(primary_key, secondary_key), + data) return - def get( + async def get( self, table_name: str, primary_key: Tuple[str, str], secondary_key: Tuple[str, str] ) -> Optional[dict]: - get_res = await self.env.getattr(table_name).get(primary_key) - return get_res.json() + get_res = await self.get_table(table_name).get(self.key_maker(primary_key, secondary_key)) + return get_res """ This query must involve partition key - it does not scan across partitions. """ - def query( + async def query( self, table_name: str, primary_key: Tuple[str, str], secondary_key_name: str ) -> List[dict]: - list_res = await self.env.getattr(table_name).list() + _options = {"prefix" : self.key_maker_partial(primary_key, (secondary_key_name,) )} + list_res = await self.get_table(table_name).list(options=_options) - return + keys = [] + for key in list_res.keys: + keys.append(key.name) + print("keys", keys) + assert len(keys) <= 100 + + + # todo: please use bulk sometime (it didn't work when i tried it) + res = [] + for key in keys: + + get_res = await self.get_table(table_name).get(key) + get_res = get_res.replace("\'", "\"") + print("gr", get_res) + + res.append(json.loads(get_res)) + return res - def delete(self, table_name: str, primary_key: Tuple[str, str], secondary_key: Tuple[str, str]): - self.env.getattr(table_name).delete(primary_key) + async def delete(self, table_name: str, primary_key: Tuple[str, str], secondary_key: Tuple[str, str]): + self.get_table(table_name).delete(self.key_maker(primary_key, secondary_key)) return From e17982f9a1d77fcef06849f494e3a1b64b8ca908 Mon Sep 17 00:00:00 2001 From: MisterMM23 Date: Mon, 17 Nov 2025 11:54:38 +0100 Subject: [PATCH 17/69] idea for cicrumvention of asyncio When running the handler as a thread and then awaiting said thread (asyncio.to_thread), we can run asyncio.run() in the subsequent call stack. --- benchmarks/wrappers/cloudflare/python/handler.py | 7 +++++-- benchmarks/wrappers/cloudflare/python/storage.py | 4 ++-- 2 files changed, 7 insertions(+), 4 deletions(-) diff --git a/benchmarks/wrappers/cloudflare/python/handler.py b/benchmarks/wrappers/cloudflare/python/handler.py index 5ead82496..8ffe6f448 100644 --- a/benchmarks/wrappers/cloudflare/python/handler.py +++ b/benchmarks/wrappers/cloudflare/python/handler.py @@ -1,4 +1,5 @@ import datetime, io, json, os, uuid, sys, ast +import asyncio import importlib.util import traceback from workers import WorkerEntrypoint, Response @@ -122,8 +123,10 @@ async def fetch2(self, request, env): make_benchmark_func() function = import_from_path("function.function", "/tmp/function.py") - ret = await function.handler(event) - + async def run_handler(): + return function.handler(event) + ret = await asyncio.to_thread(run_handler()) + log_data = { 'output': ret['result'] diff --git a/benchmarks/wrappers/cloudflare/python/storage.py b/benchmarks/wrappers/cloudflare/python/storage.py index dccf2e1d7..75bb197b3 100644 --- a/benchmarks/wrappers/cloudflare/python/storage.py +++ b/benchmarks/wrappers/cloudflare/python/storage.py @@ -46,8 +46,8 @@ async def upload(self, bucket, key, filepath): unique_key = await self.upload_stream(bucket, key, f.read()) return unique_key - async def download(self, bucket, key, filepath): - data = await self.download_stream(bucket, key) + def download(self, bucket, key, filepath): + data = asyncio.run(self.download_stream(bucket, key)) # should only allow writes to tmp dir. so do have to edit the filepath here? real_fp = filepath if not filepath.startswith("/tmp"): From 214c947d9814afb121af076ce871a8b7ef62b897 Mon Sep 17 00:00:00 2001 From: "ldzgch (MacOS)" Date: Mon, 17 Nov 2025 14:12:12 +0100 Subject: [PATCH 18/69] wrappers - run_sync for storage.py --- .../wrappers/cloudflare/python/handler.py | 11 ++++---- .../wrappers/cloudflare/python/storage.py | 26 ++++++++++++------- 2 files changed, 22 insertions(+), 15 deletions(-) diff --git a/benchmarks/wrappers/cloudflare/python/handler.py b/benchmarks/wrappers/cloudflare/python/handler.py index 8ffe6f448..60497331c 100644 --- a/benchmarks/wrappers/cloudflare/python/handler.py +++ b/benchmarks/wrappers/cloudflare/python/handler.py @@ -121,12 +121,13 @@ async def fetch2(self, request, env): print("event:", event) - make_benchmark_func() - function = import_from_path("function.function", "/tmp/function.py") - async def run_handler(): - return function.handler(event) - ret = await asyncio.to_thread(run_handler()) +## make_benchmark_func() +## function = import_from_path("function.function", "/tmp/function.py") + + from function import function + + ret = function.handler(event) log_data = { 'output': ret['result'] diff --git a/benchmarks/wrappers/cloudflare/python/storage.py b/benchmarks/wrappers/cloudflare/python/storage.py index 75bb197b3..3f6ebc31d 100644 --- a/benchmarks/wrappers/cloudflare/python/storage.py +++ b/benchmarks/wrappers/cloudflare/python/storage.py @@ -2,7 +2,7 @@ import os import uuid import asyncio -from pyodide.ffi import to_js, jsnull +from pyodide.ffi import to_js, jsnull, run_sync from pyodide.webloop import WebLoop from workers import WorkerEntrypoint @@ -38,16 +38,16 @@ def init_instance(entry: WorkerEntrypoint): storage.instance = storage() storage.instance.entry_env = entry.env storage.instance.written_files = set() - - async def upload(self, bucket, key, filepath): + + def upload(self, bucket, key, filepath): if filepath in self.written_files: filepath = "/tmp" + os.path.abspath(filepath) with open(filepath, "rb") as f: - unique_key = await self.upload_stream(bucket, key, f.read()) + unique_key = self.upload_stream(bucket, key, f.read()) return unique_key def download(self, bucket, key, filepath): - data = asyncio.run(self.download_stream(bucket, key)) + data = self.download_stream(bucket, key) # should only allow writes to tmp dir. so do have to edit the filepath here? real_fp = filepath if not filepath.startswith("/tmp"): @@ -58,17 +58,20 @@ def download(self, bucket, key, filepath): f.write(data) return - async def download_directory(self, bucket, prefix, out_path): + def download_directory(self, bucket, prefix, out_path): bobj = self.get_bucket(bucket) - list_res = await bobj.list(prefix = prefix) ## gives only first 1000? + list_res = run_sync(bobj.list(prefix = prefix)) ## gives only first 1000? for obj in list_res.objects: file_nameß = obj.key path_to_file = os.path.dirname(file_name) os.makedirs(os.path.join(path, path_to_file), exist_ok=True) - await self.download(bucket, file_name, os.path.join(out_path, file_name)) + self.download(bucket, file_name, os.path.join(out_path, file_name)) return - async def upload_stream(self, bucket, key, data): + def upload_stream(self, bucket, key, data): + return run_sync(self.aupload_stream(bucket, key, data)) + + async def aupload_stream(self, bucket, key, data): unique_key = storage.unique_name(key) data_js = to_js(data) bobj = self.get_bucket(bucket) @@ -76,7 +79,10 @@ async def upload_stream(self, bucket, key, data): ##print(put_res) return unique_key - async def download_stream(self, bucket, key): + def download_stream(self, bucket, key): + return run_sync(self.adownload_stream(bucket, key)) + + async def adownload_stream(self, bucket, key): bobj = self.get_bucket(bucket) get_res = await bobj.get(key) if get_res == jsnull: From b8f7c5cbe04f91211a08dd59172bad99fff6f9ae Mon Sep 17 00:00:00 2001 From: ldzgch Date: Wed, 19 Nov 2025 11:34:42 +0100 Subject: [PATCH 19/69] nosql wrapper uses run_sync --- .../wrappers/cloudflare/python/nosql.py | 43 +++++++++++-------- 1 file changed, 25 insertions(+), 18 deletions(-) diff --git a/benchmarks/wrappers/cloudflare/python/nosql.py b/benchmarks/wrappers/cloudflare/python/nosql.py index 48b523675..bb1f94633 100644 --- a/benchmarks/wrappers/cloudflare/python/nosql.py +++ b/benchmarks/wrappers/cloudflare/python/nosql.py @@ -1,6 +1,6 @@ from typing import List, Optional, Tuple import json -from pyodide.ffi import to_js +from pyodide.ffi import to_js, run_sync from workers import WorkerEntrypoint class nosql: @@ -21,50 +21,57 @@ def key_maker_partial(self, key1, key2): def get_table(self, table_name): return getattr(self.env, (table_name)) - async def insert( + def insert( self, table_name: str, primary_key: Tuple[str, str], secondary_key: Tuple[str, str], data: dict, ): - put_res = await self.get_table(table_name).put( - self.key_maker(primary_key, secondary_key), - json.dumps(data)) + put_res = ( + run_sync(self.get_table(table_name).put( + self.key_maker(primary_key, secondary_key), + json.dumps(data)) + )) return - async def update( + def update( self, table_name: str, primary_key: Tuple[str, str], secondary_key: Tuple[str, str], data: dict, ): - put_res = await self.get_table(table_name).put( - self.key_maker(primary_key, secondary_key), - data) + put_res = run_sync( + self.get_table(table_name).put( + self.key_maker(primary_key, secondary_key), + json.dumps(data) + )) return - async def get( + def get( self, table_name: str, primary_key: Tuple[str, str], secondary_key: Tuple[str, str] ) -> Optional[dict]: - get_res = await self.get_table(table_name).get(self.key_maker(primary_key, secondary_key)) + get_res = run_sync( + self.get_table(table_name).get( + self.key_maker(primary_key, secondary_key) + )) return get_res """ This query must involve partition key - it does not scan across partitions. """ - async def query( + def query( self, table_name: str, primary_key: Tuple[str, str], secondary_key_name: str ) -> List[dict]: _options = {"prefix" : self.key_maker_partial(primary_key, (secondary_key_name,) )} - list_res = await self.get_table(table_name).list(options=_options) + list_res = run_sync(self.get_table(table_name).list(options=_options)) keys = [] for key in list_res.keys: keys.append(key.name) - print("keys", keys) + ##print("keys", keys) assert len(keys) <= 100 @@ -72,15 +79,15 @@ async def query( res = [] for key in keys: - get_res = await self.get_table(table_name).get(key) + get_res = run_sync(self.get_table(table_name).get(key)) get_res = get_res.replace("\'", "\"") - print("gr", get_res) + ##print("gr", get_res) res.append(json.loads(get_res)) return res - async def delete(self, table_name: str, primary_key: Tuple[str, str], secondary_key: Tuple[str, str]): - self.get_table(table_name).delete(self.key_maker(primary_key, secondary_key)) + def delete(self, table_name: str, primary_key: Tuple[str, str], secondary_key: Tuple[str, str]): + run_sync(self.get_table(table_name).delete(self.key_maker(primary_key, secondary_key))) return From dba29926c8c0390d14b613008e3ddb9ce89f6d6a Mon Sep 17 00:00:00 2001 From: laurin Date: Wed, 19 Nov 2025 19:42:57 +0100 Subject: [PATCH 20/69] cloudflare nodejs wrapper without r2 as fs polyfill, just node_compat modules --- .../wrappers/cloudflare/nodejs/build.js | 161 ++++++++++ .../wrappers/cloudflare/nodejs/fs-polyfill.js | 289 ------------------ .../wrappers/cloudflare/nodejs/handler.js | 36 --- .../cloudflare/nodejs/request-polyfill.js | 96 ------ configs/systems.json | 3 +- experiments.json | 76 +++++ package-lock.json | 6 + package.json | 1 + sebs/cloudflare/cloudflare.py | 82 ++++- test-fs.js | 7 + 10 files changed, 321 insertions(+), 436 deletions(-) create mode 100644 benchmarks/wrappers/cloudflare/nodejs/build.js delete mode 100644 benchmarks/wrappers/cloudflare/nodejs/fs-polyfill.js delete mode 100644 benchmarks/wrappers/cloudflare/nodejs/request-polyfill.js create mode 100644 experiments.json create mode 100644 package-lock.json create mode 100644 package.json create mode 100644 test-fs.js diff --git a/benchmarks/wrappers/cloudflare/nodejs/build.js b/benchmarks/wrappers/cloudflare/nodejs/build.js new file mode 100644 index 000000000..a9d7ebcb0 --- /dev/null +++ b/benchmarks/wrappers/cloudflare/nodejs/build.js @@ -0,0 +1,161 @@ +const { build } = require('esbuild'); +const fs = require('fs'); +const { join, extname, dirname, relative } = require('path'); + +function getAllFiles(dir, fileList = []) { + const files = fs.readdirSync(dir, { withFileTypes: true }); + for (const file of files) { + const filePath = join(dir, file.name); + if (file.isDirectory()) { + if (file.name !== 'node_modules' && + file.name !== 'test' && + file.name !== 'tests' && + file.name !== '__tests__' && + file.name !== 'dist' && + !file.name.startsWith('.')) { + getAllFiles(filePath, fileList); + } + } else { + if (!file.name.includes('.test.') && + !file.name.includes('.spec.') && + file.name !== 'build.js' && + file.name !== 'wrangler.toml') { + fileList.push(filePath); + } + } + } + return fileList; +} + +function copyFile(src, dest) { + const destDir = dirname(dest); + if (!fs.existsSync(destDir)) { + fs.mkdirSync(destDir, { recursive: true }); + } + fs.copyFileSync(src, dest); +} + +const nodeBuiltinsPlugin = { + name: 'node-builtins-external', + setup(build) { + // Keep node: prefixed modules external + build.onResolve({ filter: /^node:/ }, (args) => { + return { path: args.path, external: true }; + }); + + // Map bare node built-in names to node: versions and keep external + build.onResolve({ filter: /^(fs|querystring|path|crypto|stream|buffer|util|events|http|https|net|tls|zlib|os|child_process|tty|assert|url)$/ }, (args) => { + return { path: 'node:' + args.path, external: true }; + }); + } +}; + +async function customBuild() { + const srcDir = './'; + const outDir = './dist'; + + if (fs.existsSync(outDir)) { + fs.rmSync(outDir, { recursive: true }); + } + fs.mkdirSync(outDir, { recursive: true }); + + try { + const files = getAllFiles(srcDir); + + const jsFiles = files.filter(f => + ['.js', '.ts', '.jsx', '.tsx'].includes(extname(f)) + ); + + const otherFiles = files.filter(f => + !['.js', '.ts', '.jsx', '.tsx'].includes(extname(f)) + ); + + console.log('Building JS files:', jsFiles); + + if (jsFiles.length > 0) { + await build({ + entryPoints: jsFiles, + bundle: true, + format: 'esm', + outdir: outDir, + outbase: srcDir, + platform: 'neutral', + target: 'es2020', + sourcemap: true, + allowOverwrite: true, + plugins: [nodeBuiltinsPlugin], + define: { + 'process.env.NODE_ENV': '"production"', + 'global': 'globalThis', + '__dirname': '"/bundle"' + }, + mainFields: ['module', 'main'], + treeShaking: true, + }); + + // POST-PROCESS: Replace dynamic requires with static imports + console.log('Post-processing to fix node: module imports...'); + + for (const jsFile of jsFiles) { + const outPath = join(outDir, relative(srcDir, jsFile)); + + if (fs.existsSync(outPath)) { + let content = fs.readFileSync(outPath, 'utf-8'); + + // Find all node: modules being dynamically required + const nodeModules = new Set(); + const requireRegex = /__require\d*\("(node:[^"]+)"\)/g; + let match; + while ((match = requireRegex.exec(content)) !== null) { + nodeModules.add(match[1]); + } + + if (nodeModules.size > 0) { + // Generate static imports at the top + let imports = ''; + const mapping = {}; + let i = 0; + for (const mod of nodeModules) { + const varName = `__node_${mod.replace('node:', '').replace(/[^a-z0-9]/gi, '_')}_${i++}`; + imports += `import * as ${varName} from '${mod}';\n`; + mapping[mod] = varName; + } + + // Add cache object + imports += '\nconst __node_cache = {\n'; + for (const [mod, varName] of Object.entries(mapping)) { + imports += ` '${mod}': ${varName},\n`; + } + imports += '};\n\n'; + + // Replace all __require calls with cache lookups + content = content.replace(/__require(\d*)\("(node:[^"]+)"\)/g, (match, num, mod) => { + return `__node_cache['${mod}']`; + }); + + // Prepend imports to the file + content = imports + content; + + fs.writeFileSync(outPath, content, 'utf-8'); + console.log(`✓ Fixed ${nodeModules.size} node: imports in ${relative(srcDir, jsFile)}`); + } + } + } + } + + // Copy non-JS files (templates, etc.) + for (const file of otherFiles) { + const relativePath = relative(srcDir, file); + const destPath = join(outDir, relativePath); + copyFile(file, destPath); + console.log(`Copied: ${relativePath}`); + } + + console.log('✓ Build completed successfully'); + } catch (error) { + console.error('Build failed:', error); + process.exit(1); + } +} + +customBuild(); \ No newline at end of file diff --git a/benchmarks/wrappers/cloudflare/nodejs/fs-polyfill.js b/benchmarks/wrappers/cloudflare/nodejs/fs-polyfill.js deleted file mode 100644 index 747cc15a9..000000000 --- a/benchmarks/wrappers/cloudflare/nodejs/fs-polyfill.js +++ /dev/null @@ -1,289 +0,0 @@ -import * as nodeFs from 'node:fs'; -import { Writable } from 'node:stream'; - -// Global cache for files written/read during this request -// This allows sync operations to work within a single request context -if (!globalThis.FS_CACHE) { - globalThis.FS_CACHE = new Map(); -} - -/** - * Normalize a file path for R2 - */ -function normalizePath(path) { - let normalizedPath = path.replace(/^\.?\//, '').replace(/^tmp\//, ''); - - if (globalThis.BENCHMARK_NAME && !normalizedPath.startsWith(globalThis.BENCHMARK_NAME + '/')) { - normalizedPath = globalThis.BENCHMARK_NAME + '/' + normalizedPath; - } - - return normalizedPath; -} - -/** - * Read a file from R2 bucket - * @param {string} path - File path in R2 bucket (e.g., 'templates/index.html') - * @param {string|object|function} encoding - Encoding or options or callback - * @param {function} callback - Callback function (err, data) - */ -export async function readFile(path, encoding, callback) { - // Handle overloaded arguments: readFile(path, callback) or readFile(path, encoding, callback) - let actualEncoding = 'utf8'; - let actualCallback = callback; - - if (typeof encoding === 'function') { - actualCallback = encoding; - actualEncoding = 'utf8'; - } else if (typeof encoding === 'string') { - actualEncoding = encoding; - } else if (typeof encoding === 'object' && encoding !== null && encoding.encoding) { - actualEncoding = encoding.encoding; - } - - try { - // Check if R2 bucket is available - if (!globalThis.R2_BUCKET) { - throw new Error('R2 bucket not available. Ensure R2 binding is configured in wrangler.toml'); - } - - const normalizedPath = normalizePath(path); - - // Get object from R2 - const object = await globalThis.R2_BUCKET.get(normalizedPath); - - if (!object) { - throw new Error(`ENOENT: no such file or directory, open '${path}' (R2 key: ${normalizedPath})`); - } - - // Read the content - let content; - if (actualEncoding === 'utf8' || actualEncoding === 'utf-8') { - content = await object.text(); - } else if (actualEncoding === 'buffer' || actualEncoding === null) { - const arrayBuffer = await object.arrayBuffer(); - content = Buffer.from(arrayBuffer); - } else { - // For other encodings, get text and let caller handle conversion - content = await object.text(); - } - - // Store in cache for potential synchronous access - if (globalThis.FS_CACHE) { - globalThis.FS_CACHE.set(normalizedPath, content); - } - - if (actualCallback) { - actualCallback(null, content); - } - return content; - } catch (err) { - if (actualCallback) { - actualCallback(err, null); - } else { - throw err; - } - } -} - -/** - * Synchronous version of readFile - * Reads from cache if available, otherwise throws error - */ -export function readFileSync(path, encoding) { - const normalizedPath = normalizePath(path); - - // Check cache first - if (globalThis.FS_CACHE && globalThis.FS_CACHE.has(normalizedPath)) { - const data = globalThis.FS_CACHE.get(normalizedPath); - - if (encoding === 'utf8' || encoding === 'utf-8') { - return typeof data === 'string' ? data : Buffer.from(data).toString('utf8'); - } else if (encoding === null || encoding === 'buffer') { - return Buffer.isBuffer(data) ? data : Buffer.from(data); - } - return data; - } - - // File not in cache - in Workers we can't do sync I/O - throw new Error(`ENOENT: no such file or directory, open '${path}'. File not in cache. In Cloudflare Workers, files must be written in the same request before being read synchronously.`); -} - -/** - * Check if a file exists in R2 - */ -export async function exists(path, callback) { - try { - if (!globalThis.R2_BUCKET) { - if (callback) callback(false); - return false; - } - - let normalizedPath = path.replace(/^\.?\//, ''); - - if (globalThis.BENCHMARK_NAME && !normalizedPath.startsWith(globalThis.BENCHMARK_NAME + '/')) { - normalizedPath = globalThis.BENCHMARK_NAME + '/' + normalizedPath; - } - - const object = await globalThis.R2_BUCKET.head(normalizedPath); - - const result = object !== null; - if (callback) callback(result); - return result; - } catch (err) { - if (callback) callback(false); - return false; - } -} - -/** - * Synchronous version of exists - * Checks cache for file existence - */ -export function existsSync(path) { - if (!globalThis.R2_BUCKET) { - return false; - } - - const normalizedPath = normalizePath(path); - - // Check if file is in cache - if (globalThis.FS_CACHE && globalThis.FS_CACHE.has(normalizedPath)) { - return true; - } - - // File not in cache - return false; -} - -/** - * Get file stats from R2 - */ -export async function stat(path, callback) { - try { - if (!globalThis.R2_BUCKET) { - throw new Error('R2 bucket not available'); - } - - let normalizedPath = path.replace(/^\.?\//, ''); - - if (globalThis.BENCHMARK_NAME && !normalizedPath.startsWith(globalThis.BENCHMARK_NAME + '/')) { - normalizedPath = globalThis.BENCHMARK_NAME + '/' + normalizedPath; - } - - const object = await globalThis.R2_BUCKET.head(normalizedPath); - - if (!object) { - throw new Error(`ENOENT: no such file or directory, stat '${path}'`); - } - - const stats = { - size: object.size, - isFile: () => true, - isDirectory: () => false, - mtime: object.uploaded, - }; - - if (callback) callback(null, stats); - return stats; - } catch (err) { - if (callback) callback(err, null); - else throw err; - } -} - -/** - * Create a write stream (memory-buffered, writes to R2 on close) - */ -export function createWriteStream(path, options) { - const chunks = []; - - const stream = new Writable({ - write(chunk, encoding, callback) { - chunks.push(chunk); - callback(); - }, - final(callback) { - // Write to R2 when stream is closed - (async () => { - try { - if (!globalThis.R2_BUCKET) { - throw new Error('R2 bucket not available'); - } - - const normalizedPath = normalizePath(path); - - const buffer = Buffer.concat(chunks); - - // Store in cache for synchronous access - if (globalThis.FS_CACHE) { - globalThis.FS_CACHE.set(normalizedPath, buffer); - } - - await globalThis.R2_BUCKET.put(normalizedPath, buffer); - callback(); - } catch (err) { - callback(err); - } - })(); - } - }); - - return stream; -} - -/** - * Write file to R2 - */ -export async function writeFile(path, data, options, callback) { - let actualCallback = callback; - let actualOptions = options; - - if (typeof options === 'function') { - actualCallback = options; - actualOptions = {}; - } - - try { - if (!globalThis.R2_BUCKET) { - throw new Error('R2 bucket not available'); - } - - let normalizedPath = path.replace(/^\.?\//, ''); - - if (globalThis.BENCHMARK_NAME && !normalizedPath.startsWith(globalThis.BENCHMARK_NAME + '/')) { - normalizedPath = globalThis.BENCHMARK_NAME + '/' + normalizedPath; - } - - await globalThis.R2_BUCKET.put(normalizedPath, data); - - if (actualCallback) actualCallback(null); - } catch (err) { - if (actualCallback) actualCallback(err); - else throw err; - } -} - -/** - * Synchronous write file to R2 - */ -export function writeFileSync(path, data, options) { - return new Promise((resolve, reject) => { - writeFile(path, data, options, (err) => { - if (err) reject(err); - else resolve(); - }); - }); -} - -// Export everything from node:fs (what's available), but override specific methods -export default { - ...nodeFs, - readFile, - readFileSync, - exists, - existsSync, - stat, - createWriteStream, - writeFile, - writeFileSync, -}; diff --git a/benchmarks/wrappers/cloudflare/nodejs/handler.js b/benchmarks/wrappers/cloudflare/nodejs/handler.js index 0b4a827c1..8baa646b3 100644 --- a/benchmarks/wrappers/cloudflare/nodejs/handler.js +++ b/benchmarks/wrappers/cloudflare/nodejs/handler.js @@ -1,35 +1,3 @@ -// Simple CommonJS polyfill for Cloudflare Workers -// This allows us to load CommonJS modules that use require() and module.exports -const moduleCache = {}; - -function createRequire(currentModule) { - return function require(modulePath) { - if (moduleCache[modulePath]) { - return moduleCache[modulePath].exports; - } - - // Create module object - const module = { exports: {} }; - moduleCache[modulePath] = module; - - // This is a placeholder - actual module loading would happen here - // For our use case, we'll manually register modules below - throw new Error(`Module ${modulePath} not found in polyfill cache`); - }; -} - -// Polyfill for __dirname and __filename if not available -if (typeof globalThis.__dirname === 'undefined') { - globalThis.__dirname = '.'; -} - -if (typeof globalThis.__filename === 'undefined') { - globalThis.__filename = './handler.js'; -} - -if (typeof globalThis.require === 'undefined') { - globalThis.require = createRequire(globalThis); -} export default { @@ -43,10 +11,6 @@ export default { globalThis.BENCHMARK_NAME = env.BENCHMARK_NAME; } - // Match behavior of the Python handler: parse body, parse URL params, - // set request-id and income timestamp, call the benchmark function, - // and return a JSON response with the same fields. - if (request.url.includes('favicon')) { return new Response('None'); } diff --git a/benchmarks/wrappers/cloudflare/nodejs/request-polyfill.js b/benchmarks/wrappers/cloudflare/nodejs/request-polyfill.js deleted file mode 100644 index 5b86d18c4..000000000 --- a/benchmarks/wrappers/cloudflare/nodejs/request-polyfill.js +++ /dev/null @@ -1,96 +0,0 @@ -/** - * Minimal request polyfill for Cloudflare Workers - * Provides a subset of the 'request' npm package API using fetch() - */ - -class RequestStream { - constructor(url, options = {}) { - this.url = url; - this.options = options; - this.pipeDestination = null; - } - - pipe(destination) { - this.pipeDestination = destination; - - // Start the fetch and pipe to destination - (async () => { - try { - const response = await fetch(this.url, this.options); - - if (!response.ok) { - this.pipeDestination.emit('error', new Error(`HTTP ${response.status}: ${response.statusText}`)); - return; - } - - // Read the response body and write to destination - const reader = response.body.getReader(); - - while (true) { - const { done, value } = await reader.read(); - - if (done) { - this.pipeDestination.end(); - break; - } - - // Write chunk to destination stream - if (!this.pipeDestination.write(value)) { - // Backpressure - wait for drain - await new Promise(resolve => { - this.pipeDestination.once('drain', resolve); - }); - } - } - } catch (error) { - if (this.pipeDestination) { - this.pipeDestination.emit('error', error); - } - } - })(); - - return this.pipeDestination; - } -} - -/** - * Main request function - creates a request stream - * @param {string|object} urlOrOptions - URL string or options object - * @param {object} options - Additional options if first param is URL - * @returns {RequestStream} - */ -function request(urlOrOptions, options) { - let url, opts; - - if (typeof urlOrOptions === 'string') { - url = urlOrOptions; - opts = options || {}; - } else { - url = urlOrOptions.url || urlOrOptions.uri; - opts = urlOrOptions; - } - - // Add default headers to avoid 403 errors from some servers - const defaultHeaders = { - 'User-Agent': 'Mozilla/5.0 (compatible; Cloudflare-Workers/1.0)', - 'Accept': '*/*', - }; - - const headers = { ...defaultHeaders, ...(opts.headers || {}) }; - - return new RequestStream(url, { - method: opts.method || 'GET', - headers: headers, - body: opts.body, - }); -} - -// Add common HTTP method shortcuts -request.get = (url, options) => request(url, { ...options, method: 'GET' }); -request.post = (url, options) => request(url, { ...options, method: 'POST' }); -request.put = (url, options) => request(url, { ...options, method: 'PUT' }); -request.delete = (url, options) => request(url, { ...options, method: 'DELETE' }); - -// Export as CommonJS module -module.exports = request; -module.exports.default = request; diff --git a/configs/systems.json b/configs/systems.json index 52eabb497..3eb79b648 100644 --- a/configs/systems.json +++ b/configs/systems.json @@ -462,8 +462,7 @@ "handler.js", "storage.js", "nosql.js", - "fs-polyfill.js", - "request-polyfill.js" + "build.js" ], "packages": { "uuid": "3.4.0" diff --git a/experiments.json b/experiments.json new file mode 100644 index 000000000..364c2e10e --- /dev/null +++ b/experiments.json @@ -0,0 +1,76 @@ +{ + "_invocations": { + "110-dynamic-html-nodejs-18": { + "0": { + "billing": { + "_billed_time": null, + "_gb_seconds": 0, + "_memory": null + }, + "output": { + "begin": 1763577748.037, + "compute_time": 0, + "container_id": "0", + "end": 1763577748.037, + "environ_container_id": "no_id", + "is_cold": false, + "is_cold_worker": false, + "request_id": "0", + "result": { + "output": "\n\n \n Randomly generated data.\n \n \n \n \n \n
\n

Welcome testname!

\n

Data generated at: 11/19/2025, 6:42:28 PM!

\n

Requested random numbers:

\n
    \n
  • 65
    • \n
  • 64
    • \n
  • 7
    • \n
  • 8
    • \n
  • 11
    • \n
  • 80
    • \n
  • 28
    • \n
  • 82
    • \n
  • 90
    • \n
  • 50
    • \n
\n
\n \n\n" + }, + "results_time": 0 + }, + "provider_times": { + "execution": 0, + "initialization": 0 + }, + "request_id": "0", + "stats": { + "cold_start": false, + "failure": false, + "memory_used": null + }, + "times": { + "benchmark": 0, + "client": 27866, + "client_begin": "2025-11-19 19:42:27.957743", + "client_end": "2025-11-19 19:42:27.985609", + "http_first_byte_return": 0.027801, + "http_startup": 0.015255, + "initialization": 0 + } + } + } + }, + "_metrics": {}, + "begin_time": 1763577747.723884, + "config": { + "deployment": { + "credentials": { + "account_id": "eaf7050d8d599d4ae7d925a6f0fd5ea4" + }, + "name": "cloudflare", + "region": "global", + "resources": { + "benchmarks": "sebs-benchmarks-cb6e76ec", + "resources_id": "cb6e76ec" + } + }, + "experiments": { + "architecture": "x64", + "container_deployment": false, + "download_results": false, + "experiments": {}, + "flags": {}, + "runtime": { + "language": "nodejs", + "version": "18" + }, + "update_code": true, + "update_storage": false + } + }, + "end_time": 1763577747.986338, + "result_bucket": null +} \ No newline at end of file diff --git a/package-lock.json b/package-lock.json new file mode 100644 index 000000000..e1fe15f56 --- /dev/null +++ b/package-lock.json @@ -0,0 +1,6 @@ +{ + "name": "serverless-benchmarks-cloudflare", + "lockfileVersion": 3, + "requires": true, + "packages": {} +} diff --git a/package.json b/package.json new file mode 100644 index 000000000..0967ef424 --- /dev/null +++ b/package.json @@ -0,0 +1 @@ +{} diff --git a/sebs/cloudflare/cloudflare.py b/sebs/cloudflare/cloudflare.py index d299be793..0632414a2 100644 --- a/sebs/cloudflare/cloudflare.py +++ b/sebs/cloudflare/cloudflare.py @@ -187,6 +187,7 @@ def _ensure_wrangler_installed(self): except subprocess.TimeoutExpired: raise RuntimeError("Wrangler version check timed out") + def _generate_wrangler_toml(self, worker_name: str, package_dir: str, language: str, account_id: str, benchmark_name: Optional[str] = None) -> str: """ Generate a wrangler.toml configuration file for the worker. @@ -201,26 +202,36 @@ def _generate_wrangler_toml(self, worker_name: str, package_dir: str, language: Returns: Path to the generated wrangler.toml file """ - main_file = "handler.js" if language == "nodejs" else "handler.py" - + main_file = "dist/handler.js" if language == "nodejs" else "handler.py" + + + # Build wrangler.toml content toml_content = f"""name = "{worker_name}" main = "{main_file}" -compatibility_date = "2024-11-01" +compatibility_date = "2025-11-18" account_id = "{account_id}" - """ - - - - # Add compatibility flags based on language + if language == "nodejs": - toml_content += """# Custom polyfills for fs and path that read from R2 bucket + toml_content += """# Use nodejs_compat for Node.js built-in support compatibility_flags = ["nodejs_compat"] -[alias] -"fs" = "./fs-polyfill" -"request" = "./request-polyfill" +no_bundle = true + +[build] +command = "node build.js" + +[[rules]] +type = "ESModule" +globs = ["**/*.js"] +fallthrough = true + +[[rules]] +type = "Text" +globs = ["**/*.html"] +fallthrough = true + """ elif language == "python": toml_content += """# Enable Python Workers runtime @@ -443,8 +454,9 @@ def package_code( if os.path.exists(package_file) and not os.path.exists(node_modules): self.logging.info(f"Installing Node.js dependencies in {directory}") try: + # Install production dependencies result = subprocess.run( - ["npm", "install", "--production"], + ["npm", "install"], cwd=directory, capture_output=True, text=True, @@ -454,6 +466,20 @@ def package_code( self.logging.info("npm install completed successfully") if result.stdout: self.logging.debug(f"npm output: {result.stdout}") + + # Install esbuild as a dev dependency (needed by build.js) + self.logging.info("Installing esbuild for custom build script...") + result = subprocess.run( + ["npm", "install", "--save-dev", "esbuild"], + cwd=directory, + capture_output=True, + text=True, + check=True, + timeout=60 + ) + self.logging.info("esbuild installed successfully") + + except subprocess.TimeoutExpired: self.logging.error("npm install timed out") raise RuntimeError("Failed to install Node.js dependencies: timeout") @@ -466,6 +492,23 @@ def package_code( ) elif os.path.exists(node_modules): self.logging.info(f"Node.js dependencies already installed in {directory}") + + # Ensure esbuild is available even for cached installations + esbuild_path = os.path.join(node_modules, "esbuild") + if not os.path.exists(esbuild_path): + self.logging.info("Installing esbuild for custom build script...") + try: + subprocess.run( + ["npm", "install", "--save-dev", "esbuild"], + cwd=directory, + capture_output=True, + text=True, + check=True, + timeout=60 + ) + self.logging.info("esbuild installed successfully") + except Exception as e: + self.logging.warning(f"Failed to install esbuild: {e}") elif language_name == "python": requirements_file = os.path.join(directory, "requirements.txt") @@ -649,6 +692,19 @@ def _create_or_update_worker( Returns: Worker deployment result """ + # # Convert CommonJS function.js to ESM if it exists + # if language == "nodejs": + # function_js = os.path.join(package_dir, "function.js") + # if os.path.exists(function_js): + # self.logging.info(f"Converting function.js from CommonJS to ESM...") + # try: + # esm_content = self._convert_commonjs_to_esm(function_js) + # with open(function_js, 'w') as f: + # f.write(esm_content) + # self.logging.info("Successfully converted function.js to ESM") + # except Exception as e: + # self.logging.error(f"Failed to convert function.js to ESM: {e}") + # raise # Generate wrangler.toml for this worker self._generate_wrangler_toml(worker_name, package_dir, language, account_id, benchmark_name) diff --git a/test-fs.js b/test-fs.js new file mode 100644 index 000000000..1da5f453b --- /dev/null +++ b/test-fs.js @@ -0,0 +1,7 @@ +import { readFile, readFileSync } from 'node:fs'; + +export default { + async fetch(request) { + return new Response(readFileSync('./test-fs.js', 'utf-8')); + } +}; \ No newline at end of file From 539002169a9327470f7a9eebb6a4ecbd61b102fe Mon Sep 17 00:00:00 2001 From: laurin Date: Wed, 19 Nov 2025 21:35:46 +0100 Subject: [PATCH 21/69] cleanup nodejs deployment cloudflare, no uploading files necessary anymore --- experiments.json | 24 +++---- sebs/cloudflare/cloudflare.py | 116 ---------------------------------- test-fs.js | 7 -- 3 files changed, 13 insertions(+), 134 deletions(-) delete mode 100644 test-fs.js diff --git a/experiments.json b/experiments.json index 364c2e10e..549ed7625 100644 --- a/experiments.json +++ b/experiments.json @@ -1,6 +1,6 @@ { "_invocations": { - "110-dynamic-html-nodejs-18": { + "130-crud-api-nodejs-18": { "0": { "billing": { "_billed_time": null, @@ -8,16 +8,18 @@ "_memory": null }, "output": { - "begin": 1763577748.037, + "begin": 1763584521.868, "compute_time": 0, "container_id": "0", - "end": 1763577748.037, + "end": 1763584521.868, "environ_container_id": "no_id", "is_cold": false, "is_cold_worker": false, "request_id": "0", "result": { - "output": "\n\n \n Randomly generated data.\n \n \n \n \n \n
\n

Welcome testname!

\n

Data generated at: 11/19/2025, 6:42:28 PM!

\n

Requested random numbers:

\n
    \n
  • 65
    • \n
  • 64
    • \n
  • 7
    • \n
  • 8
    • \n
  • 11
    • \n
  • 80
    • \n
  • 28
    • \n
  • 82
    • \n
  • 90
    • \n
  • 50
    • \n
\n
\n \n\n" + "output": [ + {} + ] }, "results_time": 0 }, @@ -33,18 +35,18 @@ }, "times": { "benchmark": 0, - "client": 27866, - "client_begin": "2025-11-19 19:42:27.957743", - "client_end": "2025-11-19 19:42:27.985609", - "http_first_byte_return": 0.027801, - "http_startup": 0.015255, + "client": 29638, + "client_begin": "2025-11-19 21:35:21.807697", + "client_end": "2025-11-19 21:35:21.837335", + "http_first_byte_return": 0.029473, + "http_startup": 0.00964, "initialization": 0 } } } }, "_metrics": {}, - "begin_time": 1763577747.723884, + "begin_time": 1763584521.660329, "config": { "deployment": { "credentials": { @@ -71,6 +73,6 @@ "update_storage": false } }, - "end_time": 1763577747.986338, + "end_time": 1763584521.838648, "result_bucket": null } \ No newline at end of file diff --git a/sebs/cloudflare/cloudflare.py b/sebs/cloudflare/cloudflare.py index 0632414a2..aae2406a9 100644 --- a/sebs/cloudflare/cloudflare.py +++ b/sebs/cloudflare/cloudflare.py @@ -293,112 +293,6 @@ def _get_auth_headers(self) -> Dict[str, str]: else: raise RuntimeError("Invalid Cloudflare credentials configuration") - def _convert_templates_to_modules(self, directory: str): - """ - Convert template files to JavaScript modules for bundling. - - Searches for template directories and converts HTML/text files - to JavaScript modules that can be imported. - - Args: - directory: Package directory to search for templates - """ - templates_dir = os.path.join(directory, "templates") - if not os.path.exists(templates_dir): - return - - self.logging.info(f"Converting template files in {templates_dir} to JavaScript modules") - - for root, dirs, files in os.walk(templates_dir): - for file in files: - if file.endswith(('.html', '.txt', '.xml', '.csv')): - file_path = os.path.join(root, file) - rel_path = os.path.relpath(file_path, directory) - - # Read the template content - with open(file_path, 'r', encoding='utf-8') as f: - content = f.read() - - # Escape for JavaScript string - content_escaped = (content - .replace('\\', '\\\\') - .replace('`', '\\`') - .replace('$', '\\$')) - - # Create a .js module file next to the template - module_path = file_path + '.js' - with open(module_path, 'w', encoding='utf-8') as f: - f.write(f'export default `{content_escaped}`;\n') - - self.logging.debug(f"Created template module: {module_path}") - - def _upload_benchmark_files_to_r2(self, directory: str, benchmark_name: str) -> int: - """ - Upload benchmark data files to R2 bucket for fs-polyfill access. - - This allows the fs-polyfill to read files from R2 instead of trying - to bundle them with the worker code. - - Args: - directory: Package directory containing files to upload - benchmark_name: Name of the benchmark (used as prefix in R2) - - Returns: - Number of files uploaded - """ - try: - storage = self.system_resources.get_storage() - bucket_name = storage.get_bucket(Resources.StorageBucketType.BENCHMARKS) - - if not bucket_name: - self.logging.warning("R2 bucket not configured, skipping file upload") - return 0 - - uploaded_count = 0 - - # Upload template files - templates_dir = os.path.join(directory, "templates") - if os.path.exists(templates_dir): - for root, dirs, files in os.walk(templates_dir): - for file in files: - # Skip the .js module files we created - if file.endswith('.js'): - continue - - file_path = os.path.join(root, file) - # Create R2 key: benchmark_name/templates/filename - rel_path = os.path.relpath(file_path, directory) - r2_key = f"{benchmark_name}/{rel_path}" - - try: - with open(file_path, 'rb') as f: - file_content = f.read() - - self.logging.info(f"Uploading {rel_path} to R2 as {r2_key}...") - storage.upload_bytes( - bucket_name, - r2_key, - file_content - ) - uploaded_count += 1 - self.logging.info(f"✓ Uploaded {rel_path} ({len(file_content)} bytes)") - except Exception as e: - self.logging.error(f"✗ Failed to upload {rel_path} to R2: {e}") - - if uploaded_count > 0: - self.logging.info( - f"Uploaded {uploaded_count} benchmark files to R2 bucket '{bucket_name}'" - ) - - return uploaded_count - - except Exception as e: - self.logging.warning( - f"Could not upload benchmark files to R2: {e}. " - f"fs-polyfill will not be able to read files from R2." - ) - return 0 - def package_code( self, directory: str, @@ -434,16 +328,6 @@ def package_code( # Ensure Wrangler is installed self._ensure_wrangler_installed() - # Upload benchmark files to R2 for fs-polyfill access - if language_name == "nodejs": - uploaded = self._upload_benchmark_files_to_r2(directory, benchmark) - if uploaded > 0: - self.logging.info(f"Successfully uploaded {uploaded} files to R2") - else: - self.logging.warning( - "No files were uploaded to R2. Benchmarks requiring file access may fail. " - "Ensure R2 API credentials are configured." - ) # Install dependencies if language_name == "nodejs": diff --git a/test-fs.js b/test-fs.js deleted file mode 100644 index 1da5f453b..000000000 --- a/test-fs.js +++ /dev/null @@ -1,7 +0,0 @@ -import { readFile, readFileSync } from 'node:fs'; - -export default { - async fetch(request) { - return new Response(readFileSync('./test-fs.js', 'utf-8')); - } -}; \ No newline at end of file From 24497a2dc5a66e5e763cd397f312a08ce9d18941 Mon Sep 17 00:00:00 2001 From: "ldzgch (MacOS)" Date: Sun, 23 Nov 2025 22:45:12 +0100 Subject: [PATCH 22/69] add folder structure to python code package --- sebs/cloudflare/cloudflare.py | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/sebs/cloudflare/cloudflare.py b/sebs/cloudflare/cloudflare.py index aae2406a9..cd940386f 100644 --- a/sebs/cloudflare/cloudflare.py +++ b/sebs/cloudflare/cloudflare.py @@ -395,6 +395,14 @@ def package_code( self.logging.warning(f"Failed to install esbuild: {e}") elif language_name == "python": + funcdir = os.path.join(directory, "function") + if not os.path.exists(funcdir): + os.makedirs(funcdir) + + for thing in os.listdir(directory): + if thing.endswith(".py") and not thing.endswith("handler.py"): + shutil.move(os.path.join(directory, thing),os.path.join(directory, "function", thing)) + requirements_file = os.path.join(directory, "requirements.txt") if os.path.exists(requirements_file): self.logging.info(f"Installing Python dependencies in {directory}") From 88127085a4a58a96d837163e9e6b2074d1c840e5 Mon Sep 17 00:00:00 2001 From: "ldzgch (MacOS)" Date: Fri, 28 Nov 2025 15:34:06 +0100 Subject: [PATCH 23/69] nosql wrapper - duarble object - may work --- .../wrappers/cloudflare/python/handler.py | 101 ++++++++-------- .../wrappers/cloudflare/python/nosql.py | 111 +++++++++++++++++- 2 files changed, 162 insertions(+), 50 deletions(-) diff --git a/benchmarks/wrappers/cloudflare/python/handler.py b/benchmarks/wrappers/cloudflare/python/handler.py index 60497331c..39ceffbdd 100644 --- a/benchmarks/wrappers/cloudflare/python/handler.py +++ b/benchmarks/wrappers/cloudflare/python/handler.py @@ -2,7 +2,7 @@ import asyncio import importlib.util import traceback -from workers import WorkerEntrypoint, Response +from workers import WorkerEntrypoint, Response, DurableObject ## sys.path.append(os.path.join(os.path.dirname(__file__), '.python_packages/lib/site-packages')) @@ -18,52 +18,10 @@ """ - -def import_from_path(module_name, file_path): - spec = importlib.util.spec_from_file_location(module_name, file_path) - module = importlib.util.module_from_spec(spec) - sys.modules[module_name] = module - spec.loader.exec_module(module) - return module - - -working_dir = os.path.dirname(__file__) - -class MakeAsync(ast.NodeTransformer): - def visit_FunctionDef(self, node): - if node.name != "handler": - return node - return ast.AsyncFunctionDef( - name=node.name, - args=node.args, - body=node.body, - decorator_list=node.decorator_list, - returns=node.returns, - type_params=node.type_params) - -class AddAwait(ast.NodeTransformer): - to_find = ["upload_stream", "download_stream", "upload", "download", "download_directory"] - - def visit_Call(self, node): - if isinstance(node.func, ast.Attribute) and node.func.attr in self.to_find: - #print(ast.dump(node.func, indent=2)) - return ast.Await(value=node) - - return node - -def make_benchmark_func(): - with open(working_dir +"/function/function.py") as f: - module = ast.parse(f.read()) - module = ast.fix_missing_locations(MakeAsync().visit(module)) - module = ast.fix_missing_locations(AddAwait().visit(module)) - new_source = ast.unparse(module) - ##print("new_source:") - ##print(new_source) - ##print() - with open("/tmp/function.py", "w") as wf: - wf.write(new_source) +class KVApiObject(DurableObject): + def __getattr__(self, name): + return getattr(self.ctx.storage, name) - class Default(WorkerEntrypoint): async def fetch(self, request, env): try: @@ -97,8 +55,6 @@ async def fetch2(self, request, env): - - ## we might need more data in self.env to know this ID req_id = 0 ## note: time fixed in worker @@ -152,3 +108,52 @@ async def fetch2(self, request, env): 'environ_container_id': "no_id", 'request_id': "0" })) + + +### ---------- old ------- + +def import_from_path(module_name, file_path): + spec = importlib.util.spec_from_file_location(module_name, file_path) + module = importlib.util.module_from_spec(spec) + sys.modules[module_name] = module + spec.loader.exec_module(module) + return module + + +working_dir = os.path.dirname(__file__) + +class MakeAsync(ast.NodeTransformer): + def visit_FunctionDef(self, node): + if node.name != "handler": + return node + return ast.AsyncFunctionDef( + name=node.name, + args=node.args, + body=node.body, + decorator_list=node.decorator_list, + returns=node.returns, + type_params=node.type_params) + +class AddAwait(ast.NodeTransformer): + to_find = ["upload_stream", "download_stream", "upload", "download", "download_directory"] + + def visit_Call(self, node): + if isinstance(node.func, ast.Attribute) and node.func.attr in self.to_find: + #print(ast.dump(node.func, indent=2)) + return ast.Await(value=node) + + return node + +def make_benchmark_func(): + with open(working_dir +"/function/function.py") as f: + module = ast.parse(f.read()) + module = ast.fix_missing_locations(MakeAsync().visit(module)) + module = ast.fix_missing_locations(AddAwait().visit(module)) + new_source = ast.unparse(module) + ##print("new_source:") + ##print(new_source) + ##print() + with open("/tmp/function.py", "w") as wf: + wf.write(new_source) + + diff --git a/benchmarks/wrappers/cloudflare/python/nosql.py b/benchmarks/wrappers/cloudflare/python/nosql.py index bb1f94633..9de22fe69 100644 --- a/benchmarks/wrappers/cloudflare/python/nosql.py +++ b/benchmarks/wrappers/cloudflare/python/nosql.py @@ -1,9 +1,111 @@ from typing import List, Optional, Tuple import json +import pickle from pyodide.ffi import to_js, run_sync -from workers import WorkerEntrypoint +from workers import WorkerEntrypoint, DurableObject -class nosql: + +class nosql_do: + instance: Optional["nosql"] = None + DO_BINDING_NAME = "DURABLE_STORE" + + @staticmethod + def init_instance(entry: WorkerEntrypoint): + nosql.instance = nosql() + nosql.instance.binding = getattr(entry.env, nosql_do.DO_BINDING_NAME) + + + def get_table(self, table_name): + kvapiobj = self.binding.getByName(table_name) + return kvapiobj + + def key_maker(self, key1, key2): + return f"({key1[0]},{str(key1[1])})+({key2[0]},{key2[1]})" + + def key_maker_partial(self, key1, key2): + return f"({key1[0]},{str(key1[1])})+({key2[0]}" + +## these data conversion funcs should not be necessary. i couldn't get pyodide to clone the data otherwise + def data_pre(self, data): + return pickle.dumps(data, 0).decode("ascii") + + def data_post(self, data): + return pickle.loads(bytes(data, "ascii")) + + def insert( + self, + table_name: str, + primary_key: Tuple[str, str], + secondary_key: Tuple[str, str], + data: dict, + ): + send_data = self.data_pre(data) + k=self.key_maker(primary_key, secondary_key) + put_res = run_sync(self.get_table(table_name).put(k, send_data)) + return + + ## does this really need different behaviour from insert? + def update( + self, + table_name: str, + primary_key: Tuple[str, str], + secondary_key: Tuple[str, str], + data: dict, + ): + self.insert(table_name, primary_key, secondary_key, data) + return + + + def get( + self, table_name: str, primary_key: Tuple[str, str], secondary_key: Tuple[str, str] + ) -> Optional[dict]: + k=self.key_maker(primary_key, secondary_key) + get_res = run_sync(self.get_table(table_name).get(k)) + ## print(get_res) + return self.data_post(get_res) + + """ + This query must involve partition key - it does not scan across partitions. + """ + + def query( + self, table_name: str, primary_key: Tuple[str, str], secondary_key_name: str + ) -> List[dict]: + + prefix_key = self.key_maker_partial(primary_key, (secondary_key_name,)) + list_res = run_sync(self.get_table(table_name).list()) + + keys = [] + for key in list_res: + if key.startswith(prefix_key): + print(key) + keys.append(key) + ##print("keys", keys) + assert len(keys) <= 100 + + + # todo: please use bulk sometime (it didn't work when i tried it) + res = [] + for key in keys: + + get_res = run_sync(self.get_table(table_name).get(key)) + ## print(get_res) + res.append(self.data_post(get_res)) + return res + + def delete(self, table_name: str, primary_key: Tuple[str, str], secondary_key: Tuple[str, str]): + run_sync(self.get_table(table_name).delete(self.key_maker(primary_key, secondary_key))) + return + + @staticmethod + def get_instance(): + if nosql_do.instance is None: + nosql_do.instance = nosql_do() + return nosql_do.instance + +### ------------------------------ + +class nosql_kv: instance: Optional["nosql"] = None @@ -96,3 +198,8 @@ def get_instance(): if nosql.instance is None: nosql.instance = nosql() return nosql.instance + + + + +nosql = nosql_do From 5b3d78425a5cc8ef25b29284611b2e4a2c974dac Mon Sep 17 00:00:00 2001 From: "ldzgch (MacOS)" Date: Fri, 28 Nov 2025 16:10:44 +0100 Subject: [PATCH 24/69] fix python. 110 runs for me. --- .../wrappers/cloudflare/python/handler.py | 10 +- sebs/cloudflare/cloudflare.py | 209 +++++++++--------- 2 files changed, 111 insertions(+), 108 deletions(-) diff --git a/benchmarks/wrappers/cloudflare/python/handler.py b/benchmarks/wrappers/cloudflare/python/handler.py index 39ceffbdd..332c2b67b 100644 --- a/benchmarks/wrappers/cloudflare/python/handler.py +++ b/benchmarks/wrappers/cloudflare/python/handler.py @@ -69,12 +69,12 @@ async def fetch2(self, request, env): storage.storage.init_instance(self) - from function import nosql - - nosql.nosql.init_instance(self) - - + if 'NOSQL_STORAGE_DATABASE' in os.environ: + from function import nosql + + nosql.nosql.get_instance(self) + print("event:", event) diff --git a/sebs/cloudflare/cloudflare.py b/sebs/cloudflare/cloudflare.py index cd940386f..f6c60956b 100644 --- a/sebs/cloudflare/cloudflare.py +++ b/sebs/cloudflare/cloudflare.py @@ -23,11 +23,11 @@ class Cloudflare(System): """ Cloudflare Workers serverless platform implementation. - + Cloudflare Workers run on Cloudflare's edge network, providing low-latency serverless execution globally. """ - + _config: CloudflareConfig @staticmethod @@ -71,7 +71,7 @@ def __init__( def initialize(self, config: Dict[str, str] = {}, resource_prefix: Optional[str] = None): """ Initialize the Cloudflare Workers platform. - + Args: config: Additional configuration parameters resource_prefix: Prefix for resource naming @@ -79,14 +79,14 @@ def initialize(self, config: Dict[str, str] = {}, resource_prefix: Optional[str] # Verify credentials are valid self._verify_credentials() self.initialize_resources(select_prefix=resource_prefix) - + def initialize_resources(self, select_prefix: Optional[str] = None): """ Initialize Cloudflare resources. - + Overrides the base class method to handle R2 storage gracefully. Cloudflare Workers can operate without R2 storage for many benchmarks. - + Args: select_prefix: Optional prefix for resource naming """ @@ -104,10 +104,10 @@ def initialize_resources(self, select_prefix: Optional[str] = None): res_id = f"{select_prefix}-{str(uuid.uuid1())[0:8]}" else: res_id = str(uuid.uuid1())[0:8] - + self.config.resources.resources_id = res_id self.logging.info(f"Generating unique resource name {res_id}") - + # Try to create R2 bucket, but don't fail if R2 is not enabled try: self.system_resources.get_storage().get_bucket(Resources.StorageBucketType.BENCHMARKS) @@ -127,30 +127,30 @@ def _verify_credentials(self): "Cloudflare API credentials are not set. Please set CLOUDFLARE_API_TOKEN " "and CLOUDFLARE_ACCOUNT_ID environment variables." ) - + if not self.config.credentials.account_id: raise RuntimeError( "Cloudflare Account ID is not set. Please set CLOUDFLARE_ACCOUNT_ID " "environment variable." ) - + headers = self._get_auth_headers() - + # Log credential type being used (without exposing the actual token) if self.config.credentials.api_token: token_preview = self.config.credentials.api_token[:8] + "..." if len(self.config.credentials.api_token) > 8 else "***" self.logging.info(f"Using API Token authentication (starts with: {token_preview})") else: self.logging.info(f"Using Email + API Key authentication (email: {self.config.credentials.email})") - + response = requests.get(f"{self._api_base_url}/user/tokens/verify", headers=headers) - + if response.status_code != 200: raise RuntimeError( f"Failed to verify Cloudflare credentials: {response.status_code} - {response.text}\n" f"Please check that your CLOUDFLARE_API_TOKEN and CLOUDFLARE_ACCOUNT_ID are correct." ) - + self.logging.info("Cloudflare credentials verified successfully") def _ensure_wrangler_installed(self): @@ -187,18 +187,18 @@ def _ensure_wrangler_installed(self): except subprocess.TimeoutExpired: raise RuntimeError("Wrangler version check timed out") - + def _generate_wrangler_toml(self, worker_name: str, package_dir: str, language: str, account_id: str, benchmark_name: Optional[str] = None) -> str: """ Generate a wrangler.toml configuration file for the worker. - + Args: worker_name: Name of the worker package_dir: Directory containing the worker code language: Programming language (nodejs or python) account_id: Cloudflare account ID benchmark_name: Optional benchmark name for R2 file path prefix - + Returns: Path to the generated wrangler.toml file """ @@ -267,13 +267,13 @@ def _generate_wrangler_toml(self, worker_name: str, package_dir: str, language: f"R2 bucket binding not configured: {e}. " f"Benchmarks requiring file access will not work properly." ) - - + + # Write wrangler.toml to package directory toml_path = os.path.join(package_dir, "wrangler.toml") with open(toml_path, 'w') as f: f.write(toml_content) - + self.logging.info(f"Generated wrangler.toml at {toml_path}") return toml_path @@ -305,9 +305,9 @@ def package_code( ) -> Tuple[str, int, str]: """ Package code for Cloudflare Workers deployment using Wrangler. - + Uses Wrangler CLI to bundle dependencies and prepare for deployment. - + Args: directory: Path to the code directory language_name: Programming language name @@ -316,7 +316,7 @@ def package_code( benchmark: Benchmark name is_cached: Whether the code is cached container_deployment: Whether to deploy as container (not supported) - + Returns: Tuple of (package_path, package_size, container_uri) """ @@ -333,7 +333,7 @@ def package_code( if language_name == "nodejs": package_file = os.path.join(directory, "package.json") node_modules = os.path.join(directory, "node_modules") - + # Only install if package.json exists and node_modules doesn't if os.path.exists(package_file) and not os.path.exists(node_modules): self.logging.info(f"Installing Node.js dependencies in {directory}") @@ -350,7 +350,7 @@ def package_code( self.logging.info("npm install completed successfully") if result.stdout: self.logging.debug(f"npm output: {result.stdout}") - + # Install esbuild as a dev dependency (needed by build.js) self.logging.info("Installing esbuild for custom build script...") result = subprocess.run( @@ -363,7 +363,7 @@ def package_code( ) self.logging.info("esbuild installed successfully") - + except subprocess.TimeoutExpired: self.logging.error("npm install timed out") raise RuntimeError("Failed to install Node.js dependencies: timeout") @@ -376,7 +376,7 @@ def package_code( ) elif os.path.exists(node_modules): self.logging.info(f"Node.js dependencies already installed in {directory}") - + # Ensure esbuild is available even for cached installations esbuild_path = os.path.join(node_modules, "esbuild") if not os.path.exists(esbuild_path): @@ -395,14 +395,6 @@ def package_code( self.logging.warning(f"Failed to install esbuild: {e}") elif language_name == "python": - funcdir = os.path.join(directory, "function") - if not os.path.exists(funcdir): - os.makedirs(funcdir) - - for thing in os.listdir(directory): - if thing.endswith(".py") and not thing.endswith("handler.py"): - shutil.move(os.path.join(directory, thing),os.path.join(directory, "function", thing)) - requirements_file = os.path.join(directory, "requirements.txt") if os.path.exists(requirements_file): self.logging.info(f"Installing Python dependencies in {directory}") @@ -426,13 +418,24 @@ def package_code( raise RuntimeError( "pip not found. Please install Python and pip to deploy Python benchmarks." ) - + # move into function dir + funcdir = os.path.join(directory, "function") + if not os.path.exists(funcdir): + os.makedirs(funcdir) + + for thing in os.listdir(directory): + if not (thing.endswith("handler.py") or thing.endswith("function") or thing.endswith("python_modules")): + src = os.path.join(directory, thing) + dest = os.path.join(directory, "function", thing) + shutil.move(src, dest) + self.logging.info(f"move {src} to {dest}") + # Create package structure CONFIG_FILES = { "nodejs": ["handler.js", "package.json", "node_modules"], "python": ["handler.py", "requirements.txt", "python_modules"], } - + if language_name not in CONFIG_FILES: raise NotImplementedError( f"Language {language_name} is not yet supported for Cloudflare Workers" @@ -441,7 +444,7 @@ def package_code( # Verify the handler exists handler_file = "handler.js" if language_name == "nodejs" else "handler.py" package_path = os.path.join(directory, handler_file) - + if not os.path.exists(package_path): if not os.path.exists(directory): raise RuntimeError( @@ -452,14 +455,14 @@ def package_code( f"Handler file {handler_file} not found in {directory}. " f"Available files: {', '.join(os.listdir(directory)) if os.path.exists(directory) else 'none'}" ) - + # Calculate total size of the package directory total_size = 0 for dirpath, dirnames, filenames in os.walk(directory): for filename in filenames: filepath = os.path.join(dirpath, filename) total_size += os.path.getsize(filepath) - + mbytes = total_size / 1024.0 / 1024.0 self.logging.info(f"Worker package size: {mbytes:.2f} MB") @@ -474,15 +477,15 @@ def create_function( ) -> CloudflareWorker: """ Create a new Cloudflare Worker. - + If a worker with the same name already exists, it will be updated. - + Args: code_package: Benchmark containing the function code func_name: Name of the worker container_deployment: Whether to deploy as container (not supported) container_uri: URI of container image (not used) - + Returns: CloudflareWorker instance """ @@ -496,16 +499,16 @@ def create_function( language = code_package.language_name language_runtime = code_package.language_version function_cfg = FunctionConfig.from_benchmark(code_package) - + func_name = self.format_function_name(func_name) account_id = self.config.credentials.account_id - + if not account_id: raise RuntimeError("Cloudflare account ID is required to create workers") # Check if worker already exists existing_worker = self._get_worker(func_name, account_id) - + if existing_worker: self.logging.info(f"Worker {func_name} already exists, updating it") worker = CloudflareWorker( @@ -521,10 +524,10 @@ def create_function( worker.updated_code = True else: self.logging.info(f"Creating new worker {func_name}") - + # Create the worker with all package files self._create_or_update_worker(func_name, package, account_id, language, benchmark) - + worker = CloudflareWorker( func_name, code_package.benchmark, @@ -537,7 +540,7 @@ def create_function( # Add LibraryTrigger and HTTPTrigger from sebs.cloudflare.triggers import LibraryTrigger, HTTPTrigger - + library_trigger = LibraryTrigger(func_name, self) library_trigger.logging_handlers = self.logging_handlers worker.add_trigger(library_trigger) @@ -555,9 +558,9 @@ def _get_worker(self, worker_name: str, account_id: str) -> Optional[dict]: """Get information about an existing worker.""" headers = self._get_auth_headers() url = f"{self._api_base_url}/accounts/{account_id}/workers/scripts/{worker_name}" - + response = requests.get(url, headers=headers) - + if response.status_code == 200: try: return response.json().get("result") @@ -573,14 +576,14 @@ def _create_or_update_worker( self, worker_name: str, package_dir: str, account_id: str, language: str, benchmark_name: Optional[str] = None ) -> dict: """Create or update a Cloudflare Worker using Wrangler CLI. - + Args: worker_name: Name of the worker package_dir: Directory containing handler and all benchmark files account_id: Cloudflare account ID language: Programming language (nodejs or python) benchmark_name: Optional benchmark name for R2 file path prefix - + Returns: Worker deployment result """ @@ -599,7 +602,7 @@ def _create_or_update_worker( # raise # Generate wrangler.toml for this worker self._generate_wrangler_toml(worker_name, package_dir, language, account_id, benchmark_name) - + # Set up environment for Wrangler env = os.environ.copy() if self.config.credentials.api_token: @@ -607,12 +610,12 @@ def _create_or_update_worker( elif self.config.credentials.email and self.config.credentials.api_key: env['CLOUDFLARE_EMAIL'] = self.config.credentials.email env['CLOUDFLARE_API_KEY'] = self.config.credentials.api_key - + env['CLOUDFLARE_ACCOUNT_ID'] = account_id - + # Deploy using Wrangler self.logging.info(f"Deploying worker {worker_name} using Wrangler...") - + try: result = subprocess.run( ["wrangler", "deploy"], @@ -623,17 +626,17 @@ def _create_or_update_worker( check=True, timeout=180 # 3 minutes for deployment ) - + self.logging.info(f"Worker {worker_name} deployed successfully") if result.stdout: self.logging.debug(f"Wrangler deploy output: {result.stdout}") - + # Parse the output to get worker URL # Wrangler typically outputs: "Published ()" # and "https://..workers.dev" - + return {"success": True, "output": result.stdout} - + except subprocess.TimeoutExpired: raise RuntimeError(f"Wrangler deployment timed out for worker {worker_name}") except subprocess.CalledProcessError as e: @@ -711,18 +714,18 @@ def _build_workers_dev_url(self, worker_name: str, account_id: Optional[str]) -> def cached_function(self, function: Function): """ Handle a function retrieved from cache. - + Refreshes triggers and logging handlers. - + Args: function: The cached function """ from sebs.cloudflare.triggers import LibraryTrigger, HTTPTrigger - + for trigger in function.triggers(Trigger.TriggerType.LIBRARY): trigger.logging_handlers = self.logging_handlers cast(LibraryTrigger, trigger).deployment_client = self - + for trigger in function.triggers(Trigger.TriggerType.HTTP): trigger.logging_handlers = self.logging_handlers @@ -735,7 +738,7 @@ def update_function( ): """ Update an existing Cloudflare Worker. - + Args: function: Existing function instance to update code_package: New benchmark containing the function code @@ -751,15 +754,15 @@ def update_function( package = code_package.code_location language = code_package.language_name benchmark = code_package.benchmark - + # Update the worker with all package files account_id = worker.account_id or self.config.credentials.account_id if not account_id: raise RuntimeError("Account ID is required to update worker") - + self._create_or_update_worker(worker.name, package, account_id, language, benchmark) self.logging.info(f"Updated worker {worker.name}") - + # Update configuration if needed self.update_function_configuration(worker, code_package) @@ -768,10 +771,10 @@ def update_function_configuration( ): """ Update the configuration of a Cloudflare Worker. - + Note: Cloudflare Workers have limited configuration options compared to traditional FaaS platforms. Memory and timeout are managed by Cloudflare. - + Args: cached_function: The function to update benchmark: The benchmark with new configuration @@ -780,9 +783,9 @@ def update_function_configuration( # - CPU time: 50ms (free), 50ms-30s (paid) # - Memory: 128MB # Most configuration is handled via wrangler.toml or API settings - + worker = cast(CloudflareWorker, cached_function) - + # For environment variables or KV namespaces, we would use the API here # For now, we'll just log that configuration update was requested self.logging.info( @@ -793,11 +796,11 @@ def update_function_configuration( def default_function_name(self, code_package: Benchmark, resources=None) -> str: """ Generate a default function name for Cloudflare Workers. - + Args: code_package: The benchmark package resources: Optional resources (not used) - + Returns: Default function name """ @@ -811,15 +814,15 @@ def default_function_name(self, code_package: Benchmark, resources=None) -> str: def format_function_name(name: str) -> str: """ Format a function name to comply with Cloudflare Worker naming rules. - + Worker names must: - Be lowercase - Contain only alphanumeric characters and hyphens - Not start or end with a hyphen - + Args: name: The original name - + Returns: Formatted name """ @@ -834,11 +837,11 @@ def format_function_name(name: str) -> str: def enforce_cold_start(self, functions: List[Function], code_package: Benchmark): """ Enforce cold start for Cloudflare Workers. - + Note: Cloudflare Workers don't have a traditional cold start mechanism like AWS Lambda. Workers are instantiated on-demand at edge locations. We can't force a cold start, but we can update the worker to invalidate caches. - + Args: functions: List of functions to enforce cold start on code_package: The benchmark package @@ -858,12 +861,12 @@ def download_metrics( ): """ Extract per-invocation metrics from ExecutionResult objects. - + The metrics are extracted from the 'measurement' field in the benchmark response, which is populated by the Cloudflare Worker handler during execution. This approach avoids dependency on Analytics Engine and provides immediate, accurate metrics for each invocation. - + Args: function_name: Name of the worker start_time: Start time (Unix timestamp in seconds) - not used @@ -874,12 +877,12 @@ def download_metrics( if not requests: self.logging.warning("No requests to extract metrics from") return - + self.logging.info( f"Extracting metrics from {len(requests)} invocations " f"of worker {function_name}" ) - + # Aggregate statistics from all requests total_invocations = len(requests) cold_starts = 0 @@ -887,38 +890,38 @@ def download_metrics( cpu_times = [] wall_times = [] memory_values = [] - + for request_id, result in requests.items(): # Count cold/warm starts if result.stats.cold_start: cold_starts += 1 else: warm_starts += 1 - + # Collect CPU times if result.provider_times.execution > 0: cpu_times.append(result.provider_times.execution) - + # Collect wall times (benchmark times) if result.times.benchmark > 0: wall_times.append(result.times.benchmark) - + # Collect memory usage if result.stats.memory_used > 0: memory_values.append(result.stats.memory_used) - + # Set billing info for Cloudflare Workers - # Cloudflare billing: $0.50 per million requests + + # Cloudflare billing: $0.50 per million requests + # $12.50 per million GB-seconds of CPU time if result.provider_times.execution > 0: result.billing.memory = 128 # Cloudflare Workers: fixed 128MB result.billing.billed_time = result.provider_times.execution # μs - + # GB-seconds calculation: (128MB / 1024MB/GB) * (cpu_time_us / 1000000 us/s) cpu_time_seconds = result.provider_times.execution / 1_000_000.0 gb_seconds = (128.0 / 1024.0) * cpu_time_seconds result.billing.gb_seconds = int(gb_seconds * 1_000_000) # micro GB-seconds - + # Calculate statistics metrics['cloudflare'] = { 'total_invocations': total_invocations, @@ -927,34 +930,34 @@ def download_metrics( 'data_source': 'response_measurements', 'note': 'Per-invocation metrics extracted from benchmark response' } - + if cpu_times: metrics['cloudflare']['avg_cpu_time_us'] = sum(cpu_times) // len(cpu_times) metrics['cloudflare']['min_cpu_time_us'] = min(cpu_times) metrics['cloudflare']['max_cpu_time_us'] = max(cpu_times) metrics['cloudflare']['cpu_time_measurements'] = len(cpu_times) - + if wall_times: metrics['cloudflare']['avg_wall_time_us'] = sum(wall_times) // len(wall_times) metrics['cloudflare']['min_wall_time_us'] = min(wall_times) metrics['cloudflare']['max_wall_time_us'] = max(wall_times) metrics['cloudflare']['wall_time_measurements'] = len(wall_times) - + if memory_values: metrics['cloudflare']['avg_memory_mb'] = sum(memory_values) / len(memory_values) metrics['cloudflare']['min_memory_mb'] = min(memory_values) metrics['cloudflare']['max_memory_mb'] = max(memory_values) metrics['cloudflare']['memory_measurements'] = len(memory_values) - + self.logging.info( f"Extracted metrics from {total_invocations} invocations: " f"{cold_starts} cold starts, {warm_starts} warm starts" ) - + if cpu_times: avg_cpu_ms = sum(cpu_times) / len(cpu_times) / 1000.0 self.logging.info(f"Average CPU time: {avg_cpu_ms:.2f} ms") - + if wall_times: avg_wall_ms = sum(wall_times) / len(wall_times) / 1000.0 self.logging.info(f"Average wall time: {avg_wall_ms:.2f} ms") @@ -964,18 +967,18 @@ def create_trigger( ) -> Trigger: """ Create a trigger for a Cloudflare Worker. - + Args: function: The function to create a trigger for trigger_type: Type of trigger to create - + Returns: The created trigger """ from sebs.cloudflare.triggers import LibraryTrigger, HTTPTrigger - + worker = cast(CloudflareWorker, function) - + if trigger_type == Trigger.TriggerType.LIBRARY: trigger = LibraryTrigger(worker.name, self) trigger.logging_handlers = self.logging_handlers @@ -994,7 +997,7 @@ def create_trigger( def shutdown(self) -> None: """ Shutdown the Cloudflare system. - + Saves configuration to cache. """ try: From cd183b89636c138c74b57f923038af991030e20c Mon Sep 17 00:00:00 2001 From: "ldzgch (MacOS)" Date: Fri, 28 Nov 2025 17:18:47 +0100 Subject: [PATCH 25/69] make it read the requirements.txt when it has a number --- sebs/cloudflare/cloudflare.py | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/sebs/cloudflare/cloudflare.py b/sebs/cloudflare/cloudflare.py index f6c60956b..13ab9b79c 100644 --- a/sebs/cloudflare/cloudflare.py +++ b/sebs/cloudflare/cloudflare.py @@ -396,6 +396,13 @@ def package_code( elif language_name == "python": requirements_file = os.path.join(directory, "requirements.txt") + + if os.path.exists(f"{requirements_file}.{language_version}"): + src = f"{requirements_file}.{language_version}" + dest = requirements_file + shutil.move(src, dest) + self.logging.info(f"move {src} to {dest}") + if os.path.exists(requirements_file): self.logging.info(f"Installing Python dependencies in {directory}") try: From 9379f39348361b83ec591067a0dbd10283a11ed8 Mon Sep 17 00:00:00 2001 From: laurin Date: Sun, 30 Nov 2025 16:01:41 +0100 Subject: [PATCH 26/69] durable objects compatibility for nodejs --- .../wrappers/cloudflare/nodejs/build.js | 54 +++++++++- .../wrappers/cloudflare/nodejs/handler.js | 60 ++++++++++- .../wrappers/cloudflare/nodejs/nosql.js | 100 ++++++++---------- sebs/cloudflare/cloudflare.py | 37 +++++-- sebs/cloudflare/durable_objects.py | 62 ++++++----- 5 files changed, 215 insertions(+), 98 deletions(-) diff --git a/benchmarks/wrappers/cloudflare/nodejs/build.js b/benchmarks/wrappers/cloudflare/nodejs/build.js index a9d7ebcb0..e6bb65dd1 100644 --- a/benchmarks/wrappers/cloudflare/nodejs/build.js +++ b/benchmarks/wrappers/cloudflare/nodejs/build.js @@ -39,7 +39,7 @@ const nodeBuiltinsPlugin = { name: 'node-builtins-external', setup(build) { // Keep node: prefixed modules external - build.onResolve({ filter: /^node:/ }, (args) => { + build.onResolve({ filter: /^(node:|cloudflare:)/ }, (args) => { return { path: args.path, external: true }; }); @@ -50,6 +50,56 @@ const nodeBuiltinsPlugin = { } }; +const asyncNosqlPlugin = { + name: 'async-nosql-transformer', + setup(build) { + // Transform function.js to make it async-compatible + build.onLoad({ filter: /function\.js$/ }, async (args) => { + let contents = await fs.promises.readFile(args.path, 'utf8'); + + console.log('🔧 Transforming function.js for async nosql...'); + + // Step 1: Add await before nosqlClient method calls + contents = contents.replace(/(\s*)((?:const|let|var)\s+\w+\s*=\s*)?nosqlClient\.(insert|get|update|query|delete)\s*\(/g, + '$1$2await nosqlClient.$3('); + + // Step 2: Make all function declarations async + contents = contents.replace(/\bfunction\s+(\w+)\s*\(/g, 'async function $1('); + + // Step 3: Make exported handler async if not already + contents = contents.replace(/exports\.handler\s*=\s*function\s*\(/g, 'exports.handler = async function('); + + // Step 4: Add await before specific function calls + // Split into lines to avoid matching function declarations + const lines = contents.split('\n'); + const transformedLines = lines.map(line => { + // Skip lines that contain function declarations + if (line.match(/\b(async\s+)?function\s+\w+\s*\(/)) { + return line; + } + + // Transform function calls in this line + const functionNames = ['addProduct', 'getProducts', 'queryProducts', 'updateProducts', 'deleteProducts']; + for (const funcName of functionNames) { + // Match calls: spaces + optional assignment + functionName( + const callRegex = new RegExp(`(\\s*)((?:const|let|var)\\s+\\w+\\s*=\\s*)?(${funcName})\\s*\\(`, 'g'); + line = line.replace(callRegex, '$1$2await $3('); + } + + return line; + }); + contents = transformedLines.join('\n'); + + console.log('✓ Transformed function.js for async nosql'); + + return { + contents, + loader: 'js', + }; + }); + } +}; + async function customBuild() { const srcDir = './'; const outDir = './dist'; @@ -83,7 +133,7 @@ async function customBuild() { target: 'es2020', sourcemap: true, allowOverwrite: true, - plugins: [nodeBuiltinsPlugin], + plugins: [nodeBuiltinsPlugin, asyncNosqlPlugin], define: { 'process.env.NODE_ENV': '"production"', 'global': 'globalThis', diff --git a/benchmarks/wrappers/cloudflare/nodejs/handler.js b/benchmarks/wrappers/cloudflare/nodejs/handler.js index 8baa646b3..c72b7d5ec 100644 --- a/benchmarks/wrappers/cloudflare/nodejs/handler.js +++ b/benchmarks/wrappers/cloudflare/nodejs/handler.js @@ -1,4 +1,29 @@ +import { DurableObject } from "cloudflare:workers"; +// Durable Object class for KV API compatibility +export class KVApiObject extends DurableObject { + constructor(state, env) { + super(state, env); + this.storage = state.storage; + } + + // Proxy methods to make the storage API accessible from the stub + async put(key, value) { + return await this.storage.put(key, value); + } + + async get(key) { + return await this.storage.get(key); + } + + async delete(key) { + return await this.storage.delete(key); + } + + async list(options) { + return await this.storage.list(options); + } +} export default { async fetch(request, env) { @@ -82,14 +107,43 @@ export default { // don't fail the request if storage init isn't available } + // Initialize nosql if environment variable is set + if (env.NOSQL_STORAGE_DATABASE) { + try { + const nosqlModule = await import('./nosql.js'); + if (nosqlModule && nosqlModule.nosql && typeof nosqlModule.nosql.init_instance === 'function') { + nosqlModule.nosql.init_instance({ env, request }); + } + } catch (e) { + // nosql module might not exist for all benchmarks + console.log('Could not initialize nosql:', e.message); + } + } + // Execute the benchmark handler let ret; try { + // Wrap the handler execution to handle sync-style async code + // The benchmark code calls async nosql methods but doesn't await them + // We need to serialize the execution if (funcModule && typeof funcModule.handler === 'function') { - // handler may be sync or return a promise - ret = await Promise.resolve(funcModule.handler(event)); + // Create a promise-aware execution context + const handler = funcModule.handler; + + // Execute handler - it will return { result: [Promise, Promise, ...] } + ret = await Promise.resolve(handler(event)); + + // Deeply resolve all promises in the result + if (ret && ret.result && Array.isArray(ret.result)) { + ret.result = await Promise.all(ret.result.map(async item => await Promise.resolve(item))); + } } else if (funcModule && funcModule.default && typeof funcModule.default.handler === 'function') { - ret = await Promise.resolve(funcModule.default.handler(event)); + const handler = funcModule.default.handler; + ret = await Promise.resolve(handler(event)); + + if (ret && ret.result && Array.isArray(ret.result)) { + ret.result = await Promise.all(ret.result.map(async item => await Promise.resolve(item))); + } } else { throw new Error('benchmark handler function not found'); } diff --git a/benchmarks/wrappers/cloudflare/nodejs/nosql.js b/benchmarks/wrappers/cloudflare/nodejs/nosql.js index 2841d3942..67b73a1fd 100644 --- a/benchmarks/wrappers/cloudflare/nodejs/nosql.js +++ b/benchmarks/wrappers/cloudflare/nodejs/nosql.js @@ -1,106 +1,90 @@ // NoSQL wrapper for Cloudflare Workers -// Supports Cloudflare KV or Durable Objects when available +// Uses Durable Objects for storage +// Returns Promises that the handler will resolve class nosql { constructor() { - this.handle = null; // KV or Durable Object binding - this._tables = {}; + this.env = null; } static init_instance(entry) { - nosql.instance = new nosql(); + // Reuse existing instance if it exists, otherwise create new one + if (!nosql.instance) { + nosql.instance = new nosql(); + } + if (entry && entry.env) { nosql.instance.env = entry.env; } } _get_table(tableName) { - if (!(tableName in this._tables)) { - const envName = `NOSQL_STORAGE_TABLE_${tableName}`; - - if (this.env && this.env[envName]) { - this._tables[tableName] = this.env[envName]; - } else if (this.env && this.env[tableName]) { - // Try direct table name - this._tables[tableName] = this.env[tableName]; - } else { - throw new Error( - `Couldn't find an environment variable ${envName} for table ${tableName}` - ); - } + // Don't cache stubs - they are request-scoped and cannot be reused + // Always create a fresh stub for each request + if (!this.env) { + throw new Error(`nosql env not initialized for table ${tableName}`); } - - return this._tables[tableName]; + + if (!this.env.DURABLE_STORE) { + // Debug: log what we have + const envKeys = Object.keys(this.env || {}); + const durableStoreType = typeof this.env.DURABLE_STORE; + throw new Error( + `DURABLE_STORE binding not found. env keys: [${envKeys.join(', ')}], DURABLE_STORE type: ${durableStoreType}` + ); + } + + // Get a Durable Object ID based on the table name and create a fresh stub + const id = this.env.DURABLE_STORE.idFromName(tableName); + return this.env.DURABLE_STORE.get(id); } + // Async methods - build.js will patch function.js to await these async insert(tableName, primaryKey, secondaryKey, data) { const keyData = { ...data }; keyData[primaryKey[0]] = primaryKey[1]; keyData[secondaryKey[0]] = secondaryKey[1]; - const table = this._get_table(tableName); + const durableObjStub = this._get_table(tableName); const compositeKey = `${primaryKey[1]}#${secondaryKey[1]}`; - // For KV binding - if (table && typeof table.put === 'function') { - await table.put(compositeKey, JSON.stringify(keyData)); - } else { - throw new Error('NoSQL table binding not properly configured'); - } + await durableObjStub.put(compositeKey, keyData); } async get(tableName, primaryKey, secondaryKey) { - const table = this._get_table(tableName); + const durableObjStub = this._get_table(tableName); const compositeKey = `${primaryKey[1]}#${secondaryKey[1]}`; - if (table && typeof table.get === 'function') { - const result = await table.get(compositeKey); - if (result) { - return JSON.parse(result); - } - return null; - } - - throw new Error('NoSQL table binding not properly configured'); + const result = await durableObjStub.get(compositeKey); + return result || null; } async update(tableName, primaryKey, secondaryKey, updates) { - // For simple KV, update is same as put with merged data const existing = await this.get(tableName, primaryKey, secondaryKey) || {}; const merged = { ...existing, ...updates }; await this.insert(tableName, primaryKey, secondaryKey, merged); } async query(tableName, primaryKey, secondaryKeyName) { - const table = this._get_table(tableName); + const durableObjStub = this._get_table(tableName); const prefix = `${primaryKey[1]}#`; - if (table && typeof table.list === 'function') { - const list = await table.list({ prefix }); - const results = []; - - for (const key of list.keys) { - const value = await table.get(key.name); - if (value) { - results.push(JSON.parse(value)); - } - } - - return results; + // List all keys with the prefix + const allEntries = await durableObjStub.list({ prefix }); + const results = []; + + for (const [key, value] of allEntries) { + results.push(value); } - throw new Error('NoSQL table binding not properly configured'); + return results; } async delete(tableName, primaryKey, secondaryKey) { - const table = this._get_table(tableName); + const durableObjStub = this._get_table(tableName); const compositeKey = `${primaryKey[1]}#${secondaryKey[1]}`; - if (table && typeof table.delete === 'function') { - await table.delete(compositeKey); - } else { - throw new Error('NoSQL table binding not properly configured'); - } + await durableObjStub.delete(compositeKey); } static get_instance() { @@ -111,4 +95,4 @@ class nosql { } } -module.exports.nosql = nosql; +export { nosql }; diff --git a/sebs/cloudflare/cloudflare.py b/sebs/cloudflare/cloudflare.py index 13ab9b79c..af183865d 100644 --- a/sebs/cloudflare/cloudflare.py +++ b/sebs/cloudflare/cloudflare.py @@ -188,7 +188,7 @@ def _ensure_wrangler_installed(self): raise RuntimeError("Wrangler version check timed out") - def _generate_wrangler_toml(self, worker_name: str, package_dir: str, language: str, account_id: str, benchmark_name: Optional[str] = None) -> str: + def _generate_wrangler_toml(self, worker_name: str, package_dir: str, language: str, account_id: str, benchmark_name: Optional[str] = None, code_package: Optional[Benchmark] = None) -> str: """ Generate a wrangler.toml configuration file for the worker. @@ -198,6 +198,7 @@ def _generate_wrangler_toml(self, worker_name: str, package_dir: str, language: language: Programming language (nodejs or python) account_id: Cloudflare account ID benchmark_name: Optional benchmark name for R2 file path prefix + code_package: Optional benchmark package for nosql configuration Returns: Path to the generated wrangler.toml file @@ -238,13 +239,30 @@ def _generate_wrangler_toml(self, worker_name: str, package_dir: str, language: compatibility_flags = ["python_workers"] """ + toml_content += """ +[[durable_objects.bindings]] +name = "DURABLE_STORE" +class_name = "KVApiObject" - # Add environment variable for benchmark name (used by fs-polyfill for R2 paths) +[[migrations]] +tag = "v1" +new_classes = ["KVApiObject"] +""" + + + # Add environment variables + vars_content = "" if benchmark_name: - toml_content += f"""# Benchmark name used for R2 file path prefix + vars_content += f'BENCHMARK_NAME = "{benchmark_name}"\n' + + # Add nosql configuration if benchmark uses it + if code_package and code_package.uses_nosql: + vars_content += 'NOSQL_STORAGE_DATABASE = "durable_objects"\n' + + if vars_content: + toml_content += f"""# Environment variables [vars] -BENCHMARK_NAME = "{benchmark_name}" - +{vars_content} """ # Add R2 bucket binding for benchmarking files (required for fs/path polyfills) @@ -533,7 +551,7 @@ def create_function( self.logging.info(f"Creating new worker {func_name}") # Create the worker with all package files - self._create_or_update_worker(func_name, package, account_id, language, benchmark) + self._create_or_update_worker(func_name, package, account_id, language, benchmark, code_package) worker = CloudflareWorker( func_name, @@ -580,7 +598,7 @@ def _get_worker(self, worker_name: str, account_id: str) -> Optional[dict]: return None def _create_or_update_worker( - self, worker_name: str, package_dir: str, account_id: str, language: str, benchmark_name: Optional[str] = None + self, worker_name: str, package_dir: str, account_id: str, language: str, benchmark_name: Optional[str] = None, code_package: Optional[Benchmark] = None ) -> dict: """Create or update a Cloudflare Worker using Wrangler CLI. @@ -590,6 +608,7 @@ def _create_or_update_worker( account_id: Cloudflare account ID language: Programming language (nodejs or python) benchmark_name: Optional benchmark name for R2 file path prefix + code_package: Optional benchmark package for nosql configuration Returns: Worker deployment result @@ -608,7 +627,7 @@ def _create_or_update_worker( # self.logging.error(f"Failed to convert function.js to ESM: {e}") # raise # Generate wrangler.toml for this worker - self._generate_wrangler_toml(worker_name, package_dir, language, account_id, benchmark_name) + self._generate_wrangler_toml(worker_name, package_dir, language, account_id, benchmark_name, code_package) # Set up environment for Wrangler env = os.environ.copy() @@ -767,7 +786,7 @@ def update_function( if not account_id: raise RuntimeError("Account ID is required to update worker") - self._create_or_update_worker(worker.name, package, account_id, language, benchmark) + self._create_or_update_worker(worker.name, package, account_id, language, benchmark, code_package) self.logging.info(f"Updated worker {worker.name}") # Update configuration if needed diff --git a/sebs/cloudflare/durable_objects.py b/sebs/cloudflare/durable_objects.py index 03d36c179..8997ebf92 100644 --- a/sebs/cloudflare/durable_objects.py +++ b/sebs/cloudflare/durable_objects.py @@ -1,5 +1,4 @@ import json -import requests from collections import defaultdict from typing import Dict, Optional, Tuple @@ -13,10 +12,11 @@ class DurableObjects(NoSQLStorage): """ Cloudflare Durable Objects implementation for NoSQL storage. - Note: Durable Objects are not a traditional NoSQL database like DynamoDB or CosmosDB. - They are stateful Workers with persistent storage. This implementation provides - a minimal interface to satisfy SeBS requirements, but full table operations - are not supported. + Note: Durable Objects are not managed via API like DynamoDB or CosmosDB. + Instead, they are defined in the Worker code and wrangler.toml, and accessed + via bindings in the Worker environment. This implementation provides a minimal + interface to satisfy SeBS requirements by tracking table names without actual + API-based table creation. """ @staticmethod @@ -35,7 +35,7 @@ def __init__( credentials: CloudflareCredentials, ): super().__init__(region, cache_client, resources) - self._credentials = credentials + # Tables are just logical names - Durable Objects are accessed via Worker bindings self._tables: Dict[str, Dict[str, str]] = defaultdict(dict) def _get_auth_headers(self) -> dict[str, str]: @@ -116,28 +116,28 @@ def create_table( self, benchmark: str, name: str, primary_key: str, secondary_key: Optional[str] = None ) -> str: """ - Create a table (Durable Object namespace). + Register a table name for a benchmark. Note: Durable Objects don't have traditional table creation via API. - They are defined in the Worker code and wrangler.toml. - This method just tracks the table name. + They are defined in the Worker code and wrangler.toml, and accessed via + bindings. This method just tracks the logical table name for the wrapper + to use when accessing the Durable Object binding. :param benchmark: benchmark name :param name: table name :param primary_key: primary key field name :param secondary_key: optional secondary key field name - :return: table name + :return: table name (same as input name - used directly as binding name) """ - resource_id = self._cloud_resources.resources_id - table_name = f"sebs-benchmarks-{resource_id}-{benchmark}-{name}" - - self._tables[benchmark][name] = table_name + # For Cloudflare, table names are used directly as the binding names + # in the wrapper code, so we just use the simple name + self._tables[benchmark][name] = name self.logging.info( - f"Registered Durable Objects table {table_name} for benchmark {benchmark}" + f"Registered Durable Object table '{name}' for benchmark {benchmark}" ) - return table_name + return name def write_to_table( self, @@ -150,8 +150,10 @@ def write_to_table( """ Write data to a table (Durable Object). - Note: This would require HTTP requests to the Durable Object endpoints. - For now, this is not fully implemented. + Note: Cloudflare Durable Objects can only be written to from within the Worker, + not via external API calls. Data seeding for benchmarks is not supported. + Benchmarks that require pre-populated data (like test/small sizes of crud-api) + will return empty results. Use 'large' size which creates its own data. :param benchmark: benchmark name :param table: table name @@ -164,23 +166,25 @@ def write_to_table( if not table_name: raise ValueError(f"Table {table} not found for benchmark {benchmark}") - self.logging.warning( - f"write_to_table not fully implemented for Durable Objects table {table_name}" - ) + # Silently skip data seeding for Cloudflare Durable Objects + # This is a platform limitation + pass def clear_table(self, name: str) -> str: """ Clear all data from a table. + Note: Durable Object data is managed within the Worker. + :param name: table name :return: table name """ - self.logging.warning(f"clear_table not fully implemented for Durable Objects table {name}") + self.logging.info(f"Durable Objects data is managed within the Worker") return name def remove_table(self, name: str) -> str: """ - Remove a table. + Remove a table from tracking. :param name: table name :return: table name @@ -202,8 +206,14 @@ def envs(self) -> dict: """ Get environment variables for accessing Durable Objects. + Durable Objects are accessed via bindings in the Worker environment, + which are configured in wrangler.toml. We set a marker environment + variable so the wrapper knows Durable Objects are available. + :return: dictionary of environment variables """ - # Durable Objects are accessed via bindings in the Worker - # No additional environment variables needed - return {} + # Set a marker that Durable Objects are enabled + # The actual bindings (DURABLE_STORE, etc.) are configured in wrangler.toml + return { + "NOSQL_STORAGE_DATABASE": "durable_objects" + } From 5f9ad9c5157607f0b3932000cc0dc3d205618ef6 Mon Sep 17 00:00:00 2001 From: laurin Date: Sun, 30 Nov 2025 16:08:07 +0100 Subject: [PATCH 27/69] asyncified the function calls... --- .../wrappers/cloudflare/nodejs/build.js | 50 +++++++++++++------ 1 file changed, 34 insertions(+), 16 deletions(-) diff --git a/benchmarks/wrappers/cloudflare/nodejs/build.js b/benchmarks/wrappers/cloudflare/nodejs/build.js index e6bb65dd1..fc946e845 100644 --- a/benchmarks/wrappers/cloudflare/nodejs/build.js +++ b/benchmarks/wrappers/cloudflare/nodejs/build.js @@ -57,34 +57,52 @@ const asyncNosqlPlugin = { build.onLoad({ filter: /function\.js$/ }, async (args) => { let contents = await fs.promises.readFile(args.path, 'utf8'); + // Only transform if file uses nosql + if (!contents.includes('nosqlClient')) { + return { contents, loader: 'js' }; + } + console.log('🔧 Transforming function.js for async nosql...'); // Step 1: Add await before nosqlClient method calls contents = contents.replace(/(\s*)((?:const|let|var)\s+\w+\s*=\s*)?nosqlClient\.(insert|get|update|query|delete)\s*\(/g, '$1$2await nosqlClient.$3('); - // Step 2: Make all function declarations async - contents = contents.replace(/\bfunction\s+(\w+)\s*\(/g, 'async function $1('); + // Step 2: Make all function declarations async (but not function expressions) + contents = contents.replace(/^(\s*)function\s+(\w+)\s*\(/gm, '$1async function $2('); - // Step 3: Make exported handler async if not already - contents = contents.replace(/exports\.handler\s*=\s*function\s*\(/g, 'exports.handler = async function('); - - // Step 4: Add await before specific function calls - // Split into lines to avoid matching function declarations + // Step 3: Add await before user-defined function calls + // Process line by line to handle specific patterns const lines = contents.split('\n'); const transformedLines = lines.map(line => { - // Skip lines that contain function declarations - if (line.match(/\b(async\s+)?function\s+\w+\s*\(/)) { + // Skip lines with function declarations or function expressions + if (line.match(/\bfunction\s+\w+\s*\(/) || line.match(/=\s*(async\s+)?function\s*\(/)) { return line; } - // Transform function calls in this line - const functionNames = ['addProduct', 'getProducts', 'queryProducts', 'updateProducts', 'deleteProducts']; - for (const funcName of functionNames) { - // Match calls: spaces + optional assignment + functionName( - const callRegex = new RegExp(`(\\s*)((?:const|let|var)\\s+\\w+\\s*=\\s*)?(${funcName})\\s*\\(`, 'g'); - line = line.replace(callRegex, '$1$2await $3('); - } + // Add await before function calls that look like user-defined functions + // Match: identifier followed by ( where identifier starts line or follows whitespace/operators + // but NOT if preceded by = (assignment), . (method call), or keywords + line = line.replace(/(^|\s+|;|,|\()((?:const|let|var)\s+\w+\s*=\s*)?(\w+)\s*\(/g, (match, prefix, assignment, funcName) => { + // Skip control flow keywords + const controlFlow = ['if', 'for', 'while', 'switch', 'catch', 'return']; + if (controlFlow.includes(funcName)) { + return match; + } + + // Skip built-in JavaScript functions and methods + const builtins = ['console', 'require', 'push', 'join', 'split', + 'map', 'filter', 'reduce', 'forEach', 'find', 'findIndex', + 'some', 'every', 'includes', 'parseInt', 'parseFloat', + 'isNaN', 'Array', 'Object', 'String', 'Number', 'Boolean', + 'Math', 'JSON', 'Date', 'RegExp', 'Error', 'Promise']; + if (builtins.includes(funcName)) { + return match; + } + + // Add await for everything else + return `${prefix}${assignment || ''}await ${funcName}(`; + }); return line; }); From 92db5ae52e15ec33d5e10fc59ced1cde1e2baef7 Mon Sep 17 00:00:00 2001 From: ldzgch Date: Mon, 1 Dec 2025 23:21:14 +0100 Subject: [PATCH 28/69] fix python vendored modules --- .../python/function_cloudflare.py | 56 +++++++ .../wrappers/cloudflare/python/handler.py | 20 +-- sebs/cloudflare/cloudflare.py | 145 ++++++++++++++---- 3 files changed, 179 insertions(+), 42 deletions(-) create mode 100644 benchmarks/100.webapps/120.uploader/python/function_cloudflare.py diff --git a/benchmarks/100.webapps/120.uploader/python/function_cloudflare.py b/benchmarks/100.webapps/120.uploader/python/function_cloudflare.py new file mode 100644 index 000000000..98372cf0f --- /dev/null +++ b/benchmarks/100.webapps/120.uploader/python/function_cloudflare.py @@ -0,0 +1,56 @@ + +import datetime +import os + +from pyodide.ffi import run_sync +from pyodide.http import pyfetch + +from . import storage +client = storage.storage.get_instance() + +SEBS_USER_AGENT = "SeBS/1.2 (https://github.com/spcl/serverless-benchmarks) SeBS Benchmark Suite/1.2" + +async def do_request(url, download_path): + headers = {'User-Agent': SEBS_USER_AGENT} + + res = await pyfetch(url, headers=headers) + bs = await res.bytes() + + with open(download_path, 'wb') as f: + f.write(bs) + +def handler(event): + + bucket = event.get('bucket').get('bucket') + output_prefix = event.get('bucket').get('output') + url = event.get('object').get('url') + name = os.path.basename(url) + download_path = '/tmp/{}'.format(name) + + process_begin = datetime.datetime.now() + + run_sync(do_request(url, download_path)) + + size = os.path.getsize(download_path) + process_end = datetime.datetime.now() + + upload_begin = datetime.datetime.now() + key_name = client.upload(bucket, os.path.join(output_prefix, name), download_path) + upload_end = datetime.datetime.now() + + process_time = (process_end - process_begin) / datetime.timedelta(microseconds=1) + upload_time = (upload_end - upload_begin) / datetime.timedelta(microseconds=1) + return { + 'result': { + 'bucket': bucket, + 'url': url, + 'key': key_name + }, + 'measurement': { + 'download_time': 0, + 'download_size': 0, + 'upload_time': upload_time, + 'upload_size': size, + 'compute_time': process_time + } + } diff --git a/benchmarks/wrappers/cloudflare/python/handler.py b/benchmarks/wrappers/cloudflare/python/handler.py index 332c2b67b..3f8ba6ca8 100644 --- a/benchmarks/wrappers/cloudflare/python/handler.py +++ b/benchmarks/wrappers/cloudflare/python/handler.py @@ -21,7 +21,7 @@ class KVApiObject(DurableObject): def __getattr__(self, name): return getattr(self.ctx.storage, name) - + class Default(WorkerEntrypoint): async def fetch(self, request, env): try: @@ -70,11 +70,11 @@ async def fetch2(self, request, env): storage.storage.init_instance(self) - if 'NOSQL_STORAGE_DATABASE' in os.environ: + if self.env.NOSQL_STORAGE_DATABASE: from function import nosql - - nosql.nosql.get_instance(self) - + + nosql.nosql.init_instance(self) + print("event:", event) @@ -82,7 +82,7 @@ async def fetch2(self, request, env): ## function = import_from_path("function.function", "/tmp/function.py") from function import function - + ret = function.handler(event) log_data = { @@ -136,14 +136,14 @@ def visit_FunctionDef(self, node): class AddAwait(ast.NodeTransformer): to_find = ["upload_stream", "download_stream", "upload", "download", "download_directory"] - + def visit_Call(self, node): if isinstance(node.func, ast.Attribute) and node.func.attr in self.to_find: #print(ast.dump(node.func, indent=2)) return ast.Await(value=node) - + return node - + def make_benchmark_func(): with open(working_dir +"/function/function.py") as f: module = ast.parse(f.read()) @@ -155,5 +155,5 @@ def make_benchmark_func(): ##print() with open("/tmp/function.py", "w") as wf: wf.write(new_source) - + diff --git a/sebs/cloudflare/cloudflare.py b/sebs/cloudflare/cloudflare.py index af183865d..946e5203c 100644 --- a/sebs/cloudflare/cloudflare.py +++ b/sebs/cloudflare/cloudflare.py @@ -187,6 +187,40 @@ def _ensure_wrangler_installed(self): except subprocess.TimeoutExpired: raise RuntimeError("Wrangler version check timed out") + def _ensure_pywrangler_installed(self): + """Necessary to download python dependencies""" + try: + result = subprocess.run( + ["pywrangler", "--version"], + capture_output=True, + text=True, + check=True, + timeout=10 + ) + version = result.stdout.strip() + self.logging.info(f"pywrangler is installed: {version}") + except (subprocess.CalledProcessError, FileNotFoundError): + self.logging.info("pywrangler not found, installing globally via uv tool install...") + try: + result = subprocess.run( + ["uv", "tool", "install", "workers-py"], + capture_output=True, + text=True, + check=True, + timeout=120 + ) + self.logging.info("pywrangler installed successfully") + if result.stdout: + self.logging.debug(f"uv tool install workers-py output: {result.stdout}") + except subprocess.CalledProcessError as e: + raise RuntimeError(f"Failed to install pywrangler: {e.stderr}") + except FileNotFoundError: + raise RuntimeError( + "uv not found. Please install uv." + ) + except subprocess.TimeoutExpired: + raise RuntimeError("pywrangler version check timed out") + def _generate_wrangler_toml(self, worker_name: str, package_dir: str, language: str, account_id: str, benchmark_name: Optional[str] = None, code_package: Optional[Benchmark] = None) -> str: """ @@ -254,11 +288,11 @@ def _generate_wrangler_toml(self, worker_name: str, package_dir: str, language: vars_content = "" if benchmark_name: vars_content += f'BENCHMARK_NAME = "{benchmark_name}"\n' - + # Add nosql configuration if benchmark uses it if code_package and code_package.uses_nosql: vars_content += 'NOSQL_STORAGE_DATABASE = "durable_objects"\n' - + if vars_content: toml_content += f"""# Environment variables [vars] @@ -274,12 +308,12 @@ def _generate_wrangler_toml(self, worker_name: str, package_dir: str, language: toml_content += f"""# R2 bucket binding for benchmarking files # This bucket is used by fs and path polyfills to read benchmark data [[r2_buckets]] -binding = "R2" +binding = "{bucket_name}" bucket_name = "{bucket_name}" """ r2_bucket_configured = True - self.logging.info(f"R2 bucket '{bucket_name}' will be bound to worker as 'R2'") + self.logging.info(f"R2 bucket '{bucket_name}' will be bound to worker as '{bucket_name}'") except Exception as e: self.logging.warning( f"R2 bucket binding not configured: {e}. " @@ -343,12 +377,12 @@ def package_code( "Container deployment is not supported for Cloudflare Workers" ) - # Ensure Wrangler is installed - self._ensure_wrangler_installed() - # Install dependencies if language_name == "nodejs": + # Ensure Wrangler is installed + self._ensure_wrangler_installed() + package_file = os.path.join(directory, "package.json") node_modules = os.path.join(directory, "node_modules") @@ -413,43 +447,90 @@ def package_code( self.logging.warning(f"Failed to install esbuild: {e}") elif language_name == "python": - requirements_file = os.path.join(directory, "requirements.txt") + # Ensure Wrangler is installed + self._ensure_pywrangler_installed() + requirements_file = os.path.join(directory, "requirements.txt") if os.path.exists(f"{requirements_file}.{language_version}"): src = f"{requirements_file}.{language_version}" dest = requirements_file shutil.move(src, dest) self.logging.info(f"move {src} to {dest}") + + + # move function_cloudflare.py into function.py + function_cloudflare_file = os.path.join(directory, "function_cloudflare.py") + if os.path.exists(function_cloudflare_file): + src = function_cloudflare_file + dest = os.path.join(directory, "function.py") + shutil.move(src, dest) + self.logging.info(f"move {src} to {dest}") + if os.path.exists(requirements_file): - self.logging.info(f"Installing Python dependencies in {directory}") - try: - # Install to a local directory that can be bundled - target_dir = os.path.join(directory, "python_modules") - result = subprocess.run( - ["pip", "install", "-r", "requirements.txt", "-t", target_dir], - cwd=directory, - capture_output=True, - text=True, - check=True - ) - self.logging.info("pip install completed successfully") - if result.stdout: - self.logging.debug(f"pip output: {result.stdout}") - except subprocess.CalledProcessError as e: - self.logging.error(f"pip install failed: {e.stderr}") - raise RuntimeError(f"Failed to install Python dependencies: {e.stderr}") - except FileNotFoundError: - raise RuntimeError( - "pip not found. Please install Python and pip to deploy Python benchmarks." - ) + with open(requirements_file, 'r') as reqf: + reqtext = reqf.read() + supported_pkg = \ +['affine', 'aiohappyeyeballs', 'aiohttp', 'aiosignal', 'altair', 'annotated-types',\ +'anyio', 'apsw', 'argon2-cffi', 'argon2-cffi-bindings', 'asciitree', 'astropy', 'astropy_iers_data',\ +'asttokens', 'async-timeout', 'atomicwrites', 'attrs', 'audioop-lts', 'autograd', 'awkward-cpp', 'b2d',\ +'bcrypt', 'beautifulsoup4', 'bilby.cython', 'biopython', 'bitarray', 'bitstring', 'bleach', 'blosc2', 'bokeh',\ +'boost-histogram', 'brotli', 'cachetools', 'casadi', 'cbor-diag', 'certifi', 'cffi', 'cffi_example', 'cftime',\ +'charset-normalizer', 'clarabel', 'click', 'cligj', 'clingo', 'cloudpickle', 'cmyt', 'cobs', 'colorspacious',\ +'contourpy', 'coolprop', 'coverage', 'cramjam', 'crc32c', 'cryptography', 'css-inline', 'cssselect', 'cvxpy-base', 'cycler',\ +'cysignals', 'cytoolz', 'decorator', 'demes', 'deprecation', 'diskcache', 'distlib', 'distro', 'docutils', 'donfig',\ +'ewah_bool_utils', 'exceptiongroup', 'executing', 'fastapi', 'fastcan', 'fastparquet', 'fiona', 'fonttools', 'freesasa',\ +'frozenlist', 'fsspec', 'future', 'galpy', 'gmpy2', 'gsw', 'h11', 'h3', 'h5py', 'highspy', 'html5lib', 'httpcore',\ +'httpx', 'idna', 'igraph', 'imageio', 'imgui-bundle', 'iminuit', 'iniconfig', 'inspice', 'ipython', 'jedi', 'Jinja2',\ +'jiter', 'joblib', 'jsonpatch', 'jsonpointer', 'jsonschema', 'jsonschema_specifications', 'kiwisolver',\ +'lakers-python', 'lazy_loader', 'lazy-object-proxy', 'libcst', 'lightgbm', 'logbook', 'lxml', 'lz4', 'MarkupSafe',\ +'matplotlib', 'matplotlib-inline', 'memory-allocator', 'micropip', 'mmh3', 'more-itertools', 'mpmath',\ +'msgpack', 'msgspec', 'msprime', 'multidict', 'munch', 'mypy', 'narwhals', 'ndindex', 'netcdf4', 'networkx',\ +'newick', 'nh3', 'nlopt', 'nltk', 'numcodecs', 'numpy', 'openai', 'opencv-python', 'optlang', 'orjson',\ +'packaging', 'pandas', 'parso', 'patsy', 'pcodec', 'peewee', 'pi-heif', 'Pillow', 'pillow-heif', 'pkgconfig',\ +'platformdirs', 'pluggy', 'ply', 'pplpy', 'primecountpy', 'prompt_toolkit', 'propcache', 'protobuf', 'pure-eval',\ +'py', 'pyclipper', 'pycparser', 'pycryptodome', 'pydantic', 'pydantic_core', 'pyerfa', 'pygame-ce', 'Pygments',\ +'pyheif', 'pyiceberg', 'pyinstrument', 'pylimer-tools', 'PyMuPDF', 'pynacl', 'pyodide-http', 'pyodide-unix-timezones',\ +'pyparsing', 'pyrsistent', 'pysam', 'pyshp', 'pytaglib', 'pytest', 'pytest-asyncio', 'pytest-benchmark', 'pytest_httpx',\ +'python-calamine', 'python-dateutil', 'python-flint', 'python-magic', 'python-sat', 'python-solvespace', 'pytz', 'pywavelets',\ +'pyxel', 'pyxirr', 'pyyaml', 'rasterio', 'rateslib', 'rebound', 'reboundx', 'referencing', 'regex', 'requests',\ +'retrying', 'rich', 'river', 'RobotRaconteur', 'rpds-py', 'ruamel.yaml', 'rustworkx', 'scikit-image', 'scikit-learn',\ +'scipy', 'screed', 'setuptools', 'shapely', 'simplejson', 'sisl', 'six', 'smart-open', 'sniffio', 'sortedcontainers',\ +'soundfile', 'soupsieve', 'sourmash', 'soxr', 'sparseqr', 'sqlalchemy', 'stack-data', 'starlette', 'statsmodels', 'strictyaml',\ +'svgwrite', 'swiglpk', 'sympy', 'tblib', 'termcolor', 'texttable', 'texture2ddecoder', 'threadpoolctl', 'tiktoken', 'tomli',\ +'tomli-w', 'toolz', 'tqdm', 'traitlets', 'traits', 'tree-sitter', 'tree-sitter-go', 'tree-sitter-java', 'tree-sitter-python',\ +'tskit', 'typing-extensions', 'tzdata', 'ujson', 'uncertainties', 'unyt', 'urllib3', 'vega-datasets', 'vrplib', 'wcwidth',\ +'webencodings', 'wordcloud', 'wrapt', 'xarray', 'xgboost', 'xlrd', 'xxhash', 'xyzservices', 'yarl', 'yt', 'zengl', 'zfpy', 'zstandard'] + needed_pkg = [] + for pkg in supported_pkg: + if pkg.lower() in reqtext.lower(): + needed_pkg.append(pkg) + + project_file = os.path.join(directory, "pyproject.toml") + depstr = str(needed_pkg).replace("\'", "\"") + with open(project_file, 'w') as pf: + pf.write(f""" +[project] +name = "{benchmark.replace(".", "-")}-python-{language_version.replace(".", "")}" +version = "0.1.0" +description = "dummy description" +requires-python = ">={language_version}" +dependencies = {depstr} + +[dependency-groups] +dev = [ + "workers-py", + "workers-runtime-sdk" +] + """) # move into function dir funcdir = os.path.join(directory, "function") if not os.path.exists(funcdir): os.makedirs(funcdir) + dont_move = ["handler.py", "function", "python_modules", "pyproject.toml"] for thing in os.listdir(directory): - if not (thing.endswith("handler.py") or thing.endswith("function") or thing.endswith("python_modules")): + if thing not in dont_move: src = os.path.join(directory, thing) dest = os.path.join(directory, "function", thing) shutil.move(src, dest) @@ -489,7 +570,7 @@ def package_code( total_size += os.path.getsize(filepath) mbytes = total_size / 1024.0 / 1024.0 - self.logging.info(f"Worker package size: {mbytes:.2f} MB") + self.logging.info(f"Worker package size: {mbytes:.2f} MB (Python: missing vendored modules)") return (directory, total_size, "") @@ -644,7 +725,7 @@ def _create_or_update_worker( try: result = subprocess.run( - ["wrangler", "deploy"], + ["wrangler" if language == "nodejs" else "pywrangler", "deploy"], cwd=package_dir, env=env, capture_output=True, From 51892b092a3857be4f213bc2a09083bb7ee153b5 Mon Sep 17 00:00:00 2001 From: laurin Date: Sun, 30 Nov 2025 18:19:32 +0100 Subject: [PATCH 29/69] added request polyfill for benchmark 120 --- .../wrappers/cloudflare/nodejs/build.js | 11 ++ .../cloudflare/nodejs/request-polyfill.js | 100 ++++++++++++++++++ configs/systems.json | 3 +- 3 files changed, 113 insertions(+), 1 deletion(-) create mode 100644 benchmarks/wrappers/cloudflare/nodejs/request-polyfill.js diff --git a/benchmarks/wrappers/cloudflare/nodejs/build.js b/benchmarks/wrappers/cloudflare/nodejs/build.js index fc946e845..7caf096dd 100644 --- a/benchmarks/wrappers/cloudflare/nodejs/build.js +++ b/benchmarks/wrappers/cloudflare/nodejs/build.js @@ -38,6 +38,8 @@ function copyFile(src, dest) { const nodeBuiltinsPlugin = { name: 'node-builtins-external', setup(build) { + const { resolve } = require('path'); + // Keep node: prefixed modules external build.onResolve({ filter: /^(node:|cloudflare:)/ }, (args) => { return { path: args.path, external: true }; @@ -47,6 +49,15 @@ const nodeBuiltinsPlugin = { build.onResolve({ filter: /^(fs|querystring|path|crypto|stream|buffer|util|events|http|https|net|tls|zlib|os|child_process|tty|assert|url)$/ }, (args) => { return { path: 'node:' + args.path, external: true }; }); + + // Polyfill 'request' module with fetch-based implementation + build.onResolve({ filter: /^request$/ }, (args) => { + // Get the directory where build.js is located (wrapper directory) + const wrapperDir = __dirname; + return { + path: resolve(wrapperDir, 'request-polyfill.js') + }; + }); } }; diff --git a/benchmarks/wrappers/cloudflare/nodejs/request-polyfill.js b/benchmarks/wrappers/cloudflare/nodejs/request-polyfill.js new file mode 100644 index 000000000..f44bfa232 --- /dev/null +++ b/benchmarks/wrappers/cloudflare/nodejs/request-polyfill.js @@ -0,0 +1,100 @@ +/** + * Polyfill for the 'request' module using Cloudflare Workers fetch API + * Implements the minimal interface needed for benchmark compatibility + */ + +const { Writable } = require('node:stream'); +const fs = require('node:fs'); + +function request(url, options, callback) { + // Handle different call signatures + if (typeof options === 'function') { + callback = options; + options = {}; + } + + // Add default headers to mimic a browser request + const fetchOptions = { + ...options, + headers: { + 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36', + 'Accept': '*/*', + ...((options && options.headers) || {}) + } + }; + + // Create a simple object that has a pipe method + const requestObj = { + pipe(destination) { + // Perform the fetch and write to destination + fetch(url, fetchOptions) + .then(async (response) => { + if (!response.ok) { + const error = new Error(`HTTP ${response.status}: ${response.statusText}`); + error.statusCode = response.status; + destination.emit('error', error); + if (callback) callback(error, response, null); + return destination; + } + + // Get the response as arrayBuffer and write it all at once + const buffer = await response.arrayBuffer(); + + // Write the buffer to the destination + if (destination.write) { + destination.write(Buffer.from(buffer)); + destination.end(); + } + + if (callback) callback(null, response, Buffer.from(buffer)); + }) + .catch((error) => { + destination.emit('error', error); + if (callback) callback(error, null, null); + }); + + return destination; + }, + + abort() { + // No-op for compatibility + } + }; + + return requestObj; +} + +// Add common request methods +request.get = (url, options, callback) => { + if (typeof options === 'function') { + callback = options; + options = {}; + } + return request(url, { ...options, method: 'GET' }, callback); +}; + +request.post = (url, options, callback) => { + if (typeof options === 'function') { + callback = options; + options = {}; + } + return request(url, { ...options, method: 'POST' }, callback); +}; + +request.put = (url, options, callback) => { + if (typeof options === 'function') { + callback = options; + options = {}; + } + return request(url, { ...options, method: 'PUT' }, callback); +}; + +request.delete = (url, options, callback) => { + if (typeof options === 'function') { + callback = options; + options = {}; + } + return request(url, { ...options, method: 'DELETE' }, callback); +}; + +module.exports = request; diff --git a/configs/systems.json b/configs/systems.json index 3eb79b648..4ac3131f9 100644 --- a/configs/systems.json +++ b/configs/systems.json @@ -462,7 +462,8 @@ "handler.js", "storage.js", "nosql.js", - "build.js" + "build.js", + "request-polyfill.js" ], "packages": { "uuid": "3.4.0" From 3235d3f4fd29a8a254d51af1bc34c8b0ca86a905 Mon Sep 17 00:00:00 2001 From: laurin Date: Thu, 4 Dec 2025 12:00:49 +0100 Subject: [PATCH 30/69] fixed r2 usage for 120, 311 --- .../311.compression/nodejs/function.js | 147 ++++++++++++++++++ .../311.compression/nodejs/package.json | 9 ++ .../wrappers/cloudflare/nodejs/handler.js | 14 +- .../wrappers/cloudflare/nodejs/storage.js | 60 ++++--- sebs/cloudflare/cloudflare.py | 4 +- 5 files changed, 204 insertions(+), 30 deletions(-) create mode 100644 benchmarks/300.utilities/311.compression/nodejs/function.js create mode 100644 benchmarks/300.utilities/311.compression/nodejs/package.json diff --git a/benchmarks/300.utilities/311.compression/nodejs/function.js b/benchmarks/300.utilities/311.compression/nodejs/function.js new file mode 100644 index 000000000..5f7cc04d4 --- /dev/null +++ b/benchmarks/300.utilities/311.compression/nodejs/function.js @@ -0,0 +1,147 @@ +const fs = require('fs'); +const path = require('path'); +const zlib = require('zlib'); +const { v4: uuidv4 } = require('uuid'); +const storage = require('./storage'); + +let storage_handler = new storage.storage(); + +/** + * Calculate total size of a directory recursively + * @param {string} directory - Path to directory + * @returns {number} Total size in bytes + */ +function parseDirectory(directory) { + let size = 0; + + function walkDir(dir) { + const files = fs.readdirSync(dir); + for (const file of files) { + const filepath = path.join(dir, file); + const stat = fs.statSync(filepath); + if (stat.isDirectory()) { + walkDir(filepath); + } else { + size += stat.size; + } + } + } + + walkDir(directory); + return size; +} + +/** + * Create a simple tar.gz archive from a directory using native zlib + * This creates a gzip-compressed tar archive without external dependencies + * @param {string} sourceDir - Directory to compress + * @param {string} outputPath - Path for the output archive file + * @returns {Promise} + */ +async function createTarGzArchive(sourceDir, outputPath) { + // Create a simple tar-like format (concatenated files with headers) + const files = []; + + function collectFiles(dir, baseDir = '') { + const entries = fs.readdirSync(dir); + for (const entry of entries) { + const fullPath = path.join(dir, entry); + const relativePath = path.join(baseDir, entry); + const stat = fs.statSync(fullPath); + + if (stat.isDirectory()) { + collectFiles(fullPath, relativePath); + } else { + files.push({ + path: relativePath, + fullPath: fullPath, + size: stat.size + }); + } + } + } + + collectFiles(sourceDir); + + // Create a concatenated buffer of all files with simple headers + const chunks = []; + for (const file of files) { + const content = fs.readFileSync(file.fullPath); + // Simple header: filename length (4 bytes) + filename + content length (4 bytes) + content + const pathBuffer = Buffer.from(file.path); + const pathLengthBuffer = Buffer.allocUnsafe(4); + pathLengthBuffer.writeUInt32BE(pathBuffer.length, 0); + const contentLengthBuffer = Buffer.allocUnsafe(4); + contentLengthBuffer.writeUInt32BE(content.length, 0); + + chunks.push(pathLengthBuffer); + chunks.push(pathBuffer); + chunks.push(contentLengthBuffer); + chunks.push(content); + } + + const combined = Buffer.concat(chunks); + + // Compress using gzip + const compressed = zlib.gzipSync(combined, { level: 9 }); + fs.writeFileSync(outputPath, compressed); +} + +exports.handler = async function(event) { + const bucket = event.bucket.bucket; + const input_prefix = event.bucket.input; + const output_prefix = event.bucket.output; + const key = event.object.key; + + // Create unique download path + const download_path = path.join('/tmp', `${key}-${uuidv4()}`); + fs.mkdirSync(download_path, { recursive: true }); + + // Download directory from storage + const s3_download_begin = Date.now(); + await storage_handler.download_directory(bucket, path.join(input_prefix, key), download_path); + const s3_download_stop = Date.now(); + + // Calculate size of downloaded files + const size = parseDirectory(download_path); + + // Compress directory + const compress_begin = Date.now(); + const archive_name = `${key}.tar.gz`; + const archive_path = path.join(download_path, archive_name); + await createTarGzArchive(download_path, archive_path); + const compress_end = Date.now(); + + // Get archive size + const archive_size = fs.statSync(archive_path).size; + + // Upload compressed archive + const s3_upload_begin = Date.now(); + const [key_name, uploadPromise] = storage_handler.upload( + bucket, + path.join(output_prefix, archive_name), + archive_path + ); + await uploadPromise; + const s3_upload_stop = Date.now(); + + // Calculate times in microseconds + const download_time = (s3_download_stop - s3_download_begin) * 1000; + const upload_time = (s3_upload_stop - s3_upload_begin) * 1000; + const process_time = (compress_end - compress_begin) * 1000; + + return { + result: { + bucket: bucket, + key: key_name + }, + measurement: { + download_time: download_time, + download_size: size, + upload_time: upload_time, + upload_size: archive_size, + compute_time: process_time + } + }; +}; + diff --git a/benchmarks/300.utilities/311.compression/nodejs/package.json b/benchmarks/300.utilities/311.compression/nodejs/package.json new file mode 100644 index 000000000..56827265a --- /dev/null +++ b/benchmarks/300.utilities/311.compression/nodejs/package.json @@ -0,0 +1,9 @@ +{ + "name": "compression-benchmark", + "version": "1.0.0", + "description": "Compression benchmark for serverless platforms", + "main": "function.js", + "dependencies": { + "uuid": "^10.0.0" + } +} diff --git a/benchmarks/wrappers/cloudflare/nodejs/handler.js b/benchmarks/wrappers/cloudflare/nodejs/handler.js index c72b7d5ec..507d68153 100644 --- a/benchmarks/wrappers/cloudflare/nodejs/handler.js +++ b/benchmarks/wrappers/cloudflare/nodejs/handler.js @@ -96,12 +96,20 @@ export default { throw new Error('Failed to import benchmark function module: ' + e2.message); } - // If the function module exposes a storage initializer, call it + // Initialize storage - try function module first, then fall back to wrapper storage try { if (funcModule && funcModule.storage && typeof funcModule.storage.init_instance === 'function') { + funcModule.storage.init_instance({ env, request }); + } else { + // Function doesn't export storage, so initialize wrapper storage directly try { - funcModule.storage.init_instance({ env, request }); - } catch (ignore) {} + const storageModule = await import('./storage.js'); + if (storageModule && storageModule.storage && typeof storageModule.storage.init_instance === 'function') { + storageModule.storage.init_instance({ env, request }); + } + } catch (storageErr) { + // Ignore errors from storage initialization + } } } catch (e) { // don't fail the request if storage init isn't available diff --git a/benchmarks/wrappers/cloudflare/nodejs/storage.js b/benchmarks/wrappers/cloudflare/nodejs/storage.js index 72e71e288..a49cc3347 100644 --- a/benchmarks/wrappers/cloudflare/nodejs/storage.js +++ b/benchmarks/wrappers/cloudflare/nodejs/storage.js @@ -31,15 +31,32 @@ class storage { // so callers should use upload_stream or pass raw data. For Node.js we read // the file from disk and put it into R2 if available, otherwise throw. upload(__bucket, key, filepath) { + // Use singleton instance if available, otherwise use this instance + const instance = storage.instance || this; + // If file was previously written during this invocation, use /tmp absolute let realPath = filepath; - if (this.written_files.has(filepath)) { + if (instance.written_files.has(filepath)) { realPath = path.join('/tmp', path.resolve(filepath)); } - // In Workers environment with R2, check if file exists in R2 + const unique_key = storage.unique_name(key); + + // Try filesystem first (for Workers with nodejs_compat that have /tmp) + if (fs && fs.existsSync(realPath)) { + const data = fs.readFileSync(realPath); + + if (instance.handle) { + const uploadPromise = instance.handle.put(unique_key, data); + return [unique_key, uploadPromise]; + } else { + return [unique_key, Promise.resolve()]; + } + } + + // Fallback: In Workers environment with R2, check if file exists in R2 // (it may have been written by fs-polyfill's createWriteStream) - if (this.handle) { + if (instance.handle) { // Normalize the path to match what fs-polyfill would use let normalizedPath = realPath.replace(/^\.?\//, '').replace(/^tmp\//, ''); @@ -49,13 +66,11 @@ class storage { normalizedPath = globalThis.BENCHMARK_NAME + '/' + normalizedPath; } - const unique_key = storage.unique_name(key); - // Read from R2 and re-upload with unique key - const uploadPromise = this.handle.get(normalizedPath).then(async (obj) => { + const uploadPromise = instance.handle.get(normalizedPath).then(async (obj) => { if (obj) { const data = await obj.arrayBuffer(); - return this.handle.put(unique_key, data); + return instance.handle.put(unique_key, data); } else { throw new Error(`File not found in R2: ${normalizedPath} (original path: ${filepath})`); } @@ -64,23 +79,13 @@ class storage { return [unique_key, uploadPromise]; } - // Fallback: Read file content from local filesystem (Node.js environment) - if (fs && fs.existsSync(realPath)) { - const data = fs.readFileSync(realPath); - const unique_key = storage.unique_name(key); - - // Return [uniqueName, promise] to match Azure storage API - const uploadPromise = Promise.resolve(); - - return [unique_key, uploadPromise]; - } - // If running in Workers (no fs) and caller provided Buffer/Stream, they // should call upload_stream directly. Otherwise, throw. throw new Error('upload(): file not found on disk and no R2 handle provided'); } async download(__bucket, key, filepath) { + const instance = storage.instance || this; const data = await this.download_stream(__bucket, key); let real_fp = filepath; @@ -88,7 +93,7 @@ class storage { real_fp = path.join('/tmp', path.resolve(filepath)); } - this.written_files.add(filepath); + instance.written_files.add(filepath); // Write data to file if we have fs if (fs) { @@ -106,11 +111,13 @@ class storage { } async download_directory(__bucket, prefix, out_path) { - if (!this.handle) { + const instance = storage.instance || this; + + if (!instance.handle) { throw new Error('download_directory requires R2 binding (env.R2)'); } - const list_res = await this.handle.list({ prefix }); + const list_res = await instance.handle.list({ prefix }); const objects = list_res.objects || []; for (const obj of objects) { const file_name = obj.key; @@ -121,10 +128,11 @@ class storage { } async upload_stream(__bucket, key, data) { + const instance = storage.instance || this; const unique_key = storage.unique_name(key); - if (this.handle) { + if (instance.handle) { // R2 put accepts ArrayBuffer, ReadableStream, or string - await this.handle.put(unique_key, data); + await instance.handle.put(unique_key, data); return unique_key; } @@ -141,8 +149,10 @@ class storage { } async download_stream(__bucket, key) { - if (this.handle) { - const obj = await this.handle.get(key); + const instance = storage.instance || this; + + if (instance.handle) { + const obj = await instance.handle.get(key); if (!obj) return null; // R2 object provides arrayBuffer()/text() helpers in Workers if (typeof obj.arrayBuffer === 'function') { diff --git a/sebs/cloudflare/cloudflare.py b/sebs/cloudflare/cloudflare.py index 946e5203c..0d24b122a 100644 --- a/sebs/cloudflare/cloudflare.py +++ b/sebs/cloudflare/cloudflare.py @@ -308,12 +308,12 @@ def _generate_wrangler_toml(self, worker_name: str, package_dir: str, language: toml_content += f"""# R2 bucket binding for benchmarking files # This bucket is used by fs and path polyfills to read benchmark data [[r2_buckets]] -binding = "{bucket_name}" +binding = "R2" bucket_name = "{bucket_name}" """ r2_bucket_configured = True - self.logging.info(f"R2 bucket '{bucket_name}' will be bound to worker as '{bucket_name}'") + self.logging.info(f"R2 bucket '{bucket_name}' will be bound to worker as 'R2'") except Exception as e: self.logging.warning( f"R2 bucket binding not configured: {e}. " From 416b67bb3d987bea4904df4c1532df432ec10777 Mon Sep 17 00:00:00 2001 From: laurin Date: Sun, 7 Dec 2025 23:10:00 +0100 Subject: [PATCH 31/69] support for cloudflare containers (python and nodejs), container worker orchestrator, worker orchestrator proxy for r2 and durable objects to be used in container --- .../cloudflare/nodejs/container/handler.js | 195 ++++++ .../cloudflare/nodejs/container/nosql.js | 118 ++++ .../cloudflare/nodejs/container/package.json | 10 + .../cloudflare/nodejs/container/storage.js | 294 +++++++++ .../cloudflare/nodejs/container/worker.js | 362 ++++++++++++ .../cloudflare/python/container/handler.py | 196 ++++++ .../cloudflare/python/container/nosql.py | 117 ++++ .../cloudflare/python/container/storage.py | 203 +++++++ .../wrappers/cloudflare/python/handler.py | 2 +- .../wrappers/cloudflare/python/nosql.py | 9 +- .../wrappers/cloudflare/python/storage.py | 33 +- configs/cloudflare-test.json | 4 +- configs/systems.json | 36 +- dockerfiles/cloudflare/nodejs/Dockerfile | 21 + dockerfiles/cloudflare/python/Dockerfile | 31 + sebs/cli.py | 5 +- sebs/cloudflare/cloudflare.py | 557 ++++++++++++++++-- sebs/cloudflare/r2.py | 67 ++- sebs/experiments/config.py | 2 +- 19 files changed, 2186 insertions(+), 76 deletions(-) create mode 100644 benchmarks/wrappers/cloudflare/nodejs/container/handler.js create mode 100644 benchmarks/wrappers/cloudflare/nodejs/container/nosql.js create mode 100644 benchmarks/wrappers/cloudflare/nodejs/container/package.json create mode 100644 benchmarks/wrappers/cloudflare/nodejs/container/storage.js create mode 100644 benchmarks/wrappers/cloudflare/nodejs/container/worker.js create mode 100644 benchmarks/wrappers/cloudflare/python/container/handler.py create mode 100644 benchmarks/wrappers/cloudflare/python/container/nosql.py create mode 100644 benchmarks/wrappers/cloudflare/python/container/storage.py create mode 100644 dockerfiles/cloudflare/nodejs/Dockerfile create mode 100644 dockerfiles/cloudflare/python/Dockerfile diff --git a/benchmarks/wrappers/cloudflare/nodejs/container/handler.js b/benchmarks/wrappers/cloudflare/nodejs/container/handler.js new file mode 100644 index 000000000..6f99c6728 --- /dev/null +++ b/benchmarks/wrappers/cloudflare/nodejs/container/handler.js @@ -0,0 +1,195 @@ +// Container handler for Cloudflare Workers - Node.js +// This handler is used when deploying as a container worker + +const http = require('http'); + +// Monkey-patch the 'request' library to always include a User-Agent header +// This is needed because Wikimedia (and other sites) require a User-Agent +try { + const Module = require('module'); + const originalRequire = Module.prototype.require; + + Module.prototype.require = function(id) { + const module = originalRequire.apply(this, arguments); + + if (id === 'request') { + // Wrap the request function to inject default headers + const originalRequest = module; + const wrappedRequest = function(options, callback) { + if (typeof options === 'string') { + options = { uri: options }; + } + if (!options.headers) { + options.headers = {}; + } + if (!options.headers['User-Agent'] && !options.headers['user-agent']) { + options.headers['User-Agent'] = 'SeBS/1.2 (https://github.com/spcl/serverless-benchmarks) SeBS Benchmark Suite/1.2'; + } + return originalRequest(options, callback); + }; + // Copy all properties from original request + Object.keys(originalRequest).forEach(key => { + wrappedRequest[key] = originalRequest[key]; + }); + return wrappedRequest; + } + + return module; + }; +} catch (e) { + console.error('Failed to patch request module:', e); +} + +// Import the benchmark function +const { handler: benchmarkHandler } = require('./function'); + +// Import storage and nosql if they exist +let storage, nosql; +try { + storage = require('./storage'); +} catch (e) { + console.log('Storage module not available'); +} +try { + nosql = require('./nosql'); +} catch (e) { + console.log('NoSQL module not available'); +} + +const PORT = process.env.PORT || 8080; + +const server = http.createServer(async (req, res) => { + // Handle favicon requests + if (req.url.includes('favicon')) { + res.writeHead(200); + res.end('None'); + return; + } + + try { + // Extract Worker URL from header for R2 and NoSQL proxy + const workerUrl = req.headers['x-worker-url']; + if (workerUrl) { + if (storage && storage.storage && storage.storage.set_worker_url) { + storage.storage.set_worker_url(workerUrl); + } + if (nosql && nosql.nosql && nosql.nosql.set_worker_url) { + nosql.nosql.set_worker_url(workerUrl); + } + console.log(`Set worker URL for R2/NoSQL proxy: ${workerUrl}`); + } + + // Start timing measurements + const begin = Date.now() / 1000; + const start = performance.now(); + + // Read request body + let body = ''; + for await (const chunk of req) { + body += chunk; + } + + // Parse event from JSON body or URL params + let event = {}; + if (body && body.length > 0) { + try { + event = JSON.parse(body); + } catch (e) { + console.error('Failed to parse JSON body:', e); + } + } + + // Parse URL parameters + const url = new URL(req.url, `http://${req.headers.host}`); + for (const [key, value] of url.searchParams) { + if (!event[key]) { + const intValue = parseInt(value); + event[key] = isNaN(intValue) ? value : intValue; + } + } + + // Add request metadata + const reqId = 0; + const incomeTimestamp = Math.floor(Date.now() / 1000); + event['request-id'] = reqId; + event['income-timestamp'] = incomeTimestamp; + + console.error('!!! Event:', JSON.stringify(event)); + + // For debugging: check /tmp directory before and after benchmark + const fs = require('fs'); + console.error('!!! Files in /tmp before benchmark:', fs.readdirSync('/tmp')); + + // Call the benchmark function + console.error('!!! Calling benchmark handler...'); + const ret = await benchmarkHandler(event); + console.error('!!! Benchmark result:', JSON.stringify(ret)); + + // Check what was downloaded + console.error('!!! Files in /tmp after benchmark:', fs.readdirSync('/tmp')); + const tmpFiles = fs.readdirSync('/tmp'); + for (const file of tmpFiles) { + const filePath = `/tmp/${file}`; + const stats = fs.statSync(filePath); + console.error(`!!! ${file}: ${stats.size} bytes`); + if (stats.size < 500) { + const content = fs.readFileSync(filePath, 'utf8'); + console.error(`!!! First 300 chars: ${content.substring(0, 300)}`); + } + } + + // Calculate elapsed time + const end = Date.now() / 1000; + const elapsed = performance.now() - start; + const micro = elapsed * 1000; // Convert milliseconds to microseconds + + // Build log_data similar to native handler + const log_data = { output: ret && ret.result !== undefined ? ret.result : ret }; + if (ret && ret.measurement !== undefined) { + log_data.measurement = ret.measurement; + } + if (event.logs !== undefined) { + log_data.time = 0; + } + + console.log('Sending response with log_data:', log_data); + + // Send response matching Python handler format exactly + if (event.html) { + res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' }); + res.end(String(ret && ret.result !== undefined ? ret.result : ret)); + } else { + const responseBody = JSON.stringify({ + begin: "0", + end: "0", + results_time: "0", + result: log_data, + is_cold: false, + is_cold_worker: false, + container_id: '0', + environ_container_id: 'no_id', + request_id: '0', + }); + res.writeHead(200, { 'Content-Type': 'application/json' }); + res.end(responseBody); + } + + } catch (error) { + console.error('Error processing request:', error); + console.error('Stack trace:', error.stack); + + const errorPayload = JSON.stringify({ + error: error.message, + stack: error.stack + }); + + res.writeHead(500, { 'Content-Type': 'application/json' }); + res.end(errorPayload); + } +}); + +// Ensure server is listening before handling requests +server.listen(PORT, '0.0.0.0', () => { + console.log(`Container server listening on 0.0.0.0:${PORT}`); + console.log('Server ready to accept connections'); +}); diff --git a/benchmarks/wrappers/cloudflare/nodejs/container/nosql.js b/benchmarks/wrappers/cloudflare/nodejs/container/nosql.js new file mode 100644 index 000000000..3469bf6b9 --- /dev/null +++ b/benchmarks/wrappers/cloudflare/nodejs/container/nosql.js @@ -0,0 +1,118 @@ +/** + * NoSQL module for Cloudflare Node.js Containers + * Uses HTTP proxy to access Durable Objects through the Worker's binding + */ + +class nosql { + constructor() { + // Container accesses Durable Objects through worker.js proxy + } + + static worker_url = null; // Set by handler from X-Worker-URL header + + static init_instance(entry) { + if (!nosql.instance) { + nosql.instance = new nosql(); + } + return nosql.instance; + } + + static set_worker_url(url) { + nosql.worker_url = url; + } + + async _make_request(operation, params) { + if (!nosql.worker_url) { + throw new Error('Worker URL not set - cannot access NoSQL'); + } + + const url = `${nosql.worker_url}/nosql/${operation}`; + const data = JSON.stringify(params); + + try { + const response = await fetch(url, { + method: 'POST', + headers: { 'Content-Type': 'application/json' }, + body: data, + }); + + if (!response.ok) { + let errorMsg; + try { + const errorData = await response.json(); + errorMsg = errorData.error || await response.text(); + } catch { + errorMsg = await response.text(); + } + throw new Error(`NoSQL operation failed: ${errorMsg}`); + } + + return await response.json(); + } catch (error) { + throw new Error(`NoSQL operation failed: ${error.message}`); + } + } + + async insert(tableName, primaryKey, secondaryKey, data) { + const params = { + table_name: tableName, + primary_key: primaryKey, + secondary_key: secondaryKey, + data: data, + }; + return this._make_request('insert', params); + } + + async get(tableName, primaryKey, secondaryKey) { + const params = { + table_name: tableName, + primary_key: primaryKey, + secondary_key: secondaryKey, + }; + const result = await this._make_request('get', params); + return result.data || null; + } + + async update(tableName, primaryKey, secondaryKey, updates) { + const params = { + table_name: tableName, + primary_key: primaryKey, + secondary_key: secondaryKey, + data: updates, + }; + return this._make_request('update', params); + } + + async query(tableName, primaryKey, secondaryKeyName) { + const params = { + table_name: tableName, + primary_key: primaryKey, + secondary_key_name: secondaryKeyName, + }; + const result = await this._make_request('query', params); + console.error(`[nosql.query] result:`, JSON.stringify(result)); + console.error(`[nosql.query] result.items:`, result.items); + console.error(`[nosql.query] Array.isArray(result.items):`, Array.isArray(result.items)); + const items = result.items || []; + console.error(`[nosql.query] returning items:`, items); + return items; + } + + async delete(tableName, primaryKey, secondaryKey) { + const params = { + table_name: tableName, + primary_key: primaryKey, + secondary_key: secondaryKey, + }; + return this._make_request('delete', params); + } + + static get_instance() { + if (!nosql.instance) { + nosql.instance = new nosql(); + } + return nosql.instance; + } +} + +module.exports.nosql = nosql; diff --git a/benchmarks/wrappers/cloudflare/nodejs/container/package.json b/benchmarks/wrappers/cloudflare/nodejs/container/package.json new file mode 100644 index 000000000..729c56fdc --- /dev/null +++ b/benchmarks/wrappers/cloudflare/nodejs/container/package.json @@ -0,0 +1,10 @@ +{ + "name": "cloudflare-container-worker", + "version": "1.0.0", + "description": "Cloudflare Container Worker wrapper", + "main": "worker.js", + "type": "module", + "dependencies": { + "@cloudflare/containers": "^1.0.0" + } +} diff --git a/benchmarks/wrappers/cloudflare/nodejs/container/storage.js b/benchmarks/wrappers/cloudflare/nodejs/container/storage.js new file mode 100644 index 000000000..d893245ef --- /dev/null +++ b/benchmarks/wrappers/cloudflare/nodejs/container/storage.js @@ -0,0 +1,294 @@ +const fs = require('fs'); +const path = require('path'); +const uuid = require('uuid'); + +/** + * Storage module for Cloudflare Node.js Containers + * Uses HTTP proxy to access R2 storage through the Worker's R2 binding + */ + +class storage { + constructor() { + this.r2_enabled = true; + } + + static worker_url = null; // Set by handler from X-Worker-URL header + + + static worker_url = null; // Set by handler from X-Worker-URL header + + static unique_name(name) { + const parsed = path.parse(name); + const uuid_name = uuid.v4().split('-')[0]; + return path.join(parsed.dir, `${parsed.name}.${uuid_name}${parsed.ext}`); + } + + static init_instance(entry) { + if (!storage.instance) { + storage.instance = new storage(); + } + return storage.instance; + } + + static set_worker_url(url) { + storage.worker_url = url; + } + + static get_instance() { + if (!storage.instance) { + storage.init_instance(); + } + return storage.instance; + } + + async upload_stream(bucket, key, data) { + if (!this.r2_enabled) { + console.log('Warning: R2 not configured, skipping upload'); + return key; + } + + if (!storage.worker_url) { + throw new Error('Worker URL not set - cannot access R2'); + } + + const unique_key = storage.unique_name(key); + + // Convert data to Buffer if needed + let buffer; + if (Buffer.isBuffer(data)) { + buffer = data; + } else if (typeof data === 'string') { + buffer = Buffer.from(data, 'utf-8'); + } else if (data instanceof ArrayBuffer) { + buffer = Buffer.from(data); + } else { + buffer = Buffer.from(String(data), 'utf-8'); + } + + // Upload via worker proxy + const params = new URLSearchParams({ bucket, key: unique_key }); + const url = `${storage.worker_url}/r2/upload?${params}`; + + try { + const response = await fetch(url, { + method: 'POST', + headers: { 'Content-Type': 'application/octet-stream' }, + body: buffer, + }); + + if (!response.ok) { + throw new Error(`HTTP ${response.status}: ${await response.text()}`); + } + + const result = await response.json(); + return result.key; + } catch (error) { + console.error('R2 upload error:', error); + throw new Error(`Failed to upload to R2: ${error.message}`); + } + } + + async download_stream(bucket, key) { + if (!this.r2_enabled) { + throw new Error('R2 not configured'); + } + + if (!storage.worker_url) { + throw new Error('Worker URL not set - cannot access R2'); + } + + // Download via worker proxy + const params = new URLSearchParams({ bucket, key }); + const url = `${storage.worker_url}/r2/download?${params}`; + + try { + const response = await fetch(url); + + if (response.status === 404) { + throw new Error(`Object not found: ${key}`); + } + + if (!response.ok) { + throw new Error(`HTTP ${response.status}: ${await response.text()}`); + } + + const arrayBuffer = await response.arrayBuffer(); + return Buffer.from(arrayBuffer); + } catch (error) { + console.error('R2 download error:', error); + throw new Error(`Failed to download from R2: ${error.message}`); + } + } + + upload(bucket, key, filepath) { + // Generate unique key synchronously so it can be returned immediately + const unique_key = storage.unique_name(key); + console.error(`!!! [storage.upload] bucket=${bucket}, key=${key}, unique_key=${unique_key}, filepath=${filepath}`); + + // Read file from disk and upload + if (fs.existsSync(filepath)) { + const stats = fs.statSync(filepath); + console.error(`!!! [storage.upload] File exists, size on disk: ${stats.size} bytes`); + const data = fs.readFileSync(filepath); + console.error(`!!! [storage.upload] Read ${data.length} bytes from ${filepath}`); + console.error(`!!! [storage.upload] Data type: ${typeof data}, isBuffer: ${Buffer.isBuffer(data)}, isString: ${typeof data === 'string'}`); + console.error(`!!! [storage.upload] First 200 chars of data: ${data.toString().substring(0, 200)}`); + // Call internal version that doesn't generate another unique key + const uploadPromise = this._upload_stream_with_key(bucket, unique_key, data); + console.error(`!!! [storage.upload] Returning unique_key=${unique_key} and upload promise`); + return [unique_key, uploadPromise]; + } + + console.error(`!!! [storage.upload] File not found: ${filepath}`); + throw new Error(`upload(): file not found: ${filepath}`); + } + + async _upload_stream_with_key(bucket, key, data) { + // Internal method that uploads with exact key (no unique naming) + console.log(`[storage._upload_stream_with_key] Starting upload: bucket=${bucket}, key=${key}, data_size=${data.length}`); + + if (!this.r2_enabled) { + console.log('Warning: R2 not configured, skipping upload'); + return key; + } + + if (!storage.worker_url) { + console.error('[storage._upload_stream_with_key] Worker URL not set!'); + throw new Error('Worker URL not set - cannot access R2'); + } + + console.log(`[storage._upload_stream_with_key] Worker URL: ${storage.worker_url}`); + + // Convert data to Buffer if needed + let buffer; + if (Buffer.isBuffer(data)) { + buffer = data; + } else if (typeof data === 'string') { + buffer = Buffer.from(data, 'utf-8'); + } else if (data instanceof ArrayBuffer) { + buffer = Buffer.from(data); + } else { + buffer = Buffer.from(String(data), 'utf-8'); + } + + // Upload via worker proxy + const params = new URLSearchParams({ bucket, key }); + const url = `${storage.worker_url}/r2/upload?${params}`; + console.log(`[storage._upload_stream_with_key] Uploading to URL: ${url}, buffer size: ${buffer.length}`); + + try { + const response = await fetch(url, { + method: 'POST', + headers: { 'Content-Type': 'application/octet-stream' }, + body: buffer, + }); + + console.log(`[storage._upload_stream_with_key] Response status: ${response.status}`); + + if (!response.ok) { + const errorText = await response.text(); + console.error(`[storage._upload_stream_with_key] Upload failed: ${response.status} - ${errorText}`); + throw new Error(`HTTP ${response.status}: ${errorText}`); + } + + const result = await response.json(); + console.log(`[storage._upload_stream_with_key] Upload successful, returned key: ${result.key}`); + return result.key; + } catch (error) { + console.error('R2 upload error:', error); + throw new Error(`Failed to upload to R2: ${error.message}`); + } + } + + async download(bucket, key, filepath) { + const data = await this.download_stream(bucket, key); + + let real_fp = filepath; + if (!filepath.startsWith('/tmp')) { + real_fp = path.join('/tmp', path.resolve(filepath)); + } + + // Write data to file + fs.mkdirSync(path.dirname(real_fp), { recursive: true }); + fs.writeFileSync(real_fp, data); + } + + async download_directory(bucket, prefix, out_path) { + // List all objects with the prefix and download each one + if (!this.r2_enabled) { + console.log('Warning: R2 not configured, skipping download_directory'); + return; + } + + if (!storage.worker_url) { + throw new Error('Worker URL not set - cannot access R2'); + } + + // List objects via worker proxy + const listParams = new URLSearchParams({ bucket, prefix }); + const listUrl = `${storage.worker_url}/r2/list?${listParams}`; + + try { + const response = await fetch(listUrl, { + method: 'GET', + headers: { 'Content-Type': 'application/json' }, + }); + + if (!response.ok) { + const errorText = await response.text(); + throw new Error(`HTTP ${response.status}: ${errorText}`); + } + + const result = await response.json(); + const objects = result.objects || []; + + for (const obj of objects) { + const file_name = obj.key; + const path_to_file = path.dirname(file_name); + fs.mkdirSync(path.join(out_path, path_to_file), { recursive: true }); + await this.download(bucket, file_name, path.join(out_path, file_name)); + } + } catch (error) { + console.error('R2 download_directory error:', error); + throw new Error(`Failed to download directory from R2: ${error.message}`); + } + } + + uploadStream(bucket, key) { + // Return [stream, promise, unique_key] to match native wrapper API + const unique_key = storage.unique_name(key); + + const stream = require('stream'); + const passThrough = new stream.PassThrough(); + const chunks = []; + + passThrough.on('data', (chunk) => chunks.push(chunk)); + + const upload = new Promise((resolve, reject) => { + passThrough.on('end', async () => { + try { + const buffer = Buffer.concat(chunks); + await this._upload_stream_with_key(bucket, unique_key, buffer); + resolve(); + } catch (err) { + reject(err); + } + }); + passThrough.on('error', reject); + }); + + return [passThrough, upload, unique_key]; + } + + async downloadStream(bucket, key) { + // Return a Promise that resolves to a readable stream + const data = await this.download_stream(bucket, key); + const stream = require('stream'); + const readable = new stream.Readable(); + readable.push(data); + readable.push(null); // Signal end of stream + return readable; + } +} + +module.exports.storage = storage; diff --git a/benchmarks/wrappers/cloudflare/nodejs/container/worker.js b/benchmarks/wrappers/cloudflare/nodejs/container/worker.js new file mode 100644 index 000000000..78140794f --- /dev/null +++ b/benchmarks/wrappers/cloudflare/nodejs/container/worker.js @@ -0,0 +1,362 @@ +import { Container, getContainer } from "@cloudflare/containers"; +import { DurableObject } from "cloudflare:workers"; + +// Container wrapper class +export class ContainerWorker extends Container { + defaultPort = 8080; + sleepAfter = "10m"; +} + +// Durable Object for NoSQL storage (simple proxy to ctx.storage) +export class KVApiObject extends DurableObject { + constructor(ctx, env) { + super(ctx, env); + } + + async insert(key, value) { + await this.ctx.storage.put(key.join(':'), value); + return { success: true }; + } + + async update(key, value) { + await this.ctx.storage.put(key.join(':'), value); + return { success: true }; + } + + async get(key) { + const value = await this.ctx.storage.get(key.join(':')); + return { data: value || null }; + } + + async query(keyPrefix) { + const list = await this.ctx.storage.list(); + const items = []; + for (const [k, v] of list) { + items.push(v); + } + return { items }; + } + + async delete(key) { + await this.ctx.storage.delete(key.join(':')); + return { success: true }; + } +} + +export default { + async fetch(request, env) { + const url = new URL(request.url); + + // Health check endpoint + if (url.pathname === '/health' || url.pathname === '/_health') { + try { + const containerId = 'default'; + const id = env.CONTAINER_WORKER.idFromName(containerId); + const stub = env.CONTAINER_WORKER.get(id); + + // Make a simple GET request to the root path to verify container is responsive + const healthRequest = new Request('http://localhost/', { + method: 'GET', + headers: { + 'X-Health-Check': 'true' + } + }); + + const response = await stub.fetch(healthRequest); + + // Container is ready if it responds (even with an error from the benchmark handler) + // A 500 from the handler means the container is running, just not a valid benchmark request + if (response.status >= 200 && response.status < 600) { + return new Response('OK', { status: 200 }); + } else { + return new Response(JSON.stringify({ + error: 'Container not responding', + status: response.status + }), { + status: 503, + headers: { 'Content-Type': 'application/json' } + }); + } + + } catch (error) { + return new Response(JSON.stringify({ + error: 'Container failed to start', + details: error.message, + stack: error.stack + }), { + status: 503, + headers: { 'Content-Type': 'application/json' } + }); + } + } + + try { + // Handle NoSQL proxy requests - intercept BEFORE forwarding to container + if (url.pathname.startsWith('/nosql/')) { + return await handleNoSQLRequest(request, env); + } + + // Handle R2 proxy requests - intercept BEFORE forwarding to container + if (url.pathname.startsWith('/r2/')) { + return await handleR2Request(request, env); + } + + // Get or create container instance + const containerId = request.headers.get('x-container-id') || 'default'; + const id = env.CONTAINER_WORKER.idFromName(containerId); + const stub = env.CONTAINER_WORKER.get(id); + + // Clone request and add Worker URL as header so container knows where to proxy R2 requests + const modifiedRequest = new Request(request); + modifiedRequest.headers.set('X-Worker-URL', url.origin); + + // Forward the request to the container + return await stub.fetch(modifiedRequest); + + } catch (error) { + console.error('Worker error:', error); + + const errorMessage = error.message || String(error); + + // Handle container not ready errors with 503 + if (errorMessage.includes('Container failed to start') || + errorMessage.includes('no container instance') || + errorMessage.includes('Durable Object') || + errorMessage.includes('provisioning')) { + + return new Response(JSON.stringify({ + error: 'Container failed to start', + details: 'there is no container instance that can be provided to this durable object', + message: errorMessage + }), { + status: 503, + headers: { 'Content-Type': 'application/json' } + }); + } + + // Other errors get 500 + return new Response(JSON.stringify({ + error: 'Internal server error', + details: errorMessage, + stack: error.stack + }), { + status: 500, + headers: { 'Content-Type': 'application/json' } + }); + } + } +}; + +/** + * Handle NoSQL (Durable Object) requests proxied from the container + * Routes: + * - POST /nosql/insert - insert item + * - POST /nosql/update - update item + * - POST /nosql/get - get item + * - POST /nosql/query - query items + * - POST /nosql/delete - delete item + */ +async function handleNoSQLRequest(request, env) { + try { + const url = new URL(request.url); + const operation = url.pathname.split('/').pop(); + + // Parse request body + const params = await request.json(); + const { table_name, primary_key, secondary_key, secondary_key_name, data } = params; + + // Get Durable Object stub - table_name should match the DO class name + if (!env[table_name]) { + return new Response(JSON.stringify({ + error: `Durable Object binding '${table_name}' not found` + }), { + status: 500, + headers: { 'Content-Type': 'application/json' } + }); + } + + // Create DO ID from primary key + const doId = env[table_name].idFromName(primary_key.join(':')); + const doStub = env[table_name].get(doId); + + // Forward operation to Durable Object + let result; + switch (operation) { + case 'insert': + result = await doStub.insert(secondary_key, data); + break; + case 'update': + result = await doStub.update(secondary_key, data); + break; + case 'get': + result = await doStub.get(secondary_key); + break; + case 'query': + result = await doStub.query(secondary_key_name); + break; + case 'delete': + result = await doStub.delete(secondary_key); + break; + default: + return new Response(JSON.stringify({ + error: 'Unknown NoSQL operation' + }), { + status: 404, + headers: { 'Content-Type': 'application/json' } + }); + } + + return new Response(JSON.stringify(result || {}), { + headers: { 'Content-Type': 'application/json' } + }); + + } catch (error) { + console.error('NoSQL proxy error:', error); + return new Response(JSON.stringify({ + error: error.message, + stack: error.stack + }), { + status: 500, + headers: { 'Content-Type': 'application/json' } + }); + } +} + +/** + * Handle R2 storage requests proxied from the container + * Routes: + * - GET /r2/download?bucket=X&key=Y - download object + * - POST /r2/upload?bucket=X&key=Y - upload object (body contains data) + */ +async function handleR2Request(request, env) { + try { + const url = new URL(request.url); + const bucket = url.searchParams.get('bucket'); + const key = url.searchParams.get('key'); + + // Check if R2 binding exists + if (!env.R2) { + return new Response(JSON.stringify({ + error: 'R2 binding not configured' + }), { + status: 500, + headers: { 'Content-Type': 'application/json' } + }); + } + + if (url.pathname === '/r2/list') { + // List objects in R2 with a prefix (only needs bucket) + if (!bucket) { + return new Response(JSON.stringify({ + error: 'Missing bucket parameter' + }), { + status: 400, + headers: { 'Content-Type': 'application/json' } + }); + } + + try { + const prefix = url.searchParams.get('prefix') || ''; + const list_res = await env.R2.list({ prefix }); + + return new Response(JSON.stringify({ + objects: list_res.objects || [] + }), { + headers: { 'Content-Type': 'application/json' } + }); + } catch (error) { + console.error('[worker.js /r2/list] Error:', error); + return new Response(JSON.stringify({ + error: error.message + }), { + status: 500, + headers: { 'Content-Type': 'application/json' } + }); + } + } + + // All other R2 operations require both bucket and key + if (!bucket || !key) { + return new Response(JSON.stringify({ + error: 'Missing bucket or key parameter' + }), { + status: 400, + headers: { 'Content-Type': 'application/json' } + }); + } + + if (url.pathname === '/r2/download') { + // Download from R2 + const object = await env.R2.get(key); + + if (!object) { + return new Response(JSON.stringify({ + error: 'Object not found' + }), { + status: 404, + headers: { 'Content-Type': 'application/json' } + }); + } + + // Return the object data + return new Response(object.body, { + headers: { + 'Content-Type': object.httpMetadata?.contentType || 'application/octet-stream', + 'Content-Length': object.size.toString() + } + }); + + } else if (url.pathname === '/r2/upload') { + // Upload to R2 + console.log(`[worker.js /r2/upload] bucket=${bucket}, key=${key}`); + console.log(`[worker.js /r2/upload] env.R2 exists:`, !!env.R2); + const data = await request.arrayBuffer(); + console.log(`[worker.js /r2/upload] Received ${data.byteLength} bytes`); + + // Use the key as-is (container already generates unique keys if needed) + try { + const putResult = await env.R2.put(key, data); + console.log(`[worker.js /r2/upload] R2.put() returned:`, putResult); + console.log(`[worker.js /r2/upload] Successfully uploaded to R2 with key=${key}`); + } catch (error) { + console.error(`[worker.js /r2/upload] R2.put() error:`, error); + throw error; + } + + return new Response(JSON.stringify({ + key: key + }), { + headers: { 'Content-Type': 'application/json' } + }); + + } else { + return new Response(JSON.stringify({ + error: 'Unknown R2 operation' + }), { + status: 404, + headers: { 'Content-Type': 'application/json' } + }); + } + + } catch (error) { + console.error('R2 proxy error:', error); + return new Response(JSON.stringify({ + error: error.message, + stack: error.stack + }), { + status: 500, + headers: { 'Content-Type': 'application/json' } + }); + } +} + +/** + * Generate unique key for uploaded files + */ +function generateUniqueKey(key) { + const parts = key.split('.'); + const ext = parts.length > 1 ? '.' + parts.pop() : ''; + const name = parts.join('.'); + const uuid = crypto.randomUUID().split('-')[0]; + return `${name}.${uuid}${ext}`; +} diff --git a/benchmarks/wrappers/cloudflare/python/container/handler.py b/benchmarks/wrappers/cloudflare/python/container/handler.py new file mode 100644 index 000000000..4eb21bd8c --- /dev/null +++ b/benchmarks/wrappers/cloudflare/python/container/handler.py @@ -0,0 +1,196 @@ +#!/usr/bin/env python3 +""" +Container handler for Cloudflare Workers - Python +This handler is used when deploying as a container worker +""" + +import json +import sys +import os +import traceback +from http.server import HTTPServer, BaseHTTPRequestHandler +from urllib.parse import urlparse, parse_qs +import datetime + +# Monkey-patch requests library to add User-Agent header +# This is needed because many HTTP servers (like Wikimedia) reject requests without User-Agent +try: + import requests + original_request = requests.request + + def patched_request(method, url, **kwargs): + if 'headers' not in kwargs: + kwargs['headers'] = {} + if 'User-Agent' not in kwargs['headers']: + kwargs['headers']['User-Agent'] = 'SeBS/1.2 (https://github.com/spcl/serverless-benchmarks) SeBS Benchmark Suite/1.2' + return original_request(method, url, **kwargs) + + requests.request = patched_request + print("Monkey-patched requests library to add User-Agent header") +except ImportError: + print("requests library not available, skipping User-Agent monkey-patch") + +# Also patch urllib for libraries that use it directly +import urllib.request +original_urlopen = urllib.request.urlopen + +def patched_urlopen(url, data=None, timeout=None, **kwargs): + if isinstance(url, str): + req = urllib.request.Request(url, data=data) + req.add_header('User-Agent', 'SeBS/1.2 (https://github.com/spcl/serverless-benchmarks) SeBS Benchmark Suite/1.2') + return original_urlopen(req, timeout=timeout, **kwargs) + elif isinstance(url, urllib.request.Request): + if not url.has_header('User-Agent'): + url.add_header('User-Agent', 'SeBS/1.2 (https://github.com/spcl/serverless-benchmarks) SeBS Benchmark Suite/1.2') + return original_urlopen(url, data=data, timeout=timeout, **kwargs) + else: + return original_urlopen(url, data=data, timeout=timeout, **kwargs) + +urllib.request.urlopen = patched_urlopen +print("Monkey-patched urllib.request.urlopen to add User-Agent header") + +# Import the benchmark handler function +from function import handler as benchmark_handler + +# Import storage and nosql if available +try: + import storage +except ImportError: + storage = None + print("Storage module not available") + +try: + import nosql +except ImportError: + nosql = None + print("NoSQL module not available") + +PORT = int(os.environ.get('PORT', 8080)) + + +class ContainerHandler(BaseHTTPRequestHandler): + def do_GET(self): + self.handle_request() + + def do_POST(self): + self.handle_request() + + def handle_request(self): + # Handle favicon requests + if 'favicon' in self.path: + self.send_response(200) + self.end_headers() + self.wfile.write(b'None') + return + + try: + # Extract Worker URL from header for R2 and NoSQL proxy + worker_url = self.headers.get('X-Worker-URL') + if worker_url: + if storage: + storage.storage.set_worker_url(worker_url) + if nosql: + nosql.nosql.set_worker_url(worker_url) + print(f"Set worker URL for R2/NoSQL proxy: {worker_url}") + + # Read request body + content_length = int(self.headers.get('Content-Length', 0)) + body = self.rfile.read(content_length).decode('utf-8') if content_length > 0 else '' + + # Parse event from JSON body or URL params + event = {} + if body: + try: + event = json.loads(body) + except json.JSONDecodeError as e: + print(f'Failed to parse JSON body: {e}') + + # Parse URL parameters + parsed_url = urlparse(self.path) + params = parse_qs(parsed_url.query) + for key, values in params.items(): + if key not in event and values: + value = values[0] + try: + event[key] = int(value) + except ValueError: + event[key] = value + + # Add request metadata + import random + req_id = random.randint(0, 1000000) + income_timestamp = datetime.datetime.now().timestamp() + event['request-id'] = req_id + event['income-timestamp'] = income_timestamp + + print(f"!!! Event received: {json.dumps(event, default=str)}") + print(f"!!! Event keys: {list(event.keys())}") + print(f"!!! Event has 'bucket' key: {'bucket' in event}") + if 'bucket' in event: + print(f"!!! bucket value: {event['bucket']}") + + # Measure execution time + begin = datetime.datetime.now().timestamp() + + # Call the benchmark function + result = benchmark_handler(event) + + # Calculate timing + end = datetime.datetime.now().timestamp() + compute_time = end - begin + + # Prepare response matching native handler format exactly + log_data = { + 'output': result['result'] + } + if 'measurement' in result: + log_data['measurement'] = result['measurement'] + + response_data = { + 'begin': "0", + 'end': "0", + 'results_time': "0", + 'result': log_data, + 'is_cold': False, + 'is_cold_worker': False, + 'container_id': "0", + 'environ_container_id': "no_id", + 'request_id': "0" + } + + # Send response + if event.get('html'): + # For HTML requests, return just the result + self.send_response(200) + self.send_header('Content-Type', 'text/html; charset=utf-8') + self.end_headers() + html_result = result.get('result', result) + self.wfile.write(str(html_result).encode('utf-8')) + else: + # For API requests, return structured response + self.send_response(200) + self.send_header('Content-Type', 'application/json') + self.end_headers() + self.wfile.write(json.dumps(response_data).encode('utf-8')) + + except Exception as error: + print(f'Error processing request: {error}') + traceback.print_exc() + self.send_response(500) + self.send_header('Content-Type', 'application/json') + self.end_headers() + error_response = { + 'error': str(error), + 'traceback': traceback.format_exc() + } + self.wfile.write(json.dumps(error_response).encode('utf-8')) + + def log_message(self, format, *args): + # Override to use print instead of stderr + print(f"{self.address_string()} - {format % args}") + + +if __name__ == '__main__': + server = HTTPServer(('0.0.0.0', PORT), ContainerHandler) + print(f'Container server listening on port {PORT}') + server.serve_forever() diff --git a/benchmarks/wrappers/cloudflare/python/container/nosql.py b/benchmarks/wrappers/cloudflare/python/container/nosql.py new file mode 100644 index 000000000..936a49901 --- /dev/null +++ b/benchmarks/wrappers/cloudflare/python/container/nosql.py @@ -0,0 +1,117 @@ +""" +NoSQL module for Cloudflare Python Containers +Uses HTTP proxy to access Durable Objects through the Worker's binding +""" +import json +import urllib.request +import urllib.parse +from typing import List, Optional, Tuple + + +class nosql: + """NoSQL client for containers using HTTP proxy to Worker's Durable Object""" + + instance: Optional["nosql"] = None + worker_url = None # Set by handler from X-Worker-URL header + + @staticmethod + def init_instance(*args, **kwargs): + """Initialize singleton instance""" + if nosql.instance is None: + nosql.instance = nosql() + return nosql.instance + + @staticmethod + def set_worker_url(url): + """Set worker URL for NoSQL proxy (called by handler)""" + nosql.worker_url = url + + def _make_request(self, operation: str, params: dict) -> dict: + """Make HTTP request to worker nosql proxy""" + if not nosql.worker_url: + raise RuntimeError("Worker URL not set - cannot access NoSQL") + + url = f"{nosql.worker_url}/nosql/{operation}" + data = json.dumps(params).encode('utf-8') + + req = urllib.request.Request(url, data=data, method='POST') + req.add_header('Content-Type', 'application/json') + + try: + with urllib.request.urlopen(req) as response: + return json.loads(response.read().decode('utf-8')) + except urllib.error.HTTPError as e: + error_body = e.read().decode('utf-8') + try: + error_data = json.loads(error_body) + raise RuntimeError(f"NoSQL operation failed: {error_data.get('error', error_body)}") + except json.JSONDecodeError: + raise RuntimeError(f"NoSQL operation failed: {error_body}") + except Exception as e: + raise RuntimeError(f"NoSQL operation failed: {e}") + + def insert( + self, + table_name: str, + primary_key: Tuple[str, str], + secondary_key: Tuple[str, str], + data: dict, + ): + params = { + 'table_name': table_name, + 'primary_key': list(primary_key), + 'secondary_key': list(secondary_key), + 'data': data + } + return self._make_request('insert', params) + + def update( + self, + table_name: str, + primary_key: Tuple[str, str], + secondary_key: Tuple[str, str], + data: dict, + ): + params = { + 'table_name': table_name, + 'primary_key': list(primary_key), + 'secondary_key': list(secondary_key), + 'data': data + } + return self._make_request('update', params) + + def get( + self, table_name: str, primary_key: Tuple[str, str], secondary_key: Tuple[str, str] + ) -> Optional[dict]: + params = { + 'table_name': table_name, + 'primary_key': list(primary_key), + 'secondary_key': list(secondary_key) + } + result = self._make_request('get', params) + return result.get('data') + + def query( + self, table_name: str, primary_key: Tuple[str, str], secondary_key_name: str + ) -> List[dict]: + params = { + 'table_name': table_name, + 'primary_key': list(primary_key), + 'secondary_key_name': secondary_key_name + } + result = self._make_request('query', params) + return result.get('items', []) + + def delete(self, table_name: str, primary_key: Tuple[str, str], secondary_key: Tuple[str, str]): + params = { + 'table_name': table_name, + 'primary_key': list(primary_key), + 'secondary_key': list(secondary_key) + } + return self._make_request('delete', params) + + @staticmethod + def get_instance(): + if nosql.instance is None: + nosql.instance = nosql() + return nosql.instance diff --git a/benchmarks/wrappers/cloudflare/python/container/storage.py b/benchmarks/wrappers/cloudflare/python/container/storage.py new file mode 100644 index 000000000..3182a66c3 --- /dev/null +++ b/benchmarks/wrappers/cloudflare/python/container/storage.py @@ -0,0 +1,203 @@ +""" +Storage module for Cloudflare Python Containers +Uses HTTP proxy to access R2 storage through the Worker's R2 binding +""" +import io +import os +import json +import urllib.request +import urllib.parse + +class storage: + """R2 storage client for containers using HTTP proxy to Worker""" + instance = None + worker_url = None # Set by handler from X-Worker-URL header + + def __init__(self): + # Container accesses R2 through worker.js proxy + # Worker URL is injected via X-Worker-URL header in each request + self.r2_enabled = True + + @staticmethod + def init_instance(entry=None): + """Initialize singleton instance""" + if storage.instance is None: + storage.instance = storage() + return storage.instance + + @staticmethod + def get_instance(): + """Get singleton instance""" + if storage.instance is None: + storage.init_instance() + return storage.instance + + @staticmethod + def set_worker_url(url): + """Set worker URL for R2 proxy (called by handler)""" + storage.worker_url = url + + @staticmethod + def unique_name(name): + """Generate unique name for file""" + import uuid + name_part, extension = os.path.splitext(name) + return f'{name_part}.{str(uuid.uuid4()).split("-")[0]}{extension}' + + def upload_stream(self, bucket: str, key: str, data): + """Upload data to R2 via worker proxy""" + if not self.r2_enabled: + print("Warning: R2 not configured, skipping upload") + return key + + if not storage.worker_url: + raise RuntimeError("Worker URL not set - cannot access R2") + + # Handle BytesIO objects + if isinstance(data, io.BytesIO): + data = data.getvalue() + + # Convert to bytes if needed + if isinstance(data, str): + data = data.encode('utf-8') + + # Upload via worker proxy + params = urllib.parse.urlencode({'bucket': bucket, 'key': key}) + url = f"{storage.worker_url}/r2/upload?{params}" + + req = urllib.request.Request(url, data=data, method='POST') + req.add_header('Content-Type', 'application/octet-stream') + + try: + with urllib.request.urlopen(req) as response: + result = json.loads(response.read().decode('utf-8')) + return result['key'] + except Exception as e: + print(f"R2 upload error: {e}") + raise RuntimeError(f"Failed to upload to R2: {e}") + + def download_stream(self, bucket: str, key: str) -> bytes: + """Download data from R2 via worker proxy""" + if not self.r2_enabled: + raise RuntimeError("R2 not configured") + + if not storage.worker_url: + raise RuntimeError("Worker URL not set - cannot access R2") + + # Download via worker proxy + params = urllib.parse.urlencode({'bucket': bucket, 'key': key}) + url = f"{storage.worker_url}/r2/download?{params}" + + try: + with urllib.request.urlopen(url) as response: + return response.read() + except urllib.error.HTTPError as e: + if e.code == 404: + raise RuntimeError(f"Object not found: {key}") + else: + raise RuntimeError(f"Failed to download from R2: {e}") + except Exception as e: + print(f"R2 download error: {e}") + raise RuntimeError(f"Failed to download from R2: {e}") + + def upload(self, bucket, key, filepath): + """Upload file from disk with unique key generation""" + # Generate unique key to avoid conflicts + unique_key = self.unique_name(key) + print(f"!!! [storage.upload] bucket={bucket}, key={key}, unique_key={unique_key}, filepath={filepath}") + + with open(filepath, 'rb') as f: + data = f.read() + print(f"!!! [storage.upload] Read {len(data)} bytes from {filepath}") + # Upload with the unique key + self._upload_with_key(bucket, unique_key, data) + return unique_key + + def _upload_with_key(self, bucket: str, key: str, data): + """Upload data to R2 via worker proxy with exact key (internal method)""" + if not self.r2_enabled: + print("Warning: R2 not configured, skipping upload") + return + + if not storage.worker_url: + raise RuntimeError("Worker URL not set - cannot access R2") + + # Handle BytesIO objects + if isinstance(data, io.BytesIO): + data = data.getvalue() + + # Convert to bytes if needed + if isinstance(data, str): + data = data.encode('utf-8') + + # Upload via worker proxy with exact key + params = urllib.parse.urlencode({'bucket': bucket, 'key': key}) + url = f"{storage.worker_url}/r2/upload?{params}" + + req = urllib.request.Request(url, data=data, method='POST') + req.add_header('Content-Type', 'application/octet-stream') + + try: + with urllib.request.urlopen(req) as response: + result = json.loads(response.read().decode('utf-8')) + print(f"!!! [storage._upload_with_key] Upload successful, key={result['key']}") + except Exception as e: + print(f"R2 upload error: {e}") + raise RuntimeError(f"Failed to upload to R2: {e}") + + def download(self, bucket, key, filepath): + """Download file to disk""" + data = self.download_stream(bucket, key) + os.makedirs(os.path.dirname(filepath), exist_ok=True) + with open(filepath, 'wb') as f: + f.write(data) + + def download_directory(self, bucket, prefix, local_path): + """ + Download all files with a given prefix to a local directory. + Lists objects via /r2/list endpoint and downloads each one. + """ + if not storage.worker_url: + raise RuntimeError("Worker URL not set - cannot access R2") + + # Create local directory + os.makedirs(local_path, exist_ok=True) + + # List objects with prefix via worker proxy + params = urllib.parse.urlencode({'bucket': bucket, 'prefix': prefix}) + list_url = f"{storage.worker_url}/r2/list?{params}" + + try: + req = urllib.request.Request(list_url) + req.add_header('User-Agent', 'SeBS/1.2 (https://github.com/spcl/serverless-benchmarks) SeBS Benchmark Suite/1.2') + + with urllib.request.urlopen(req) as response: + result = json.loads(response.read().decode('utf-8')) + objects = result.get('objects', []) + + print(f"Found {len(objects)} objects with prefix '{prefix}'") + + # Download each object + for obj in objects: + obj_key = obj['key'] + # Create local file path by removing the prefix + relative_path = obj_key + if prefix and obj_key.startswith(prefix): + relative_path = obj_key[len(prefix):].lstrip('/') + + local_file_path = os.path.join(local_path, relative_path) + + # Create directory structure if needed + local_dir = os.path.dirname(local_file_path) + if local_dir: + os.makedirs(local_dir, exist_ok=True) + + # Download the file + print(f"Downloading {obj_key} to {local_file_path}") + self.download(bucket, obj_key, local_file_path) + + return local_path + + except Exception as e: + print(f"Error listing/downloading directory: {e}") + raise RuntimeError(f"Failed to download directory: {e}") diff --git a/benchmarks/wrappers/cloudflare/python/handler.py b/benchmarks/wrappers/cloudflare/python/handler.py index 3f8ba6ca8..a0b63dcf9 100644 --- a/benchmarks/wrappers/cloudflare/python/handler.py +++ b/benchmarks/wrappers/cloudflare/python/handler.py @@ -70,7 +70,7 @@ async def fetch2(self, request, env): storage.storage.init_instance(self) - if self.env.NOSQL_STORAGE_DATABASE: + if hasattr(self.env, 'NOSQL_STORAGE_DATABASE'): from function import nosql nosql.nosql.init_instance(self) diff --git a/benchmarks/wrappers/cloudflare/python/nosql.py b/benchmarks/wrappers/cloudflare/python/nosql.py index 9de22fe69..27fc94ce0 100644 --- a/benchmarks/wrappers/cloudflare/python/nosql.py +++ b/benchmarks/wrappers/cloudflare/python/nosql.py @@ -30,7 +30,14 @@ def data_pre(self, data): return pickle.dumps(data, 0).decode("ascii") def data_post(self, data): - return pickle.loads(bytes(data, "ascii")) + # Handle None (key not found in storage) + if data is None: + return None + # Handle both string and bytes data from Durable Object storage + if isinstance(data, str): + return pickle.loads(bytes(data, "ascii")) + else: + return pickle.loads(data) def insert( self, diff --git a/benchmarks/wrappers/cloudflare/python/storage.py b/benchmarks/wrappers/cloudflare/python/storage.py index 3f6ebc31d..2ac2e6187 100644 --- a/benchmarks/wrappers/cloudflare/python/storage.py +++ b/benchmarks/wrappers/cloudflare/python/storage.py @@ -2,8 +2,10 @@ import os import uuid import asyncio -from pyodide.ffi import to_js, jsnull, run_sync +import base64 +from pyodide.ffi import to_js, jsnull, run_sync, JsProxy from pyodide.webloop import WebLoop +import js from workers import WorkerEntrypoint @@ -31,7 +33,9 @@ def unique_name(name): random=str(uuid.uuid4()).split('-')[0] ) def get_bucket(self, bucket): - return getattr(self.entry_env, bucket) + # R2 buckets are always bound as 'R2' in wrangler.toml + # The bucket parameter is the actual bucket name but we access via the binding + return self.entry_env.R2 @staticmethod def init_instance(entry: WorkerEntrypoint): @@ -60,11 +64,11 @@ def download(self, bucket, key, filepath): def download_directory(self, bucket, prefix, out_path): bobj = self.get_bucket(bucket) - list_res = run_sync(bobj.list(prefix = prefix)) ## gives only first 1000? + list_res = run_sync(bobj.list(to_js({"prefix": prefix}))) for obj in list_res.objects: - file_nameß = obj.key + file_name = obj.key path_to_file = os.path.dirname(file_name) - os.makedirs(os.path.join(path, path_to_file), exist_ok=True) + os.makedirs(os.path.join(out_path, path_to_file), exist_ok=True) self.download(bucket, file_name, os.path.join(out_path, file_name)) return @@ -73,10 +77,22 @@ def upload_stream(self, bucket, key, data): async def aupload_stream(self, bucket, key, data): unique_key = storage.unique_name(key) - data_js = to_js(data) + # Handle BytesIO objects - extract bytes + if hasattr(data, 'getvalue'): + data = data.getvalue() + # Convert bytes to Blob using base64 encoding as intermediate step + if isinstance(data, bytes): + # Encode as base64 + b64_str = base64.b64encode(data).decode('ascii') + # Create a Response from base64, then get the blob + # This creates a proper JavaScript Blob that R2 will accept + response = await js.fetch(f"data:application/octet-stream;base64,{b64_str}") + blob = await response.blob() + data_js = blob + else: + data_js = str(data) bobj = self.get_bucket(bucket) put_res = await bobj.put(unique_key, data_js) - ##print(put_res) return unique_key def download_stream(self, bucket, key): @@ -88,8 +104,9 @@ async def adownload_stream(self, bucket, key): if get_res == jsnull: print("key not stored in bucket") return b'' + # Always read as raw binary data (Blob/ArrayBuffer) data = await get_res.bytes() - return data + return bytes(data) def get_instance(): if storage.instance is None: diff --git a/configs/cloudflare-test.json b/configs/cloudflare-test.json index af98daff4..2b3b85827 100644 --- a/configs/cloudflare-test.json +++ b/configs/cloudflare-test.json @@ -13,7 +13,7 @@ }, "deployment": { "name": "cloudflare", - "cloudflare": { - } + "cloudflare": {}, + "container": false } } diff --git a/configs/systems.json b/configs/systems.json index 4ac3131f9..f65174f0c 100644 --- a/configs/systems.json +++ b/configs/systems.json @@ -438,6 +438,15 @@ "3.12": "ubuntu:22.04" } }, + "container_images": { + "x64": { + "3.8": "python:3.8-slim", + "3.9": "python:3.9-slim", + "3.10": "python:3.10-slim", + "3.11": "python:3.11-slim", + "3.12": "python:3.12-slim" + } + }, "images": [], "deployment": { "files": [ @@ -447,6 +456,15 @@ ], "packages": [], "module_packages": {} + }, + "container_deployment": { + "files": [ + "handler.py", + "storage.py", + "nosql.py" + ], + "packages": [], + "module_packages": {} } }, "nodejs": { @@ -456,6 +474,12 @@ "20": "ubuntu:22.04" } }, + "container_images": { + "x64": { + "18": "node:18-slim", + "20": "node:20-slim" + } + }, "images": [], "deployment": { "files": [ @@ -468,10 +492,20 @@ "packages": { "uuid": "3.4.0" } + }, + "container_deployment": { + "files": [ + "handler.js", + "storage.js", + "nosql.js" + ], + "packages": { + "uuid": "3.4.0" + } } } }, "architecture": ["x64"], - "deployments": ["package"] + "deployments": ["package", "container"] } } diff --git a/dockerfiles/cloudflare/nodejs/Dockerfile b/dockerfiles/cloudflare/nodejs/Dockerfile new file mode 100644 index 000000000..c64351581 --- /dev/null +++ b/dockerfiles/cloudflare/nodejs/Dockerfile @@ -0,0 +1,21 @@ +FROM node:18-slim + +WORKDIR /app + +# Copy package files first for better caching +COPY package*.json ./ + +# Install dependencies +RUN npm install --production + +# Copy all application files +COPY . . + +# Expose port 8080 for container communication +EXPOSE 8080 + +# Set environment variable for port +ENV PORT=8080 + +# Start the HTTP server +CMD ["node", "handler.js"] diff --git a/dockerfiles/cloudflare/python/Dockerfile b/dockerfiles/cloudflare/python/Dockerfile new file mode 100644 index 000000000..101a1e9f1 --- /dev/null +++ b/dockerfiles/cloudflare/python/Dockerfile @@ -0,0 +1,31 @@ +FROM python:3.11-slim + +# Install system dependencies (ffmpeg for video processing benchmarks) +RUN apt-get update && apt-get install -y --no-install-recommends \ + ffmpeg \ + && rm -rf /var/lib/apt/lists/* + +WORKDIR /app + +# Copy all application files first +COPY . . + +# Create ffmpeg directory and symlink for video-processing benchmark compatibility +RUN mkdir -p /app/ffmpeg && ln -s /usr/bin/ffmpeg /app/ffmpeg/ffmpeg + +# Install dependencies +# Core dependencies for wrapper modules: +# - storage.py uses urllib (stdlib) to proxy R2 requests through worker.js +# - nosql.py, worker.py, handler.py use stdlib only +# Then install benchmark-specific requirements from requirements.txt +RUN pip install --no-cache-dir --upgrade pip && \ + if [ -f requirements.txt ]; then pip install --no-cache-dir -r requirements.txt; fi + +# Expose port 8080 for container communication +EXPOSE 8080 + +# Set environment variable for port +ENV PORT=8080 + +# Start the HTTP server +CMD ["python", "handler.py"] diff --git a/sebs/cli.py b/sebs/cli.py index f65c5eb6e..6de1d4dca 100755 --- a/sebs/cli.py +++ b/sebs/cli.py @@ -185,7 +185,10 @@ def parse_common_params( update_nested_dict(config_obj, ["experiments", "update_code"], update_code) update_nested_dict(config_obj, ["experiments", "update_storage"], update_storage) update_nested_dict(config_obj, ["experiments", "architecture"], architecture) - update_nested_dict(config_obj, ["experiments", "container_deployment"], container_deployment) + # Only override container_deployment if explicitly set via CLI + # If not in config, use CLI default (False) + if container_deployment or "container_deployment" not in config_obj.get("experiments", {}): + update_nested_dict(config_obj, ["experiments", "container_deployment"], container_deployment) # set the path the configuration was loaded from update_nested_dict(config_obj, ["deployment", "local", "path"], config) diff --git a/sebs/cloudflare/cloudflare.py b/sebs/cloudflare/cloudflare.py index 0d24b122a..e199957ac 100644 --- a/sebs/cloudflare/cloudflare.py +++ b/sebs/cloudflare/cloudflare.py @@ -3,6 +3,8 @@ import json import uuid import subprocess +import time +from datetime import datetime from typing import cast, Dict, List, Optional, Tuple, Type import docker @@ -222,7 +224,7 @@ def _ensure_pywrangler_installed(self): raise RuntimeError("pywrangler version check timed out") - def _generate_wrangler_toml(self, worker_name: str, package_dir: str, language: str, account_id: str, benchmark_name: Optional[str] = None, code_package: Optional[Benchmark] = None) -> str: + def _generate_wrangler_toml(self, worker_name: str, package_dir: str, language: str, account_id: str, benchmark_name: Optional[str] = None, code_package: Optional[Benchmark] = None, container_deployment: bool = False, container_uri: str = "") -> str: """ Generate a wrangler.toml configuration file for the worker. @@ -233,24 +235,92 @@ def _generate_wrangler_toml(self, worker_name: str, package_dir: str, language: account_id: Cloudflare account ID benchmark_name: Optional benchmark name for R2 file path prefix code_package: Optional benchmark package for nosql configuration + container_deployment: Whether this is a container deployment + container_uri: Container image URI/tag Returns: Path to the generated wrangler.toml file """ - main_file = "dist/handler.js" if language == "nodejs" else "handler.py" + # Container deployment configuration + if container_deployment: + # Containers ALWAYS use Node.js worker.js for orchestration (@cloudflare/containers is Node.js only) + # The container itself can run any language (Python, Node.js, etc.) + # R2 and NoSQL access is proxied through worker.js which has the bindings + + # Determine if this benchmark needs larger disk space + # 411.image-recognition needs more disk for PyTorch models + # 311.compression needs more disk for file compression operations + # 504.dna-visualisation needs more disk for DNA sequence processing + # Python containers need even more space due to zip file creation doubling disk usage + instance_type = "" + if benchmark_name and ("411.image-recognition" in benchmark_name or "311.compression" in benchmark_name or "504.dna-visualisation" in benchmark_name): + # Use "standard" (largest) for Python, "standard-4" for Node.js + if language == "python": + instance_type = '\ninstance_type = "standard" # Largest available - needed for Python zip operations\n' + else: + instance_type = '\ninstance_type = "standard-4" # 20GB Disk, 12GB Memory\n' + + toml_content = f"""name = "{worker_name}" +main = "worker.js" +compatibility_date = "2025-11-18" +account_id = "{account_id}" +compatibility_flags = ["nodejs_compat"] + +[observability] +enabled = true + +[[containers]] +max_instances = 10 +class_name = "ContainerWorker" +image = "./Dockerfile"{instance_type} +# Durable Object binding for Container class (required by @cloudflare/containers) +[[durable_objects.bindings]] +name = "CONTAINER_WORKER" +class_name = "ContainerWorker" +""" + # Add nosql table bindings if benchmark uses them + if code_package and code_package.uses_nosql: + # Get registered nosql tables for this benchmark + nosql_storage = self.system_resources.get_nosql_storage() + if nosql_storage.retrieve_cache(benchmark_name): + nosql_tables = nosql_storage._tables.get(benchmark_name, {}) + for table_name in nosql_tables.keys(): + toml_content += f"""[[durable_objects.bindings]] +name = "{table_name}" +class_name = "KVApiObject" - # Build wrangler.toml content - toml_content = f"""name = "{worker_name}" +""" + self.logging.info(f"Added Durable Object binding for nosql table '{table_name}'") + + # Add migrations for both ContainerWorker and KVApiObject + # Both need new_sqlite_classes (Container requires SQLite DO backend) + toml_content += """[[migrations]] +tag = "v1" +new_sqlite_classes = ["ContainerWorker", "KVApiObject"] + +""" + else: + # Container without nosql - only ContainerWorker migration + toml_content += """[[migrations]] +tag = "v1" +new_sqlite_classes = ["ContainerWorker"] + +""" + else: + # Native worker configuration + main_file = "dist/handler.js" if language == "nodejs" else "handler.py" + + # Build wrangler.toml content + toml_content = f"""name = "{worker_name}" main = "{main_file}" compatibility_date = "2025-11-18" account_id = "{account_id}" """ - - if language == "nodejs": - toml_content += """# Use nodejs_compat for Node.js built-in support + if language == "nodejs": + toml_content += """# Use nodejs_compat for Node.js built-in support compatibility_flags = ["nodejs_compat"] no_bundle = true @@ -268,23 +338,23 @@ def _generate_wrangler_toml(self, worker_name: str, package_dir: str, language: fallthrough = true """ - elif language == "python": - toml_content += """# Enable Python Workers runtime + elif language == "python": + toml_content += """# Enable Python Workers runtime compatibility_flags = ["python_workers"] """ - toml_content += """ + toml_content += """ [[durable_objects.bindings]] name = "DURABLE_STORE" class_name = "KVApiObject" [[migrations]] -tag = "v1" +tag = "v3" new_classes = ["KVApiObject"] """ - # Add environment variables + # Add environment variables (for both native and container deployments) vars_content = "" if benchmark_name: vars_content += f'BENCHMARK_NAME = "{benchmark_name}"\n' @@ -299,7 +369,7 @@ def _generate_wrangler_toml(self, worker_name: str, package_dir: str, language: {vars_content} """ - # Add R2 bucket binding for benchmarking files (required for fs/path polyfills) + # Add R2 bucket binding for benchmarking files (for both native and container deployments) r2_bucket_configured = False try: storage = self.system_resources.get_storage() @@ -367,17 +437,34 @@ def package_code( architecture: Target architecture (not used for Workers) benchmark: Benchmark name is_cached: Whether the code is cached - container_deployment: Whether to deploy as container (not supported) + container_deployment: Whether to deploy as container Returns: Tuple of (package_path, package_size, container_uri) """ + # Container deployment flow - build Docker image if container_deployment: - raise NotImplementedError( - "Container deployment is not supported for Cloudflare Workers" + self.logging.info(f"Building container image for {benchmark}") + return self._package_code_container( + directory, language_name, language_version, benchmark ) + + # Native worker deployment flow (existing logic) + return self._package_code_native( + directory, language_name, language_version, benchmark, is_cached + ) + def _package_code_native( + self, + directory: str, + language_name: str, + language_version: str, + benchmark: str, + is_cached: bool, + ) -> Tuple[str, int, str]: + """Package code for native Cloudflare Workers deployment.""" + # Install dependencies if language_name == "nodejs": # Ensure Wrangler is installed @@ -574,6 +661,291 @@ def package_code( return (directory, total_size, "") + def _package_code_container( + self, + directory: str, + language_name: str, + language_version: str, + benchmark: str, + ) -> Tuple[str, int, str]: + """ + Package code for Cloudflare container worker deployment. + + Builds a Docker image and returns the image tag for deployment. + """ + self.logging.info(f"Packaging container for {language_name} {language_version}") + + # Get wrapper directory for container files + wrapper_base = os.path.join( + os.path.dirname(__file__), "..", "..", "benchmarks", "wrappers", "cloudflare" + ) + wrapper_container_dir = os.path.join(wrapper_base, language_name, "container") + + if not os.path.exists(wrapper_container_dir): + raise RuntimeError( + f"Container wrapper directory not found: {wrapper_container_dir}" + ) + + # Copy container wrapper files to the package directory + # Copy Dockerfile from dockerfiles/cloudflare/{language}/ + dockerfile_src = os.path.join( + os.path.dirname(__file__), + "..", + "..", + "dockerfiles", + "cloudflare", + language_name, + "Dockerfile" + ) + dockerfile_dest = os.path.join(directory, "Dockerfile") + if os.path.exists(dockerfile_src): + shutil.copy2(dockerfile_src, dockerfile_dest) + self.logging.info(f"Copied Dockerfile from {dockerfile_src}") + else: + raise RuntimeError(f"Dockerfile not found at {dockerfile_src}") + + # Copy handler and utility files from wrapper/container + # Note: ALL containers use worker.js for orchestration (@cloudflare/containers is Node.js only) + # The handler inside the container can be Python or Node.js + container_files = ["handler.py" if language_name == "python" else "handler.js"] + + # For worker.js orchestration file, always use the nodejs version + nodejs_wrapper_dir = os.path.join(wrapper_base, "nodejs", "container") + worker_js_src = os.path.join(nodejs_wrapper_dir, "worker.js") + worker_js_dest = os.path.join(directory, "worker.js") + if os.path.exists(worker_js_src): + shutil.copy2(worker_js_src, worker_js_dest) + self.logging.info(f"Copied worker.js orchestration file from nodejs/container") + + # Copy storage and nosql utilities from language-specific wrapper + if language_name == "nodejs": + container_files.extend(["storage.js", "nosql.js"]) + else: + container_files.extend(["storage.py", "nosql.py"]) + + for file in container_files: + src = os.path.join(wrapper_container_dir, file) + dest = os.path.join(directory, file) + if os.path.exists(src): + shutil.copy2(src, dest) + self.logging.info(f"Copied container file: {file}") + + # For Python containers, fix relative imports in benchmark code + # Containers use flat structure, so "from . import storage" must become "import storage" + if language_name == "python": + for item in os.listdir(directory): + if item.endswith('.py') and item not in ['handler.py', 'storage.py', 'nosql.py', 'worker.py']: + filepath = os.path.join(directory, item) + with open(filepath, 'r') as f: + content = f.read() + + # Replace relative imports with absolute imports + modified = False + if 'from . import storage' in content: + content = content.replace('from . import storage', 'import storage') + modified = True + if 'from . import nosql' in content: + content = content.replace('from . import nosql', 'import nosql') + modified = True + + if modified: + with open(filepath, 'w') as f: + f.write(content) + self.logging.info(f"Fixed relative imports in {item}") + + # For Node.js containers, transform benchmark code to be async-compatible + # The container wrapper uses async HTTP calls, but benchmarks expect sync + elif language_name == "nodejs": + import re + for item in os.listdir(directory): + if item.endswith('.js') and item not in ['handler.js', 'storage.js', 'nosql.js', 'worker.js', 'build.js', 'request-polyfill.js']: + filepath = os.path.join(directory, item) + with open(filepath, 'r') as f: + content = f.read() + + # Only transform if file uses nosqlClient + if 'nosqlClient' not in content: + continue + + self.logging.info(f"Transforming {item} for async nosql...") + + # Step 1: Add await before nosqlClient method calls + content = re.sub( + r'(\s*)((?:const|let|var)\s+\w+\s*=\s*)?nosqlClient\.(insert|get|update|query|delete)\s*\(', + r'\1\2await nosqlClient.\3(', + content + ) + + # Step 2: Make all function declarations async + content = re.sub(r'^(\s*)function\s+(\w+)\s*\(', r'\1async function \2(', content, flags=re.MULTILINE) + + # Step 3: Add await before user-defined function calls + lines = content.split('\n') + transformed_lines = [] + control_flow = {'if', 'for', 'while', 'switch', 'catch', 'return'} + builtins = {'console', 'require', 'push', 'join', 'split', 'map', 'filter', + 'reduce', 'forEach', 'find', 'findIndex', 'some', 'every', + 'includes', 'parseInt', 'parseFloat', 'isNaN', 'Array', + 'Object', 'String', 'Number', 'Boolean', 'Math', 'JSON', + 'Date', 'RegExp', 'Error', 'Promise'} + + for line in lines: + # Skip function declarations + if re.search(r'\bfunction\s+\w+\s*\(', line) or re.search(r'=\s*(async\s+)?function\s*\(', line): + transformed_lines.append(line) + continue + + # Add await before likely user-defined function calls + def replacer(match): + prefix = match.group(1) + assignment = match.group(2) or '' + func_name = match.group(3) + + if func_name in control_flow or func_name in builtins: + return match.group(0) + + return f"{prefix}{assignment}await {func_name}(" + + line = re.sub( + r'(^|\s+|;|,|\()((?:const|let|var)\s+\w+\s*=\s*)?(\w+)\s*\(', + replacer, + line + ) + transformed_lines.append(line) + + content = '\n'.join(transformed_lines) + + with open(filepath, 'w') as f: + f.write(content) + self.logging.info(f"Transformed {item} for async nosql") + + # Install dependencies for container orchestration + # ALL containers need @cloudflare/containers for worker.js orchestration + worker_package_json = { + "name": f"{benchmark}-worker", + "version": "1.0.0", + "dependencies": { + "@cloudflare/containers": "*" + } + } + + if language_name == "nodejs": + # Read the benchmark's package.json if it exists and merge dependencies + benchmark_package_file = os.path.join(directory, "package.json") + if os.path.exists(benchmark_package_file): + with open(benchmark_package_file, 'r') as f: + benchmark_package = json.load(f) + # Merge benchmark dependencies with worker dependencies + if "dependencies" in benchmark_package: + worker_package_json["dependencies"].update(benchmark_package["dependencies"]) + + # Write the combined package.json + with open(benchmark_package_file, 'w') as f: + json.dump(worker_package_json, f, indent=2) + else: # Python containers also need package.json for worker.js orchestration + # Create package.json just for @cloudflare/containers (Python code in container) + package_json_path = os.path.join(directory, "package.json") + with open(package_json_path, 'w') as f: + json.dump(worker_package_json, f, indent=2) + self.logging.info("Created package.json for Python container worker.js orchestration") + + # Install Node.js dependencies (needed for all containers for worker.js) + self.logging.info(f"Installing @cloudflare/containers for worker.js orchestration in {directory}") + try: + result = subprocess.run( + ["npm", "install", "--production"], + cwd=directory, + capture_output=True, + text=True, + check=True, + timeout=120 + ) + self.logging.info("npm install completed successfully") + except Exception as e: + self.logging.error(f"npm install failed: {e}") + raise RuntimeError(f"Failed to install Node.js dependencies: {e}") + + # For Python containers, also handle Python requirements + if language_name == "python": + # Python requirements will be installed in the Dockerfile + # Rename version-specific requirements.txt to requirements.txt + requirements_file = os.path.join(directory, "requirements.txt") + versioned_requirements = os.path.join(directory, f"requirements.txt.{language_version}") + + if os.path.exists(versioned_requirements): + shutil.copy2(versioned_requirements, requirements_file) + self.logging.info(f"Copied requirements.txt.{language_version} to requirements.txt") + elif not os.path.exists(requirements_file): + # Create empty requirements.txt if none exists + with open(requirements_file, 'w') as f: + f.write("") + self.logging.info("Created empty requirements.txt") + + # Build Docker image locally for cache compatibility + # wrangler will re-build/push during deployment from the Dockerfile + image_tag = self._build_container_image_local(directory, benchmark, language_name, language_version) + + # Calculate package size (approximate, as it's a source directory) + total_size = 0 + for dirpath, dirnames, filenames in os.walk(directory): + for filename in filenames: + filepath = os.path.join(dirpath, filename) + total_size += os.path.getsize(filepath) + + self.logging.info(f"Container package prepared with local image: {image_tag}") + + # Return local image tag (wrangler will rebuild from Dockerfile during deploy) + return (directory, total_size, image_tag) + + def _build_container_image_local( + self, + directory: str, + benchmark: str, + language_name: str, + language_version: str, + ) -> str: + """ + Build a Docker image locally for cache purposes. + wrangler will rebuild from Dockerfile during deployment. + + Returns the local image tag. + """ + # Generate image tag + image_name = f"{benchmark.replace('.', '-')}-{language_name}-{language_version.replace('.', '')}" + image_tag = f"{image_name}:latest" + + self.logging.info(f"Building local container image: {image_tag}") + + try: + # Build the Docker image locally (no push) + # Use --no-cache to ensure handler changes are picked up + result = subprocess.run( + ["docker", "build", "--no-cache", "-t", image_tag, "."], + cwd=directory, + capture_output=True, + text=True, + check=True, + timeout=300 # 5 minutes for build + ) + + self.logging.info(f"Local container image built: {image_tag}") + if result.stdout: + self.logging.debug(f"Docker build output: {result.stdout}") + + return image_tag + + except subprocess.CalledProcessError as e: + error_msg = f"Docker build failed for {image_tag}" + if e.stderr: + error_msg += f": {e.stderr}" + self.logging.error(error_msg) + raise RuntimeError(error_msg) + except subprocess.TimeoutExpired: + raise RuntimeError(f"Docker build timed out for {image_tag}") + + + return (directory, total_size, "") + def create_function( self, code_package: Benchmark, @@ -589,24 +961,19 @@ def create_function( Args: code_package: Benchmark containing the function code func_name: Name of the worker - container_deployment: Whether to deploy as container (not supported) - container_uri: URI of container image (not used) + container_deployment: Whether to deploy as container + container_uri: URI of container image Returns: CloudflareWorker instance """ - if container_deployment: - raise NotImplementedError( - "Container deployment is not supported for Cloudflare Workers" - ) - package = code_package.code_location benchmark = code_package.benchmark language = code_package.language_name language_runtime = code_package.language_version function_cfg = FunctionConfig.from_benchmark(code_package) - func_name = self.format_function_name(func_name) + func_name = self.format_function_name(func_name, container_deployment) account_id = self.config.credentials.account_id if not account_id: @@ -632,7 +999,7 @@ def create_function( self.logging.info(f"Creating new worker {func_name}") # Create the worker with all package files - self._create_or_update_worker(func_name, package, account_id, language, benchmark, code_package) + self._create_or_update_worker(func_name, package, account_id, language, benchmark, code_package, container_deployment, container_uri) worker = CloudflareWorker( func_name, @@ -679,7 +1046,7 @@ def _get_worker(self, worker_name: str, account_id: str) -> Optional[dict]: return None def _create_or_update_worker( - self, worker_name: str, package_dir: str, account_id: str, language: str, benchmark_name: Optional[str] = None, code_package: Optional[Benchmark] = None + self, worker_name: str, package_dir: str, account_id: str, language: str, benchmark_name: Optional[str] = None, code_package: Optional[Benchmark] = None, container_deployment: bool = False, container_uri: str = "" ) -> dict: """Create or update a Cloudflare Worker using Wrangler CLI. @@ -690,28 +1057,24 @@ def _create_or_update_worker( language: Programming language (nodejs or python) benchmark_name: Optional benchmark name for R2 file path prefix code_package: Optional benchmark package for nosql configuration + container_deployment: Whether this is a container deployment + container_uri: Container image URI/tag Returns: Worker deployment result """ - # # Convert CommonJS function.js to ESM if it exists - # if language == "nodejs": - # function_js = os.path.join(package_dir, "function.js") - # if os.path.exists(function_js): - # self.logging.info(f"Converting function.js from CommonJS to ESM...") - # try: - # esm_content = self._convert_commonjs_to_esm(function_js) - # with open(function_js, 'w') as f: - # f.write(esm_content) - # self.logging.info("Successfully converted function.js to ESM") - # except Exception as e: - # self.logging.error(f"Failed to convert function.js to ESM: {e}") - # raise # Generate wrangler.toml for this worker - self._generate_wrangler_toml(worker_name, package_dir, language, account_id, benchmark_name, code_package) + self._generate_wrangler_toml(worker_name, package_dir, language, account_id, benchmark_name, code_package, container_deployment, container_uri) # Set up environment for Wrangler env = os.environ.copy() + + # Add uv tools bin directory to PATH for pywrangler access + home_dir = os.path.expanduser("~") + uv_bin_dir = os.path.join(home_dir, ".local", "share", "uv", "tools", "workers-py", "bin") + if os.path.exists(uv_bin_dir): + env['PATH'] = f"{uv_bin_dir}:{env.get('PATH', '')}" + if self.config.credentials.api_token: env['CLOUDFLARE_API_TOKEN'] = self.config.credentials.api_token elif self.config.credentials.email and self.config.credentials.api_key: @@ -723,21 +1086,49 @@ def _create_or_update_worker( # Deploy using Wrangler self.logging.info(f"Deploying worker {worker_name} using Wrangler...") + # For container deployments, always use wrangler (not pywrangler) + # For native deployments, use wrangler for nodejs, pywrangler for python + if container_deployment: + wrangler_cmd = "wrangler" + else: + wrangler_cmd = "wrangler" if language == "nodejs" else "pywrangler" + try: + # Increase timeout for large container images (e.g., 411.image-recognition with PyTorch) + # Container deployment requires pushing large images to Cloudflare + deploy_timeout = 1200 if container_deployment else 180 # 20 minutes for containers, 3 for native + result = subprocess.run( - ["wrangler" if language == "nodejs" else "pywrangler", "deploy"], + [wrangler_cmd, "deploy"], cwd=package_dir, env=env, capture_output=True, text=True, check=True, - timeout=180 # 3 minutes for deployment + timeout=deploy_timeout ) self.logging.info(f"Worker {worker_name} deployed successfully") if result.stdout: self.logging.debug(f"Wrangler deploy output: {result.stdout}") + # For container deployments, wait for Durable Object infrastructure to initialize + # The container binding needs time to propagate before first invocation + if container_deployment: + self.logging.info("Waiting for container Durable Object to initialize...") + self._wait_for_durable_object_ready(worker_name, package_dir, env) + + # for benchmarks 220, 311, 411 we need to wait longer after deployment + # if benchmark_name in ["220.video-processing", "311.compression", "411.image-recognition", "504.dna-visualisation"]: + # self.logging.info("Waiting 120 seconds for benchmark initialization...") + # time.sleep(400) + + # For container deployments, wait for Durable Object infrastructure to initialize + # The container binding needs time to propagate before first invocation + if container_deployment: + self.logging.info("Waiting 60 seconds for container Durable Object to initialize...") + time.sleep(60) + # Parse the output to get worker URL # Wrangler typically outputs: "Published ()" # and "https://..workers.dev" @@ -753,6 +1144,69 @@ def _create_or_update_worker( self.logging.error(error_msg) raise RuntimeError(error_msg) + def _wait_for_durable_object_ready(self, worker_name: str, package_dir: str, env: dict): + """Wait for container Durable Object to be fully provisioned and ready.""" + max_wait_seconds = 400 + wait_interval = 10 + start_time = time.time() + + account_id = env.get('CLOUDFLARE_ACCOUNT_ID') + worker_url = self._build_workers_dev_url(worker_name, account_id) + + self.logging.info("Checking container Durable Object readiness via health endpoint...") + + consecutive_failures = 0 + max_consecutive_failures = 5 + + while time.time() - start_time < max_wait_seconds: + try: + # Use health check endpoint + response = requests.get( + f"{worker_url}/health", + timeout=60 + ) + + # 200 = ready + if response.status_code == 200: + self.logging.info("Container Durable Object is ready!") + return True + + # 503 = not ready yet (expected, keep waiting) + elif response.status_code == 503: + elapsed = int(time.time() - start_time) + try: + error_data = response.json() + error_msg = error_data.get('error', 'Container provisioning') + self.logging.info(f"{error_msg}... ({elapsed}s elapsed)") + except: + self.logging.info(f"Container provisioning... ({elapsed}s elapsed)") + consecutive_failures = 0 # This is expected + + # 500 or other = something's wrong + else: + consecutive_failures += 1 + self.logging.warning(f"Unexpected status {response.status_code}: {response.text[:200]}") + + # If we get too many unexpected errors, something might be broken + if consecutive_failures >= max_consecutive_failures: + self.logging.error(f"Got {consecutive_failures} consecutive errors, container may be broken") + return False + + except requests.exceptions.Timeout: + elapsed = int(time.time() - start_time) + self.logging.info(f"Health check timeout (container may be starting)... ({elapsed}s elapsed)") + except requests.exceptions.RequestException as e: + elapsed = int(time.time() - start_time) + self.logging.debug(f"Connection error ({elapsed}s): {str(e)[:100]}") + + time.sleep(wait_interval) + + self.logging.warning( + f"Container Durable Object may not be fully ready after {max_wait_seconds}s. " + "First invocation may still experience initialization delay." + ) + return False + def _get_workers_dev_subdomain(self, account_id: str) -> Optional[str]: """Fetch the workers.dev subdomain for the given account. @@ -849,14 +1303,9 @@ def update_function( Args: function: Existing function instance to update code_package: New benchmark containing the function code - container_deployment: Whether to deploy as container (not supported) - container_uri: URI of container image (not used) + container_deployment: Whether to deploy as container + container_uri: URI of container image """ - if container_deployment: - raise NotImplementedError( - "Container deployment is not supported for Cloudflare Workers" - ) - worker = cast(CloudflareWorker, function) package = code_package.code_location language = code_package.language_name @@ -867,7 +1316,7 @@ def update_function( if not account_id: raise RuntimeError("Account ID is required to update worker") - self._create_or_update_worker(worker.name, package, account_id, language, benchmark, code_package) + self._create_or_update_worker(worker.name, package, account_id, language, benchmark, code_package, container_deployment, container_uri) self.logging.info(f"Updated worker {worker.name}") # Update configuration if needed @@ -918,7 +1367,7 @@ def default_function_name(self, code_package: Benchmark, resources=None) -> str: ).lower() @staticmethod - def format_function_name(name: str) -> str: + def format_function_name(name: str, container_deployment: bool = False) -> str: """ Format a function name to comply with Cloudflare Worker naming rules. @@ -926,9 +1375,11 @@ def format_function_name(name: str) -> str: - Be lowercase - Contain only alphanumeric characters and hyphens - Not start or end with a hyphen + - Not start with a digit Args: name: The original name + container_deployment: Whether this is a container worker (adds 'w-' prefix if name starts with digit) Returns: Formatted name @@ -939,6 +1390,10 @@ def format_function_name(name: str) -> str: formatted = ''.join(c for c in formatted if c.isalnum() or c == '-') # Remove leading/trailing hyphens formatted = formatted.strip('-') + # Ensure container worker names don't start with a digit (Cloudflare requirement) + # Only add prefix for container workers to differentiate from native workers + if container_deployment and formatted and formatted[0].isdigit(): + formatted = 'container-' + formatted return formatted def enforce_cold_start(self, functions: List[Function], code_package: Benchmark): diff --git a/sebs/cloudflare/r2.py b/sebs/cloudflare/r2.py index 73e047fb7..660588e1f 100644 --- a/sebs/cloudflare/r2.py +++ b/sebs/cloudflare/r2.py @@ -1,4 +1,5 @@ import json +import os import requests from sebs.cloudflare.config import CloudflareCredentials @@ -233,18 +234,48 @@ def upload_bytes(self, bucket_name: str, key: str, data: bytes): def list_bucket(self, bucket_name: str, prefix: str = "") -> List[str]: """ - Retrieves list of files in a bucket. + Retrieves list of files in a bucket using S3-compatible API. :param bucket_name: :param prefix: optional prefix filter :return: list of files in a given bucket """ - account_id = self._credentials.account_id + # Use S3-compatible API with R2 credentials + if not self._credentials.r2_access_key_id or not self._credentials.r2_secret_access_key: + self.logging.warning(f"R2 S3 credentials not configured, cannot list bucket {bucket_name}") + return [] - # R2 uses S3-compatible API for listing objects - # For now, return empty list as listing objects requires S3 credentials - self.logging.warning(f"list_bucket not fully implemented for R2 bucket {bucket_name}") - return [] + try: + import boto3 + from botocore.config import Config + + account_id = self._credentials.account_id + r2_endpoint = f"https://{account_id}.r2.cloudflarestorage.com" + + s3_client = boto3.client( + 's3', + endpoint_url=r2_endpoint, + aws_access_key_id=self._credentials.r2_access_key_id, + aws_secret_access_key=self._credentials.r2_secret_access_key, + config=Config(signature_version='s3v4'), + region_name='auto' + ) + + # List objects with optional prefix + paginator = s3_client.get_paginator('list_objects_v2') + page_iterator = paginator.paginate(Bucket=bucket_name, Prefix=prefix) + + files = [] + for page in page_iterator: + if 'Contents' in page: + for obj in page['Contents']: + files.append(obj['Key']) + + return files + + except Exception as e: + self.logging.warning(f"Failed to list R2 bucket {bucket_name}: {str(e)}") + return [] def list_buckets(self, bucket_name: Optional[str] = None) -> List[str]: """ @@ -346,9 +377,25 @@ def uploader_func(self, bucket_idx: int, file: str, filepath: str) -> None: """ Upload a file to a bucket (used for parallel uploads). - :param bucket_idx: index of the bucket to upload to - :param file: destination file name + :param bucket_idx: index of the bucket/prefix to upload to + :param file: destination file name/key :param filepath: source file path """ - self.logging.warning(f"uploader_func not fully implemented for R2") - pass + # Skip upload when using cached buckets and not updating storage + if self.cached and not self.replace_existing: + return + + # Build the key with the input prefix + key = os.path.join(self.input_prefixes[bucket_idx], file) + + bucket_name = self.get_bucket(Resources.StorageBucketType.BENCHMARKS) + + # Check if file already exists (if not replacing existing files) + if not self.replace_existing: + for f in self.input_prefixes_files[bucket_idx]: + if key == f: + self.logging.info(f"Skipping upload of {filepath} to {bucket_name} (already exists)") + return + + # Upload the file + self.upload(bucket_name, filepath, key) diff --git a/sebs/experiments/config.py b/sebs/experiments/config.py index edde88de4..30483948a 100644 --- a/sebs/experiments/config.py +++ b/sebs/experiments/config.py @@ -173,7 +173,7 @@ def deserialize(config: dict) -> "Config": cfg._update_code = config["update_code"] cfg._update_storage = config["update_storage"] cfg._download_results = config["download_results"] - cfg._container_deployment = config["container_deployment"] + cfg._container_deployment = config.get("container_deployment", False) cfg._runtime = Runtime.deserialize(config["runtime"]) cfg._flags = config["flags"] if "flags" in config else {} cfg._architecture = config["architecture"] From 5284880fa0b6ddc59818a56f714d2fe1c244aef3 Mon Sep 17 00:00:00 2001 From: laurin Date: Mon, 8 Dec 2025 11:23:18 +0100 Subject: [PATCH 32/69] bigger container for python containers --- sebs/cloudflare/cloudflare.py | 42 +++++++++++++++++++++++++++++++---- 1 file changed, 38 insertions(+), 4 deletions(-) diff --git a/sebs/cloudflare/cloudflare.py b/sebs/cloudflare/cloudflare.py index e199957ac..a710b436c 100644 --- a/sebs/cloudflare/cloudflare.py +++ b/sebs/cloudflare/cloudflare.py @@ -255,10 +255,10 @@ def _generate_wrangler_toml(self, worker_name: str, package_dir: str, language: instance_type = "" if benchmark_name and ("411.image-recognition" in benchmark_name or "311.compression" in benchmark_name or "504.dna-visualisation" in benchmark_name): # Use "standard" (largest) for Python, "standard-4" for Node.js - if language == "python": - instance_type = '\ninstance_type = "standard" # Largest available - needed for Python zip operations\n' - else: - instance_type = '\ninstance_type = "standard-4" # 20GB Disk, 12GB Memory\n' + # if language == "python": + # instance_type = '\ninstance_type = "standard-4" # Largest available - needed for Python zip operations\n' + # else: + instance_type = '\ninstance_type = "standard-4" # 20GB Disk, 12GB Memory\n' toml_content = f"""name = "{worker_name}" main = "worker.js" @@ -875,6 +875,40 @@ def replacer(match): if os.path.exists(versioned_requirements): shutil.copy2(versioned_requirements, requirements_file) self.logging.info(f"Copied requirements.txt.{language_version} to requirements.txt") + + # Fix torch wheel URLs for container compatibility + # Replace direct wheel URLs with proper torch installation + with open(requirements_file, 'r') as f: + content = f.read() + + # Replace torch wheel URLs with proper installation commands + import re + modified = False + if 'download.pytorch.org/whl' in content: + # Remove direct wheel URLs and replace with proper torch installation + lines = content.split('\n') + new_lines = [] + for line in lines: + if 'download.pytorch.org/whl/cpu/torch-' in line: + # Extract version from URL (e.g., torch-2.0.0+cpu) + match = re.search(r'torch-([0-9.]+)(?:%2B|\+)cpu', line) + if match: + version = match.group(1) + # Use index-url method instead of direct wheel + new_lines.append(f'torch=={version}') + modified = True + else: + new_lines.append(line) + else: + new_lines.append(line) + + if modified: + # Add extra-index-url at the top for CPU-only torch + content = '--extra-index-url https://download.pytorch.org/whl/cpu\n' + '\n'.join(new_lines) + with open(requirements_file, 'w') as f: + f.write(content) + self.logging.info("Modified requirements.txt to use torch index-url instead of direct wheels") + elif not os.path.exists(requirements_file): # Create empty requirements.txt if none exists with open(requirements_file, 'w') as f: From b6de39b14565e51a6e63dd70a78e99fdd04e6173 Mon Sep 17 00:00:00 2001 From: laurin Date: Mon, 8 Dec 2025 13:41:25 +0100 Subject: [PATCH 33/69] sleep delay longer --- benchmarks/wrappers/cloudflare/nodejs/container/worker.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/benchmarks/wrappers/cloudflare/nodejs/container/worker.js b/benchmarks/wrappers/cloudflare/nodejs/container/worker.js index 78140794f..8dee914a0 100644 --- a/benchmarks/wrappers/cloudflare/nodejs/container/worker.js +++ b/benchmarks/wrappers/cloudflare/nodejs/container/worker.js @@ -4,7 +4,7 @@ import { DurableObject } from "cloudflare:workers"; // Container wrapper class export class ContainerWorker extends Container { defaultPort = 8080; - sleepAfter = "10m"; + sleepAfter = "30m"; } // Durable Object for NoSQL storage (simple proxy to ctx.storage) From 812f5925a89c7d56d0f7c1ac2456c6fab42685a3 Mon Sep 17 00:00:00 2001 From: laurin Date: Mon, 8 Dec 2025 14:02:10 +0100 Subject: [PATCH 34/69] request_id has to be string --- benchmarks/wrappers/cloudflare/python/container/handler.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/benchmarks/wrappers/cloudflare/python/container/handler.py b/benchmarks/wrappers/cloudflare/python/container/handler.py index 4eb21bd8c..16537f5de 100644 --- a/benchmarks/wrappers/cloudflare/python/container/handler.py +++ b/benchmarks/wrappers/cloudflare/python/container/handler.py @@ -118,7 +118,7 @@ def handle_request(self): # Add request metadata import random - req_id = random.randint(0, 1000000) + req_id = str(random.randint(0, 1000000)) income_timestamp = datetime.datetime.now().timestamp() event['request-id'] = req_id event['income-timestamp'] = income_timestamp From 9229f9fa9eb72f31e35cae0a58854f555b8350ba Mon Sep 17 00:00:00 2001 From: laurin Date: Mon, 8 Dec 2025 14:31:56 +0100 Subject: [PATCH 35/69] update container fixed --- sebs/cloudflare/cloudflare.py | 14 +++++++++++--- 1 file changed, 11 insertions(+), 3 deletions(-) diff --git a/sebs/cloudflare/cloudflare.py b/sebs/cloudflare/cloudflare.py index a710b436c..602480309 100644 --- a/sebs/cloudflare/cloudflare.py +++ b/sebs/cloudflare/cloudflare.py @@ -1350,10 +1350,18 @@ def update_function( if not account_id: raise RuntimeError("Account ID is required to update worker") - self._create_or_update_worker(worker.name, package, account_id, language, benchmark, code_package, container_deployment, container_uri) - self.logging.info(f"Updated worker {worker.name}") + # For container deployments, skip redeployment if code hasn't changed + # Containers don't support runtime memory configuration changes + # Detect container deployment by checking if worker name starts with "container-" + is_container = worker.name.startswith("container-") + + if is_container: + self.logging.info(f"Skipping redeployment for container worker {worker.name} - containers don't support runtime memory updates") + else: + self._create_or_update_worker(worker.name, package, account_id, language, benchmark, code_package, container_deployment, container_uri) + self.logging.info(f"Updated worker {worker.name}") - # Update configuration if needed + # Update configuration if needed (no-op for containers since they don't support runtime memory changes) self.update_function_configuration(worker, code_package) def update_function_configuration( From 5899d87ee40144f058f7b2d17ffd614ad712f9b8 Mon Sep 17 00:00:00 2001 From: =Laurin <=laurin@stomp.li> Date: Sat, 13 Dec 2025 13:35:51 +0100 Subject: [PATCH 36/69] fixed benchmark wrapper request ids for experiment results as well as begin/end --- .../cloudflare/nodejs/container/handler.js | 18 ++++++++++----- .../wrappers/cloudflare/nodejs/handler.js | 13 ++++++++--- .../cloudflare/python/container/handler.py | 19 +++++++++++----- .../wrappers/cloudflare/python/handler.py | 22 ++++++++++++++----- sebs/cloudflare/cloudflare.py | 2 +- 5 files changed, 53 insertions(+), 21 deletions(-) diff --git a/benchmarks/wrappers/cloudflare/nodejs/container/handler.js b/benchmarks/wrappers/cloudflare/nodejs/container/handler.js index 6f99c6728..967db73c0 100644 --- a/benchmarks/wrappers/cloudflare/nodejs/container/handler.js +++ b/benchmarks/wrappers/cloudflare/nodejs/container/handler.js @@ -67,6 +67,10 @@ const server = http.createServer(async (req, res) => { } try { + // Get unique request ID from Cloudflare (CF-Ray header) + const crypto = require('crypto'); + const reqId = req.headers['cf-ray'] || crypto.randomUUID(); + // Extract Worker URL from header for R2 and NoSQL proxy const workerUrl = req.headers['x-worker-url']; if (workerUrl) { @@ -109,7 +113,6 @@ const server = http.createServer(async (req, res) => { } // Add request metadata - const reqId = 0; const incomeTimestamp = Math.floor(Date.now() / 1000); event['request-id'] = reqId; event['income-timestamp'] = incomeTimestamp; @@ -154,21 +157,26 @@ const server = http.createServer(async (req, res) => { console.log('Sending response with log_data:', log_data); + // Get memory usage in MB + const memUsage = process.memoryUsage(); + const memory_mb = memUsage.heapUsed / 1024 / 1024; + // Send response matching Python handler format exactly if (event.html) { res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' }); res.end(String(ret && ret.result !== undefined ? ret.result : ret)); } else { const responseBody = JSON.stringify({ - begin: "0", - end: "0", - results_time: "0", + begin: begin, + end: end, + results_time: 0, result: log_data, is_cold: false, is_cold_worker: false, container_id: '0', environ_container_id: 'no_id', - request_id: '0', + request_id: reqId, + memory_used: memory_mb, }); res.writeHead(200, { 'Content-Type': 'application/json' }); res.end(responseBody); diff --git a/benchmarks/wrappers/cloudflare/nodejs/handler.js b/benchmarks/wrappers/cloudflare/nodejs/handler.js index 507d68153..4303be81e 100644 --- a/benchmarks/wrappers/cloudflare/nodejs/handler.js +++ b/benchmarks/wrappers/cloudflare/nodejs/handler.js @@ -40,6 +40,9 @@ export default { return new Response('None'); } + // Get unique request ID from Cloudflare (CF-Ray header) + const req_id = request.headers.get('CF-Ray') || crypto.randomUUID(); + // Start timing measurements const begin = Date.now() / 1000; const start = performance.now(); @@ -80,8 +83,7 @@ export default { } } - // Set request id and timestamps (Python used 0 for request id) - const req_id = 0; + // Set timestamps const income_timestamp = Math.floor(Date.now() / 1000); event['request-id'] = req_id; event['income-timestamp'] = income_timestamp; @@ -201,6 +203,10 @@ export default { }); } + // Get memory usage in MB + const memUsage = process.memoryUsage(); + const memory_mb = memUsage.heapUsed / 1024 / 1024; + const responseBody = JSON.stringify({ begin: begin, end: end, @@ -211,7 +217,8 @@ export default { is_cold_worker: false, container_id: '0', environ_container_id: 'no_id', - request_id: '0', + request_id: req_id, + memory_used: memory_mb, }); return new Response(responseBody, { headers: { 'Content-Type': 'application/json' } }); diff --git a/benchmarks/wrappers/cloudflare/python/container/handler.py b/benchmarks/wrappers/cloudflare/python/container/handler.py index 16537f5de..dd52cb0ed 100644 --- a/benchmarks/wrappers/cloudflare/python/container/handler.py +++ b/benchmarks/wrappers/cloudflare/python/container/handler.py @@ -8,6 +8,7 @@ import sys import os import traceback +import resource from http.server import HTTPServer, BaseHTTPRequestHandler from urllib.parse import urlparse, parse_qs import datetime @@ -84,6 +85,10 @@ def handle_request(self): return try: + # Get unique request ID from Cloudflare (CF-Ray header) + import uuid + req_id = self.headers.get('CF-Ray', str(uuid.uuid4())) + # Extract Worker URL from header for R2 and NoSQL proxy worker_url = self.headers.get('X-Worker-URL') if worker_url: @@ -117,8 +122,6 @@ def handle_request(self): event[key] = value # Add request metadata - import random - req_id = str(random.randint(0, 1000000)) income_timestamp = datetime.datetime.now().timestamp() event['request-id'] = req_id event['income-timestamp'] = income_timestamp @@ -146,16 +149,20 @@ def handle_request(self): if 'measurement' in result: log_data['measurement'] = result['measurement'] + # Get memory usage in MB + memory_mb = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss / 1024.0 + response_data = { - 'begin': "0", - 'end': "0", - 'results_time': "0", + 'begin': begin, + 'end': end, + 'results_time': 0, 'result': log_data, 'is_cold': False, 'is_cold_worker': False, 'container_id': "0", 'environ_container_id': "no_id", - 'request_id': "0" + 'request_id': req_id, + 'memory_used': memory_mb } # Send response diff --git a/benchmarks/wrappers/cloudflare/python/handler.py b/benchmarks/wrappers/cloudflare/python/handler.py index a0b63dcf9..37cbf58ba 100644 --- a/benchmarks/wrappers/cloudflare/python/handler.py +++ b/benchmarks/wrappers/cloudflare/python/handler.py @@ -2,6 +2,7 @@ import asyncio import importlib.util import traceback +import resource from workers import WorkerEntrypoint, Response, DurableObject ## sys.path.append(os.path.join(os.path.dirname(__file__), '.python_packages/lib/site-packages')) @@ -34,6 +35,9 @@ async def fetch(self, request, env): async def fetch2(self, request, env): if "favicon" in request.url: return Response("None") + # Get unique request ID from Cloudflare (CF-Ray header) + req_id = request.headers.get('CF-Ray', str(uuid.uuid4())) + req_text = await request.text() event = json.loads(req_text) if len(req_text) > 0 else {} @@ -55,8 +59,6 @@ async def fetch2(self, request, env): - ## we might need more data in self.env to know this ID - req_id = 0 ## note: time fixed in worker income_timestamp = datetime.datetime.now().timestamp() @@ -97,16 +99,24 @@ async def fetch2(self, request, env): headers = {"Content-Type" : "text/html; charset=utf-8"} return Response(str(ret["result"]), headers = headers) else: + # Get memory usage in MB + memory_mb = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss / 1024.0 + + # Calculate timestamps + end_timestamp = datetime.datetime.now().timestamp() + begin_timestamp = income_timestamp + return Response(json.dumps({ - 'begin': "0", - 'end': "0", - 'results_time': "0", + 'begin': begin_timestamp, + 'end': end_timestamp, + 'results_time': 0, 'result': log_data, 'is_cold': False, 'is_cold_worker': False, 'container_id': "0", 'environ_container_id': "no_id", - 'request_id': "0" + 'request_id': req_id, + 'memory_used': memory_mb })) diff --git a/sebs/cloudflare/cloudflare.py b/sebs/cloudflare/cloudflare.py index 602480309..7977abed1 100644 --- a/sebs/cloudflare/cloudflare.py +++ b/sebs/cloudflare/cloudflare.py @@ -1511,7 +1511,7 @@ def download_metrics( wall_times.append(result.times.benchmark) # Collect memory usage - if result.stats.memory_used > 0: + if result.stats.memory_used is not None and result.stats.memory_used > 0: memory_values.append(result.stats.memory_used) # Set billing info for Cloudflare Workers From 6e0cd2bd1b8bca6950c1b8ec3f1fe5213337ee08 Mon Sep 17 00:00:00 2001 From: =Laurin <=laurin@stomp.li> Date: Sat, 13 Dec 2025 14:25:12 +0100 Subject: [PATCH 37/69] extract memory correctly --- .../cloudflare/nodejs/container/handler.js | 15 +++++++-------- benchmarks/wrappers/cloudflare/nodejs/handler.js | 13 ++++++++----- .../cloudflare/python/container/handler.py | 8 +++++--- benchmarks/wrappers/cloudflare/python/handler.py | 13 ++++++++----- 4 files changed, 28 insertions(+), 21 deletions(-) diff --git a/benchmarks/wrappers/cloudflare/nodejs/container/handler.js b/benchmarks/wrappers/cloudflare/nodejs/container/handler.js index 967db73c0..e18212342 100644 --- a/benchmarks/wrappers/cloudflare/nodejs/container/handler.js +++ b/benchmarks/wrappers/cloudflare/nodejs/container/handler.js @@ -150,16 +150,16 @@ const server = http.createServer(async (req, res) => { const log_data = { output: ret && ret.result !== undefined ? ret.result : ret }; if (ret && ret.measurement !== undefined) { log_data.measurement = ret.measurement; + } else { + log_data.measurement = {}; } - if (event.logs !== undefined) { - log_data.time = 0; - } - - console.log('Sending response with log_data:', log_data); - - // Get memory usage in MB + + // Add memory usage to measurement const memUsage = process.memoryUsage(); const memory_mb = memUsage.heapUsed / 1024 / 1024; + log_data.measurement.memory_used_mb = memory_mb; + + console.log('Sending response with log_data:', log_data); // Send response matching Python handler format exactly if (event.html) { @@ -176,7 +176,6 @@ const server = http.createServer(async (req, res) => { container_id: '0', environ_container_id: 'no_id', request_id: reqId, - memory_used: memory_mb, }); res.writeHead(200, { 'Content-Type': 'application/json' }); res.end(responseBody); diff --git a/benchmarks/wrappers/cloudflare/nodejs/handler.js b/benchmarks/wrappers/cloudflare/nodejs/handler.js index 4303be81e..379fa23ad 100644 --- a/benchmarks/wrappers/cloudflare/nodejs/handler.js +++ b/benchmarks/wrappers/cloudflare/nodejs/handler.js @@ -192,7 +192,15 @@ export default { const log_data = { output: ret && ret.result !== undefined ? ret.result : ret }; if (ret && ret.measurement !== undefined) { log_data.measurement = ret.measurement; + } else { + log_data.measurement = {}; } + + // Add memory usage to measurement + const memUsage = process.memoryUsage(); + const memory_mb = memUsage.heapUsed / 1024 / 1024; + log_data.measurement.memory_used_mb = memory_mb; + if (event.logs !== undefined) { log_data.time = 0; } @@ -203,10 +211,6 @@ export default { }); } - // Get memory usage in MB - const memUsage = process.memoryUsage(); - const memory_mb = memUsage.heapUsed / 1024 / 1024; - const responseBody = JSON.stringify({ begin: begin, end: end, @@ -218,7 +222,6 @@ export default { container_id: '0', environ_container_id: 'no_id', request_id: req_id, - memory_used: memory_mb, }); return new Response(responseBody, { headers: { 'Content-Type': 'application/json' } }); diff --git a/benchmarks/wrappers/cloudflare/python/container/handler.py b/benchmarks/wrappers/cloudflare/python/container/handler.py index dd52cb0ed..5f3cb2a43 100644 --- a/benchmarks/wrappers/cloudflare/python/container/handler.py +++ b/benchmarks/wrappers/cloudflare/python/container/handler.py @@ -148,9 +148,12 @@ def handle_request(self): } if 'measurement' in result: log_data['measurement'] = result['measurement'] + else: + log_data['measurement'] = {} - # Get memory usage in MB + # Add memory usage to measurement memory_mb = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss / 1024.0 + log_data['measurement']['memory_used_mb'] = memory_mb response_data = { 'begin': begin, @@ -161,8 +164,7 @@ def handle_request(self): 'is_cold_worker': False, 'container_id': "0", 'environ_container_id': "no_id", - 'request_id': req_id, - 'memory_used': memory_mb + 'request_id': req_id } # Send response diff --git a/benchmarks/wrappers/cloudflare/python/handler.py b/benchmarks/wrappers/cloudflare/python/handler.py index 37cbf58ba..8b424df46 100644 --- a/benchmarks/wrappers/cloudflare/python/handler.py +++ b/benchmarks/wrappers/cloudflare/python/handler.py @@ -92,6 +92,13 @@ async def fetch2(self, request, env): } if 'measurement' in ret: log_data['measurement'] = ret['measurement'] + else: + log_data['measurement'] = {} + + # Add memory usage to measurement + memory_mb = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss / 1024.0 + log_data['measurement']['memory_used_mb'] = memory_mb + if 'logs' in event: log_data['time'] = 0 @@ -99,9 +106,6 @@ async def fetch2(self, request, env): headers = {"Content-Type" : "text/html; charset=utf-8"} return Response(str(ret["result"]), headers = headers) else: - # Get memory usage in MB - memory_mb = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss / 1024.0 - # Calculate timestamps end_timestamp = datetime.datetime.now().timestamp() begin_timestamp = income_timestamp @@ -115,8 +119,7 @@ async def fetch2(self, request, env): 'is_cold_worker': False, 'container_id': "0", 'environ_container_id': "no_id", - 'request_id': req_id, - 'memory_used': memory_mb + 'request_id': req_id })) From 3cd741fca97d3d39acacc9253151d85849cad176 Mon Sep 17 00:00:00 2001 From: =Laurin <=laurin@stomp.li> Date: Sun, 14 Dec 2025 11:47:03 +0100 Subject: [PATCH 38/69] pyiodide does not support resource module for memory measurement --- .../wrappers/cloudflare/python/handler.py | 17 +++++++++++++---- 1 file changed, 13 insertions(+), 4 deletions(-) diff --git a/benchmarks/wrappers/cloudflare/python/handler.py b/benchmarks/wrappers/cloudflare/python/handler.py index 8b424df46..91be3acf9 100644 --- a/benchmarks/wrappers/cloudflare/python/handler.py +++ b/benchmarks/wrappers/cloudflare/python/handler.py @@ -2,7 +2,12 @@ import asyncio import importlib.util import traceback -import resource +try: + import resource + HAS_RESOURCE = True +except ImportError: + # Pyodide (Python native workers) doesn't support resource module + HAS_RESOURCE = False from workers import WorkerEntrypoint, Response, DurableObject ## sys.path.append(os.path.join(os.path.dirname(__file__), '.python_packages/lib/site-packages')) @@ -95,9 +100,13 @@ async def fetch2(self, request, env): else: log_data['measurement'] = {} - # Add memory usage to measurement - memory_mb = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss / 1024.0 - log_data['measurement']['memory_used_mb'] = memory_mb + # Add memory usage to measurement (if resource module is available) + if HAS_RESOURCE: + memory_mb = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss / 1024.0 + log_data['measurement']['memory_used_mb'] = memory_mb + else: + # Pyodide doesn't support resource module + log_data['measurement']['memory_used_mb'] = 0.0 if 'logs' in event: log_data['time'] = 0 From 2615a3659ac7d97bc67d4f95420ceb9a0102c858 Mon Sep 17 00:00:00 2001 From: =Laurin <=laurin@stomp.li> Date: Mon, 15 Dec 2025 16:20:59 +0100 Subject: [PATCH 39/69] timing fix for cloudflare handler --- .../wrappers/cloudflare/nodejs/handler.js | 26 +++++++++++++++++-- 1 file changed, 24 insertions(+), 2 deletions(-) diff --git a/benchmarks/wrappers/cloudflare/nodejs/handler.js b/benchmarks/wrappers/cloudflare/nodejs/handler.js index 379fa23ad..df0cee97b 100644 --- a/benchmarks/wrappers/cloudflare/nodejs/handler.js +++ b/benchmarks/wrappers/cloudflare/nodejs/handler.js @@ -44,8 +44,9 @@ export default { const req_id = request.headers.get('CF-Ray') || crypto.randomUUID(); // Start timing measurements - const begin = Date.now() / 1000; const start = performance.now(); + const begin = Date.now() / 1000; + // Parse JSON body first (similar to Azure handler which uses req.body) const req_text = await request.text(); @@ -158,6 +159,16 @@ export default { throw new Error('benchmark handler function not found'); } } catch (err) { + // Trigger a fetch request to update the timer before measuring + // Time measurements only update after a fetch request or R2 operation + try { + // Fetch the worker's own URL with favicon to minimize overhead + const finalUrl = new URL(request.url); + finalUrl.pathname = '/favicon'; + await fetch(finalUrl.toString(), { method: 'HEAD' }); + } catch (e) { + // Ignore fetch errors + } // Calculate timing even for errors const end = Date.now() / 1000; const elapsed = performance.now() - start; @@ -183,7 +194,18 @@ export default { return new Response(errorPayload, { status: 500, headers: { 'Content-Type': 'application/json' } }); } - // Calculate elapsed time + // Trigger a fetch request to update the timer before measuring + // Time measurements only update after a fetch request or R2 operation + try { + // Fetch the worker's own URL with favicon to minimize overhead + const finalUrl = new URL(request.url); + finalUrl.pathname = '/favicon'; + await fetch(finalUrl.toString(), { method: 'HEAD' }); + } catch (e) { + // Ignore fetch errors + } + + // Now read the updated timer const end = Date.now() / 1000; const elapsed = performance.now() - start; const micro = elapsed * 1000; // Convert milliseconds to microseconds From e69243adab3e86d38fce017fa11c602fc7b1ecc1 Mon Sep 17 00:00:00 2001 From: =Laurin <=laurin@stomp.li> Date: Mon, 15 Dec 2025 19:00:14 +0100 Subject: [PATCH 40/69] fixed python timing issue --- .../wrappers/cloudflare/python/handler.py | 27 ++++++++++++++++--- 1 file changed, 23 insertions(+), 4 deletions(-) diff --git a/benchmarks/wrappers/cloudflare/python/handler.py b/benchmarks/wrappers/cloudflare/python/handler.py index 91be3acf9..19eff8baf 100644 --- a/benchmarks/wrappers/cloudflare/python/handler.py +++ b/benchmarks/wrappers/cloudflare/python/handler.py @@ -2,6 +2,7 @@ import asyncio import importlib.util import traceback +import time try: import resource HAS_RESOURCE = True @@ -9,6 +10,7 @@ # Pyodide (Python native workers) doesn't support resource module HAS_RESOURCE = False from workers import WorkerEntrypoint, Response, DurableObject +from js import fetch as js_fetch, URL ## sys.path.append(os.path.join(os.path.dirname(__file__), '.python_packages/lib/site-packages')) @@ -43,6 +45,10 @@ async def fetch2(self, request, env): # Get unique request ID from Cloudflare (CF-Ray header) req_id = request.headers.get('CF-Ray', str(uuid.uuid4())) + # Start timing measurements + start = time.perf_counter() + begin = datetime.datetime.now().timestamp() + req_text = await request.text() event = json.loads(req_text) if len(req_text) > 0 else {} @@ -115,13 +121,26 @@ async def fetch2(self, request, env): headers = {"Content-Type" : "text/html; charset=utf-8"} return Response(str(ret["result"]), headers = headers) else: + # Trigger a fetch request to update the timer before measuring + # Time measurements only update after a fetch request or R2 operation + try: + # Fetch the worker's own URL with favicon to minimize overhead + final_url = URL.new(request.url) + final_url.pathname = '/favicon' + await js_fetch(str(final_url), method='HEAD') + except: + # Ignore fetch errors + pass + # Calculate timestamps - end_timestamp = datetime.datetime.now().timestamp() - begin_timestamp = income_timestamp + end = datetime.datetime.now().timestamp() + elapsed = time.perf_counter() - start + micro = elapsed * 1_000_000 # Convert seconds to microseconds return Response(json.dumps({ - 'begin': begin_timestamp, - 'end': end_timestamp, + 'begin': begin, + 'end': end, + 'compute_time': micro, 'results_time': 0, 'result': log_data, 'is_cold': False, From f39aad05453e95d13ab5a0f7321b8c24f1f846d8 Mon Sep 17 00:00:00 2001 From: laurin Date: Mon, 5 Jan 2026 11:30:21 +0100 Subject: [PATCH 41/69] removed faulty nodejs implementations of 000 bmks --- .../020.network-benchmark/config.json | 2 +- .../020.network-benchmark/nodejs/function.js | 94 -------------- .../020.network-benchmark/nodejs/package.json | 9 -- .../030.clock-synchronization/config.json | 2 +- .../nodejs/function.js | 115 ------------------ .../nodejs/package.json | 9 -- .../040.server-reply/config.json | 2 +- .../040.server-reply/nodejs/function.js | 31 ----- .../040.server-reply/nodejs/package.json | 9 -- 9 files changed, 3 insertions(+), 270 deletions(-) delete mode 100644 benchmarks/000.microbenchmarks/020.network-benchmark/nodejs/function.js delete mode 100644 benchmarks/000.microbenchmarks/020.network-benchmark/nodejs/package.json delete mode 100644 benchmarks/000.microbenchmarks/030.clock-synchronization/nodejs/function.js delete mode 100644 benchmarks/000.microbenchmarks/030.clock-synchronization/nodejs/package.json delete mode 100644 benchmarks/000.microbenchmarks/040.server-reply/nodejs/function.js delete mode 100644 benchmarks/000.microbenchmarks/040.server-reply/nodejs/package.json diff --git a/benchmarks/000.microbenchmarks/020.network-benchmark/config.json b/benchmarks/000.microbenchmarks/020.network-benchmark/config.json index 455933282..c3c2c73b1 100644 --- a/benchmarks/000.microbenchmarks/020.network-benchmark/config.json +++ b/benchmarks/000.microbenchmarks/020.network-benchmark/config.json @@ -1,6 +1,6 @@ { "timeout": 30, "memory": 128, - "languages": ["python", "nodejs"], + "languages": ["python"], "modules": [] } diff --git a/benchmarks/000.microbenchmarks/020.network-benchmark/nodejs/function.js b/benchmarks/000.microbenchmarks/020.network-benchmark/nodejs/function.js deleted file mode 100644 index 431ccbe39..000000000 --- a/benchmarks/000.microbenchmarks/020.network-benchmark/nodejs/function.js +++ /dev/null @@ -1,94 +0,0 @@ -const dgram = require('dgram'); -const fs = require('fs'); -const path = require('path'); -const storage = require('./storage'); - -const storage_handler = new storage.storage(); - -function sleep(ms) { - return new Promise(resolve => setTimeout(resolve, ms)); -} - -exports.handler = async function(event) { - const requestId = event['request-id']; - const address = event['server-address']; - const port = event['server-port']; - const repetitions = event['repetitions']; - const outputBucket = event.bucket.bucket; - const outputPrefix = event.bucket.output; - - const times = []; - let i = 0; - const client = dgram.createSocket('udp4'); - client.bind(); - - const message = Buffer.from(String(requestId)); - let consecutiveFailures = 0; - let key = null; - - while (i < repetitions + 1) { - try { - const sendBegin = Date.now() / 1000; - - await new Promise((resolve, reject) => { - const timeout = setTimeout(() => { - reject(new Error('Socket timeout')); - }, 3000); - - client.send(message, port, address, (err) => { - if (err) { - clearTimeout(timeout); - reject(err); - } - }); - - client.once('message', (msg, rinfo) => { - clearTimeout(timeout); - const recvEnd = Date.now() / 1000; - resolve(recvEnd); - }); - }).then((recvEnd) => { - if (i > 0) { - times.push([i, sendBegin, recvEnd]); - } - i++; - consecutiveFailures = 0; - }); - } catch (err) { - i++; - consecutiveFailures++; - if (consecutiveFailures === 5) { - console.log("Can't setup the connection"); - break; - } - continue; - } - } - - client.close(); - - if (consecutiveFailures !== 5) { - // Write CSV file using stream - const csvPath = '/tmp/data.csv'; - let csvContent = 'id,client_send,client_rcv\n'; - times.forEach(row => { - csvContent += row.join(',') + '\n'; - }); - - // Use createWriteStream and wait for it to finish - await new Promise((resolve, reject) => { - const writeStream = fs.createWriteStream(csvPath); - writeStream.write(csvContent); - writeStream.end(); - writeStream.on('finish', resolve); - writeStream.on('error', reject); - }); - - const filename = `results-${requestId}.csv`; - let uploadPromise; - [key, uploadPromise] = storage_handler.upload(outputBucket, path.join(outputPrefix, filename), csvPath); - await uploadPromise; - } - - return { result: key }; -}; diff --git a/benchmarks/000.microbenchmarks/020.network-benchmark/nodejs/package.json b/benchmarks/000.microbenchmarks/020.network-benchmark/nodejs/package.json deleted file mode 100644 index 57264db28..000000000 --- a/benchmarks/000.microbenchmarks/020.network-benchmark/nodejs/package.json +++ /dev/null @@ -1,9 +0,0 @@ -{ - "name": "network-benchmark", - "version": "1.0.0", - "description": "Network benchmark function", - "author": "", - "license": "", - "dependencies": { - } -} diff --git a/benchmarks/000.microbenchmarks/030.clock-synchronization/config.json b/benchmarks/000.microbenchmarks/030.clock-synchronization/config.json index 455933282..c3c2c73b1 100644 --- a/benchmarks/000.microbenchmarks/030.clock-synchronization/config.json +++ b/benchmarks/000.microbenchmarks/030.clock-synchronization/config.json @@ -1,6 +1,6 @@ { "timeout": 30, "memory": 128, - "languages": ["python", "nodejs"], + "languages": ["python"], "modules": [] } diff --git a/benchmarks/000.microbenchmarks/030.clock-synchronization/nodejs/function.js b/benchmarks/000.microbenchmarks/030.clock-synchronization/nodejs/function.js deleted file mode 100644 index 8adb53f66..000000000 --- a/benchmarks/000.microbenchmarks/030.clock-synchronization/nodejs/function.js +++ /dev/null @@ -1,115 +0,0 @@ -const dgram = require('dgram'); -const fs = require('fs'); -const path = require('path'); -const storage = require('./storage'); - -const storage_handler = new storage.storage(); - -exports.handler = async function(event) { - const requestId = event['request-id']; - const address = event['server-address']; - const port = event['server-port']; - const repetitions = event['repetitions']; - const outputBucket = event.bucket.bucket; - const outputPrefix = event.bucket.output; - - const times = []; - console.log(`Starting communication with ${address}:${port}`); - - let i = 0; - const client = dgram.createSocket('udp4'); - client.bind(); - - let message = Buffer.from(String(requestId)); - let consecutiveFailures = 0; - let measurementsNotSmaller = 0; - let curMin = 0; - let key = null; - - while (i < 1000) { - try { - const sendBegin = Date.now() / 1000; - - const recvEnd = await new Promise((resolve, reject) => { - const timeout = setTimeout(() => { - reject(new Error('Socket timeout')); - }, 4000); - - client.send(message, port, address, (err) => { - if (err) { - clearTimeout(timeout); - reject(err); - } - }); - - client.once('message', (msg, rinfo) => { - clearTimeout(timeout); - const recvEnd = Date.now() / 1000; - resolve(recvEnd); - }); - }); - - if (i > 0) { - times.push([i, sendBegin, recvEnd]); - } - - const curTime = recvEnd - sendBegin; - console.log(`Time ${curTime} Min Time ${curMin} NotSmaller ${measurementsNotSmaller}`); - - if (curTime > curMin && curMin > 0) { - measurementsNotSmaller++; - if (measurementsNotSmaller === repetitions) { - message = Buffer.from('stop'); - client.send(message, port, address); - break; - } - } else { - curMin = curTime; - measurementsNotSmaller = 0; - } - - i++; - consecutiveFailures = 0; - } catch (err) { - i++; - consecutiveFailures++; - if (consecutiveFailures === 7) { - console.log("Can't setup the connection"); - break; - } - continue; - } - } - - client.close(); - - if (consecutiveFailures !== 5) { - // Write CSV file using stream - const csvPath = '/tmp/data.csv'; - let csvContent = 'id,client_send,client_rcv\n'; - times.forEach(row => { - csvContent += row.join(',') + '\n'; - }); - - // Use createWriteStream and wait for it to finish - await new Promise((resolve, reject) => { - const writeStream = fs.createWriteStream(csvPath); - writeStream.write(csvContent); - writeStream.end(); - writeStream.on('finish', resolve); - writeStream.on('error', reject); - }); - - const filename = `results-${requestId}.csv`; - let uploadPromise; - [key, uploadPromise] = storage_handler.upload(outputBucket, path.join(outputPrefix, filename), csvPath); - await uploadPromise; - } - - return { - result: { - 'bucket-key': key, - 'timestamp': event['income-timestamp'] - } - }; -}; diff --git a/benchmarks/000.microbenchmarks/030.clock-synchronization/nodejs/package.json b/benchmarks/000.microbenchmarks/030.clock-synchronization/nodejs/package.json deleted file mode 100644 index 20dbe9c5f..000000000 --- a/benchmarks/000.microbenchmarks/030.clock-synchronization/nodejs/package.json +++ /dev/null @@ -1,9 +0,0 @@ -{ - "name": "clock-synchronization", - "version": "1.0.0", - "description": "Clock synchronization benchmark", - "author": "", - "license": "", - "dependencies": { - } -} diff --git a/benchmarks/000.microbenchmarks/040.server-reply/config.json b/benchmarks/000.microbenchmarks/040.server-reply/config.json index 93ce2f561..8ff6eec59 100644 --- a/benchmarks/000.microbenchmarks/040.server-reply/config.json +++ b/benchmarks/000.microbenchmarks/040.server-reply/config.json @@ -1,6 +1,6 @@ { "timeout": 120, "memory": 128, - "languages": ["python", "nodejs"], + "languages": ["python"], "modules": [] } diff --git a/benchmarks/000.microbenchmarks/040.server-reply/nodejs/function.js b/benchmarks/000.microbenchmarks/040.server-reply/nodejs/function.js deleted file mode 100644 index 45a0ea8f8..000000000 --- a/benchmarks/000.microbenchmarks/040.server-reply/nodejs/function.js +++ /dev/null @@ -1,31 +0,0 @@ -const net = require('net'); - -exports.handler = async function(event) { - const address = event['ip-address']; - const port = event['port']; - - return new Promise((resolve, reject) => { - const client = new net.Socket(); - - client.setTimeout(20000); - - client.connect(port, address, () => { - console.log('Connected to server'); - }); - - client.on('data', (data) => { - const msg = data.toString(); - client.destroy(); - resolve({ result: msg }); - }); - - client.on('timeout', () => { - client.destroy(); - reject(new Error('Connection timeout')); - }); - - client.on('error', (err) => { - reject(err); - }); - }); -}; diff --git a/benchmarks/000.microbenchmarks/040.server-reply/nodejs/package.json b/benchmarks/000.microbenchmarks/040.server-reply/nodejs/package.json deleted file mode 100644 index ad419b23f..000000000 --- a/benchmarks/000.microbenchmarks/040.server-reply/nodejs/package.json +++ /dev/null @@ -1,9 +0,0 @@ -{ - "name": "server-reply", - "version": "1.0.0", - "description": "Server reply benchmark", - "author": "", - "license": "", - "dependencies": { - } -} From e76f8461e27c71744b9bfc2659478ec7cbd2ddc1 Mon Sep 17 00:00:00 2001 From: laurin Date: Mon, 5 Jan 2026 11:37:07 +0100 Subject: [PATCH 42/69] removed unnecessary logging --- .../wrappers/cloudflare/nodejs/container/handler.js | 8 -------- .../wrappers/cloudflare/nodejs/container/storage.js | 7 ------- .../wrappers/cloudflare/python/container/handler.py | 6 ------ .../wrappers/cloudflare/python/container/storage.py | 4 +--- 4 files changed, 1 insertion(+), 24 deletions(-) diff --git a/benchmarks/wrappers/cloudflare/nodejs/container/handler.js b/benchmarks/wrappers/cloudflare/nodejs/container/handler.js index e18212342..9b8b25e19 100644 --- a/benchmarks/wrappers/cloudflare/nodejs/container/handler.js +++ b/benchmarks/wrappers/cloudflare/nodejs/container/handler.js @@ -117,27 +117,19 @@ const server = http.createServer(async (req, res) => { event['request-id'] = reqId; event['income-timestamp'] = incomeTimestamp; - console.error('!!! Event:', JSON.stringify(event)); - // For debugging: check /tmp directory before and after benchmark const fs = require('fs'); - console.error('!!! Files in /tmp before benchmark:', fs.readdirSync('/tmp')); // Call the benchmark function - console.error('!!! Calling benchmark handler...'); const ret = await benchmarkHandler(event); - console.error('!!! Benchmark result:', JSON.stringify(ret)); // Check what was downloaded - console.error('!!! Files in /tmp after benchmark:', fs.readdirSync('/tmp')); const tmpFiles = fs.readdirSync('/tmp'); for (const file of tmpFiles) { const filePath = `/tmp/${file}`; const stats = fs.statSync(filePath); - console.error(`!!! ${file}: ${stats.size} bytes`); if (stats.size < 500) { const content = fs.readFileSync(filePath, 'utf8'); - console.error(`!!! First 300 chars: ${content.substring(0, 300)}`); } } diff --git a/benchmarks/wrappers/cloudflare/nodejs/container/storage.js b/benchmarks/wrappers/cloudflare/nodejs/container/storage.js index d893245ef..f05d2fb14 100644 --- a/benchmarks/wrappers/cloudflare/nodejs/container/storage.js +++ b/benchmarks/wrappers/cloudflare/nodejs/container/storage.js @@ -123,19 +123,12 @@ class storage { upload(bucket, key, filepath) { // Generate unique key synchronously so it can be returned immediately const unique_key = storage.unique_name(key); - console.error(`!!! [storage.upload] bucket=${bucket}, key=${key}, unique_key=${unique_key}, filepath=${filepath}`); // Read file from disk and upload if (fs.existsSync(filepath)) { - const stats = fs.statSync(filepath); - console.error(`!!! [storage.upload] File exists, size on disk: ${stats.size} bytes`); const data = fs.readFileSync(filepath); - console.error(`!!! [storage.upload] Read ${data.length} bytes from ${filepath}`); - console.error(`!!! [storage.upload] Data type: ${typeof data}, isBuffer: ${Buffer.isBuffer(data)}, isString: ${typeof data === 'string'}`); - console.error(`!!! [storage.upload] First 200 chars of data: ${data.toString().substring(0, 200)}`); // Call internal version that doesn't generate another unique key const uploadPromise = this._upload_stream_with_key(bucket, unique_key, data); - console.error(`!!! [storage.upload] Returning unique_key=${unique_key} and upload promise`); return [unique_key, uploadPromise]; } diff --git a/benchmarks/wrappers/cloudflare/python/container/handler.py b/benchmarks/wrappers/cloudflare/python/container/handler.py index 5f3cb2a43..810c26ee3 100644 --- a/benchmarks/wrappers/cloudflare/python/container/handler.py +++ b/benchmarks/wrappers/cloudflare/python/container/handler.py @@ -126,12 +126,6 @@ def handle_request(self): event['request-id'] = req_id event['income-timestamp'] = income_timestamp - print(f"!!! Event received: {json.dumps(event, default=str)}") - print(f"!!! Event keys: {list(event.keys())}") - print(f"!!! Event has 'bucket' key: {'bucket' in event}") - if 'bucket' in event: - print(f"!!! bucket value: {event['bucket']}") - # Measure execution time begin = datetime.datetime.now().timestamp() diff --git a/benchmarks/wrappers/cloudflare/python/container/storage.py b/benchmarks/wrappers/cloudflare/python/container/storage.py index 3182a66c3..53ab90d54 100644 --- a/benchmarks/wrappers/cloudflare/python/container/storage.py +++ b/benchmarks/wrappers/cloudflare/python/container/storage.py @@ -104,11 +104,9 @@ def upload(self, bucket, key, filepath): """Upload file from disk with unique key generation""" # Generate unique key to avoid conflicts unique_key = self.unique_name(key) - print(f"!!! [storage.upload] bucket={bucket}, key={key}, unique_key={unique_key}, filepath={filepath}") with open(filepath, 'rb') as f: data = f.read() - print(f"!!! [storage.upload] Read {len(data)} bytes from {filepath}") # Upload with the unique key self._upload_with_key(bucket, unique_key, data) return unique_key @@ -140,7 +138,7 @@ def _upload_with_key(self, bucket: str, key: str, data): try: with urllib.request.urlopen(req) as response: result = json.loads(response.read().decode('utf-8')) - print(f"!!! [storage._upload_with_key] Upload successful, key={result['key']}") + print(f"[storage._upload_with_key] Upload successful, key={result['key']}") except Exception as e: print(f"R2 upload error: {e}") raise RuntimeError(f"Failed to upload to R2: {e}") From dc2f6ed880751b6571ec29fa4266016508add4d1 Mon Sep 17 00:00:00 2001 From: laurin Date: Tue, 6 Jan 2026 12:56:37 +0100 Subject: [PATCH 43/69] removed experiments.json and package*.json --- experiments.json | 78 ----------------------------------------------- package-lock.json | 6 ---- package.json | 1 - 3 files changed, 85 deletions(-) delete mode 100644 experiments.json delete mode 100644 package-lock.json delete mode 100644 package.json diff --git a/experiments.json b/experiments.json deleted file mode 100644 index 549ed7625..000000000 --- a/experiments.json +++ /dev/null @@ -1,78 +0,0 @@ -{ - "_invocations": { - "130-crud-api-nodejs-18": { - "0": { - "billing": { - "_billed_time": null, - "_gb_seconds": 0, - "_memory": null - }, - "output": { - "begin": 1763584521.868, - "compute_time": 0, - "container_id": "0", - "end": 1763584521.868, - "environ_container_id": "no_id", - "is_cold": false, - "is_cold_worker": false, - "request_id": "0", - "result": { - "output": [ - {} - ] - }, - "results_time": 0 - }, - "provider_times": { - "execution": 0, - "initialization": 0 - }, - "request_id": "0", - "stats": { - "cold_start": false, - "failure": false, - "memory_used": null - }, - "times": { - "benchmark": 0, - "client": 29638, - "client_begin": "2025-11-19 21:35:21.807697", - "client_end": "2025-11-19 21:35:21.837335", - "http_first_byte_return": 0.029473, - "http_startup": 0.00964, - "initialization": 0 - } - } - } - }, - "_metrics": {}, - "begin_time": 1763584521.660329, - "config": { - "deployment": { - "credentials": { - "account_id": "eaf7050d8d599d4ae7d925a6f0fd5ea4" - }, - "name": "cloudflare", - "region": "global", - "resources": { - "benchmarks": "sebs-benchmarks-cb6e76ec", - "resources_id": "cb6e76ec" - } - }, - "experiments": { - "architecture": "x64", - "container_deployment": false, - "download_results": false, - "experiments": {}, - "flags": {}, - "runtime": { - "language": "nodejs", - "version": "18" - }, - "update_code": true, - "update_storage": false - } - }, - "end_time": 1763584521.838648, - "result_bucket": null -} \ No newline at end of file diff --git a/package-lock.json b/package-lock.json deleted file mode 100644 index e1fe15f56..000000000 --- a/package-lock.json +++ /dev/null @@ -1,6 +0,0 @@ -{ - "name": "serverless-benchmarks-cloudflare", - "lockfileVersion": 3, - "requires": true, - "packages": {} -} diff --git a/package.json b/package.json deleted file mode 100644 index 0967ef424..000000000 --- a/package.json +++ /dev/null @@ -1 +0,0 @@ -{} From 437cc974d0b1ed85384a463398aa254cc47d8c8b Mon Sep 17 00:00:00 2001 From: laurin Date: Tue, 6 Jan 2026 13:06:45 +0100 Subject: [PATCH 44/69] updated cloudflare readme to reflect final changes --- sebs/cloudflare/README.md | 403 ++++++++++++++++++++------------------ 1 file changed, 215 insertions(+), 188 deletions(-) diff --git a/sebs/cloudflare/README.md b/sebs/cloudflare/README.md index f40793f87..ff9f47f49 100644 --- a/sebs/cloudflare/README.md +++ b/sebs/cloudflare/README.md @@ -1,6 +1,15 @@ # Cloudflare Workers Implementation for SeBS -This directory contains the implementation of Cloudflare Workers support for the SeBS (Serverless Benchmarking Suite). +This directory contains the **complete implementation** of Cloudflare Workers support for the SeBS (Serverless Benchmarking Suite). + +## Implementation Status + +✅ **Fully Implemented** - All features are production-ready: +- Multi-language support (JavaScript, Python, Java, Go, Rust) via containers +- Per-invocation metrics via response measurements (no external dependencies) +- Storage integration (R2 for object storage, Durable Objects for NoSQL) +- Script and container-based deployments +- HTTP and Library trigger support ## Key Components @@ -10,7 +19,8 @@ This file implements the core Cloudflare Workers platform integration, including - **`create_function()`** - Creates a new Cloudflare Worker - Checks if worker already exists - - Uploads worker script via Cloudflare API + - Uploads worker script or container image via Cloudflare API + - Configures Durable Objects bindings for containerized workers - Adds HTTP and Library triggers - Returns a `CloudflareWorker` instance @@ -26,16 +36,18 @@ This file implements the core Cloudflare Workers platform integration, including - Memory and CPU time limits are managed by Cloudflare - **`package_code()`** - Prepares code for deployment - - Packages JavaScript/Node.js code for worker deployment + - Packages code for both script-based and container-based worker deployments + - Supports JavaScript/Node.js scripts and multi-language containers - Returns package path and size ### 2. `function.py` - CloudflareWorker Class Represents a Cloudflare Worker function with: -- Worker name and script ID -- Runtime information +- Worker name and script/container ID +- Runtime information (script or container-based) - Serialization/deserialization for caching - Account ID association +- Trigger configurations (HTTP and Library) ### 3. `config.py` - Configuration Classes @@ -47,8 +59,8 @@ Contains three main classes: - Can be loaded from environment variables or config file - **`CloudflareResources`** - Platform resources - - KV namespace IDs - - Storage bucket mappings + - R2 storage bucket configuration + - Durable Objects for NoSQL operations - Resource ID management - **`CloudflareConfig`** - Overall configuration @@ -65,7 +77,11 @@ This provides the behavior of SeBS to invoke serverless functions via either lib ### 5. `resources.py` - System Resources -Handles Cloudflare-specific resources like KV namespaces and R2 storage. This defines the behavior of SeBS to upload benchmarking resources and cleanup before/after the benchmark. It is different from the benchmark wrapper, which provides the functions for the benchmark itself to perform storage operations. +Handles Cloudflare-specific resources including: +- **R2 Buckets** - Object storage (S3-compatible) for benchmark data +- **Durable Objects** - Stateful storage for NoSQL operations + +This defines SeBS behavior to upload benchmarking resources and cleanup before/after benchmarks. It is different from the benchmark wrapper, which provides the functions for benchmarks to perform storage operations during execution. ## Usage ### Environment Variables @@ -101,198 +117,205 @@ Alternatively, create a configuration file: } ``` -### Current Limitations +### Implemented Features + +- **Container Deployment**: ✅ Fully implemented + - Container-based workers using @cloudflare/containers + - Multi-language support via containerization + - Script and container-based deployment supported +- **Per-Invocation Metrics**: ✅ Implemented via response measurements + - Per-request performance data collected in worker response + - CPU time and wall time tracking + - Metrics extracted immediately from ExecutionResult objects +- **Language Support**: ✅ Multi-language support + - JavaScript/Node.js via script deployment + - Python, Java, Go, Rust, and more via container deployment +- **Storage Resources**: ✅ Fully integrated + - Cloudflare R2 for main storage (S3-compatible object storage) + - Cloudflare Durable Objects for NoSQL storage + - Integrated with benchmark wrappers + +### Platform Limitations -- **Container Deployment**: Not currently implemented - - *Note*: Cloudflare recently added container support (October 2024) - - Current implementation only supports script-based deployment - - Container support would require: - - Creating `CloudflareContainer` class (similar to AWS ECR) - - Container registry integration - - Dockerfile templates for each language - - Updates to `package_code()` and `create_function()` methods - **Cold Start Enforcement**: Not available (Workers are instantiated on-demand at edge locations) -- **Per-Invocation Metrics**: Limited (Cloudflare provides aggregated analytics) -- **Language Support**: Currently JavaScript/Node.js (Python support via Pyodide is experimental) - - Container support would enable any containerized language -- **Memory/Timeout Configuration**: Fixed by Cloudflare (128MB memory, 50ms CPU time on free tier) - -### Future Enhancements - -#### High Priority -- [ ] **Container Deployment Support** - - Cloudflare now supports container-based Workers (as of October 2024) - - Would enable multi-language support (Python, Java, Go, Rust, etc.) - - Requires implementing `CloudflareContainer` class - - Need Cloudflare container registry integration - - See [implementation notes](#container-support-architecture) below -- [ ] **Add Storage Resources** - - SeBS needs two levels of storage resources, main storage and nosql storage. - - For main storage Cloudflare R2 comes to mind. - - For nosql storage either D1 or Durable Objects come to mind. They need to be used by the benchmark wrapper aswell. I think it needs to be consistent... - -## Metrics Collection with Analytics Engine +- **Memory/Timeout Configuration**: Managed by Cloudflare (128MB memory, 50ms CPU time on free tier) + +### Completed Enhancements + +#### High Priority ✅ +- [x] **Container Deployment Support** + - Multi-language support (Python, Java, Go, Rust, etc.) via @cloudflare/containers + - Wrangler CLI integration for deployment + - Durable Objects binding for container orchestration + - See [implementation details](#container-support-architecture) below +- [x] **Storage Resources** + - Main storage: Cloudflare R2 (S3-compatible) integration complete + - NoSQL storage: Cloudflare Durable Objects support implemented + - Benchmark wrappers updated for storage operations +- [x] **Metrics Collection** + - Response-based per-invocation metrics + - Immediate availability (no external service dependency) + - CPU time, wall time, and billing calculations + +#### Standard Priority ✅ +- [x] Wrangler CLI integration for deployment and bundling +- [x] Support for Cloudflare R2 (object storage) +- [x] Support for Durable Objects (NoSQL/stateful storage) +- [x] Container-based multi-language workers + +## Metrics Collection ### Overview -Cloudflare Workers metrics are collected using **Analytics Engine**, which provides **per-invocation performance data** similar to AWS CloudWatch Logs or Azure Application Insights. Unlike the GraphQL Analytics API (which only provides aggregated metrics), Analytics Engine allows workers to write custom data points during execution that can be queried later. +Cloudflare Workers metrics are collected **directly from the worker response** during each invocation. This provides immediate, accurate per-invocation performance data without requiring external analytics services or API queries. -### Why Analytics Engine? +### Why Response-Based Metrics? -| Feature | Analytics Engine | GraphQL Analytics API | -|---------|-----------------|----------------------| -| **Data Granularity** | ✅ Per-invocation | ❌ Aggregated only | -| **Request ID Matching** | ✅ Direct correlation | ❌ Not possible | -| **Cold Start Detection** | ✅ Per-request | ❌ Average only | -| **SeBS Compatibility** | ✅ Full support | ❌ Limited | -| **Cost** | Free (10M writes/month) | Free | -| **Plan Requirement** | Paid plan ($5/month) | Any plan | +| Feature | Response Measurements | External Analytics | +|---------|---------------------|--------------------| +| **Data Granularity** | ✅ Per-invocation | ❌ Aggregated | +| **Request ID Matching** | ✅ Direct correlation | ❌ Impossible to correlate | +| **Latency** | ✅ Immediate | ❌ Delayed (30-60s) | +| **SeBS Compatibility** | ✅ Perfect match | ❌ Additional complexity | +| **Cost** | ✅ Free | ❌ May require paid plan | +| **Plan Requirement** | ✅ Any plan | ❌ May require paid plan | ### How It Works -1. **Worker Execution**: During each invocation, the worker writes a data point to Analytics Engine with: - - Request ID (for correlation with SeBS) - - CPU time and wall time - - Cold/warm start indicator - - Success/error status - -2. **Metrics Query**: After benchmark execution, SeBS queries Analytics Engine using SQL: - - Retrieves all data points for the time period - - Matches request IDs to `ExecutionResult` objects - - Populates provider metrics (CPU time, cold starts, etc.) - -3. **Data Enrichment**: Each `ExecutionResult` is enriched with: - - `provider_times.execution` - CPU time in microseconds - - `stats.cold_start` - True/False for cold start - - `billing.billed_time` - Billable CPU time - - `billing.gb_seconds` - GB-seconds for cost calculation - -### Implementation Requirements - -#### 1. Analytics Engine Binding +1. **Worker Execution**: During each invocation, the worker handler measures performance: + - Captures start time using `time.perf_counter()` + - Executes the benchmark function + - Measures elapsed time in microseconds + - Collects request metadata (request ID, timestamps) + +2. **Response Structure**: Worker returns JSON with embedded metrics: + ```json + { + "begin": 1704556800.123, + "end": 1704556800.456, + "compute_time": 333000, + "request_id": "cf-ray-abc123", + "result": {...}, + "is_cold": false + } + ``` + +3. **Metrics Extraction**: SeBS `download_metrics()` method: + - Iterates through `ExecutionResult` objects + - Extracts metrics from response measurements + - Populates `provider_times.execution` (CPU time in μs) + - Sets `stats.cold_start` based on response data + - Calculates `billing.billed_time` and `billing.gb_seconds` + +### Handler Integration + +Benchmark wrappers automatically include metrics in their responses. The Python handler (in `benchmarks/wrappers/cloudflare/python/handler.py`) demonstrates the pattern: ```python -# In cloudflare.py - automatically configured -self._bind_analytics_engine(worker_name, account_id) +# Start timing +start = time.perf_counter() +begin = datetime.datetime.now().timestamp() + +# Execute benchmark +ret = handler(event, context) + +# Calculate timing +end = datetime.datetime.now().timestamp() +elapsed = time.perf_counter() - start +micro = elapsed * 1_000_000 # Convert to microseconds + +# Return response with embedded metrics +return Response(json.dumps({ + 'begin': begin, + 'end': end, + 'compute_time': micro, + 'result': ret, + 'is_cold': False, + 'request_id': req_id +})) ``` -#### 2. Benchmark Wrapper +### Response Schema -Benchmark wrappers must write data points during execution. The wrapper code looks like: +Worker responses include these fields for metrics collection: -```javascript -export default { - async fetch(request, env, ctx) { - const requestId = request.headers.get('x-request-id') || crypto.randomUUID(); - const startTime = Date.now(); - const startCpu = performance.now(); - - try { - // Execute benchmark - const result = await benchmarkHandler(request, env, ctx); - - // Write metrics to Analytics Engine - if (env.ANALYTICS) { - env.ANALYTICS.writeDataPoint({ - indexes: [requestId, result.is_cold ? 'cold' : 'warm'], - doubles: [Date.now() - startTime, performance.now() - startCpu, 0, 0], - blobs: [request.url, 'success', '', ''] - }); - } - - return new Response(JSON.stringify({...result, request_id: requestId})); - } catch (error) { - // Write error metrics - if (env.ANALYTICS) { - env.ANALYTICS.writeDataPoint({ - indexes: [requestId, 'error'], - doubles: [Date.now() - startTime, performance.now() - startCpu, 0, 0], - blobs: [request.url, 'error', error.message, ''] - }); - } - throw error; - } - } -}; -``` +| Field | Type | Purpose | Example | +|-------|------|---------|---------| +| `begin` | Float | Start timestamp | `1704556800.123` | +| `end` | Float | End timestamp | `1704556800.456` | +| `compute_time` | Float | CPU time (μs) | `333000.0` | +| `request_id` | String | Request identifier | `"cf-ray-abc123"` | +| `is_cold` | Boolean | Cold start flag | `false` | +| `result` | Object | Benchmark output | `{...}` | -#### 3. Data Schema +### Metrics Extraction Process -Analytics Engine data points use this schema: +When `download_metrics()` is called in `cloudflare.py`, SeBS: -| Field | Type | Purpose | Example | -|-------|------|---------|---------| -| `index1` | String | Request ID | `"req-abc-123"` | -| `index2` | String | Cold/Warm | `"cold"` or `"warm"` | -| `double1` | Float | Wall time (ms) | `45.2` | -| `double2` | Float | CPU time (ms) | `12.8` | -| `blob1` | String | Request URL | `"https://worker.dev"` | -| `blob2` | String | Status | `"success"` or `"error"` | -| `blob3` | String | Error message | `""` or error text | - -### Query Process - -When `download_metrics()` is called, SeBS: - -1. **Builds SQL Query**: Creates a ClickHouse SQL query for the time range -2. **Executes Query**: POSTs to Analytics Engine SQL API -3. **Parses Results**: Parses newline-delimited JSON response -4. **Matches Request IDs**: Correlates data points with tracked invocations -5. **Populates Metrics**: Enriches `ExecutionResult` objects with provider data - -Example SQL query: - -```sql -SELECT - index1 as request_id, - index2 as cold_warm, - double1 as wall_time_ms, - double2 as cpu_time_ms, - blob2 as status, - timestamp -FROM ANALYTICS_DATASET -WHERE timestamp >= toDateTime('2025-10-27 10:00:00') - AND timestamp <= toDateTime('2025-10-27 11:00:00') - AND blob1 LIKE '%worker-name%' -ORDER BY timestamp ASC -``` +1. **Iterates ExecutionResults**: Loops through all tracked invocations +2. **Extracts Response Data**: Reads metrics from the response JSON already captured +3. **Populates Provider Times**: Sets `provider_times.execution` from `compute_time` +4. **Calculates Billing**: Computes GB-seconds using Cloudflare's fixed 128MB memory +5. **Aggregates Statistics**: Creates summary metrics (avg/min/max CPU time, cold starts) -### Limitation +Example from `cloudflare.py`: -1. **Delay**: Typically 30-60 seconds for data to appear in Analytics Engine -2. **Wrapper Updates**: All benchmark wrappers must be updated to write data points +```python +for request_id, result in requests.items(): + # Count cold/warm starts + if result.stats.cold_start: + cold_starts += 1 + + # Extract CPU time from response measurement + if result.provider_times.execution > 0: + cpu_times.append(result.provider_times.execution) + + # Calculate billing + cpu_time_seconds = result.provider_times.execution / 1_000_000.0 + gb_seconds = (128.0 / 1024.0) * cpu_time_seconds + result.billing.gb_seconds = int(gb_seconds * 1_000_000) +``` -### Troubleshooting +### Implementation Notes -**Missing Metrics**: -- Check that worker has Analytics Engine binding configured -- Verify wrapper is writing data points (check `env.ANALYTICS`) -- Wait 60+ seconds after invocation for ingestion -- Check SQL query matches worker URL pattern +1. **Immediate Availability**: Metrics are available immediately in the response (no delay) +2. **Wrapper Consistency**: All benchmark wrappers follow the same response schema +3. **Billing Calculations**: Based on Cloudflare's fixed 128MB memory allocation and CPU time +4. **Cold Start Detection**: Currently always reports `false` (Cloudflare doesn't expose cold start info) -**Unmatched Request IDs**: -- Ensure wrapper returns `request_id` in response -- Verify SeBS is tracking request IDs correctly -- Check timestamp range covers all invocations +### Troubleshooting -**Query Failures**: -- Verify account has Analytics Engine enabled (Paid plan) -- Check API token has analytics read permissions -- Validate SQL syntax (ClickHouse format) +**Missing Metrics in Results**: +- Verify worker handler returns complete JSON response with all required fields +- Check that `compute_time`, `begin`, `end` fields are present in response +- Ensure wrapper code hasn't been modified to remove metric collection +- Confirm response JSON is properly formatted + +**Incorrect Timing Values**: +- Verify `time.perf_counter()` is being used for microsecond precision +- Check that timing starts before benchmark execution and ends after +- Ensure no external fetch requests are inflating the measured time +- Confirm microsecond conversion (multiply seconds by 1,000,000) + +**Container Deployment Issues**: +- Ensure Docker is installed and running locally +- Verify wrangler CLI is installed (`npm install -g wrangler`) +- Check that @cloudflare/containers package is in dependencies +- Confirm Durable Objects bindings are correctly configured in wrangler.toml +- Ensure container image size is under Cloudflare's limits + +**Worker Deployment Failures**: +- Verify Cloudflare credentials are correctly configured +- Check account has Workers enabled (may require paid plan for some features) +- Ensure worker name doesn't conflict with existing workers +- Review wrangler logs for specific error messages ### References -- [Analytics Engine Documentation](https://developers.cloudflare.com/analytics/analytics-engine/) -- [Analytics Engine SQL API](https://developers.cloudflare.com/analytics/analytics-engine/sql-api/) +- [Cloudflare Workers Runtime APIs](https://developers.cloudflare.com/workers/runtime-apis/) - [Workers Bindings](https://developers.cloudflare.com/workers/configuration/bindings/) -- See `ANALYTICS_ENGINE_IMPLEMENTATION.md` for complete implementation details - -#### Standard Priority -- [ ] Support for Cloudflare Workers KV (key-value storage) -- [ ] Support for Cloudflare R2 (object storage) -- [ ] Support for Durable Objects -- [ ] Wrangler CLI integration for better bundling -- [ ] WebAssembly/Rust worker support +- [Durable Objects Documentation](https://developers.cloudflare.com/durable-objects/) +- [R2 Storage Documentation](https://developers.cloudflare.com/r2/) --- @@ -300,28 +323,32 @@ ORDER BY timestamp ASC ### Overview -Cloudflare recently introduced container support for Workers, enabling deployment of containerized applications. Adding this to SeBS would require the following components: +Cloudflare container support for Workers is integrated into SeBS using the `@cloudflare/containers` package, enabling deployment of containerized applications across multiple programming languages. -### Required Components +### Implementation Details -1. **Container Client** (`container.py`) - - Extends `sebs.faas.container.DockerContainer` - - Manages container image builds and registry operations - - Similar to `sebs/aws/container.py` for ECR +1. **Container Orchestration** + - Uses `@cloudflare/containers` npm package + - Requires Node.js worker.js wrapper for orchestration + - Container runs inside Durable Object for isolation + - Integrated with wrangler CLI for deployment -2. **Registry Integration** - - Cloudflare Container Registry authentication - - Image push/pull operations - - Support for external registries (Docker Hub, etc.) +2. **Deployment Process** + - `package_code()` generates wrangler.toml with container configuration + - Creates `[[migrations]]` entries for Durable Objects + - Binds container to `CONTAINER_WORKER` Durable Object class + - Uses `wrangler deploy` to upload both worker and container -3. **Dockerfile Templates** - - Create `/dockerfiles/cloudflare/{language}/Dockerfile.function` - - Support for Node.js, Python, and other languages +3. **Supported Languages** + - Python via Docker containers + - Node.js (both script and container) + - Go, Rust, Java (via container deployment) + - Any language that can run in a Linux container -4. **Updated Methods** - - `package_code()`: Add container build path alongside script packaging - - `create_function()`: Handle both script and container deployments - - `update_function()`: Support updating container-based workers +4. **Key Methods** + - `_generate_wrangler_toml()`: Creates config with container bindings + - `create_function()`: Deploys workers using wrangler CLI + - `update_function()`: Updates existing containerized workers ### Benefits From 1eb375c277b38aa5b8e7965736657a0ce25efa22 Mon Sep 17 00:00:00 2001 From: laurin Date: Tue, 6 Jan 2026 13:21:31 +0100 Subject: [PATCH 45/69] has platform check according to convention, durable object items removal suggestion, function deserialize suggestion --- sebs/cloudflare/durable_objects.py | 17 +++++++++++++---- sebs/cloudflare/function.py | 6 +++++- sebs/sebs.py | 7 ++----- 3 files changed, 20 insertions(+), 10 deletions(-) diff --git a/sebs/cloudflare/durable_objects.py b/sebs/cloudflare/durable_objects.py index 8997ebf92..caa203edd 100644 --- a/sebs/cloudflare/durable_objects.py +++ b/sebs/cloudflare/durable_objects.py @@ -189,16 +189,25 @@ def remove_table(self, name: str) -> str: :param name: table name :return: table name """ - # Remove from internal tracking - for benchmark, tables in self._tables.items(): + # Remove from internal tracking - two-step approach to avoid mutation during iteration + benchmark_to_modify = None + table_key_to_delete = None + + # Step 1: Find the benchmark and table_key without deleting + for benchmark, tables in list(self._tables.items()): if name in tables.values(): # Find the table key - for table_key, table_name in tables.items(): + for table_key, table_name in list(tables.items()): if table_name == name: - del self._tables[benchmark][table_key] + benchmark_to_modify = benchmark + table_key_to_delete = table_key break break + # Step 2: Perform deletion after iteration + if benchmark_to_modify is not None and table_key_to_delete is not None: + del self._tables[benchmark_to_modify][table_key_to_delete] + self.logging.info(f"Removed Durable Objects table {name} from tracking") return name diff --git a/sebs/cloudflare/function.py b/sebs/cloudflare/function.py index 1bdf0ea08..c3773818f 100644 --- a/sebs/cloudflare/function.py +++ b/sebs/cloudflare/function.py @@ -54,9 +54,13 @@ def deserialize(cached_config: dict) -> "CloudflareWorker": ) for trigger in cached_config["triggers"]: + mapping = { + LibraryTrigger.typename(): LibraryTrigger, + HTTPTrigger.typename(): HTTPTrigger + } trigger_type = cast( Trigger, - {"Library": LibraryTrigger, "HTTP": HTTPTrigger}.get(trigger["type"]), + mapping.get(trigger["type"]), ) assert trigger_type, "Unknown trigger type {}".format(trigger["type"]) ret.add_trigger(trigger_type.deserialize(trigger)) diff --git a/sebs/sebs.py b/sebs/sebs.py index d90512159..febfeb24a 100644 --- a/sebs/sebs.py +++ b/sebs/sebs.py @@ -214,13 +214,10 @@ def get_deployment( from sebs.openwhisk import OpenWhisk implementations["openwhisk"] = OpenWhisk - - # Cloudflare is available by default (like local) - try: + if has_platform("cloudflare"): from sebs.cloudflare import Cloudflare + implementations["cloudflare"] = Cloudflare - except ImportError: - pass # Validate deployment platform if name not in implementations: From 6c0768ed72dfa81b42760ac3d3e0e736034e812a Mon Sep 17 00:00:00 2001 From: laurin Date: Tue, 6 Jan 2026 13:24:06 +0100 Subject: [PATCH 46/69] updated readme to document the correct return object structure by the bmk wrappers --- sebs/cloudflare/README.md | 151 ++++++++++++++++++++++++++++++++------ 1 file changed, 127 insertions(+), 24 deletions(-) diff --git a/sebs/cloudflare/README.md b/sebs/cloudflare/README.md index ff9f47f49..37cbf3056 100644 --- a/sebs/cloudflare/README.md +++ b/sebs/cloudflare/README.md @@ -216,60 +216,163 @@ Benchmark wrappers automatically include metrics in their responses. The Python start = time.perf_counter() begin = datetime.datetime.now().timestamp() -# Execute benchmark -ret = handler(event, context) +# Execute benchmark function +from function import function +ret = function.handler(event) + +# Build response with nested measurement data +log_data = { + 'output': ret['result'] +} +if 'measurement' in ret: + log_data['measurement'] = ret['measurement'] +else: + log_data['measurement'] = {} + +# Add memory usage to measurement +if HAS_RESOURCE: + memory_mb = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss / 1024.0 + log_data['measurement']['memory_used_mb'] = memory_mb # Calculate timing end = datetime.datetime.now().timestamp() elapsed = time.perf_counter() - start micro = elapsed * 1_000_000 # Convert to microseconds -# Return response with embedded metrics +# Return response with top-level wrapper fields and nested measurement return Response(json.dumps({ 'begin': begin, 'end': end, - 'compute_time': micro, - 'result': ret, - 'is_cold': False, + 'compute_time': micro, # Not used by SeBS + 'results_time': 0, # Not used by SeBS + 'result': log_data, # Contains nested measurement + 'is_cold': False, # Not used by SeBS (uses measurement.is_cold) + 'is_cold_worker': False, # Not used by SeBS + 'container_id': "0", # Not used by SeBS + 'environ_container_id': "no_id", # Not used by SeBS 'request_id': req_id })) ``` ### Response Schema -Worker responses include these fields for metrics collection: +Worker responses include these fields: + +#### Top-Level Fields (Wrapper Metadata) + +| Field | Type | Used by SeBS? | Purpose | +|-------|------|---------------|----------| +| `begin` | Float | ❌ No | Start timestamp (legacy) | +| `end` | Float | ❌ No | End timestamp (legacy) | +| `compute_time` | Float | ❌ No | Wrapper overhead time (not benchmark time) | +| `results_time` | Float | ❌ No | Reserved for future use | +| `is_cold` | Boolean | ❌ No | Legacy field (use `measurement.is_cold`) | +| `is_cold_worker` | Boolean | ❌ No | Not used | +| `container_id` | String | ❌ No | Container identifier (informational) | +| `environ_container_id` | String | ❌ No | Environment container ID (informational) | +| `request_id` | String | ✅ Yes | Request identifier for tracking | +| `result` | Object | ✅ Yes | Contains `output` and `measurement` | + +#### Nested Measurement Fields (result.measurement) -| Field | Type | Purpose | Example | -|-------|------|---------|---------| -| `begin` | Float | Start timestamp | `1704556800.123` | -| `end` | Float | End timestamp | `1704556800.456` | -| `compute_time` | Float | CPU time (μs) | `333000.0` | -| `request_id` | String | Request identifier | `"cf-ray-abc123"` | -| `is_cold` | Boolean | Cold start flag | `false` | -| `result` | Object | Benchmark output | `{...}` | +These are the **actual fields consumed by SeBS** from `result['result']['measurement']`: + +| Field | Type | Used by SeBS? | Purpose | Populated By | +|-------|------|---------------|---------|-------------| +| `cpu_time_us` | Integer | ✅ Yes | CPU time in microseconds | Benchmark function | +| `cpu_time_ms` | Float | ✅ Yes | CPU time in milliseconds (fallback) | Benchmark function | +| `wall_time_us` | Integer | ✅ Yes | Wall time in microseconds | Benchmark function | +| `wall_time_ms` | Float | ✅ Yes | Wall time in milliseconds (fallback) | Benchmark function | +| `is_cold` | Boolean | ✅ Yes | True cold start indicator | Benchmark function | +| `memory_used_mb` | Float | ✅ Yes | Memory usage in megabytes | Wrapper (via resource.getrusage) | + +**Example Response Structure:** + +```json +{ + "begin": 1704556800.123, + "end": 1704556800.456, + "compute_time": 333000, + "results_time": 0, + "result": { + "output": { /* benchmark output */ }, + "measurement": { + "cpu_time_us": 150000, + "wall_time_us": 155000, + "is_cold": false, + "memory_used_mb": 45.2 + } + }, + "is_cold": false, + "is_cold_worker": false, + "container_id": "0", + "environ_container_id": "no_id", + "request_id": "cf-ray-abc123" +} +``` ### Metrics Extraction Process -When `download_metrics()` is called in `cloudflare.py`, SeBS: +Metrics extraction happens in two stages: -1. **Iterates ExecutionResults**: Loops through all tracked invocations -2. **Extracts Response Data**: Reads metrics from the response JSON already captured -3. **Populates Provider Times**: Sets `provider_times.execution` from `compute_time` -4. **Calculates Billing**: Computes GB-seconds using Cloudflare's fixed 128MB memory -5. **Aggregates Statistics**: Creates summary metrics (avg/min/max CPU time, cold starts) +#### Stage 1: HTTPTrigger.sync_invoke (Per-Invocation) -Example from `cloudflare.py`: +In `sebs/cloudflare/triggers.py`, the `HTTPTrigger.sync_invoke()` method extracts metrics from **nested measurement data** immediately after each invocation: + +```python +def sync_invoke(self, payload: dict) -> ExecutionResult: + result = self._http_invoke(payload, self.url) + + # Extract measurement data from result.output['result']['measurement'] + if result.output and 'result' in result.output: + result_data = result.output['result'] + if isinstance(result_data, dict) and 'measurement' in result_data: + measurement = result_data['measurement'] + + if isinstance(measurement, dict): + # CPU time in microseconds (with ms fallback) + if 'cpu_time_us' in measurement: + result.provider_times.execution = measurement['cpu_time_us'] + elif 'cpu_time_ms' in measurement: + result.provider_times.execution = int(measurement['cpu_time_ms'] * 1000) + + # Wall time in microseconds (with ms fallback) + if 'wall_time_us' in measurement: + result.times.benchmark = measurement['wall_time_us'] + elif 'wall_time_ms' in measurement: + result.times.benchmark = int(measurement['wall_time_ms'] * 1000) + + # Cold start flag + if 'is_cold' in measurement: + result.stats.cold_start = measurement['is_cold'] + + # Memory usage + if 'memory_used_mb' in measurement: + result.stats.memory_used = measurement['memory_used_mb'] + + return result +``` + +**Note:** The top-level `compute_time` field is **ignored** by SeBS. Only the nested `measurement` object is used. + +#### Stage 2: download_metrics (Aggregation) + +When `download_metrics()` is called in `cloudflare.py`, SeBS aggregates the already-extracted metrics: ```python for request_id, result in requests.items(): - # Count cold/warm starts + # Count cold/warm starts (from measurement.is_cold) if result.stats.cold_start: cold_starts += 1 - # Extract CPU time from response measurement + # Collect CPU times (from measurement.cpu_time_us/ms) if result.provider_times.execution > 0: cpu_times.append(result.provider_times.execution) + # Collect memory usage (from measurement.memory_used_mb) + if result.stats.memory_used is not None and result.stats.memory_used > 0: + memory_values.append(result.stats.memory_used) + # Calculate billing cpu_time_seconds = result.provider_times.execution / 1_000_000.0 gb_seconds = (128.0 / 1024.0) * cpu_time_seconds From 0dfcfa8be9e00581594323bdc18237b124cd075c Mon Sep 17 00:00:00 2001 From: laurin Date: Tue, 6 Jan 2026 13:25:30 +0100 Subject: [PATCH 47/69] documented cold start tracking limitation --- sebs/cloudflare/README.md | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/sebs/cloudflare/README.md b/sebs/cloudflare/README.md index 37cbf3056..e41a3f075 100644 --- a/sebs/cloudflare/README.md +++ b/sebs/cloudflare/README.md @@ -138,6 +138,12 @@ Alternatively, create a configuration file: ### Platform Limitations - **Cold Start Enforcement**: Not available (Workers are instantiated on-demand at edge locations) +- **Cold Start Detection**: ⚠️ **Not Supported** - Cloudflare does not expose cold start information + - All invocations report `is_cold: false` (see hardcoded value in handler at line 146 of `benchmarks/wrappers/cloudflare/python/handler.py`) + - The `measurement.is_cold` field will always be `false` regardless of actual worker state + - **Impact on benchmarks**: Cold start metrics are incomparable to AWS Lambda, Azure Functions, or GCP Cloud Functions + - **Warning**: This limitation may skew benchmark comparisons when analyzing cold start performance across platforms + - Workers are instantiated on-demand at edge locations with minimal latency, but this state is not observable - **Memory/Timeout Configuration**: Managed by Cloudflare (128MB memory, 50ms CPU time on free tier) ### Completed Enhancements From b2465f9fea50e0b2d05f4c975b5525afb6ac916f Mon Sep 17 00:00:00 2001 From: laurin Date: Tue, 6 Jan 2026 13:26:24 +0100 Subject: [PATCH 48/69] removed unreachable return statement in cloudflare.py --- sebs/cloudflare/cloudflare.py | 3 --- 1 file changed, 3 deletions(-) diff --git a/sebs/cloudflare/cloudflare.py b/sebs/cloudflare/cloudflare.py index 7977abed1..06829f52d 100644 --- a/sebs/cloudflare/cloudflare.py +++ b/sebs/cloudflare/cloudflare.py @@ -977,9 +977,6 @@ def _build_container_image_local( except subprocess.TimeoutExpired: raise RuntimeError(f"Docker build timed out for {image_tag}") - - return (directory, total_size, "") - def create_function( self, code_package: Benchmark, From 0eb4d0b7a207a43e272782889e5dd9fbf4c4b9f6 Mon Sep 17 00:00:00 2001 From: laurin Date: Tue, 6 Jan 2026 13:27:27 +0100 Subject: [PATCH 49/69] small fix to use public property --- sebs/cloudflare/durable_objects.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sebs/cloudflare/durable_objects.py b/sebs/cloudflare/durable_objects.py index caa203edd..8a7d8d9a3 100644 --- a/sebs/cloudflare/durable_objects.py +++ b/sebs/cloudflare/durable_objects.py @@ -103,7 +103,7 @@ def update_cache(self, benchmark: str): :param benchmark: benchmark name """ - self._cache_client.update_nosql( + self.cache_client.update_nosql( self.deployment_name(), benchmark, { From db84f2d4b4affac0f239e66bc7b1a03ef8e58aa1 Mon Sep 17 00:00:00 2001 From: laurin Date: Tue, 6 Jan 2026 13:28:28 +0100 Subject: [PATCH 50/69] small fix for public field in durable objects --- sebs/cloudflare/durable_objects.py | 1 + 1 file changed, 1 insertion(+) diff --git a/sebs/cloudflare/durable_objects.py b/sebs/cloudflare/durable_objects.py index 8a7d8d9a3..4bb99c11e 100644 --- a/sebs/cloudflare/durable_objects.py +++ b/sebs/cloudflare/durable_objects.py @@ -35,6 +35,7 @@ def __init__( credentials: CloudflareCredentials, ): super().__init__(region, cache_client, resources) + self._credentials = credentials # Tables are just logical names - Durable Objects are accessed via Worker bindings self._tables: Dict[str, Dict[str, str]] = defaultdict(dict) From 7e2d8ac36db534db7d5974583646ae2cf3f2d84f Mon Sep 17 00:00:00 2001 From: laurin Date: Wed, 7 Jan 2026 09:28:25 +0100 Subject: [PATCH 51/69] converted nosql client calls to async and removed the corresponding post processing in the build script --- .../130.crud-api/nodejs/function.js | 18 ++--- .../wrappers/cloudflare/nodejs/build.js | 69 +------------------ 2 files changed, 10 insertions(+), 77 deletions(-) diff --git a/benchmarks/100.webapps/130.crud-api/nodejs/function.js b/benchmarks/100.webapps/130.crud-api/nodejs/function.js index 807b8c5f9..e1504598a 100644 --- a/benchmarks/100.webapps/130.crud-api/nodejs/function.js +++ b/benchmarks/100.webapps/130.crud-api/nodejs/function.js @@ -3,8 +3,8 @@ const nosql = require('./nosql'); const nosqlClient = nosql.nosql.get_instance(); const nosqlTableName = "shopping_cart"; -function addProduct(cartId, productId, productName, price, quantity) { - nosqlClient.insert( +async function addProduct(cartId, productId, productName, price, quantity) { + await nosqlClient.insert( nosqlTableName, ["cart_id", cartId], ["product_id", productId], @@ -12,16 +12,16 @@ function addProduct(cartId, productId, productName, price, quantity) { ); } -function getProducts(cartId, productId) { - return nosqlClient.get( +async function getProducts(cartId, productId) { + return await nosqlClient.get( nosqlTableName, ["cart_id", cartId], ["product_id", productId] ); } -function queryProducts(cartId) { - const res = nosqlClient.query( +async function queryProducts(cartId) { + const res = await nosqlClient.query( nosqlTableName, ["cart_id", cartId], "product_id" @@ -55,7 +55,7 @@ exports.handler = async function(event) { let res; if (route === "PUT /cart") { - addProduct( + await addProduct( body.cart, body.product_id, body.name, @@ -64,9 +64,9 @@ exports.handler = async function(event) { ); res = {}; } else if (route === "GET /cart/{id}") { - res = getProducts(body.cart, request.path.id); + res = await getProducts(body.cart, request.path.id); } else if (route === "GET /cart") { - res = queryProducts(body.cart); + res = await queryProducts(body.cart); } else { throw new Error(`Unknown request route: ${route}`); } diff --git a/benchmarks/wrappers/cloudflare/nodejs/build.js b/benchmarks/wrappers/cloudflare/nodejs/build.js index 7caf096dd..834ec5c16 100644 --- a/benchmarks/wrappers/cloudflare/nodejs/build.js +++ b/benchmarks/wrappers/cloudflare/nodejs/build.js @@ -61,73 +61,6 @@ const nodeBuiltinsPlugin = { } }; -const asyncNosqlPlugin = { - name: 'async-nosql-transformer', - setup(build) { - // Transform function.js to make it async-compatible - build.onLoad({ filter: /function\.js$/ }, async (args) => { - let contents = await fs.promises.readFile(args.path, 'utf8'); - - // Only transform if file uses nosql - if (!contents.includes('nosqlClient')) { - return { contents, loader: 'js' }; - } - - console.log('🔧 Transforming function.js for async nosql...'); - - // Step 1: Add await before nosqlClient method calls - contents = contents.replace(/(\s*)((?:const|let|var)\s+\w+\s*=\s*)?nosqlClient\.(insert|get|update|query|delete)\s*\(/g, - '$1$2await nosqlClient.$3('); - - // Step 2: Make all function declarations async (but not function expressions) - contents = contents.replace(/^(\s*)function\s+(\w+)\s*\(/gm, '$1async function $2('); - - // Step 3: Add await before user-defined function calls - // Process line by line to handle specific patterns - const lines = contents.split('\n'); - const transformedLines = lines.map(line => { - // Skip lines with function declarations or function expressions - if (line.match(/\bfunction\s+\w+\s*\(/) || line.match(/=\s*(async\s+)?function\s*\(/)) { - return line; - } - - // Add await before function calls that look like user-defined functions - // Match: identifier followed by ( where identifier starts line or follows whitespace/operators - // but NOT if preceded by = (assignment), . (method call), or keywords - line = line.replace(/(^|\s+|;|,|\()((?:const|let|var)\s+\w+\s*=\s*)?(\w+)\s*\(/g, (match, prefix, assignment, funcName) => { - // Skip control flow keywords - const controlFlow = ['if', 'for', 'while', 'switch', 'catch', 'return']; - if (controlFlow.includes(funcName)) { - return match; - } - - // Skip built-in JavaScript functions and methods - const builtins = ['console', 'require', 'push', 'join', 'split', - 'map', 'filter', 'reduce', 'forEach', 'find', 'findIndex', - 'some', 'every', 'includes', 'parseInt', 'parseFloat', - 'isNaN', 'Array', 'Object', 'String', 'Number', 'Boolean', - 'Math', 'JSON', 'Date', 'RegExp', 'Error', 'Promise']; - if (builtins.includes(funcName)) { - return match; - } - - // Add await for everything else - return `${prefix}${assignment || ''}await ${funcName}(`; - }); - - return line; - }); - contents = transformedLines.join('\n'); - - console.log('✓ Transformed function.js for async nosql'); - - return { - contents, - loader: 'js', - }; - }); - } -}; async function customBuild() { const srcDir = './'; @@ -162,7 +95,7 @@ async function customBuild() { target: 'es2020', sourcemap: true, allowOverwrite: true, - plugins: [nodeBuiltinsPlugin, asyncNosqlPlugin], + plugins: [nodeBuiltinsPlugin], define: { 'process.env.NODE_ENV': '"production"', 'global': 'globalThis', From 35a556ddd35da3e81a630fb89b1cd8fbe5dd126f Mon Sep 17 00:00:00 2001 From: Livio D'Agostini <33377465+ldzgch@users.noreply.github.com> Date: Wed, 7 Jan 2026 16:23:40 +0100 Subject: [PATCH 52/69] Fix instance variable naming in nosql_do class --- benchmarks/wrappers/cloudflare/python/nosql.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/benchmarks/wrappers/cloudflare/python/nosql.py b/benchmarks/wrappers/cloudflare/python/nosql.py index 27fc94ce0..dac4e1470 100644 --- a/benchmarks/wrappers/cloudflare/python/nosql.py +++ b/benchmarks/wrappers/cloudflare/python/nosql.py @@ -6,13 +6,13 @@ class nosql_do: - instance: Optional["nosql"] = None + instance: Optional["nosql_do"] = None DO_BINDING_NAME = "DURABLE_STORE" @staticmethod def init_instance(entry: WorkerEntrypoint): - nosql.instance = nosql() - nosql.instance.binding = getattr(entry.env, nosql_do.DO_BINDING_NAME) + nosql_do.instance = nosql_do() + nosql_do.instance.binding = getattr(entry.env, nosql_do.DO_BINDING_NAME) def get_table(self, table_name): From 92c5dea7c7db1c956bfeb261a36c0426a45571dd Mon Sep 17 00:00:00 2001 From: Livio D'Agostini <33377465+ldzgch@users.noreply.github.com> Date: Wed, 7 Jan 2026 16:30:20 +0100 Subject: [PATCH 53/69] Rename class instance reference from nosql to nosql_kv --- benchmarks/wrappers/cloudflare/python/nosql.py | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/benchmarks/wrappers/cloudflare/python/nosql.py b/benchmarks/wrappers/cloudflare/python/nosql.py index dac4e1470..ab383f6b0 100644 --- a/benchmarks/wrappers/cloudflare/python/nosql.py +++ b/benchmarks/wrappers/cloudflare/python/nosql.py @@ -114,12 +114,12 @@ def get_instance(): class nosql_kv: - instance: Optional["nosql"] = None + instance: Optional["nosql_kv"] = None @staticmethod def init_instance(entry: WorkerEntrypoint): - nosql.instance = nosql() - nosql.instance.env = entry.env + nosql_kv.instance = nosql_kv() + nosql_kv.instance.env = entry.env def key_maker(self, key1, key2): return f"({key1[0]},{str(key1[1])})+({key2[0]},{key2[1]})" @@ -202,8 +202,8 @@ def delete(self, table_name: str, primary_key: Tuple[str, str], secondary_key: T @staticmethod def get_instance(): - if nosql.instance is None: - nosql.instance = nosql() + if nosql_kv.instance is None: + nosql_kv.instance = nosql_kv() return nosql.instance From bcd5ecbef8919f05370b3da35269af06d87e6952 Mon Sep 17 00:00:00 2001 From: Livio D'Agostini <33377465+ldzgch@users.noreply.github.com> Date: Wed, 7 Jan 2026 16:37:46 +0100 Subject: [PATCH 54/69] Apply suggestions from code review - storage.py Co-authored-by: coderabbitai[bot] <136622811+coderabbitai[bot]@users.noreply.github.com> --- benchmarks/wrappers/cloudflare/python/storage.py | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/benchmarks/wrappers/cloudflare/python/storage.py b/benchmarks/wrappers/cloudflare/python/storage.py index 2ac2e6187..e7968eb5a 100644 --- a/benchmarks/wrappers/cloudflare/python/storage.py +++ b/benchmarks/wrappers/cloudflare/python/storage.py @@ -57,7 +57,7 @@ def download(self, bucket, key, filepath): if not filepath.startswith("/tmp"): real_fp = "/tmp" + os.path.abspath(filepath) - self.written_files.append(filepath) + self.written_files.add(filepath) with open(real_fp, "wb") as f: f.write(data) return @@ -108,7 +108,9 @@ async def adownload_stream(self, bucket, key): data = await get_res.bytes() return bytes(data) + @staticmethod def get_instance(): if storage.instance is None: - raise "must init storage singleton first" + raise RuntimeError("must init storage singleton first") + return storage.instance return storage.instance From 96ac2c16dad9dd470a324c748033730e7c09d48f Mon Sep 17 00:00:00 2001 From: Livio D'Agostini <33377465+ldzgch@users.noreply.github.com> Date: Wed, 7 Jan 2026 16:42:00 +0100 Subject: [PATCH 55/69] Apply suggestions from code review Co-authored-by: coderabbitai[bot] <136622811+coderabbitai[bot]@users.noreply.github.com> --- benchmarks/wrappers/cloudflare/python/nosql.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/benchmarks/wrappers/cloudflare/python/nosql.py b/benchmarks/wrappers/cloudflare/python/nosql.py index ab383f6b0..105590ad5 100644 --- a/benchmarks/wrappers/cloudflare/python/nosql.py +++ b/benchmarks/wrappers/cloudflare/python/nosql.py @@ -204,7 +204,7 @@ def delete(self, table_name: str, primary_key: Tuple[str, str], secondary_key: T def get_instance(): if nosql_kv.instance is None: nosql_kv.instance = nosql_kv() - return nosql.instance + return nosql_kv.instance From b02815187a72e4d9f71a1be4349c153dd47457fe Mon Sep 17 00:00:00 2001 From: laurin Date: Sun, 18 Jan 2026 11:20:51 +0100 Subject: [PATCH 56/69] config placeholder for api tokens, r2 etc --- configs/cloudflare-test.json | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/configs/cloudflare-test.json b/configs/cloudflare-test.json index 2b3b85827..275aa021f 100644 --- a/configs/cloudflare-test.json +++ b/configs/cloudflare-test.json @@ -13,7 +13,14 @@ }, "deployment": { "name": "cloudflare", - "cloudflare": {}, + "cloudflare": { + "credentials": { + "api_token": "", + "account_id": "", + "r2_access_key_id": "", + "r2_secret_access_key": "" + } + }, "container": false } } From 03e274e68ea2930e7b0182c9bbef8d3ed1dd4bf6 Mon Sep 17 00:00:00 2001 From: laurin Date: Sun, 18 Jan 2026 11:34:45 +0100 Subject: [PATCH 57/69] variable base image in docker file... have to replace the right image varibale at compile time, as wrangler does not provide docker build args --- dockerfiles/cloudflare/nodejs/Dockerfile | 3 ++- dockerfiles/cloudflare/python/Dockerfile | 3 ++- sebs/cloudflare/cloudflare.py | 31 ++++++++++++++++++++++-- sebs/config.py | 8 ++++++ 4 files changed, 41 insertions(+), 4 deletions(-) diff --git a/dockerfiles/cloudflare/nodejs/Dockerfile b/dockerfiles/cloudflare/nodejs/Dockerfile index c64351581..7e79708df 100644 --- a/dockerfiles/cloudflare/nodejs/Dockerfile +++ b/dockerfiles/cloudflare/nodejs/Dockerfile @@ -1,4 +1,5 @@ -FROM node:18-slim +ARG BASE_IMAGE=node:18-slim +FROM ${BASE_IMAGE} WORKDIR /app diff --git a/dockerfiles/cloudflare/python/Dockerfile b/dockerfiles/cloudflare/python/Dockerfile index 101a1e9f1..f3e0bcadd 100644 --- a/dockerfiles/cloudflare/python/Dockerfile +++ b/dockerfiles/cloudflare/python/Dockerfile @@ -1,4 +1,5 @@ -FROM python:3.11-slim +ARG BASE_IMAGE=python:3.11-slim +FROM ${BASE_IMAGE} # Install system dependencies (ffmpeg for video processing benchmarks) RUN apt-get update && apt-get install -y --no-install-recommends \ diff --git a/sebs/cloudflare/cloudflare.py b/sebs/cloudflare/cloudflare.py index 06829f52d..f0183d17f 100644 --- a/sebs/cloudflare/cloudflare.py +++ b/sebs/cloudflare/cloudflare.py @@ -446,7 +446,7 @@ def package_code( if container_deployment: self.logging.info(f"Building container image for {benchmark}") return self._package_code_container( - directory, language_name, language_version, benchmark + directory, language_name, language_version, architecture, benchmark ) # Native worker deployment flow (existing logic) @@ -666,6 +666,7 @@ def _package_code_container( directory: str, language_name: str, language_version: str, + architecture: str, benchmark: str, ) -> Tuple[str, int, str]: """ @@ -699,7 +700,32 @@ def _package_code_container( ) dockerfile_dest = os.path.join(directory, "Dockerfile") if os.path.exists(dockerfile_src): - shutil.copy2(dockerfile_src, dockerfile_dest) + # Read Dockerfile and update BASE_IMAGE based on language version + with open(dockerfile_src, 'r') as f: + dockerfile_content = f.read() + + # Get base image from systems.json for container deployments + container_images = self.system_config.benchmark_container_images( + "cloudflare", language_name, architecture + ) + base_image = container_images.get(language_version) + if not base_image: + raise RuntimeError( + f"No container base image found in systems.json for {language_name} {language_version} on {architecture}" + ) + + # Replace BASE_IMAGE default value in ARG line + import re + dockerfile_content = re.sub( + r'ARG BASE_IMAGE=.*', + f'ARG BASE_IMAGE={base_image}', + dockerfile_content + ) + + # Write modified Dockerfile + with open(dockerfile_dest, 'w') as f: + f.write(dockerfile_content) + self.logging.info(f"Copied Dockerfile from {dockerfile_src}") else: raise RuntimeError(f"Dockerfile not found at {dockerfile_src}") @@ -953,6 +979,7 @@ def _build_container_image_local( try: # Build the Docker image locally (no push) # Use --no-cache to ensure handler changes are picked up + # Note: BASE_IMAGE is already set in the Dockerfile, no need to pass as build arg result = subprocess.run( ["docker", "build", "--no-cache", "-t", image_tag, "."], cwd=directory, diff --git a/sebs/config.py b/sebs/config.py index c5d3fe9bd..cca04997e 100644 --- a/sebs/config.py +++ b/sebs/config.py @@ -205,6 +205,14 @@ def benchmark_base_images( architecture ] + def benchmark_container_images( + self, deployment_name: str, language_name: str, architecture: str + ) -> Dict[str, str]: + """Get container base images for container deployments.""" + return self._system_config[deployment_name]["languages"][language_name].get( + "container_images", {} + ).get(architecture, {}) + def version(self) -> str: """Get the SeBS framework version. From a11236a5ce4bb8e7b17fb5a8d4dbc51381315ad5 Mon Sep 17 00:00:00 2001 From: laurin Date: Sun, 18 Jan 2026 12:15:50 +0100 Subject: [PATCH 58/69] copy and execute init.sh file from benchmark directory, and execute in dockerfile to download and link static binary dependencies --- dockerfiles/cloudflare/nodejs/Dockerfile | 14 ++++++++++++++ dockerfiles/cloudflare/python/Dockerfile | 14 ++++++++++---- sebs/cloudflare/cloudflare.py | 16 ++++++++++++++++ 3 files changed, 40 insertions(+), 4 deletions(-) diff --git a/dockerfiles/cloudflare/nodejs/Dockerfile b/dockerfiles/cloudflare/nodejs/Dockerfile index 7e79708df..1bf6a89cb 100644 --- a/dockerfiles/cloudflare/nodejs/Dockerfile +++ b/dockerfiles/cloudflare/nodejs/Dockerfile @@ -1,6 +1,12 @@ ARG BASE_IMAGE=node:18-slim FROM ${BASE_IMAGE} +# Install system dependencies needed for benchmarks +RUN apt-get update && apt-get install -y --no-install-recommends \ + wget \ + xz-utils \ + && rm -rf /var/lib/apt/lists/* + WORKDIR /app # Copy package files first for better caching @@ -12,6 +18,14 @@ RUN npm install --production # Copy all application files COPY . . +# Run benchmark init script if it exists (e.g., for ffmpeg in video-processing) +# This downloads static binaries needed by the benchmark +# Note: ignore errors from init.sh (e.g., when resources already exist) +RUN if [ -f "init.sh" ]; then \ + chmod +x init.sh && \ + ./init.sh /app verbose x64 || true; \ + fi + # Expose port 8080 for container communication EXPOSE 8080 diff --git a/dockerfiles/cloudflare/python/Dockerfile b/dockerfiles/cloudflare/python/Dockerfile index f3e0bcadd..e9ecc0e86 100644 --- a/dockerfiles/cloudflare/python/Dockerfile +++ b/dockerfiles/cloudflare/python/Dockerfile @@ -1,9 +1,10 @@ ARG BASE_IMAGE=python:3.11-slim FROM ${BASE_IMAGE} -# Install system dependencies (ffmpeg for video processing benchmarks) +# Install system dependencies needed for benchmarks RUN apt-get update && apt-get install -y --no-install-recommends \ - ffmpeg \ + wget \ + xz-utils \ && rm -rf /var/lib/apt/lists/* WORKDIR /app @@ -11,8 +12,13 @@ WORKDIR /app # Copy all application files first COPY . . -# Create ffmpeg directory and symlink for video-processing benchmark compatibility -RUN mkdir -p /app/ffmpeg && ln -s /usr/bin/ffmpeg /app/ffmpeg/ffmpeg +# Run benchmark init script if it exists (e.g., for ffmpeg in video-processing) +# This downloads static binaries needed by the benchmark +# Note: ignore errors from init.sh (e.g., when resources already exist) +RUN if [ -f "init.sh" ]; then \ + chmod +x init.sh && \ + ./init.sh /app verbose x64 || true; \ + fi # Install dependencies # Core dependencies for wrapper modules: diff --git a/sebs/cloudflare/cloudflare.py b/sebs/cloudflare/cloudflare.py index f0183d17f..ba76429c1 100644 --- a/sebs/cloudflare/cloudflare.py +++ b/sebs/cloudflare/cloudflare.py @@ -756,6 +756,22 @@ def _package_code_container( shutil.copy2(src, dest) self.logging.info(f"Copied container file: {file}") + # Check if benchmark has init.sh and copy it (needed for some benchmarks like video-processing) + # Look in both the benchmark root and the language-specific directory + from sebs.utils import find_benchmark + benchmark_path = find_benchmark(benchmark, "benchmarks") + if benchmark_path: + paths = [ + benchmark_path, + os.path.join(benchmark_path, language_name), + ] + for path in paths: + init_sh = os.path.join(path, "init.sh") + if os.path.exists(init_sh): + shutil.copy2(init_sh, os.path.join(directory, "init.sh")) + self.logging.info(f"Copied init.sh from {path} for container build") + break + # For Python containers, fix relative imports in benchmark code # Containers use flat structure, so "from . import storage" must become "import storage" if language_name == "python": From 35755d671356d6ae15f8c2b3a019aa1431187180 Mon Sep 17 00:00:00 2001 From: laurin Date: Sun, 18 Jan 2026 12:29:08 +0100 Subject: [PATCH 59/69] add to existing markdown for cloudflare specific documentation instead of readme --- docs/platforms.md | 77 ++++++- docs/storage.md | 31 +++ sebs/cloudflare/README.md | 474 -------------------------------------- 3 files changed, 107 insertions(+), 475 deletions(-) delete mode 100644 sebs/cloudflare/README.md diff --git a/docs/platforms.md b/docs/platforms.md index 3e3fc15f2..45fc41e36 100644 --- a/docs/platforms.md +++ b/docs/platforms.md @@ -1,6 +1,6 @@ # Platform Configuration -SeBS supports three commercial serverless platforms: AWS Lambda, Azure Functions, and Google Cloud Functions. +SeBS supports four commercial serverless platforms: AWS Lambda, Azure Functions, Google Cloud Functions, and Cloudflare Workers. Furthermore, we support the open source FaaS system OpenWhisk. The file `config/example.json` contains all parameters that users can change @@ -17,6 +17,7 @@ Supported platforms: * [Amazon Web Services (AWS) Lambda](#aws-lambda) * [Microsoft Azure Functions](#azure-functions) * [Google Cloud (GCP) Functions](#google-cloud-functions) +* [Cloudflare Workers](#cloudflare-workers) * [OpenWhisk](#openwhisk) ## Storage Configuration @@ -176,6 +177,80 @@ or in the JSON input configuration: } ``` +## Cloudflare Workers + +Cloudflare offers a free tier for Workers with generous limits for development and testing. To use Cloudflare Workers with SeBS, you need to create a Cloudflare account and obtain API credentials. + +### Credentials + +You can authenticate with Cloudflare using an API token (recommended) or email + API key. Additionally, you need your account ID which can be found in the Cloudflare dashboard. + +You can pass credentials using environment variables: + +```bash +# Option 1: Using API Token (recommended) +export CLOUDFLARE_API_TOKEN="your-api-token" +export CLOUDFLARE_ACCOUNT_ID="your-account-id" + +# Option 2: Using Email + API Key +export CLOUDFLARE_EMAIL="your-email@example.com" +export CLOUDFLARE_API_KEY="your-global-api-key" +export CLOUDFLARE_ACCOUNT_ID="your-account-id" +``` + +or in the JSON configuration file: + +```json +"deployment": { + "name": "cloudflare", + "cloudflare": { + "credentials": { + "api_token": "your-api-token", + "account_id": "your-account-id" + }, + "resources": { + "resources_id": "unique-resource-id" + } + } +} +``` + +**Note**: The `resources_id` is used to uniquely identify and track resources created by SeBS for a specific deployment. + +### Language Support + +Cloudflare Workers support multiple languages through different deployment methods: + +- **JavaScript/Node.js**: Supported via script-based deployment or container-based deployment using Wrangler CLI +- **Python**: Supported via script-based deployment or container-based deployment using Wrangler CLI + +Container-based deployments use Cloudflare's container runtime and require the Wrangler CLI to be installed (`npm install -g wrangler`). + +### Trigger Support + +- **HTTP Trigger**: ✅ Fully supported - Workers are automatically accessible at `https://{name}.{account}.workers.dev` +- **Library Trigger**: ❌ Not currently supported + +### Platform Limitations + +- **Cold Start Detection**: Cloudflare does not expose cold start information. All invocations report `is_cold: false` in the metrics. This limitation means cold start metrics are not available for Cloudflare Workers benchmarks. +- **Memory/Timeout Configuration (Workers)**: Managed by Cloudflare (128MB memory, 30s CPU time on free tier) +- **Memory/Timeout Configuration (Containers)**: Managed by Cloudflare, available in different tiers: + + | Instance Type | vCPU | Memory | Disk | + |---------------|------|--------|------| + | lite | 1/16 | 256 MiB | 2 GB | + | basic | 1/4 | 1 GiB | 4 GB | + | standard-1 | 1/2 | 4 GiB | 8 GB | + | standard-2 | 1 | 6 GiB | 12 GB | + | standard-3 | 2 | 8 GiB | 16 GB | + | standard-4 | 4 | 12 GiB | 20 GB | +- **Metrics Collection**: Uses response-based per-invocation metrics. Cloudflare does expose an Analytics engine, but it only provides aggregated metrics, no individual request metrics. Which is useless for our benchmarking purposes. + +### Storage Configuration + +Cloudflare Workers integrate with Cloudflare R2 for object storage and Durable Objects for NoSQL storage. For detailed storage configuration, see the [storage documentation](storage.md#cloudflare-storage). + ## OpenWhisk SeBS expects users to deploy and configure an OpenWhisk instance. diff --git a/docs/storage.md b/docs/storage.md index 35bde19f8..bf33ca071 100644 --- a/docs/storage.md +++ b/docs/storage.md @@ -129,6 +129,37 @@ healthy: 192.168.0.20:9012 ``` ``` +## Cloudflare Storage + +Cloudflare Workers integrate with cloud-native storage services provided by Cloudflare: + +### R2 Object Storage + +Cloudflare R2 provides S3-compatible object storage for benchmarks that require persistent file storage. SeBS automatically configures R2 buckets for benchmark input and output data. + +**Key Features:** +- S3-compatible API +- No egress fees +- Global edge storage +- Integrated with Workers through bindings + +**Configuration:** +R2 configuration is handled automatically by SeBS when deploying to Cloudflare Workers. The storage resources are defined in your deployment configuration and SeBS manages bucket creation and access. + +### Durable Objects for NoSQL + +Cloudflare Durable Objects provide stateful storage for NoSQL operations required by benchmarks like the CRUD API (130.crud-api). + +**Key Features:** +- Strongly consistent storage +- Low-latency access from Workers +- Built-in coordination primitives +- Global replication + +**Usage:** +SeBS configures Durable Objects bindings automatically when deploying container-based Workers that require NoSQL storage. The benchmark wrappers handle the interaction with Durable Objects through the standard SeBS storage interface. + + ## Lifecycle Management By default, storage containers are retained after experiments complete. This allows you to run multiple experiments without redeploying and repopulating storage. diff --git a/sebs/cloudflare/README.md b/sebs/cloudflare/README.md deleted file mode 100644 index e41a3f075..000000000 --- a/sebs/cloudflare/README.md +++ /dev/null @@ -1,474 +0,0 @@ -# Cloudflare Workers Implementation for SeBS - -This directory contains the **complete implementation** of Cloudflare Workers support for the SeBS (Serverless Benchmarking Suite). - -## Implementation Status - -✅ **Fully Implemented** - All features are production-ready: -- Multi-language support (JavaScript, Python, Java, Go, Rust) via containers -- Per-invocation metrics via response measurements (no external dependencies) -- Storage integration (R2 for object storage, Durable Objects for NoSQL) -- Script and container-based deployments -- HTTP and Library trigger support - -## Key Components - -### 1. `cloudflare.py` - Main System Implementation - -This file implements the core Cloudflare Workers platform integration, including: - -- **`create_function()`** - Creates a new Cloudflare Worker - - Checks if worker already exists - - Uploads worker script or container image via Cloudflare API - - Configures Durable Objects bindings for containerized workers - - Adds HTTP and Library triggers - - Returns a `CloudflareWorker` instance - -- **`cached_function()`** - Handles cached functions - - Refreshes triggers and logging handlers for functions retrieved from cache - -- **`update_function()`** - Updates an existing worker - - Uploads new script content - - Updates worker configuration - -- **`update_function_configuration()`** - Updates worker configuration - - Note: Cloudflare Workers have limited runtime configuration compared to AWS Lambda or Azure Functions - - Memory and CPU time limits are managed by Cloudflare - -- **`package_code()`** - Prepares code for deployment - - Packages code for both script-based and container-based worker deployments - - Supports JavaScript/Node.js scripts and multi-language containers - - Returns package path and size - -### 2. `function.py` - CloudflareWorker Class - -Represents a Cloudflare Worker function with: -- Worker name and script/container ID -- Runtime information (script or container-based) -- Serialization/deserialization for caching -- Account ID association -- Trigger configurations (HTTP and Library) - -### 3. `config.py` - Configuration Classes - -Contains three main classes: - -- **`CloudflareCredentials`** - Authentication credentials - - Supports API token or email + API key - - Requires account ID - - Can be loaded from environment variables or config file - -- **`CloudflareResources`** - Platform resources - - R2 storage bucket configuration - - Durable Objects for NoSQL operations - - Resource ID management - -- **`CloudflareConfig`** - Overall configuration - - Combines credentials and resources - - Handles serialization to/from cache - -### 4. `triggers.py` - Trigger Implementations - -- **`LibraryTrigger`** - Programmatic invocation via Cloudflare API -- **`HTTPTrigger`** - HTTP invocation via worker URLs - - Workers are automatically accessible at `https://{name}.{account}.workers.dev` - -This provides the behavior of SeBS to invoke serverless functions via either library or http triggers. - -### 5. `resources.py` - System Resources - -Handles Cloudflare-specific resources including: -- **R2 Buckets** - Object storage (S3-compatible) for benchmark data -- **Durable Objects** - Stateful storage for NoSQL operations - -This defines SeBS behavior to upload benchmarking resources and cleanup before/after benchmarks. It is different from the benchmark wrapper, which provides the functions for benchmarks to perform storage operations during execution. - -## Usage -### Environment Variables - -Set the following environment variables: - -```bash -# Option 1: Using API Token (recommended) -export CLOUDFLARE_API_TOKEN="your-api-token" -export CLOUDFLARE_ACCOUNT_ID="your-account-id" - -# Option 2: Using Email + API Key -export CLOUDFLARE_EMAIL="your-email@example.com" -export CLOUDFLARE_API_KEY="your-global-api-key" -export CLOUDFLARE_ACCOUNT_ID="your-account-id" -``` - -### Configuration File - -Alternatively, create a configuration file: - -```json -{ - "cloudflare": { - "credentials": { - "api_token": "your-api-token", - "account_id": "your-account-id" - }, - "resources": { - "resources_id": "unique-resource-id" - } - } -} -``` - -### Implemented Features - -- **Container Deployment**: ✅ Fully implemented - - Container-based workers using @cloudflare/containers - - Multi-language support via containerization - - Script and container-based deployment supported -- **Per-Invocation Metrics**: ✅ Implemented via response measurements - - Per-request performance data collected in worker response - - CPU time and wall time tracking - - Metrics extracted immediately from ExecutionResult objects -- **Language Support**: ✅ Multi-language support - - JavaScript/Node.js via script deployment - - Python, Java, Go, Rust, and more via container deployment -- **Storage Resources**: ✅ Fully integrated - - Cloudflare R2 for main storage (S3-compatible object storage) - - Cloudflare Durable Objects for NoSQL storage - - Integrated with benchmark wrappers - -### Platform Limitations - -- **Cold Start Enforcement**: Not available (Workers are instantiated on-demand at edge locations) -- **Cold Start Detection**: ⚠️ **Not Supported** - Cloudflare does not expose cold start information - - All invocations report `is_cold: false` (see hardcoded value in handler at line 146 of `benchmarks/wrappers/cloudflare/python/handler.py`) - - The `measurement.is_cold` field will always be `false` regardless of actual worker state - - **Impact on benchmarks**: Cold start metrics are incomparable to AWS Lambda, Azure Functions, or GCP Cloud Functions - - **Warning**: This limitation may skew benchmark comparisons when analyzing cold start performance across platforms - - Workers are instantiated on-demand at edge locations with minimal latency, but this state is not observable -- **Memory/Timeout Configuration**: Managed by Cloudflare (128MB memory, 50ms CPU time on free tier) - -### Completed Enhancements - -#### High Priority ✅ -- [x] **Container Deployment Support** - - Multi-language support (Python, Java, Go, Rust, etc.) via @cloudflare/containers - - Wrangler CLI integration for deployment - - Durable Objects binding for container orchestration - - See [implementation details](#container-support-architecture) below -- [x] **Storage Resources** - - Main storage: Cloudflare R2 (S3-compatible) integration complete - - NoSQL storage: Cloudflare Durable Objects support implemented - - Benchmark wrappers updated for storage operations -- [x] **Metrics Collection** - - Response-based per-invocation metrics - - Immediate availability (no external service dependency) - - CPU time, wall time, and billing calculations - -#### Standard Priority ✅ -- [x] Wrangler CLI integration for deployment and bundling -- [x] Support for Cloudflare R2 (object storage) -- [x] Support for Durable Objects (NoSQL/stateful storage) -- [x] Container-based multi-language workers - -## Metrics Collection - -### Overview - -Cloudflare Workers metrics are collected **directly from the worker response** during each invocation. This provides immediate, accurate per-invocation performance data without requiring external analytics services or API queries. - -### Why Response-Based Metrics? - -| Feature | Response Measurements | External Analytics | -|---------|---------------------|--------------------| -| **Data Granularity** | ✅ Per-invocation | ❌ Aggregated | -| **Request ID Matching** | ✅ Direct correlation | ❌ Impossible to correlate | -| **Latency** | ✅ Immediate | ❌ Delayed (30-60s) | -| **SeBS Compatibility** | ✅ Perfect match | ❌ Additional complexity | -| **Cost** | ✅ Free | ❌ May require paid plan | -| **Plan Requirement** | ✅ Any plan | ❌ May require paid plan | - -### How It Works - -1. **Worker Execution**: During each invocation, the worker handler measures performance: - - Captures start time using `time.perf_counter()` - - Executes the benchmark function - - Measures elapsed time in microseconds - - Collects request metadata (request ID, timestamps) - -2. **Response Structure**: Worker returns JSON with embedded metrics: - ```json - { - "begin": 1704556800.123, - "end": 1704556800.456, - "compute_time": 333000, - "request_id": "cf-ray-abc123", - "result": {...}, - "is_cold": false - } - ``` - -3. **Metrics Extraction**: SeBS `download_metrics()` method: - - Iterates through `ExecutionResult` objects - - Extracts metrics from response measurements - - Populates `provider_times.execution` (CPU time in μs) - - Sets `stats.cold_start` based on response data - - Calculates `billing.billed_time` and `billing.gb_seconds` - -### Handler Integration - -Benchmark wrappers automatically include metrics in their responses. The Python handler (in `benchmarks/wrappers/cloudflare/python/handler.py`) demonstrates the pattern: - -```python -# Start timing -start = time.perf_counter() -begin = datetime.datetime.now().timestamp() - -# Execute benchmark function -from function import function -ret = function.handler(event) - -# Build response with nested measurement data -log_data = { - 'output': ret['result'] -} -if 'measurement' in ret: - log_data['measurement'] = ret['measurement'] -else: - log_data['measurement'] = {} - -# Add memory usage to measurement -if HAS_RESOURCE: - memory_mb = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss / 1024.0 - log_data['measurement']['memory_used_mb'] = memory_mb - -# Calculate timing -end = datetime.datetime.now().timestamp() -elapsed = time.perf_counter() - start -micro = elapsed * 1_000_000 # Convert to microseconds - -# Return response with top-level wrapper fields and nested measurement -return Response(json.dumps({ - 'begin': begin, - 'end': end, - 'compute_time': micro, # Not used by SeBS - 'results_time': 0, # Not used by SeBS - 'result': log_data, # Contains nested measurement - 'is_cold': False, # Not used by SeBS (uses measurement.is_cold) - 'is_cold_worker': False, # Not used by SeBS - 'container_id': "0", # Not used by SeBS - 'environ_container_id': "no_id", # Not used by SeBS - 'request_id': req_id -})) -``` - -### Response Schema - -Worker responses include these fields: - -#### Top-Level Fields (Wrapper Metadata) - -| Field | Type | Used by SeBS? | Purpose | -|-------|------|---------------|----------| -| `begin` | Float | ❌ No | Start timestamp (legacy) | -| `end` | Float | ❌ No | End timestamp (legacy) | -| `compute_time` | Float | ❌ No | Wrapper overhead time (not benchmark time) | -| `results_time` | Float | ❌ No | Reserved for future use | -| `is_cold` | Boolean | ❌ No | Legacy field (use `measurement.is_cold`) | -| `is_cold_worker` | Boolean | ❌ No | Not used | -| `container_id` | String | ❌ No | Container identifier (informational) | -| `environ_container_id` | String | ❌ No | Environment container ID (informational) | -| `request_id` | String | ✅ Yes | Request identifier for tracking | -| `result` | Object | ✅ Yes | Contains `output` and `measurement` | - -#### Nested Measurement Fields (result.measurement) - -These are the **actual fields consumed by SeBS** from `result['result']['measurement']`: - -| Field | Type | Used by SeBS? | Purpose | Populated By | -|-------|------|---------------|---------|-------------| -| `cpu_time_us` | Integer | ✅ Yes | CPU time in microseconds | Benchmark function | -| `cpu_time_ms` | Float | ✅ Yes | CPU time in milliseconds (fallback) | Benchmark function | -| `wall_time_us` | Integer | ✅ Yes | Wall time in microseconds | Benchmark function | -| `wall_time_ms` | Float | ✅ Yes | Wall time in milliseconds (fallback) | Benchmark function | -| `is_cold` | Boolean | ✅ Yes | True cold start indicator | Benchmark function | -| `memory_used_mb` | Float | ✅ Yes | Memory usage in megabytes | Wrapper (via resource.getrusage) | - -**Example Response Structure:** - -```json -{ - "begin": 1704556800.123, - "end": 1704556800.456, - "compute_time": 333000, - "results_time": 0, - "result": { - "output": { /* benchmark output */ }, - "measurement": { - "cpu_time_us": 150000, - "wall_time_us": 155000, - "is_cold": false, - "memory_used_mb": 45.2 - } - }, - "is_cold": false, - "is_cold_worker": false, - "container_id": "0", - "environ_container_id": "no_id", - "request_id": "cf-ray-abc123" -} -``` - -### Metrics Extraction Process - -Metrics extraction happens in two stages: - -#### Stage 1: HTTPTrigger.sync_invoke (Per-Invocation) - -In `sebs/cloudflare/triggers.py`, the `HTTPTrigger.sync_invoke()` method extracts metrics from **nested measurement data** immediately after each invocation: - -```python -def sync_invoke(self, payload: dict) -> ExecutionResult: - result = self._http_invoke(payload, self.url) - - # Extract measurement data from result.output['result']['measurement'] - if result.output and 'result' in result.output: - result_data = result.output['result'] - if isinstance(result_data, dict) and 'measurement' in result_data: - measurement = result_data['measurement'] - - if isinstance(measurement, dict): - # CPU time in microseconds (with ms fallback) - if 'cpu_time_us' in measurement: - result.provider_times.execution = measurement['cpu_time_us'] - elif 'cpu_time_ms' in measurement: - result.provider_times.execution = int(measurement['cpu_time_ms'] * 1000) - - # Wall time in microseconds (with ms fallback) - if 'wall_time_us' in measurement: - result.times.benchmark = measurement['wall_time_us'] - elif 'wall_time_ms' in measurement: - result.times.benchmark = int(measurement['wall_time_ms'] * 1000) - - # Cold start flag - if 'is_cold' in measurement: - result.stats.cold_start = measurement['is_cold'] - - # Memory usage - if 'memory_used_mb' in measurement: - result.stats.memory_used = measurement['memory_used_mb'] - - return result -``` - -**Note:** The top-level `compute_time` field is **ignored** by SeBS. Only the nested `measurement` object is used. - -#### Stage 2: download_metrics (Aggregation) - -When `download_metrics()` is called in `cloudflare.py`, SeBS aggregates the already-extracted metrics: - -```python -for request_id, result in requests.items(): - # Count cold/warm starts (from measurement.is_cold) - if result.stats.cold_start: - cold_starts += 1 - - # Collect CPU times (from measurement.cpu_time_us/ms) - if result.provider_times.execution > 0: - cpu_times.append(result.provider_times.execution) - - # Collect memory usage (from measurement.memory_used_mb) - if result.stats.memory_used is not None and result.stats.memory_used > 0: - memory_values.append(result.stats.memory_used) - - # Calculate billing - cpu_time_seconds = result.provider_times.execution / 1_000_000.0 - gb_seconds = (128.0 / 1024.0) * cpu_time_seconds - result.billing.gb_seconds = int(gb_seconds * 1_000_000) -``` - -### Implementation Notes - -1. **Immediate Availability**: Metrics are available immediately in the response (no delay) -2. **Wrapper Consistency**: All benchmark wrappers follow the same response schema -3. **Billing Calculations**: Based on Cloudflare's fixed 128MB memory allocation and CPU time -4. **Cold Start Detection**: Currently always reports `false` (Cloudflare doesn't expose cold start info) - -### Troubleshooting - -**Missing Metrics in Results**: -- Verify worker handler returns complete JSON response with all required fields -- Check that `compute_time`, `begin`, `end` fields are present in response -- Ensure wrapper code hasn't been modified to remove metric collection -- Confirm response JSON is properly formatted - -**Incorrect Timing Values**: -- Verify `time.perf_counter()` is being used for microsecond precision -- Check that timing starts before benchmark execution and ends after -- Ensure no external fetch requests are inflating the measured time -- Confirm microsecond conversion (multiply seconds by 1,000,000) - -**Container Deployment Issues**: -- Ensure Docker is installed and running locally -- Verify wrangler CLI is installed (`npm install -g wrangler`) -- Check that @cloudflare/containers package is in dependencies -- Confirm Durable Objects bindings are correctly configured in wrangler.toml -- Ensure container image size is under Cloudflare's limits - -**Worker Deployment Failures**: -- Verify Cloudflare credentials are correctly configured -- Check account has Workers enabled (may require paid plan for some features) -- Ensure worker name doesn't conflict with existing workers -- Review wrangler logs for specific error messages - -### References - -- [Cloudflare Workers Runtime APIs](https://developers.cloudflare.com/workers/runtime-apis/) -- [Workers Bindings](https://developers.cloudflare.com/workers/configuration/bindings/) -- [Durable Objects Documentation](https://developers.cloudflare.com/durable-objects/) -- [R2 Storage Documentation](https://developers.cloudflare.com/r2/) - ---- - -## Container Support Architecture - -### Overview - -Cloudflare container support for Workers is integrated into SeBS using the `@cloudflare/containers` package, enabling deployment of containerized applications across multiple programming languages. - -### Implementation Details - -1. **Container Orchestration** - - Uses `@cloudflare/containers` npm package - - Requires Node.js worker.js wrapper for orchestration - - Container runs inside Durable Object for isolation - - Integrated with wrangler CLI for deployment - -2. **Deployment Process** - - `package_code()` generates wrangler.toml with container configuration - - Creates `[[migrations]]` entries for Durable Objects - - Binds container to `CONTAINER_WORKER` Durable Object class - - Uses `wrangler deploy` to upload both worker and container - -3. **Supported Languages** - - Python via Docker containers - - Node.js (both script and container) - - Go, Rust, Java (via container deployment) - - Any language that can run in a Linux container - -4. **Key Methods** - - `_generate_wrangler_toml()`: Creates config with container bindings - - `create_function()`: Deploys workers using wrangler CLI - - `update_function()`: Updates existing containerized workers - -### Benefits - -- **Multi-language Support**: Deploy Python, Java, Go, Rust workers -- **Complex Dependencies**: Support system libraries and compiled extensions -- **Larger Code Packages**: Overcome script size limitations -- **Consistent Environments**: Same container locally and in production - - -## References - -- [Cloudflare Workers Documentation](https://developers.cloudflare.com/workers/) -- [Cloudflare API Documentation](https://api.cloudflare.com/) -- [Workers API Reference](https://developers.cloudflare.com/workers/runtime-apis/) From b427c5b3c770e89d19d8436845f935b3f877efaf Mon Sep 17 00:00:00 2001 From: laurin Date: Sun, 18 Jan 2026 12:33:18 +0100 Subject: [PATCH 60/69] more detail about download_metrics() --- docs/platforms.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/platforms.md b/docs/platforms.md index 45fc41e36..2b32d02d5 100644 --- a/docs/platforms.md +++ b/docs/platforms.md @@ -245,7 +245,7 @@ Container-based deployments use Cloudflare's container runtime and require the W | standard-2 | 1 | 6 GiB | 12 GB | | standard-3 | 2 | 8 GiB | 16 GB | | standard-4 | 4 | 12 GiB | 20 GB | -- **Metrics Collection**: Uses response-based per-invocation metrics. Cloudflare does expose an Analytics engine, but it only provides aggregated metrics, no individual request metrics. Which is useless for our benchmarking purposes. +- **Metrics Collection**: Uses response-based per-invocation metrics. During each function invocation, the worker handler measures performance metrics (CPU time, wall time, memory usage) and embeds them directly in the JSON response. SeBS extracts these metrics immediately from each response. When `download_metrics()` is called for postprocessing, it only aggregates the metrics that were already collected during invocations—no additional data is fetched from external services. This approach provides immediate per-invocation granularity without delays. Note that while Cloudflare does expose an Analytics Engine, it only provides aggregated metrics without individual request-level data, making it unsuitable for detailed benchmarking purposes. ### Storage Configuration From 734eadf6ae02763fc301d96715628f940eaca204 Mon Sep 17 00:00:00 2001 From: laurin Date: Sun, 18 Jan 2026 14:13:10 +0100 Subject: [PATCH 61/69] Docker build container for build orchestration locally --- dockerfiles/cloudflare/Dockerfile.manage | 35 +++ docs/platforms.md | 4 +- sebs/cloudflare/cli.py | 249 +++++++++++++++++++ sebs/cloudflare/cloudflare.py | 289 +++++++++-------------- 4 files changed, 397 insertions(+), 180 deletions(-) create mode 100644 dockerfiles/cloudflare/Dockerfile.manage create mode 100644 sebs/cloudflare/cli.py diff --git a/dockerfiles/cloudflare/Dockerfile.manage b/dockerfiles/cloudflare/Dockerfile.manage new file mode 100644 index 000000000..ac18ac336 --- /dev/null +++ b/dockerfiles/cloudflare/Dockerfile.manage @@ -0,0 +1,35 @@ +FROM node:20-slim + +# Disable telemetry +ENV WRANGLER_SEND_METRICS=false + +# Install system dependencies including Docker CLI +RUN apt-get clean && apt-get update \ + && apt-get install -y ca-certificates curl gnupg gosu python3 python3-pip python3-venv git \ + && install -m 0755 -d /etc/apt/keyrings \ + && curl -fsSL https://download.docker.com/linux/debian/gpg -o /etc/apt/keyrings/docker.asc \ + && chmod a+r /etc/apt/keyrings/docker.asc \ + && echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/debian bookworm stable" > /etc/apt/sources.list.d/docker.list \ + && apt-get update \ + && apt-get install -y docker-ce-cli \ + && apt-get purge -y --auto-remove \ + && apt-get clean \ + && rm -rf /var/lib/apt/lists/* + +# Install wrangler globally +RUN npm install -g wrangler + +# Install uv (fast Python package installer) and pywrangler +# uv install script puts the binary in ~/.local/bin by default (not ~/.cargo/bin) +RUN curl -LsSf https://astral.sh/uv/install.sh | sh && \ + /root/.local/bin/uv tool install workers-py + +# Add paths to environment +ENV PATH="/root/.local/bin:/root/.local/share/uv/tools/workers-py/bin:${PATH}" + +# Create working directory +RUN mkdir -p /sebs/ +COPY dockerfiles/entrypoint.sh /sebs/entrypoint.sh +RUN chmod +x /sebs/entrypoint.sh + +ENTRYPOINT ["/sebs/entrypoint.sh"] diff --git a/docs/platforms.md b/docs/platforms.md index 2b32d02d5..2b7ac8948 100644 --- a/docs/platforms.md +++ b/docs/platforms.md @@ -224,7 +224,9 @@ Cloudflare Workers support multiple languages through different deployment metho - **JavaScript/Node.js**: Supported via script-based deployment or container-based deployment using Wrangler CLI - **Python**: Supported via script-based deployment or container-based deployment using Wrangler CLI -Container-based deployments use Cloudflare's container runtime and require the Wrangler CLI to be installed (`npm install -g wrangler`). +### CLI Container + +SeBS uses a containerized CLI approach for Cloudflare deployments, eliminating the need to install Node.js, npm, wrangler, pywrangler, or uv on your host system. The CLI container (`sebs/manage.cloudflare`) is automatically built on first use and contains all necessary tools. This ensures consistent behavior across platforms and simplifies setup—only Docker is required. ### Trigger Support diff --git a/sebs/cloudflare/cli.py b/sebs/cloudflare/cli.py new file mode 100644 index 000000000..426db5cac --- /dev/null +++ b/sebs/cloudflare/cli.py @@ -0,0 +1,249 @@ +import io +import logging +import os +import tarfile + +import docker + +from sebs.config import SeBSConfig +from sebs.utils import LoggingBase + + +class CloudflareCLI(LoggingBase): + """ + Manages a Docker container with Cloudflare Wrangler and related tools pre-installed. + + This approach isolates Cloudflare CLI tools (wrangler, pywrangler) from the host system, + avoiding global npm/uv installations and ensuring consistent behavior across platforms. + """ + + def __init__(self, system_config: SeBSConfig, docker_client: docker.client): + super().__init__() + + repo_name = system_config.docker_repository() + image_name = "manage.cloudflare" + full_image_name = repo_name + ":" + image_name + + # Try to get the image, pull if not found, build if pull fails + try: + docker_client.images.get(full_image_name) + logging.info(f"Using existing Docker image: {full_image_name}") + except docker.errors.ImageNotFound: + # Try to pull the image first + try: + logging.info(f"Pulling Docker image {full_image_name}...") + docker_client.images.pull(repo_name, image_name) + logging.info(f"Successfully pulled {full_image_name}") + except docker.errors.APIError as pull_error: + # If pull fails, try to build the image locally + logging.info(f"Pull failed: {pull_error}. Building image locally...") + + # Find the Dockerfile path + dockerfile_path = os.path.join( + os.path.dirname(__file__), + "..", + "..", + "dockerfiles", + "cloudflare", + "Dockerfile.manage" + ) + + if not os.path.exists(dockerfile_path): + raise RuntimeError( + f"Dockerfile not found at {dockerfile_path}. " + "Cannot build Cloudflare CLI container." + ) + + # Build the image + build_path = os.path.join(os.path.dirname(__file__), "..", "..") + logging.info(f"Building {full_image_name} from {dockerfile_path}...") + + try: + image, build_logs = docker_client.images.build( + path=build_path, + dockerfile=dockerfile_path, + tag=full_image_name, + rm=True, + pull=True + ) + + # Log build output + for log in build_logs: + if 'stream' in log: + logging.debug(log['stream'].strip()) + + logging.info(f"Successfully built {full_image_name}") + except docker.errors.BuildError as build_error: + raise RuntimeError( + f"Failed to build Docker image {full_image_name}: {build_error}" + ) + + # Start the container in detached mode + self.docker_instance = docker_client.containers.run( + image=full_image_name, + command="/bin/bash", + environment={ + "CONTAINER_UID": str(os.getuid()), + "CONTAINER_GID": str(os.getgid()), + "CONTAINER_USER": "docker_user", + }, + volumes={ + # Mount Docker socket for wrangler container deployments + "/var/run/docker.sock": {"bind": "/var/run/docker.sock", "mode": "rw"} + }, + remove=True, + stdout=True, + stderr=True, + detach=True, + tty=True, + ) + + self.logging.info(f"Started Cloudflare CLI container: {self.docker_instance.id}.") + + # Wait for container to be ready + while True: + try: + dkg = self.docker_instance.logs(stream=True, follow=True) + next(dkg).decode("utf-8") + break + except StopIteration: + pass + + @staticmethod + def typename() -> str: + return "Cloudflare.CLI" + + def execute(self, cmd: str, env: dict = None): + """ + Execute the given command in Cloudflare CLI container. + Throws an exception on failure (commands are expected to execute successfully). + + Args: + cmd: Shell command to execute + env: Optional environment variables dict + + Returns: + Command output as bytes + """ + # Wrap command in sh -c to support shell features like cd, pipes, etc. + shell_cmd = ["/bin/sh", "-c", cmd] + exit_code, out = self.docker_instance.exec_run( + shell_cmd, + user="root", # Run as root since entrypoint creates docker_user but we don't wait for it + environment=env + ) + if exit_code != 0: + raise RuntimeError( + "Command {} failed at Cloudflare CLI docker!\n Output {}".format( + cmd, out.decode("utf-8") + ) + ) + return out + + def upload_package(self, directory: str, dest: str): + """ + Upload a directory to the Docker container. + + This is not an efficient and memory-intensive implementation. + So far, we didn't have very large functions that require many gigabytes. + + Since docker-py does not support a straightforward copy, and we can't + put_archive in chunks. + + Args: + directory: Local directory to upload + dest: Destination path in container + """ + handle = io.BytesIO() + with tarfile.open(fileobj=handle, mode="w:gz") as tar: + for f in os.listdir(directory): + tar.add(os.path.join(directory, f), arcname=f) + + # Move to the beginning of memory before writing + handle.seek(0) + self.execute("mkdir -p {}".format(dest)) + self.docker_instance.put_archive(path=dest, data=handle.read()) + + def check_wrangler_version(self) -> str: + """ + Check wrangler version. + + Returns: + Version string + """ + out = self.execute("wrangler --version") + return out.decode("utf-8").strip() + + def check_pywrangler_version(self) -> str: + """ + Check pywrangler version. + + Returns: + Version string + """ + out = self.execute("pywrangler --version") + return out.decode("utf-8").strip() + + def wrangler_deploy(self, package_dir: str, env: dict = None) -> str: + """ + Deploy a worker using wrangler. + + Args: + package_dir: Path to package directory in container + env: Environment variables for deployment + + Returns: + Deployment output + """ + cmd = "cd {} && wrangler deploy".format(package_dir) + out = self.execute(cmd, env=env) + return out.decode("utf-8") + + def pywrangler_deploy(self, package_dir: str, env: dict = None) -> str: + """ + Deploy a Python worker using pywrangler. + + Args: + package_dir: Path to package directory in container + env: Environment variables for deployment + + Returns: + Deployment output + """ + cmd = "cd {} && pywrangler deploy".format(package_dir) + out = self.execute(cmd, env=env) + return out.decode("utf-8") + + def npm_install(self, package_dir: str) -> str: + """ + Run npm install in a directory. + + Args: + package_dir: Path to package directory in container + + Returns: + npm output + """ + cmd = "cd {} && npm install".format(package_dir) + out = self.execute(cmd) + return out.decode("utf-8") + + def docker_build(self, package_dir: str, image_tag: str) -> str: + """ + Build a Docker image for container deployment. + + Args: + package_dir: Path to package directory in container + image_tag: Tag for the Docker image + + Returns: + Docker build output + """ + cmd = "cd {} && docker build --no-cache -t {} .".format(package_dir, image_tag) + out = self.execute(cmd) + return out.decode("utf-8") + + def shutdown(self): + """Shutdown Docker instance.""" + self.logging.info("Stopping Cloudflare CLI Docker instance") + self.docker_instance.stop() diff --git a/sebs/cloudflare/cloudflare.py b/sebs/cloudflare/cloudflare.py index ba76429c1..a518bdd74 100644 --- a/sebs/cloudflare/cloudflare.py +++ b/sebs/cloudflare/cloudflare.py @@ -10,6 +10,7 @@ import docker import requests +from sebs.cloudflare.cli import CloudflareCLI from sebs.cloudflare.config import CloudflareConfig from sebs.cloudflare.function import CloudflareWorker from sebs.cloudflare.resources import CloudflareSystemResources @@ -65,10 +66,12 @@ def __init__( self.logging_handlers = logger_handlers self._config = config self._api_base_url = "https://api.cloudflare.com/client/v4" - # cached workers.dev subdomain for the account (e.g. 'marcin-copik') + # cached workers.dev subdomain for the account # This is different from the account ID and is required to build # public worker URLs like ..workers.dev self._workers_dev_subdomain: Optional[str] = None + # Initialize CLI container for wrangler/pywrangler operations + self._cli: Optional[CloudflareCLI] = None def initialize(self, config: Dict[str, str] = {}, resource_prefix: Optional[str] = None): """ @@ -154,74 +157,15 @@ def _verify_credentials(self): ) self.logging.info("Cloudflare credentials verified successfully") - - def _ensure_wrangler_installed(self): - """Ensure Wrangler CLI is installed and available.""" - try: - result = subprocess.run( - ["wrangler", "--version"], - capture_output=True, - text=True, - check=True, - timeout=10 - ) - version = result.stdout.strip() - self.logging.info(f"Wrangler is installed: {version}") - except (subprocess.CalledProcessError, FileNotFoundError): - self.logging.info("Wrangler not found, installing globally via npm...") - try: - result = subprocess.run( - ["npm", "install", "-g", "wrangler"], - capture_output=True, - text=True, - check=True, - timeout=120 - ) - self.logging.info("Wrangler installed successfully") - if result.stdout: - self.logging.debug(f"npm install wrangler output: {result.stdout}") - except subprocess.CalledProcessError as e: - raise RuntimeError(f"Failed to install Wrangler: {e.stderr}") - except FileNotFoundError: - raise RuntimeError( - "npm not found. Please install Node.js and npm to use Wrangler for deployment." - ) - except subprocess.TimeoutExpired: - raise RuntimeError("Wrangler version check timed out") - - def _ensure_pywrangler_installed(self): - """Necessary to download python dependencies""" - try: - result = subprocess.run( - ["pywrangler", "--version"], - capture_output=True, - text=True, - check=True, - timeout=10 - ) - version = result.stdout.strip() - self.logging.info(f"pywrangler is installed: {version}") - except (subprocess.CalledProcessError, FileNotFoundError): - self.logging.info("pywrangler not found, installing globally via uv tool install...") - try: - result = subprocess.run( - ["uv", "tool", "install", "workers-py"], - capture_output=True, - text=True, - check=True, - timeout=120 - ) - self.logging.info("pywrangler installed successfully") - if result.stdout: - self.logging.debug(f"uv tool install workers-py output: {result.stdout}") - except subprocess.CalledProcessError as e: - raise RuntimeError(f"Failed to install pywrangler: {e.stderr}") - except FileNotFoundError: - raise RuntimeError( - "uv not found. Please install uv." - ) - except subprocess.TimeoutExpired: - raise RuntimeError("pywrangler version check timed out") + + def _get_cli(self) -> CloudflareCLI: + """Get or initialize the Cloudflare CLI container.""" + if self._cli is None: + self._cli = CloudflareCLI(self.system_config, self.docker_client) + # Verify wrangler is available + version = self._cli.check_wrangler_version() + self.logging.info(f"Cloudflare CLI container ready: {version}") + return self._cli def _generate_wrangler_toml(self, worker_name: str, package_dir: str, language: str, account_id: str, benchmark_name: Optional[str] = None, code_package: Optional[Benchmark] = None, container_deployment: bool = False, container_uri: str = "") -> str: @@ -241,23 +185,10 @@ def _generate_wrangler_toml(self, worker_name: str, package_dir: str, language: Returns: Path to the generated wrangler.toml file """ - # Container deployment configuration if container_deployment: - # Containers ALWAYS use Node.js worker.js for orchestration (@cloudflare/containers is Node.js only) - # The container itself can run any language (Python, Node.js, etc.) - # R2 and NoSQL access is proxied through worker.js which has the bindings - - # Determine if this benchmark needs larger disk space - # 411.image-recognition needs more disk for PyTorch models - # 311.compression needs more disk for file compression operations - # 504.dna-visualisation needs more disk for DNA sequence processing - # Python containers need even more space due to zip file creation doubling disk usage instance_type = "" if benchmark_name and ("411.image-recognition" in benchmark_name or "311.compression" in benchmark_name or "504.dna-visualisation" in benchmark_name): - # Use "standard" (largest) for Python, "standard-4" for Node.js - # if language == "python": - # instance_type = '\ninstance_type = "standard-4" # Largest available - needed for Python zip operations\n' - # else: + self.logging.warning("Using standard-4 instance type for high resource benchmark") instance_type = '\ninstance_type = "standard-4" # 20GB Disk, 12GB Memory\n' toml_content = f"""name = "{worker_name}" @@ -467,52 +398,47 @@ def _package_code_native( # Install dependencies if language_name == "nodejs": - # Ensure Wrangler is installed - self._ensure_wrangler_installed() - package_file = os.path.join(directory, "package.json") node_modules = os.path.join(directory, "node_modules") # Only install if package.json exists and node_modules doesn't if os.path.exists(package_file) and not os.path.exists(node_modules): self.logging.info(f"Installing Node.js dependencies in {directory}") + # Use CLI container for npm install - no Node.js/npm needed on host + cli = self._get_cli() + container_path = f"/tmp/npm_install/{os.path.basename(directory)}" + try: + # Upload package directory to container + cli.upload_package(directory, container_path) + # Install production dependencies - result = subprocess.run( - ["npm", "install"], - cwd=directory, - capture_output=True, - text=True, - check=True, - timeout=120 - ) + self.logging.info("Installing npm dependencies in container...") + output = cli.npm_install(container_path) self.logging.info("npm install completed successfully") - if result.stdout: - self.logging.debug(f"npm output: {result.stdout}") + self.logging.debug(f"npm output: {output}") # Install esbuild as a dev dependency (needed by build.js) self.logging.info("Installing esbuild for custom build script...") - result = subprocess.run( - ["npm", "install", "--save-dev", "esbuild"], - cwd=directory, - capture_output=True, - text=True, - check=True, - timeout=60 - ) + cli.execute(f"cd {container_path} && npm install --save-dev esbuild") self.logging.info("esbuild installed successfully") + + # Download node_modules back to host + import tarfile + import io + bits, stat = cli.docker_instance.get_archive(f"{container_path}/node_modules") + file_obj = io.BytesIO() + for chunk in bits: + file_obj.write(chunk) + file_obj.seek(0) + with tarfile.open(fileobj=file_obj) as tar: + tar.extractall(directory) + + self.logging.info(f"Downloaded node_modules to {directory}") - - except subprocess.TimeoutExpired: - self.logging.error("npm install timed out") - raise RuntimeError("Failed to install Node.js dependencies: timeout") - except subprocess.CalledProcessError as e: - self.logging.error(f"npm install failed: {e.stderr}") - raise RuntimeError(f"Failed to install Node.js dependencies: {e.stderr}") - except FileNotFoundError: - raise RuntimeError( - "npm not found. Please install Node.js and npm to deploy Node.js benchmarks." - ) + except Exception as e: + self.logging.error(f"npm install in container failed: {e}") + raise RuntimeError(f"Failed to install Node.js dependencies: {e}") elif os.path.exists(node_modules): self.logging.info(f"Node.js dependencies already installed in {directory}") @@ -520,22 +446,29 @@ def _package_code_native( esbuild_path = os.path.join(node_modules, "esbuild") if not os.path.exists(esbuild_path): self.logging.info("Installing esbuild for custom build script...") + cli = self._get_cli() + container_path = f"/tmp/npm_install/{os.path.basename(directory)}" + try: - subprocess.run( - ["npm", "install", "--save-dev", "esbuild"], - cwd=directory, - capture_output=True, - text=True, - check=True, - timeout=60 - ) + cli.upload_package(directory, container_path) + cli.execute(f"cd {container_path} && npm install --save-dev esbuild") + + # Download node_modules back + import tarfile + import io + bits, stat = cli.docker_instance.get_archive(f"{container_path}/node_modules") + file_obj = io.BytesIO() + for chunk in bits: + file_obj.write(chunk) + file_obj.seek(0) + with tarfile.open(fileobj=file_obj) as tar: + tar.extractall(directory) + self.logging.info("esbuild installed successfully") except Exception as e: self.logging.warning(f"Failed to install esbuild: {e}") elif language_name == "python": - # Ensure Wrangler is installed - self._ensure_pywrangler_installed() requirements_file = os.path.join(directory, "requirements.txt") if os.path.exists(f"{requirements_file}.{language_version}"): @@ -893,16 +826,31 @@ def replacer(match): # Install Node.js dependencies (needed for all containers for worker.js) self.logging.info(f"Installing @cloudflare/containers for worker.js orchestration in {directory}") + # Use CLI container for npm install - no Node.js/npm needed on host + cli = self._get_cli() + container_path = f"/tmp/container_npm/{os.path.basename(directory)}" + try: - result = subprocess.run( - ["npm", "install", "--production"], - cwd=directory, - capture_output=True, - text=True, - check=True, - timeout=120 - ) + # Upload package directory to container + cli.upload_package(directory, container_path) + + # Install production dependencies + output = cli.execute(f"cd {container_path} && npm install --production") self.logging.info("npm install completed successfully") + self.logging.debug(f"npm output: {output.decode('utf-8')}") + + # Download node_modules back to host + import tarfile + import io + bits, stat = cli.docker_instance.get_archive(f"{container_path}/node_modules") + file_obj = io.BytesIO() + for chunk in bits: + file_obj.write(chunk) + file_obj.seek(0) + with tarfile.open(fileobj=file_obj) as tar: + tar.extractall(directory) + + self.logging.info(f"Downloaded node_modules to {directory}") except Exception as e: self.logging.error(f"npm install failed: {e}") raise RuntimeError(f"Failed to install Node.js dependencies: {e}") @@ -1122,7 +1070,7 @@ def _get_worker(self, worker_name: str, account_id: str) -> Optional[dict]: def _create_or_update_worker( self, worker_name: str, package_dir: str, account_id: str, language: str, benchmark_name: Optional[str] = None, code_package: Optional[Benchmark] = None, container_deployment: bool = False, container_uri: str = "" ) -> dict: - """Create or update a Cloudflare Worker using Wrangler CLI. + """Create or update a Cloudflare Worker using Wrangler CLI in container. Args: worker_name: Name of the worker @@ -1140,14 +1088,8 @@ def _create_or_update_worker( # Generate wrangler.toml for this worker self._generate_wrangler_toml(worker_name, package_dir, language, account_id, benchmark_name, code_package, container_deployment, container_uri) - # Set up environment for Wrangler - env = os.environ.copy() - - # Add uv tools bin directory to PATH for pywrangler access - home_dir = os.path.expanduser("~") - uv_bin_dir = os.path.join(home_dir, ".local", "share", "uv", "tools", "workers-py", "bin") - if os.path.exists(uv_bin_dir): - env['PATH'] = f"{uv_bin_dir}:{env.get('PATH', '')}" + # Set up environment for Wrangler CLI in container + env = {} if self.config.credentials.api_token: env['CLOUDFLARE_API_TOKEN'] = self.config.credentials.api_token @@ -1157,34 +1099,27 @@ def _create_or_update_worker( env['CLOUDFLARE_ACCOUNT_ID'] = account_id - # Deploy using Wrangler - self.logging.info(f"Deploying worker {worker_name} using Wrangler...") + # Get CLI container instance + cli = self._get_cli() - # For container deployments, always use wrangler (not pywrangler) - # For native deployments, use wrangler for nodejs, pywrangler for python - if container_deployment: - wrangler_cmd = "wrangler" - else: - wrangler_cmd = "wrangler" if language == "nodejs" else "pywrangler" + # Upload package directory to container + container_package_path = f"/tmp/workers/{worker_name}" + self.logging.info(f"Uploading package to container: {container_package_path}") + cli.upload_package(package_dir, container_package_path) + + # Deploy using Wrangler in container + self.logging.info(f"Deploying worker {worker_name} using Wrangler in container...") try: - # Increase timeout for large container images (e.g., 411.image-recognition with PyTorch) - # Container deployment requires pushing large images to Cloudflare - deploy_timeout = 1200 if container_deployment else 180 # 20 minutes for containers, 3 for native - - result = subprocess.run( - [wrangler_cmd, "deploy"], - cwd=package_dir, - env=env, - capture_output=True, - text=True, - check=True, - timeout=deploy_timeout - ) + # For container deployments, always use wrangler (not pywrangler) + # For native deployments, use wrangler for nodejs, pywrangler for python + if container_deployment or language == "nodejs": + output = cli.wrangler_deploy(container_package_path, env=env) + else: # python native + output = cli.pywrangler_deploy(container_package_path, env=env) self.logging.info(f"Worker {worker_name} deployed successfully") - if result.stdout: - self.logging.debug(f"Wrangler deploy output: {result.stdout}") + self.logging.debug(f"Wrangler deploy output: {output}") # For container deployments, wait for Durable Object infrastructure to initialize # The container binding needs time to propagate before first invocation @@ -1192,11 +1127,6 @@ def _create_or_update_worker( self.logging.info("Waiting for container Durable Object to initialize...") self._wait_for_durable_object_ready(worker_name, package_dir, env) - # for benchmarks 220, 311, 411 we need to wait longer after deployment - # if benchmark_name in ["220.video-processing", "311.compression", "411.image-recognition", "504.dna-visualisation"]: - # self.logging.info("Waiting 120 seconds for benchmark initialization...") - # time.sleep(400) - # For container deployments, wait for Durable Object infrastructure to initialize # The container binding needs time to propagate before first invocation if container_deployment: @@ -1207,14 +1137,10 @@ def _create_or_update_worker( # Wrangler typically outputs: "Published ()" # and "https://..workers.dev" - return {"success": True, "output": result.stdout} + return {"success": True, "output": output} - except subprocess.TimeoutExpired: - raise RuntimeError(f"Wrangler deployment timed out for worker {worker_name}") - except subprocess.CalledProcessError as e: - error_msg = f"Wrangler deployment failed for worker {worker_name}" - if e.stderr: - error_msg += f": {e.stderr}" + except RuntimeError as e: + error_msg = f"Wrangler deployment failed for worker {worker_name}: {str(e)}" self.logging.error(error_msg) raise RuntimeError(error_msg) @@ -1288,7 +1214,7 @@ def _get_workers_dev_subdomain(self, account_id: str) -> Optional[str]: subdomain (the readable name used in *.workers.dev), e.g. GET /accounts/{account_id}/workers/subdomain - Returns the subdomain string (e.g. 'marcin-copik') or None on failure. + Returns the subdomain string or None on failure. """ if self._workers_dev_subdomain: return self._workers_dev_subdomain @@ -1642,10 +1568,15 @@ def shutdown(self) -> None: """ Shutdown the Cloudflare system. - Saves configuration to cache. + Saves configuration to cache and shuts down CLI container. """ try: self.cache_client.lock() self.config.update_cache(self.cache_client) finally: self.cache_client.unlock() + + # Shutdown CLI container if it was initialized + if self._cli is not None: + self._cli.shutdown() + self._cli = None From 5ffcb06bbf78fb26ca333cd67c4cbe0330c700f0 Mon Sep 17 00:00:00 2001 From: laurin Date: Sun, 18 Jan 2026 14:26:49 +0100 Subject: [PATCH 62/69] using docker client to build local image --- sebs/cloudflare/cloudflare.py | 38 ++++++++++++++++++----------------- 1 file changed, 20 insertions(+), 18 deletions(-) diff --git a/sebs/cloudflare/cloudflare.py b/sebs/cloudflare/cloudflare.py index a518bdd74..df65cfa35 100644 --- a/sebs/cloudflare/cloudflare.py +++ b/sebs/cloudflare/cloudflare.py @@ -941,32 +941,34 @@ def _build_container_image_local( self.logging.info(f"Building local container image: {image_tag}") try: - # Build the Docker image locally (no push) - # Use --no-cache to ensure handler changes are picked up - # Note: BASE_IMAGE is already set in the Dockerfile, no need to pass as build arg - result = subprocess.run( - ["docker", "build", "--no-cache", "-t", image_tag, "."], - cwd=directory, - capture_output=True, - text=True, - check=True, - timeout=300 # 5 minutes for build + # Build the Docker image using docker-py + # nocache=True ensures handler changes are picked up + _, build_logs = self.docker_client.images.build( + path=directory, + tag=image_tag, + nocache=True, + rm=True ) + # Log build output + for log in build_logs: + if 'stream' in log: + self.logging.debug(log['stream'].strip()) + elif 'error' in log: + self.logging.error(log['error'].strip()) + self.logging.info(f"Local container image built: {image_tag}") - if result.stdout: - self.logging.debug(f"Docker build output: {result.stdout}") return image_tag - except subprocess.CalledProcessError as e: - error_msg = f"Docker build failed for {image_tag}" - if e.stderr: - error_msg += f": {e.stderr}" + except docker.errors.BuildError as e: + error_msg = f"Docker build failed for {image_tag}: {e}" + self.logging.error(error_msg) + raise RuntimeError(error_msg) + except Exception as e: + error_msg = f"Unexpected error building Docker image {image_tag}: {e}" self.logging.error(error_msg) raise RuntimeError(error_msg) - except subprocess.TimeoutExpired: - raise RuntimeError(f"Docker build timed out for {image_tag}") def create_function( self, From 4da0c31e990beb02cf8059dcb5e1eb020869f101 Mon Sep 17 00:00:00 2001 From: laurin Date: Sun, 18 Jan 2026 14:27:37 +0100 Subject: [PATCH 63/69] do not create library trigger --- sebs/cloudflare/cloudflare.py | 8 ++------ 1 file changed, 2 insertions(+), 6 deletions(-) diff --git a/sebs/cloudflare/cloudflare.py b/sebs/cloudflare/cloudflare.py index df65cfa35..4cbbe768e 100644 --- a/sebs/cloudflare/cloudflare.py +++ b/sebs/cloudflare/cloudflare.py @@ -1035,12 +1035,8 @@ def create_function( account_id, ) - # Add LibraryTrigger and HTTPTrigger - from sebs.cloudflare.triggers import LibraryTrigger, HTTPTrigger - - library_trigger = LibraryTrigger(func_name, self) - library_trigger.logging_handlers = self.logging_handlers - worker.add_trigger(library_trigger) + # Add HTTPTrigger + from sebs.cloudflare.triggers import HTTPTrigger # Build worker URL using the account's workers.dev subdomain when possible. # Falls back to account_id-based host or plain workers.dev with warnings. From 48747940a6f283941f561191072dd24e9856dd59 Mon Sep 17 00:00:00 2001 From: laurin Date: Sun, 18 Jan 2026 14:34:03 +0100 Subject: [PATCH 64/69] removed some deprecated logging, throw exception if cold start is used --- sebs/cloudflare/cloudflare.py | 11 +++-------- 1 file changed, 3 insertions(+), 8 deletions(-) diff --git a/sebs/cloudflare/cloudflare.py b/sebs/cloudflare/cloudflare.py index 4cbbe768e..dba044f92 100644 --- a/sebs/cloudflare/cloudflare.py +++ b/sebs/cloudflare/cloudflare.py @@ -1119,22 +1119,16 @@ def _create_or_update_worker( self.logging.info(f"Worker {worker_name} deployed successfully") self.logging.debug(f"Wrangler deploy output: {output}") - # For container deployments, wait for Durable Object infrastructure to initialize # The container binding needs time to propagate before first invocation if container_deployment: self.logging.info("Waiting for container Durable Object to initialize...") self._wait_for_durable_object_ready(worker_name, package_dir, env) - # For container deployments, wait for Durable Object infrastructure to initialize # The container binding needs time to propagate before first invocation if container_deployment: - self.logging.info("Waiting 60 seconds for container Durable Object to initialize...") + self.logging.info("Waiting 60 seconds for container to be fully provisioned (can sometimes take a bit longer)...") time.sleep(60) - # Parse the output to get worker URL - # Wrangler typically outputs: "Published ()" - # and "https://..workers.dev" - return {"success": True, "output": output} except RuntimeError as e: @@ -1414,10 +1408,11 @@ def enforce_cold_start(self, functions: List[Function], code_package: Benchmark) functions: List of functions to enforce cold start on code_package: The benchmark package """ - self.logging.warning( + raise NotImplementedError( "Cloudflare Workers do not support forced cold starts. " "Workers are automatically instantiated on-demand at edge locations." ) + def download_metrics( self, From 6b8e695ba2cd639f19508e81d95e5773ee1f4864 Mon Sep 17 00:00:00 2001 From: laurin Date: Sun, 18 Jan 2026 16:13:22 +0100 Subject: [PATCH 65/69] split the cloudflare.py into containers.py + workers.py... each handling their own package & deployment process orchestrated by main entry point cloudflare.py --- sebs/cloudflare/cloudflare.py | 916 +++------------------------------- sebs/cloudflare/containers.py | 547 ++++++++++++++++++++ sebs/cloudflare/workers.py | 376 ++++++++++++++ 3 files changed, 1001 insertions(+), 838 deletions(-) create mode 100644 sebs/cloudflare/containers.py create mode 100644 sebs/cloudflare/workers.py diff --git a/sebs/cloudflare/cloudflare.py b/sebs/cloudflare/cloudflare.py index dba044f92..e61b4d4aa 100644 --- a/sebs/cloudflare/cloudflare.py +++ b/sebs/cloudflare/cloudflare.py @@ -1,8 +1,5 @@ import os -import shutil -import json import uuid -import subprocess import time from datetime import datetime from typing import cast, Dict, List, Optional, Tuple, Type @@ -10,10 +7,11 @@ import docker import requests -from sebs.cloudflare.cli import CloudflareCLI from sebs.cloudflare.config import CloudflareConfig from sebs.cloudflare.function import CloudflareWorker from sebs.cloudflare.resources import CloudflareSystemResources +from sebs.cloudflare.workers import CloudflareWorkersDeployment +from sebs.cloudflare.containers import CloudflareContainersDeployment from sebs.benchmark import Benchmark from sebs.cache import Cache from sebs.config import SeBSConfig @@ -70,8 +68,14 @@ def __init__( # This is different from the account ID and is required to build # public worker URLs like ..workers.dev self._workers_dev_subdomain: Optional[str] = None - # Initialize CLI container for wrangler/pywrangler operations - self._cli: Optional[CloudflareCLI] = None + + # Initialize deployment handlers + self._workers_deployment = CloudflareWorkersDeployment( + self.logging, sebs_config, docker_client, self.system_resources + ) + self._containers_deployment = CloudflareContainersDeployment( + self.logging, sebs_config, docker_client, self.system_resources + ) def initialize(self, config: Dict[str, str] = {}, resource_prefix: Optional[str] = None): """ @@ -158,193 +162,20 @@ def _verify_credentials(self): self.logging.info("Cloudflare credentials verified successfully") - def _get_cli(self) -> CloudflareCLI: - """Get or initialize the Cloudflare CLI container.""" - if self._cli is None: - self._cli = CloudflareCLI(self.system_config, self.docker_client) - # Verify wrangler is available - version = self._cli.check_wrangler_version() - self.logging.info(f"Cloudflare CLI container ready: {version}") - return self._cli - - - def _generate_wrangler_toml(self, worker_name: str, package_dir: str, language: str, account_id: str, benchmark_name: Optional[str] = None, code_package: Optional[Benchmark] = None, container_deployment: bool = False, container_uri: str = "") -> str: - """ - Generate a wrangler.toml configuration file for the worker. - + def _get_deployment_handler(self, container_deployment: bool): + """Get the appropriate deployment handler based on deployment type. + Args: - worker_name: Name of the worker - package_dir: Directory containing the worker code - language: Programming language (nodejs or python) - account_id: Cloudflare account ID - benchmark_name: Optional benchmark name for R2 file path prefix - code_package: Optional benchmark package for nosql configuration container_deployment: Whether this is a container deployment - container_uri: Container image URI/tag - + Returns: - Path to the generated wrangler.toml file + CloudflareWorkersDeployment or CloudflareContainersDeployment """ if container_deployment: - instance_type = "" - if benchmark_name and ("411.image-recognition" in benchmark_name or "311.compression" in benchmark_name or "504.dna-visualisation" in benchmark_name): - self.logging.warning("Using standard-4 instance type for high resource benchmark") - instance_type = '\ninstance_type = "standard-4" # 20GB Disk, 12GB Memory\n' - - toml_content = f"""name = "{worker_name}" -main = "worker.js" -compatibility_date = "2025-11-18" -account_id = "{account_id}" -compatibility_flags = ["nodejs_compat"] - -[observability] -enabled = true - -[[containers]] -max_instances = 10 -class_name = "ContainerWorker" -image = "./Dockerfile"{instance_type} - -# Durable Object binding for Container class (required by @cloudflare/containers) -[[durable_objects.bindings]] -name = "CONTAINER_WORKER" -class_name = "ContainerWorker" - -""" - # Add nosql table bindings if benchmark uses them - if code_package and code_package.uses_nosql: - # Get registered nosql tables for this benchmark - nosql_storage = self.system_resources.get_nosql_storage() - if nosql_storage.retrieve_cache(benchmark_name): - nosql_tables = nosql_storage._tables.get(benchmark_name, {}) - for table_name in nosql_tables.keys(): - toml_content += f"""[[durable_objects.bindings]] -name = "{table_name}" -class_name = "KVApiObject" - -""" - self.logging.info(f"Added Durable Object binding for nosql table '{table_name}'") - - # Add migrations for both ContainerWorker and KVApiObject - # Both need new_sqlite_classes (Container requires SQLite DO backend) - toml_content += """[[migrations]] -tag = "v1" -new_sqlite_classes = ["ContainerWorker", "KVApiObject"] - -""" - else: - # Container without nosql - only ContainerWorker migration - toml_content += """[[migrations]] -tag = "v1" -new_sqlite_classes = ["ContainerWorker"] - -""" + return self._containers_deployment else: - # Native worker configuration - main_file = "dist/handler.js" if language == "nodejs" else "handler.py" - - # Build wrangler.toml content - toml_content = f"""name = "{worker_name}" -main = "{main_file}" -compatibility_date = "2025-11-18" -account_id = "{account_id}" -""" - - if language == "nodejs": - toml_content += """# Use nodejs_compat for Node.js built-in support -compatibility_flags = ["nodejs_compat"] -no_bundle = true - -[build] -command = "node build.js" - -[[rules]] -type = "ESModule" -globs = ["**/*.js"] -fallthrough = true - -[[rules]] -type = "Text" -globs = ["**/*.html"] -fallthrough = true - -""" - elif language == "python": - toml_content += """# Enable Python Workers runtime -compatibility_flags = ["python_workers"] -""" - - toml_content += """ -[[durable_objects.bindings]] -name = "DURABLE_STORE" -class_name = "KVApiObject" - -[[migrations]] -tag = "v3" -new_classes = ["KVApiObject"] -""" - - - # Add environment variables (for both native and container deployments) - vars_content = "" - if benchmark_name: - vars_content += f'BENCHMARK_NAME = "{benchmark_name}"\n' - - # Add nosql configuration if benchmark uses it - if code_package and code_package.uses_nosql: - vars_content += 'NOSQL_STORAGE_DATABASE = "durable_objects"\n' - - if vars_content: - toml_content += f"""# Environment variables -[vars] -{vars_content} -""" - - # Add R2 bucket binding for benchmarking files (for both native and container deployments) - r2_bucket_configured = False - try: - storage = self.system_resources.get_storage() - bucket_name = storage.get_bucket(Resources.StorageBucketType.BENCHMARKS) - if bucket_name: - toml_content += f"""# R2 bucket binding for benchmarking files -# This bucket is used by fs and path polyfills to read benchmark data -[[r2_buckets]] -binding = "R2" -bucket_name = "{bucket_name}" - -""" - r2_bucket_configured = True - self.logging.info(f"R2 bucket '{bucket_name}' will be bound to worker as 'R2'") - except Exception as e: - self.logging.warning( - f"R2 bucket binding not configured: {e}. " - f"Benchmarks requiring file access will not work properly." - ) - - - # Write wrangler.toml to package directory - toml_path = os.path.join(package_dir, "wrangler.toml") - with open(toml_path, 'w') as f: - f.write(toml_content) - - self.logging.info(f"Generated wrangler.toml at {toml_path}") - return toml_path + return self._workers_deployment - def _get_auth_headers(self) -> Dict[str, str]: - """Get authentication headers for Cloudflare API requests.""" - if self.config.credentials.api_token: - return { - "Authorization": f"Bearer {self.config.credentials.api_token}", - "Content-Type": "application/json", - } - elif self.config.credentials.email and self.config.credentials.api_key: - return { - "X-Auth-Email": self.config.credentials.email, - "X-Auth-Key": self.config.credentials.api_key, - "Content-Type": "application/json", - } - else: - raise RuntimeError("Invalid Cloudflare credentials configuration") def package_code( self, @@ -360,6 +191,8 @@ def package_code( Package code for Cloudflare Workers deployment using Wrangler. Uses Wrangler CLI to bundle dependencies and prepare for deployment. + Delegates to either CloudflareWorkersDeployment or CloudflareContainersDeployment + based on the deployment type. Args: directory: Path to the code directory @@ -373,602 +206,68 @@ def package_code( Returns: Tuple of (package_path, package_size, container_uri) """ + handler = self._get_deployment_handler(container_deployment) + # Container deployment flow - build Docker image if container_deployment: self.logging.info(f"Building container image for {benchmark}") - return self._package_code_container( + return handler.package_code( directory, language_name, language_version, architecture, benchmark ) - # Native worker deployment flow (existing logic) - return self._package_code_native( + # Native worker deployment flow + return handler.package_code( directory, language_name, language_version, benchmark, is_cached ) + def _get_auth_headers(self) -> Dict[str, str]: + """Get authentication headers for Cloudflare API requests.""" + if self.config.credentials.api_token: + return { + "Authorization": f"Bearer {self.config.credentials.api_token}", + "Content-Type": "application/json", + } + elif self.config.credentials.email and self.config.credentials.api_key: + return { + "X-Auth-Email": self.config.credentials.email, + "X-Auth-Key": self.config.credentials.api_key, + "Content-Type": "application/json", + } + else: + raise RuntimeError("Invalid Cloudflare credentials configuration") - def _package_code_native( + def _generate_wrangler_toml( self, - directory: str, - language_name: str, - language_version: str, - benchmark: str, - is_cached: bool, - ) -> Tuple[str, int, str]: - """Package code for native Cloudflare Workers deployment.""" - - # Install dependencies - if language_name == "nodejs": - package_file = os.path.join(directory, "package.json") - node_modules = os.path.join(directory, "node_modules") - - # Only install if package.json exists and node_modules doesn't - if os.path.exists(package_file) and not os.path.exists(node_modules): - self.logging.info(f"Installing Node.js dependencies in {directory}") - # Use CLI container for npm install - no Node.js/npm needed on host - cli = self._get_cli() - container_path = f"/tmp/npm_install/{os.path.basename(directory)}" - - try: - # Upload package directory to container - cli.upload_package(directory, container_path) - - # Install production dependencies - self.logging.info("Installing npm dependencies in container...") - output = cli.npm_install(container_path) - self.logging.info("npm install completed successfully") - self.logging.debug(f"npm output: {output}") - - # Install esbuild as a dev dependency (needed by build.js) - self.logging.info("Installing esbuild for custom build script...") - cli.execute(f"cd {container_path} && npm install --save-dev esbuild") - self.logging.info("esbuild installed successfully") - - # Download node_modules back to host - import tarfile - import io - bits, stat = cli.docker_instance.get_archive(f"{container_path}/node_modules") - file_obj = io.BytesIO() - for chunk in bits: - file_obj.write(chunk) - file_obj.seek(0) - with tarfile.open(fileobj=file_obj) as tar: - tar.extractall(directory) - - self.logging.info(f"Downloaded node_modules to {directory}") - - except Exception as e: - self.logging.error(f"npm install in container failed: {e}") - raise RuntimeError(f"Failed to install Node.js dependencies: {e}") - elif os.path.exists(node_modules): - self.logging.info(f"Node.js dependencies already installed in {directory}") - - # Ensure esbuild is available even for cached installations - esbuild_path = os.path.join(node_modules, "esbuild") - if not os.path.exists(esbuild_path): - self.logging.info("Installing esbuild for custom build script...") - cli = self._get_cli() - container_path = f"/tmp/npm_install/{os.path.basename(directory)}" - - try: - cli.upload_package(directory, container_path) - cli.execute(f"cd {container_path} && npm install --save-dev esbuild") - - # Download node_modules back - import tarfile - import io - bits, stat = cli.docker_instance.get_archive(f"{container_path}/node_modules") - file_obj = io.BytesIO() - for chunk in bits: - file_obj.write(chunk) - file_obj.seek(0) - with tarfile.open(fileobj=file_obj) as tar: - tar.extractall(directory) - - self.logging.info("esbuild installed successfully") - except Exception as e: - self.logging.warning(f"Failed to install esbuild: {e}") - - elif language_name == "python": - - requirements_file = os.path.join(directory, "requirements.txt") - if os.path.exists(f"{requirements_file}.{language_version}"): - src = f"{requirements_file}.{language_version}" - dest = requirements_file - shutil.move(src, dest) - self.logging.info(f"move {src} to {dest}") - - - - # move function_cloudflare.py into function.py - function_cloudflare_file = os.path.join(directory, "function_cloudflare.py") - if os.path.exists(function_cloudflare_file): - src = function_cloudflare_file - dest = os.path.join(directory, "function.py") - shutil.move(src, dest) - self.logging.info(f"move {src} to {dest}") - - if os.path.exists(requirements_file): - with open(requirements_file, 'r') as reqf: - reqtext = reqf.read() - supported_pkg = \ -['affine', 'aiohappyeyeballs', 'aiohttp', 'aiosignal', 'altair', 'annotated-types',\ -'anyio', 'apsw', 'argon2-cffi', 'argon2-cffi-bindings', 'asciitree', 'astropy', 'astropy_iers_data',\ -'asttokens', 'async-timeout', 'atomicwrites', 'attrs', 'audioop-lts', 'autograd', 'awkward-cpp', 'b2d',\ -'bcrypt', 'beautifulsoup4', 'bilby.cython', 'biopython', 'bitarray', 'bitstring', 'bleach', 'blosc2', 'bokeh',\ -'boost-histogram', 'brotli', 'cachetools', 'casadi', 'cbor-diag', 'certifi', 'cffi', 'cffi_example', 'cftime',\ -'charset-normalizer', 'clarabel', 'click', 'cligj', 'clingo', 'cloudpickle', 'cmyt', 'cobs', 'colorspacious',\ -'contourpy', 'coolprop', 'coverage', 'cramjam', 'crc32c', 'cryptography', 'css-inline', 'cssselect', 'cvxpy-base', 'cycler',\ -'cysignals', 'cytoolz', 'decorator', 'demes', 'deprecation', 'diskcache', 'distlib', 'distro', 'docutils', 'donfig',\ -'ewah_bool_utils', 'exceptiongroup', 'executing', 'fastapi', 'fastcan', 'fastparquet', 'fiona', 'fonttools', 'freesasa',\ -'frozenlist', 'fsspec', 'future', 'galpy', 'gmpy2', 'gsw', 'h11', 'h3', 'h5py', 'highspy', 'html5lib', 'httpcore',\ -'httpx', 'idna', 'igraph', 'imageio', 'imgui-bundle', 'iminuit', 'iniconfig', 'inspice', 'ipython', 'jedi', 'Jinja2',\ -'jiter', 'joblib', 'jsonpatch', 'jsonpointer', 'jsonschema', 'jsonschema_specifications', 'kiwisolver',\ -'lakers-python', 'lazy_loader', 'lazy-object-proxy', 'libcst', 'lightgbm', 'logbook', 'lxml', 'lz4', 'MarkupSafe',\ -'matplotlib', 'matplotlib-inline', 'memory-allocator', 'micropip', 'mmh3', 'more-itertools', 'mpmath',\ -'msgpack', 'msgspec', 'msprime', 'multidict', 'munch', 'mypy', 'narwhals', 'ndindex', 'netcdf4', 'networkx',\ -'newick', 'nh3', 'nlopt', 'nltk', 'numcodecs', 'numpy', 'openai', 'opencv-python', 'optlang', 'orjson',\ -'packaging', 'pandas', 'parso', 'patsy', 'pcodec', 'peewee', 'pi-heif', 'Pillow', 'pillow-heif', 'pkgconfig',\ -'platformdirs', 'pluggy', 'ply', 'pplpy', 'primecountpy', 'prompt_toolkit', 'propcache', 'protobuf', 'pure-eval',\ -'py', 'pyclipper', 'pycparser', 'pycryptodome', 'pydantic', 'pydantic_core', 'pyerfa', 'pygame-ce', 'Pygments',\ -'pyheif', 'pyiceberg', 'pyinstrument', 'pylimer-tools', 'PyMuPDF', 'pynacl', 'pyodide-http', 'pyodide-unix-timezones',\ -'pyparsing', 'pyrsistent', 'pysam', 'pyshp', 'pytaglib', 'pytest', 'pytest-asyncio', 'pytest-benchmark', 'pytest_httpx',\ -'python-calamine', 'python-dateutil', 'python-flint', 'python-magic', 'python-sat', 'python-solvespace', 'pytz', 'pywavelets',\ -'pyxel', 'pyxirr', 'pyyaml', 'rasterio', 'rateslib', 'rebound', 'reboundx', 'referencing', 'regex', 'requests',\ -'retrying', 'rich', 'river', 'RobotRaconteur', 'rpds-py', 'ruamel.yaml', 'rustworkx', 'scikit-image', 'scikit-learn',\ -'scipy', 'screed', 'setuptools', 'shapely', 'simplejson', 'sisl', 'six', 'smart-open', 'sniffio', 'sortedcontainers',\ -'soundfile', 'soupsieve', 'sourmash', 'soxr', 'sparseqr', 'sqlalchemy', 'stack-data', 'starlette', 'statsmodels', 'strictyaml',\ -'svgwrite', 'swiglpk', 'sympy', 'tblib', 'termcolor', 'texttable', 'texture2ddecoder', 'threadpoolctl', 'tiktoken', 'tomli',\ -'tomli-w', 'toolz', 'tqdm', 'traitlets', 'traits', 'tree-sitter', 'tree-sitter-go', 'tree-sitter-java', 'tree-sitter-python',\ -'tskit', 'typing-extensions', 'tzdata', 'ujson', 'uncertainties', 'unyt', 'urllib3', 'vega-datasets', 'vrplib', 'wcwidth',\ -'webencodings', 'wordcloud', 'wrapt', 'xarray', 'xgboost', 'xlrd', 'xxhash', 'xyzservices', 'yarl', 'yt', 'zengl', 'zfpy', 'zstandard'] - needed_pkg = [] - for pkg in supported_pkg: - if pkg.lower() in reqtext.lower(): - needed_pkg.append(pkg) - - project_file = os.path.join(directory, "pyproject.toml") - depstr = str(needed_pkg).replace("\'", "\"") - with open(project_file, 'w') as pf: - pf.write(f""" -[project] -name = "{benchmark.replace(".", "-")}-python-{language_version.replace(".", "")}" -version = "0.1.0" -description = "dummy description" -requires-python = ">={language_version}" -dependencies = {depstr} - -[dependency-groups] -dev = [ - "workers-py", - "workers-runtime-sdk" -] - """) - # move into function dir - funcdir = os.path.join(directory, "function") - if not os.path.exists(funcdir): - os.makedirs(funcdir) - - dont_move = ["handler.py", "function", "python_modules", "pyproject.toml"] - for thing in os.listdir(directory): - if thing not in dont_move: - src = os.path.join(directory, thing) - dest = os.path.join(directory, "function", thing) - shutil.move(src, dest) - self.logging.info(f"move {src} to {dest}") - - # Create package structure - CONFIG_FILES = { - "nodejs": ["handler.js", "package.json", "node_modules"], - "python": ["handler.py", "requirements.txt", "python_modules"], - } - - if language_name not in CONFIG_FILES: - raise NotImplementedError( - f"Language {language_name} is not yet supported for Cloudflare Workers" - ) - - # Verify the handler exists - handler_file = "handler.js" if language_name == "nodejs" else "handler.py" - package_path = os.path.join(directory, handler_file) - - if not os.path.exists(package_path): - if not os.path.exists(directory): - raise RuntimeError( - f"Package directory {directory} does not exist. " - "The benchmark build process may have failed to create the deployment package." - ) - raise RuntimeError( - f"Handler file {handler_file} not found in {directory}. " - f"Available files: {', '.join(os.listdir(directory)) if os.path.exists(directory) else 'none'}" - ) - - # Calculate total size of the package directory - total_size = 0 - for dirpath, dirnames, filenames in os.walk(directory): - for filename in filenames: - filepath = os.path.join(dirpath, filename) - total_size += os.path.getsize(filepath) - - mbytes = total_size / 1024.0 / 1024.0 - self.logging.info(f"Worker package size: {mbytes:.2f} MB (Python: missing vendored modules)") + worker_name: str, + package_dir: str, + language: str, + account_id: str, + benchmark_name: Optional[str] = None, + code_package: Optional[Benchmark] = None, + container_deployment: bool = False, + container_uri: str = "", + ) -> str: + """ + Generate wrangler.toml by delegating to the appropriate deployment handler. - return (directory, total_size, "") + Args: + worker_name: Name of the worker + package_dir: Directory containing the worker code + language: Programming language (nodejs or python) + account_id: Cloudflare account ID + benchmark_name: Optional benchmark name for R2 file path prefix + code_package: Optional benchmark package for nosql configuration + container_deployment: Whether this is a container deployment + container_uri: Container image URI/tag - def _package_code_container( - self, - directory: str, - language_name: str, - language_version: str, - architecture: str, - benchmark: str, - ) -> Tuple[str, int, str]: - """ - Package code for Cloudflare container worker deployment. - - Builds a Docker image and returns the image tag for deployment. + Returns: + Path to the generated wrangler.toml file """ - self.logging.info(f"Packaging container for {language_name} {language_version}") - - # Get wrapper directory for container files - wrapper_base = os.path.join( - os.path.dirname(__file__), "..", "..", "benchmarks", "wrappers", "cloudflare" + handler = self._get_deployment_handler(container_deployment) + return handler.generate_wrangler_toml( + worker_name, package_dir, language, account_id, + benchmark_name, code_package, container_uri ) - wrapper_container_dir = os.path.join(wrapper_base, language_name, "container") - - if not os.path.exists(wrapper_container_dir): - raise RuntimeError( - f"Container wrapper directory not found: {wrapper_container_dir}" - ) - - # Copy container wrapper files to the package directory - # Copy Dockerfile from dockerfiles/cloudflare/{language}/ - dockerfile_src = os.path.join( - os.path.dirname(__file__), - "..", - "..", - "dockerfiles", - "cloudflare", - language_name, - "Dockerfile" - ) - dockerfile_dest = os.path.join(directory, "Dockerfile") - if os.path.exists(dockerfile_src): - # Read Dockerfile and update BASE_IMAGE based on language version - with open(dockerfile_src, 'r') as f: - dockerfile_content = f.read() - - # Get base image from systems.json for container deployments - container_images = self.system_config.benchmark_container_images( - "cloudflare", language_name, architecture - ) - base_image = container_images.get(language_version) - if not base_image: - raise RuntimeError( - f"No container base image found in systems.json for {language_name} {language_version} on {architecture}" - ) - - # Replace BASE_IMAGE default value in ARG line - import re - dockerfile_content = re.sub( - r'ARG BASE_IMAGE=.*', - f'ARG BASE_IMAGE={base_image}', - dockerfile_content - ) - - # Write modified Dockerfile - with open(dockerfile_dest, 'w') as f: - f.write(dockerfile_content) - - self.logging.info(f"Copied Dockerfile from {dockerfile_src}") - else: - raise RuntimeError(f"Dockerfile not found at {dockerfile_src}") - - # Copy handler and utility files from wrapper/container - # Note: ALL containers use worker.js for orchestration (@cloudflare/containers is Node.js only) - # The handler inside the container can be Python or Node.js - container_files = ["handler.py" if language_name == "python" else "handler.js"] - - # For worker.js orchestration file, always use the nodejs version - nodejs_wrapper_dir = os.path.join(wrapper_base, "nodejs", "container") - worker_js_src = os.path.join(nodejs_wrapper_dir, "worker.js") - worker_js_dest = os.path.join(directory, "worker.js") - if os.path.exists(worker_js_src): - shutil.copy2(worker_js_src, worker_js_dest) - self.logging.info(f"Copied worker.js orchestration file from nodejs/container") - - # Copy storage and nosql utilities from language-specific wrapper - if language_name == "nodejs": - container_files.extend(["storage.js", "nosql.js"]) - else: - container_files.extend(["storage.py", "nosql.py"]) - - for file in container_files: - src = os.path.join(wrapper_container_dir, file) - dest = os.path.join(directory, file) - if os.path.exists(src): - shutil.copy2(src, dest) - self.logging.info(f"Copied container file: {file}") - - # Check if benchmark has init.sh and copy it (needed for some benchmarks like video-processing) - # Look in both the benchmark root and the language-specific directory - from sebs.utils import find_benchmark - benchmark_path = find_benchmark(benchmark, "benchmarks") - if benchmark_path: - paths = [ - benchmark_path, - os.path.join(benchmark_path, language_name), - ] - for path in paths: - init_sh = os.path.join(path, "init.sh") - if os.path.exists(init_sh): - shutil.copy2(init_sh, os.path.join(directory, "init.sh")) - self.logging.info(f"Copied init.sh from {path} for container build") - break - - # For Python containers, fix relative imports in benchmark code - # Containers use flat structure, so "from . import storage" must become "import storage" - if language_name == "python": - for item in os.listdir(directory): - if item.endswith('.py') and item not in ['handler.py', 'storage.py', 'nosql.py', 'worker.py']: - filepath = os.path.join(directory, item) - with open(filepath, 'r') as f: - content = f.read() - - # Replace relative imports with absolute imports - modified = False - if 'from . import storage' in content: - content = content.replace('from . import storage', 'import storage') - modified = True - if 'from . import nosql' in content: - content = content.replace('from . import nosql', 'import nosql') - modified = True - - if modified: - with open(filepath, 'w') as f: - f.write(content) - self.logging.info(f"Fixed relative imports in {item}") - - # For Node.js containers, transform benchmark code to be async-compatible - # The container wrapper uses async HTTP calls, but benchmarks expect sync - elif language_name == "nodejs": - import re - for item in os.listdir(directory): - if item.endswith('.js') and item not in ['handler.js', 'storage.js', 'nosql.js', 'worker.js', 'build.js', 'request-polyfill.js']: - filepath = os.path.join(directory, item) - with open(filepath, 'r') as f: - content = f.read() - - # Only transform if file uses nosqlClient - if 'nosqlClient' not in content: - continue - - self.logging.info(f"Transforming {item} for async nosql...") - - # Step 1: Add await before nosqlClient method calls - content = re.sub( - r'(\s*)((?:const|let|var)\s+\w+\s*=\s*)?nosqlClient\.(insert|get|update|query|delete)\s*\(', - r'\1\2await nosqlClient.\3(', - content - ) - - # Step 2: Make all function declarations async - content = re.sub(r'^(\s*)function\s+(\w+)\s*\(', r'\1async function \2(', content, flags=re.MULTILINE) - - # Step 3: Add await before user-defined function calls - lines = content.split('\n') - transformed_lines = [] - control_flow = {'if', 'for', 'while', 'switch', 'catch', 'return'} - builtins = {'console', 'require', 'push', 'join', 'split', 'map', 'filter', - 'reduce', 'forEach', 'find', 'findIndex', 'some', 'every', - 'includes', 'parseInt', 'parseFloat', 'isNaN', 'Array', - 'Object', 'String', 'Number', 'Boolean', 'Math', 'JSON', - 'Date', 'RegExp', 'Error', 'Promise'} - - for line in lines: - # Skip function declarations - if re.search(r'\bfunction\s+\w+\s*\(', line) or re.search(r'=\s*(async\s+)?function\s*\(', line): - transformed_lines.append(line) - continue - - # Add await before likely user-defined function calls - def replacer(match): - prefix = match.group(1) - assignment = match.group(2) or '' - func_name = match.group(3) - - if func_name in control_flow or func_name in builtins: - return match.group(0) - - return f"{prefix}{assignment}await {func_name}(" - - line = re.sub( - r'(^|\s+|;|,|\()((?:const|let|var)\s+\w+\s*=\s*)?(\w+)\s*\(', - replacer, - line - ) - transformed_lines.append(line) - - content = '\n'.join(transformed_lines) - - with open(filepath, 'w') as f: - f.write(content) - self.logging.info(f"Transformed {item} for async nosql") - - # Install dependencies for container orchestration - # ALL containers need @cloudflare/containers for worker.js orchestration - worker_package_json = { - "name": f"{benchmark}-worker", - "version": "1.0.0", - "dependencies": { - "@cloudflare/containers": "*" - } - } - - if language_name == "nodejs": - # Read the benchmark's package.json if it exists and merge dependencies - benchmark_package_file = os.path.join(directory, "package.json") - if os.path.exists(benchmark_package_file): - with open(benchmark_package_file, 'r') as f: - benchmark_package = json.load(f) - # Merge benchmark dependencies with worker dependencies - if "dependencies" in benchmark_package: - worker_package_json["dependencies"].update(benchmark_package["dependencies"]) - - # Write the combined package.json - with open(benchmark_package_file, 'w') as f: - json.dump(worker_package_json, f, indent=2) - else: # Python containers also need package.json for worker.js orchestration - # Create package.json just for @cloudflare/containers (Python code in container) - package_json_path = os.path.join(directory, "package.json") - with open(package_json_path, 'w') as f: - json.dump(worker_package_json, f, indent=2) - self.logging.info("Created package.json for Python container worker.js orchestration") - - # Install Node.js dependencies (needed for all containers for worker.js) - self.logging.info(f"Installing @cloudflare/containers for worker.js orchestration in {directory}") - # Use CLI container for npm install - no Node.js/npm needed on host - cli = self._get_cli() - container_path = f"/tmp/container_npm/{os.path.basename(directory)}" - - try: - # Upload package directory to container - cli.upload_package(directory, container_path) - - # Install production dependencies - output = cli.execute(f"cd {container_path} && npm install --production") - self.logging.info("npm install completed successfully") - self.logging.debug(f"npm output: {output.decode('utf-8')}") - - # Download node_modules back to host - import tarfile - import io - bits, stat = cli.docker_instance.get_archive(f"{container_path}/node_modules") - file_obj = io.BytesIO() - for chunk in bits: - file_obj.write(chunk) - file_obj.seek(0) - with tarfile.open(fileobj=file_obj) as tar: - tar.extractall(directory) - - self.logging.info(f"Downloaded node_modules to {directory}") - except Exception as e: - self.logging.error(f"npm install failed: {e}") - raise RuntimeError(f"Failed to install Node.js dependencies: {e}") - - # For Python containers, also handle Python requirements - if language_name == "python": - # Python requirements will be installed in the Dockerfile - # Rename version-specific requirements.txt to requirements.txt - requirements_file = os.path.join(directory, "requirements.txt") - versioned_requirements = os.path.join(directory, f"requirements.txt.{language_version}") - - if os.path.exists(versioned_requirements): - shutil.copy2(versioned_requirements, requirements_file) - self.logging.info(f"Copied requirements.txt.{language_version} to requirements.txt") - - # Fix torch wheel URLs for container compatibility - # Replace direct wheel URLs with proper torch installation - with open(requirements_file, 'r') as f: - content = f.read() - - # Replace torch wheel URLs with proper installation commands - import re - modified = False - if 'download.pytorch.org/whl' in content: - # Remove direct wheel URLs and replace with proper torch installation - lines = content.split('\n') - new_lines = [] - for line in lines: - if 'download.pytorch.org/whl/cpu/torch-' in line: - # Extract version from URL (e.g., torch-2.0.0+cpu) - match = re.search(r'torch-([0-9.]+)(?:%2B|\+)cpu', line) - if match: - version = match.group(1) - # Use index-url method instead of direct wheel - new_lines.append(f'torch=={version}') - modified = True - else: - new_lines.append(line) - else: - new_lines.append(line) - - if modified: - # Add extra-index-url at the top for CPU-only torch - content = '--extra-index-url https://download.pytorch.org/whl/cpu\n' + '\n'.join(new_lines) - with open(requirements_file, 'w') as f: - f.write(content) - self.logging.info("Modified requirements.txt to use torch index-url instead of direct wheels") - - elif not os.path.exists(requirements_file): - # Create empty requirements.txt if none exists - with open(requirements_file, 'w') as f: - f.write("") - self.logging.info("Created empty requirements.txt") - - # Build Docker image locally for cache compatibility - # wrangler will re-build/push during deployment from the Dockerfile - image_tag = self._build_container_image_local(directory, benchmark, language_name, language_version) - - # Calculate package size (approximate, as it's a source directory) - total_size = 0 - for dirpath, dirnames, filenames in os.walk(directory): - for filename in filenames: - filepath = os.path.join(dirpath, filename) - total_size += os.path.getsize(filepath) - - self.logging.info(f"Container package prepared with local image: {image_tag}") - - # Return local image tag (wrangler will rebuild from Dockerfile during deploy) - return (directory, total_size, image_tag) - - def _build_container_image_local( - self, - directory: str, - benchmark: str, - language_name: str, - language_version: str, - ) -> str: - """ - Build a Docker image locally for cache purposes. - wrangler will rebuild from Dockerfile during deployment. - - Returns the local image tag. - """ - # Generate image tag - image_name = f"{benchmark.replace('.', '-')}-{language_name}-{language_version.replace('.', '')}" - image_tag = f"{image_name}:latest" - - self.logging.info(f"Building local container image: {image_tag}") - - try: - # Build the Docker image using docker-py - # nocache=True ensures handler changes are picked up - _, build_logs = self.docker_client.images.build( - path=directory, - tag=image_tag, - nocache=True, - rm=True - ) - - # Log build output - for log in build_logs: - if 'stream' in log: - self.logging.debug(log['stream'].strip()) - elif 'error' in log: - self.logging.error(log['error'].strip()) - - self.logging.info(f"Local container image built: {image_tag}") - - return image_tag - - except docker.errors.BuildError as e: - error_msg = f"Docker build failed for {image_tag}: {e}" - self.logging.error(error_msg) - raise RuntimeError(error_msg) - except Exception as e: - error_msg = f"Unexpected error building Docker image {image_tag}: {e}" - self.logging.error(error_msg) - raise RuntimeError(error_msg) def create_function( self, @@ -1097,8 +396,9 @@ def _create_or_update_worker( env['CLOUDFLARE_ACCOUNT_ID'] = account_id - # Get CLI container instance - cli = self._get_cli() + # Get CLI container instance from appropriate deployment handler + handler = self._get_deployment_handler(container_deployment) + cli = handler._get_cli() # Upload package directory to container container_package_path = f"/tmp/workers/{worker_name}" @@ -1122,7 +422,11 @@ def _create_or_update_worker( # The container binding needs time to propagate before first invocation if container_deployment: self.logging.info("Waiting for container Durable Object to initialize...") - self._wait_for_durable_object_ready(worker_name, package_dir, env) + account_id = env.get('CLOUDFLARE_ACCOUNT_ID') + worker_url = self._build_workers_dev_url(worker_name, account_id) + self._containers_deployment.wait_for_durable_object_ready( + worker_name, worker_url + ) # The container binding needs time to propagate before first invocation if container_deployment: @@ -1136,69 +440,6 @@ def _create_or_update_worker( self.logging.error(error_msg) raise RuntimeError(error_msg) - def _wait_for_durable_object_ready(self, worker_name: str, package_dir: str, env: dict): - """Wait for container Durable Object to be fully provisioned and ready.""" - max_wait_seconds = 400 - wait_interval = 10 - start_time = time.time() - - account_id = env.get('CLOUDFLARE_ACCOUNT_ID') - worker_url = self._build_workers_dev_url(worker_name, account_id) - - self.logging.info("Checking container Durable Object readiness via health endpoint...") - - consecutive_failures = 0 - max_consecutive_failures = 5 - - while time.time() - start_time < max_wait_seconds: - try: - # Use health check endpoint - response = requests.get( - f"{worker_url}/health", - timeout=60 - ) - - # 200 = ready - if response.status_code == 200: - self.logging.info("Container Durable Object is ready!") - return True - - # 503 = not ready yet (expected, keep waiting) - elif response.status_code == 503: - elapsed = int(time.time() - start_time) - try: - error_data = response.json() - error_msg = error_data.get('error', 'Container provisioning') - self.logging.info(f"{error_msg}... ({elapsed}s elapsed)") - except: - self.logging.info(f"Container provisioning... ({elapsed}s elapsed)") - consecutive_failures = 0 # This is expected - - # 500 or other = something's wrong - else: - consecutive_failures += 1 - self.logging.warning(f"Unexpected status {response.status_code}: {response.text[:200]}") - - # If we get too many unexpected errors, something might be broken - if consecutive_failures >= max_consecutive_failures: - self.logging.error(f"Got {consecutive_failures} consecutive errors, container may be broken") - return False - - except requests.exceptions.Timeout: - elapsed = int(time.time() - start_time) - self.logging.info(f"Health check timeout (container may be starting)... ({elapsed}s elapsed)") - except requests.exceptions.RequestException as e: - elapsed = int(time.time() - start_time) - self.logging.debug(f"Connection error ({elapsed}s): {str(e)[:100]}") - - time.sleep(wait_interval) - - self.logging.warning( - f"Container Durable Object may not be fully ready after {max_wait_seconds}s. " - "First invocation may still experience initialization delay." - ) - return False - def _get_workers_dev_subdomain(self, account_id: str) -> Optional[str]: """Fetch the workers.dev subdomain for the given account. @@ -1561,7 +802,7 @@ def shutdown(self) -> None: """ Shutdown the Cloudflare system. - Saves configuration to cache and shuts down CLI container. + Saves configuration to cache and shuts down deployment handler CLI containers. """ try: self.cache_client.lock() @@ -1569,7 +810,6 @@ def shutdown(self) -> None: finally: self.cache_client.unlock() - # Shutdown CLI container if it was initialized - if self._cli is not None: - self._cli.shutdown() - self._cli = None + # Shutdown deployment handler CLI containers + self._workers_deployment.shutdown() + self._containers_deployment.shutdown() diff --git a/sebs/cloudflare/containers.py b/sebs/cloudflare/containers.py new file mode 100644 index 000000000..842679adc --- /dev/null +++ b/sebs/cloudflare/containers.py @@ -0,0 +1,547 @@ +""" +Cloudflare Container Workers deployment implementation. + +Handles packaging, Docker image building, and deployment of containerized +Cloudflare Workers using @cloudflare/containers. +""" + +import os +import shutil +import json +import io +import re +import time +import tarfile +from typing import Optional, Tuple + +import docker +import requests + +from sebs.benchmark import Benchmark +from sebs.cloudflare.cli import CloudflareCLI + + +class CloudflareContainersDeployment: + """Handles Cloudflare container worker deployment operations.""" + + def __init__(self, logging, system_config, docker_client, system_resources): + """ + Initialize CloudflareContainersDeployment. + + Args: + logging: Logger instance + system_config: System configuration + docker_client: Docker client instance + system_resources: System resources manager + """ + self.logging = logging + self.system_config = system_config + self.docker_client = docker_client + self.system_resources = system_resources + self._cli: Optional[CloudflareCLI] = None + + def _get_cli(self) -> CloudflareCLI: + """Get or initialize the Cloudflare CLI container.""" + if self._cli is None: + self._cli = CloudflareCLI(self.system_config, self.docker_client) + # Verify wrangler is available + version = self._cli.check_wrangler_version() + self.logging.info(f"Cloudflare CLI container ready: {version}") + return self._cli + + def generate_wrangler_toml( + self, + worker_name: str, + package_dir: str, + language: str, + account_id: str, + benchmark_name: Optional[str] = None, + code_package: Optional[Benchmark] = None, + container_uri: str = "", + ) -> str: + """ + Generate a wrangler.toml configuration file for container workers. + + Args: + worker_name: Name of the worker + package_dir: Directory containing the worker code + language: Programming language (nodejs or python) + account_id: Cloudflare account ID + benchmark_name: Optional benchmark name for R2 file path prefix + code_package: Optional benchmark package for nosql configuration + container_uri: Container image URI/tag + + Returns: + Path to the generated wrangler.toml file + """ + instance_type = "" + if benchmark_name and ("411.image-recognition" in benchmark_name or "311.compression" in benchmark_name or "504.dna-visualisation" in benchmark_name): + self.logging.warning("Using standard-4 instance type for high resource benchmark") + instance_type = '\ninstance_type = "standard-4" # 20GB Disk, 12GB Memory\n' + + toml_content = f"""name = "{worker_name}" +main = "worker.js" +compatibility_date = "2025-11-18" +account_id = "{account_id}" +compatibility_flags = ["nodejs_compat"] + +[observability] +enabled = true + +[[containers]] +max_instances = 10 +class_name = "ContainerWorker" +image = "./Dockerfile"{instance_type} + +# Durable Object binding for Container class (required by @cloudflare/containers) +[[durable_objects.bindings]] +name = "CONTAINER_WORKER" +class_name = "ContainerWorker" + +""" + # Add nosql table bindings if benchmark uses them + if code_package and code_package.uses_nosql: + # Get registered nosql tables for this benchmark + nosql_storage = self.system_resources.get_nosql_storage() + if nosql_storage.retrieve_cache(benchmark_name): + nosql_tables = nosql_storage._tables.get(benchmark_name, {}) + for table_name in nosql_tables.keys(): + toml_content += f"""# Durable Object binding for NoSQL table: {table_name} +[[durable_objects.bindings]] +name = "{table_name.upper()}" +class_name = "KVApiObject" + +""" + + # Add migrations for both ContainerWorker and KVApiObject + # Both need new_sqlite_classes (Container requires SQLite DO backend) + toml_content += """[[migrations]] +tag = "v1" +new_sqlite_classes = ["ContainerWorker", "KVApiObject"] + +""" + else: + # Container without nosql - only ContainerWorker migration + toml_content += """[[migrations]] +tag = "v1" +new_sqlite_classes = ["ContainerWorker"] + +""" + + # Add environment variables + vars_content = "" + if benchmark_name: + vars_content += f'BENCHMARK_NAME = "{benchmark_name}"\n' + + # Add nosql configuration if benchmark uses it + if code_package and code_package.uses_nosql: + vars_content += 'NOSQL_STORAGE_DATABASE = "durable_objects"\n' + + if vars_content: + toml_content += f"""# Environment variables +[vars] +{vars_content} +""" + + # Add R2 bucket binding for benchmarking files + r2_bucket_configured = False + try: + from sebs.faas.config import Resources + storage = self.system_resources.get_storage() + bucket_name = storage.get_bucket(Resources.StorageBucketType.BENCHMARKS) + if bucket_name: + toml_content += f"""# R2 bucket binding for benchmarking files +# This bucket is used by fs and path polyfills to read benchmark data +[[r2_buckets]] +binding = "R2" +bucket_name = "{bucket_name}" + +""" + r2_bucket_configured = True + self.logging.info(f"R2 bucket '{bucket_name}' will be bound to worker as 'R2'") + except Exception as e: + self.logging.warning( + f"R2 bucket binding not configured: {e}. " + f"Benchmarks requiring file access will not work properly." + ) + + # Write wrangler.toml to package directory + toml_path = os.path.join(package_dir, "wrangler.toml") + with open(toml_path, 'w') as f: + f.write(toml_content) + + self.logging.info(f"Generated wrangler.toml at {toml_path}") + return toml_path + + def package_code( + self, + directory: str, + language_name: str, + language_version: str, + architecture: str, + benchmark: str, + ) -> Tuple[str, int, str]: + """ + Package code for Cloudflare container worker deployment. + + Builds a Docker image and returns the image tag for deployment. + + Args: + directory: Path to the code directory + language_name: Programming language name + language_version: Programming language version + architecture: Target architecture + benchmark: Benchmark name + + Returns: + Tuple of (package_path, package_size, container_uri) + """ + self.logging.info(f"Packaging container for {language_name} {language_version}") + + # Get wrapper directory for container files + wrapper_base = os.path.join( + os.path.dirname(__file__), "..", "..", "benchmarks", "wrappers", "cloudflare" + ) + wrapper_container_dir = os.path.join(wrapper_base, language_name, "container") + + if not os.path.exists(wrapper_container_dir): + raise RuntimeError( + f"Container wrapper directory not found: {wrapper_container_dir}" + ) + + # Copy container wrapper files to the package directory + # Copy Dockerfile from dockerfiles/cloudflare/{language}/ + dockerfile_src = os.path.join( + os.path.dirname(__file__), + "..", + "..", + "dockerfiles", + "cloudflare", + language_name, + "Dockerfile" + ) + dockerfile_dest = os.path.join(directory, "Dockerfile") + if os.path.exists(dockerfile_src): + # Read Dockerfile and update BASE_IMAGE based on language version + with open(dockerfile_src, 'r') as f: + dockerfile_content = f.read() + + # Get base image from systems.json for container deployments + container_images = self.system_config.benchmark_container_images( + "cloudflare", language_name, architecture + ) + base_image = container_images.get(language_version) + if not base_image: + raise RuntimeError( + f"No container base image found in systems.json for {language_name} {language_version} on {architecture}" + ) + + # Replace BASE_IMAGE default value in ARG line + dockerfile_content = re.sub( + r'ARG BASE_IMAGE=.*', + f'ARG BASE_IMAGE={base_image}', + dockerfile_content + ) + + # Write modified Dockerfile + with open(dockerfile_dest, 'w') as f: + f.write(dockerfile_content) + + self.logging.info(f"Copied Dockerfile from {dockerfile_src}") + else: + raise RuntimeError(f"Dockerfile not found at {dockerfile_src}") + + # Copy handler and utility files from wrapper/container + # Note: ALL containers use worker.js for orchestration (@cloudflare/containers is Node.js only) + # The handler inside the container can be Python or Node.js + container_files = ["handler.py" if language_name == "python" else "handler.js"] + + # For worker.js orchestration file, always use the nodejs version + nodejs_wrapper_dir = os.path.join(wrapper_base, "nodejs", "container") + worker_js_src = os.path.join(nodejs_wrapper_dir, "worker.js") + worker_js_dest = os.path.join(directory, "worker.js") + if os.path.exists(worker_js_src): + shutil.copy2(worker_js_src, worker_js_dest) + self.logging.info(f"Copied worker.js orchestration file from nodejs/container") + + # Copy storage and nosql utilities from language-specific wrapper + if language_name == "nodejs": + container_files.extend(["storage.js", "nosql.js"]) + else: + container_files.extend(["storage.py", "nosql.py"]) + + for file in container_files: + src = os.path.join(wrapper_container_dir, file) + dest = os.path.join(directory, file) + if os.path.exists(src): + shutil.copy2(src, dest) + self.logging.info(f"Copied container file: {file}") + + # Check if benchmark has init.sh and copy it (needed for some benchmarks like video-processing) + # Look in both the benchmark root and the language-specific directory + from sebs.utils import find_benchmark + benchmark_path = find_benchmark(benchmark, "benchmarks") + if benchmark_path: + paths = [ + benchmark_path, + os.path.join(benchmark_path, language_name), + ] + for path in paths: + init_sh = os.path.join(path, "init.sh") + if os.path.exists(init_sh): + shutil.copy2(init_sh, os.path.join(directory, "init.sh")) + self.logging.info(f"Copied init.sh from {path}") + break + + # For Python containers, fix relative imports in benchmark code + # Containers use flat structure, so "from . import storage" must become "import storage" + if language_name == "python": + for item in os.listdir(directory): + if item.endswith('.py') and item not in ['handler.py', 'storage.py', 'nosql.py', 'worker.py']: + file_path = os.path.join(directory, item) + with open(file_path, 'r') as f: + content = f.read() + # Fix relative imports + content = re.sub(r'from \. import ', 'import ', content) + with open(file_path, 'w') as f: + f.write(content) + + # For Node.js containers, transform benchmark code to be async-compatible + # The container wrapper uses async HTTP calls, but benchmarks expect sync + elif language_name == "nodejs": + for item in os.listdir(directory): + if item.endswith('.js') and item not in ['handler.js', 'storage.js', 'nosql.js', 'worker.js', 'build.js', 'request-polyfill.js']: + file_path = os.path.join(directory, item) + # Could add transformations here if needed + pass + + # Prepare package.json for container orchestration + # ALL containers need @cloudflare/containers for worker.js orchestration + worker_package_json = { + "name": f"{benchmark}-worker", + "version": "1.0.0", + "dependencies": { + "@cloudflare/containers": "*" + } + } + + if language_name == "nodejs": + # Read the benchmark's package.json if it exists and merge dependencies + benchmark_package_file = os.path.join(directory, "package.json") + if os.path.exists(benchmark_package_file): + with open(benchmark_package_file, 'r') as f: + benchmark_package = json.load(f) + # Merge dependencies + if "dependencies" in benchmark_package: + worker_package_json["dependencies"].update(benchmark_package["dependencies"]) + + # Write the combined package.json + with open(benchmark_package_file, 'w') as f: + json.dump(worker_package_json, f, indent=2) + else: # Python containers also need package.json for worker.js orchestration + # Create package.json just for @cloudflare/containers (Python code in container) + package_json_path = os.path.join(directory, "package.json") + with open(package_json_path, 'w') as f: + json.dump(worker_package_json, f, indent=2) + + # Install Node.js dependencies for wrangler deployment + # Note: These are needed for wrangler to bundle worker.js, not for the container + # The container also installs them during Docker build + self.logging.info(f"Installing Node.js dependencies for wrangler deployment in {directory}") + cli = self._get_cli() + container_path = f"/tmp/container_npm/{os.path.basename(directory)}" + + try: + # Upload package directory to CLI container + cli.upload_package(directory, container_path) + + # Install production dependencies + output = cli.execute(f"cd {container_path} && npm install --production") + self.logging.info("npm install completed successfully") + self.logging.debug(f"npm output: {output.decode('utf-8')}") + + # Download node_modules back to host for wrangler + bits, stat = cli.docker_instance.get_archive(f"{container_path}/node_modules") + file_obj = io.BytesIO() + for chunk in bits: + file_obj.write(chunk) + file_obj.seek(0) + with tarfile.open(fileobj=file_obj) as tar: + tar.extractall(directory) + + self.logging.info(f"Downloaded node_modules to {directory} for wrangler deployment") + except Exception as e: + self.logging.error(f"npm install failed: {e}") + raise RuntimeError(f"Failed to install Node.js dependencies: {e}") + + # For Python containers, also handle Python requirements + if language_name == "python": + # Python requirements will be installed in the Dockerfile + # Rename version-specific requirements.txt to requirements.txt + requirements_file = os.path.join(directory, "requirements.txt") + versioned_requirements = os.path.join(directory, f"requirements.txt.{language_version}") + + if os.path.exists(versioned_requirements): + shutil.copy2(versioned_requirements, requirements_file) + self.logging.info(f"Copied requirements.txt.{language_version} to requirements.txt") + + # Fix torch wheel URLs for container compatibility + # Replace direct wheel URLs with proper torch installation + with open(requirements_file, 'r') as f: + content = f.read() + + # Replace torch wheel URLs with proper installation commands + modified = False + if 'download.pytorch.org/whl' in content: + # Replace direct wheel URL with pip-installable torch + content = re.sub( + r'https://download\.pytorch\.org/whl/[^\s]+\.whl', + 'torch', + content + ) + modified = True + + if modified: + with open(requirements_file, 'w') as f: + f.write(content) + self.logging.info("Fixed torch URLs in requirements.txt for container compatibility") + + elif not os.path.exists(requirements_file): + # Create empty requirements.txt if none exists + with open(requirements_file, 'w') as f: + f.write("") + self.logging.info("Created empty requirements.txt") + + # Build Docker image locally for cache compatibility + # wrangler will re-build/push during deployment from the Dockerfile + image_tag = self._build_container_image_local(directory, benchmark, language_name, language_version) + + # Calculate package size (approximate, as it's a source directory) + total_size = 0 + for dirpath, dirnames, filenames in os.walk(directory): + for filename in filenames: + filepath = os.path.join(dirpath, filename) + total_size += os.path.getsize(filepath) + + self.logging.info(f"Container package prepared with local image: {image_tag}") + + # Return local image tag (wrangler will rebuild from Dockerfile during deploy) + return (directory, total_size, image_tag) + + def _build_container_image_local( + self, + directory: str, + benchmark: str, + language_name: str, + language_version: str, + ) -> str: + """ + Build a Docker image locally for cache purposes. + wrangler will rebuild from Dockerfile during deployment. + + Returns the local image tag. + """ + # Generate image tag + image_name = f"{benchmark.replace('.', '-')}-{language_name}-{language_version.replace('.', '')}" + image_tag = f"{image_name}:latest" + + self.logging.info(f"Building local container image: {image_tag}") + + try: + # Build the Docker image using docker-py + # nocache=True ensures handler changes are picked up + _, build_logs = self.docker_client.images.build( + path=directory, + tag=image_tag, + nocache=True, + rm=True + ) + + # Log build output + for log in build_logs: + if 'stream' in log: + self.logging.debug(log['stream'].strip()) + elif 'error' in log: + self.logging.error(log['error']) + + self.logging.info(f"Local container image built: {image_tag}") + + return image_tag + + except docker.errors.BuildError as e: + error_msg = f"Docker build failed for {image_tag}: {e}" + self.logging.error(error_msg) + raise RuntimeError(error_msg) + except Exception as e: + error_msg = f"Unexpected error building Docker image {image_tag}: {e}" + self.logging.error(error_msg) + raise RuntimeError(error_msg) + + def wait_for_durable_object_ready( + self, + worker_name: str, + worker_url: str, + max_wait_seconds: int = 400 + ) -> bool: + """ + Wait for container Durable Object to be fully provisioned and ready. + + Args: + worker_name: Name of the worker + worker_url: URL of the worker + max_wait_seconds: Maximum time to wait in seconds + + Returns: + True if ready, False if timeout + """ + wait_interval = 10 + start_time = time.time() + + self.logging.info("Checking container Durable Object readiness via health endpoint...") + + consecutive_failures = 0 + max_consecutive_failures = 5 + + while time.time() - start_time < max_wait_seconds: + try: + # Use health check endpoint + response = requests.get( + f"{worker_url}/health", + timeout=60 + ) + + # 200 = ready + if response.status_code == 200: + self.logging.info("Container Durable Object is ready!") + return True + # 503 = not ready yet + elif response.status_code == 503: + elapsed = int(time.time() - start_time) + self.logging.info( + f"Container Durable Object not ready yet (503 Service Unavailable)... " + f"({elapsed}s elapsed, will retry)" + ) + # Other errors + else: + self.logging.warning(f"Unexpected status {response.status_code}: {response.text[:100]}") + + except requests.exceptions.Timeout: + elapsed = int(time.time() - start_time) + self.logging.info(f"Health check timeout (container may be starting)... ({elapsed}s elapsed)") + except requests.exceptions.RequestException as e: + elapsed = int(time.time() - start_time) + self.logging.debug(f"Connection error ({elapsed}s): {str(e)[:100]}") + + time.sleep(wait_interval) + + self.logging.warning( + f"Container Durable Object may not be fully ready after {max_wait_seconds}s. " + "First invocation may still experience initialization delay." + ) + return False + + def shutdown(self): + """Shutdown CLI container if initialized.""" + if self._cli is not None: + self._cli.shutdown() + self._cli = None diff --git a/sebs/cloudflare/workers.py b/sebs/cloudflare/workers.py new file mode 100644 index 000000000..da4a5073d --- /dev/null +++ b/sebs/cloudflare/workers.py @@ -0,0 +1,376 @@ +""" +Cloudflare Workers native deployment implementation. + +Handles packaging, deployment, and management of native Cloudflare Workers +(non-container deployments using JavaScript/Python runtime). +""" + +import os +import shutil +import json +import io +import tarfile +from typing import Optional, Tuple + +from sebs.benchmark import Benchmark +from sebs.cloudflare.cli import CloudflareCLI + + +class CloudflareWorkersDeployment: + """Handles native Cloudflare Workers deployment operations.""" + + def __init__(self, logging, system_config, docker_client, system_resources): + """ + Initialize CloudflareWorkersDeployment. + + Args: + logging: Logger instance + system_config: System configuration + docker_client: Docker client instance + system_resources: System resources manager + """ + self.logging = logging + self.system_config = system_config + self.docker_client = docker_client + self.system_resources = system_resources + self._cli: Optional[CloudflareCLI] = None + + def _get_cli(self) -> CloudflareCLI: + """Get or initialize the Cloudflare CLI container.""" + if self._cli is None: + self._cli = CloudflareCLI(self.system_config, self.docker_client) + # Verify wrangler is available + version = self._cli.check_wrangler_version() + self.logging.info(f"Cloudflare CLI container ready: {version}") + return self._cli + + def generate_wrangler_toml( + self, + worker_name: str, + package_dir: str, + language: str, + account_id: str, + benchmark_name: Optional[str] = None, + code_package: Optional[Benchmark] = None, + container_uri: str = "", + ) -> str: + """ + Generate a wrangler.toml configuration file for native workers. + + Args: + worker_name: Name of the worker + package_dir: Directory containing the worker code + language: Programming language (nodejs or python) + account_id: Cloudflare account ID + benchmark_name: Optional benchmark name for R2 file path prefix + code_package: Optional benchmark package for nosql configuration + + Returns: + Path to the generated wrangler.toml file + """ + # Native worker configuration + main_file = "dist/handler.js" if language == "nodejs" else "handler.py" + + # Build wrangler.toml content + toml_content = f"""name = "{worker_name}" +main = "{main_file}" +compatibility_date = "2025-11-18" +account_id = "{account_id}" +""" + + if language == "nodejs": + toml_content += """# Use nodejs_compat for Node.js built-in support +compatibility_flags = ["nodejs_compat"] +no_bundle = true + +[build] +command = "node build.js" + +[[rules]] +type = "ESModule" +globs = ["**/*.js"] +fallthrough = true + +[[rules]] +type = "Text" +globs = ["**/*.html"] +fallthrough = true + +""" + elif language == "python": + toml_content += """# Enable Python Workers runtime +compatibility_flags = ["python_workers"] +""" + + toml_content += """ +[[durable_objects.bindings]] +name = "DURABLE_STORE" +class_name = "KVApiObject" + +[[migrations]] +tag = "v3" +new_classes = ["KVApiObject"] +""" + + # Add environment variables + vars_content = "" + if benchmark_name: + vars_content += f'BENCHMARK_NAME = "{benchmark_name}"\n' + + # Add nosql configuration if benchmark uses it + if code_package and code_package.uses_nosql: + vars_content += 'NOSQL_STORAGE_DATABASE = "durable_objects"\n' + + if vars_content: + toml_content += f"""# Environment variables +[vars] +{vars_content} +""" + + # Add R2 bucket binding for benchmarking files + r2_bucket_configured = False + try: + from sebs.faas.config import Resources + storage = self.system_resources.get_storage() + bucket_name = storage.get_bucket(Resources.StorageBucketType.BENCHMARKS) + if bucket_name: + toml_content += f"""# R2 bucket binding for benchmarking files +# This bucket is used by fs and path polyfills to read benchmark data +[[r2_buckets]] +binding = "R2" +bucket_name = "{bucket_name}" + +""" + r2_bucket_configured = True + self.logging.info(f"R2 bucket '{bucket_name}' will be bound to worker as 'R2'") + except Exception as e: + self.logging.warning( + f"R2 bucket binding not configured: {e}. " + f"Benchmarks requiring file access will not work properly." + ) + + # Write wrangler.toml to package directory + toml_path = os.path.join(package_dir, "wrangler.toml") + with open(toml_path, 'w') as f: + f.write(toml_content) + + self.logging.info(f"Generated wrangler.toml at {toml_path}") + return toml_path + + def package_code( + self, + directory: str, + language_name: str, + language_version: str, + benchmark: str, + is_cached: bool, + ) -> Tuple[str, int, str]: + """ + Package code for native Cloudflare Workers deployment. + + Args: + directory: Path to the code directory + language_name: Programming language name + language_version: Programming language version + benchmark: Benchmark name + is_cached: Whether the code is cached + + Returns: + Tuple of (package_path, package_size, container_uri) + """ + # Install dependencies + if language_name == "nodejs": + package_file = os.path.join(directory, "package.json") + node_modules = os.path.join(directory, "node_modules") + + # Only install if package.json exists and node_modules doesn't + if os.path.exists(package_file) and not os.path.exists(node_modules): + self.logging.info(f"Installing Node.js dependencies in {directory}") + # Use CLI container for npm install - no Node.js/npm needed on host + cli = self._get_cli() + container_path = f"/tmp/npm_install/{os.path.basename(directory)}" + + try: + # Upload package directory to container + cli.upload_package(directory, container_path) + + # Install production dependencies + self.logging.info("Installing npm dependencies in container...") + output = cli.npm_install(container_path) + self.logging.info("npm install completed successfully") + self.logging.debug(f"npm output: {output}") + + # Install esbuild as a dev dependency (needed by build.js) + self.logging.info("Installing esbuild for custom build script...") + cli.execute(f"cd {container_path} && npm install --save-dev esbuild") + self.logging.info("esbuild installed successfully") + + # Download node_modules back to host + bits, stat = cli.docker_instance.get_archive(f"{container_path}/node_modules") + file_obj = io.BytesIO() + for chunk in bits: + file_obj.write(chunk) + file_obj.seek(0) + with tarfile.open(fileobj=file_obj) as tar: + tar.extractall(directory) + + self.logging.info(f"Downloaded node_modules to {directory}") + + except Exception as e: + self.logging.error(f"npm install in container failed: {e}") + raise RuntimeError(f"Failed to install Node.js dependencies: {e}") + elif os.path.exists(node_modules): + self.logging.info(f"Node.js dependencies already installed in {directory}") + + # Ensure esbuild is available even for cached installations + esbuild_path = os.path.join(node_modules, "esbuild") + if not os.path.exists(esbuild_path): + self.logging.info("Installing esbuild for custom build script...") + cli = self._get_cli() + container_path = f"/tmp/npm_install/{os.path.basename(directory)}" + + try: + cli.upload_package(directory, container_path) + cli.execute(f"cd {container_path} && npm install --save-dev esbuild") + + # Download node_modules back to host + bits, stat = cli.docker_instance.get_archive(f"{container_path}/node_modules") + file_obj = io.BytesIO() + for chunk in bits: + file_obj.write(chunk) + file_obj.seek(0) + with tarfile.open(fileobj=file_obj) as tar: + tar.extractall(directory) + + self.logging.info("esbuild installed successfully") + except Exception as e: + self.logging.error(f"Failed to install esbuild: {e}") + raise RuntimeError(f"Failed to install esbuild: {e}") + + elif language_name == "python": + requirements_file = os.path.join(directory, "requirements.txt") + if os.path.exists(f"{requirements_file}.{language_version}"): + src = f"{requirements_file}.{language_version}" + dest = requirements_file + shutil.move(src, dest) + self.logging.info(f"move {src} to {dest}") + + # move function_cloudflare.py into function.py + function_cloudflare_file = os.path.join(directory, "function_cloudflare.py") + if os.path.exists(function_cloudflare_file): + src = function_cloudflare_file + dest = os.path.join(directory, "function.py") + shutil.move(src, dest) + self.logging.info(f"move {src} to {dest}") + + if os.path.exists(requirements_file): + with open(requirements_file, 'r') as reqf: + reqtext = reqf.read() + supported_pkg = \ +['affine', 'aiohappyeyeballs', 'aiohttp', 'aiosignal', 'altair', 'annotated-types',\ +'anyio', 'apsw', 'argon2-cffi', 'argon2-cffi-bindings', 'asciitree', 'astropy', 'astropy_iers_data',\ +'asttokens', 'async-timeout', 'atomicwrites', 'attrs', 'audioop-lts', 'autograd', 'awkward-cpp', 'b2d',\ +'bcrypt', 'beautifulsoup4', 'bilby.cython', 'biopython', 'bitarray', 'bitstring', 'bleach', 'blosc2', 'bokeh',\ +'boost-histogram', 'brotli', 'cachetools', 'casadi', 'cbor-diag', 'certifi', 'cffi', 'cffi_example', 'cftime',\ +'charset-normalizer', 'clarabel', 'click', 'cligj', 'clingo', 'cloudpickle', 'cmyt', 'cobs', 'colorspacious',\ +'contourpy', 'coolprop', 'coverage', 'cramjam', 'crc32c', 'cryptography', 'css-inline', 'cssselect', 'cvxpy-base', 'cycler',\ +'cysignals', 'cytoolz', 'decorator', 'demes', 'deprecation', 'diskcache', 'distlib', 'distro', 'docutils', 'donfig',\ +'ewah_bool_utils', 'exceptiongroup', 'executing', 'fastapi', 'fastcan', 'fastparquet', 'fiona', 'fonttools', 'freesasa',\ +'frozenlist', 'fsspec', 'future', 'galpy', 'gmpy2', 'gsw', 'h11', 'h3', 'h5py', 'highspy', 'html5lib', 'httpcore',\ +'httpx', 'idna', 'igraph', 'imageio', 'imgui-bundle', 'iminuit', 'iniconfig', 'inspice', 'ipython', 'jedi', 'Jinja2',\ +'jiter', 'joblib', 'jsonpatch', 'jsonpointer', 'jsonschema', 'jsonschema_specifications', 'kiwisolver',\ +'lakers-python', 'lazy_loader', 'lazy-object-proxy', 'libcst', 'lightgbm', 'logbook', 'lxml', 'lz4', 'MarkupSafe',\ +'matplotlib', 'matplotlib-inline', 'memory-allocator', 'micropip', 'mmh3', 'more-itertools', 'mpmath',\ +'msgpack', 'msgspec', 'msprime', 'multidict', 'munch', 'mypy', 'narwhals', 'ndindex', 'netcdf4', 'networkx',\ +'newick', 'nh3', 'nlopt', 'nltk', 'numcodecs', 'numpy', 'openai', 'opencv-python', 'optlang', 'orjson',\ +'packaging', 'pandas', 'parso', 'patsy', 'pcodec', 'peewee', 'pi-heif', 'Pillow', 'pillow-heif', 'pkgconfig',\ +'platformdirs', 'pluggy', 'ply', 'pplpy', 'primecountpy', 'prompt_toolkit', 'propcache', 'protobuf', 'pure-eval',\ +'py', 'pyclipper', 'pycparser', 'pycryptodome', 'pydantic', 'pydantic_core', 'pyerfa', 'pygame-ce', 'Pygments',\ +'pyheif', 'pyiceberg', 'pyinstrument', 'pylimer-tools', 'PyMuPDF', 'pynacl', 'pyodide-http', 'pyodide-unix-timezones',\ +'pyparsing', 'pyrsistent', 'pysam', 'pyshp', 'pytaglib', 'pytest', 'pytest-asyncio', 'pytest-benchmark', 'pytest_httpx',\ +'python-calamine', 'python-dateutil', 'python-flint', 'python-magic', 'python-sat', 'python-solvespace', 'pytz', 'pywavelets',\ +'pyxel', 'pyxirr', 'pyyaml', 'rasterio', 'rateslib', 'rebound', 'reboundx', 'referencing', 'regex', 'requests',\ +'retrying', 'rich', 'river', 'RobotRaconteur', 'rpds-py', 'ruamel.yaml', 'rustworkx', 'scikit-image', 'scikit-learn',\ +'scipy', 'screed', 'setuptools', 'shapely', 'simplejson', 'sisl', 'six', 'smart-open', 'sniffio', 'sortedcontainers',\ +'soundfile', 'soupsieve', 'sourmash', 'soxr', 'sparseqr', 'sqlalchemy', 'stack-data', 'starlette', 'statsmodels', 'strictyaml',\ +'svgwrite', 'swiglpk', 'sympy', 'tblib', 'termcolor', 'texttable', 'texture2ddecoder', 'threadpoolctl', 'tiktoken', 'tomli',\ +'tomli-w', 'toolz', 'tqdm', 'traitlets', 'traits', 'tree-sitter', 'tree-sitter-go', 'tree-sitter-java', 'tree-sitter-python',\ +'tskit', 'typing-extensions', 'tzdata', 'ujson', 'uncertainties', 'unyt', 'urllib3', 'vega-datasets', 'vrplib', 'wcwidth',\ +'webencodings', 'wordcloud', 'wrapt', 'xarray', 'xgboost', 'xlrd', 'xxhash', 'xyzservices', 'yarl', 'yt', 'zengl', 'zfpy', 'zstandard'] + needed_pkg = [] + for pkg in supported_pkg: + if pkg.lower() in reqtext.lower(): + needed_pkg.append(pkg) + + project_file = os.path.join(directory, "pyproject.toml") + depstr = str(needed_pkg).replace("\'", "\"") + with open(project_file, 'w') as pf: + pf.write(f""" +[project] +name = "{benchmark.replace(".", "-")}-python-{language_version.replace(".", "")}" +version = "0.1.0" +description = "dummy description" +requires-python = ">={language_version}" +dependencies = {depstr} + +[dependency-groups] +dev = [ + "workers-py", + "workers-runtime-sdk" +] + """) + # move into function dir + funcdir = os.path.join(directory, "function") + if not os.path.exists(funcdir): + os.makedirs(funcdir) + + dont_move = ["handler.py", "function", "python_modules", "pyproject.toml"] + for thing in os.listdir(directory): + if thing not in dont_move: + src = os.path.join(directory, thing) + dest = os.path.join(directory, "function", thing) + shutil.move(src, dest) + + # Create package structure + CONFIG_FILES = { + "nodejs": ["handler.js", "package.json", "node_modules"], + "python": ["handler.py", "requirements.txt", "python_modules"], + } + + if language_name not in CONFIG_FILES: + raise NotImplementedError( + f"Language {language_name} is not yet supported for Cloudflare Workers" + ) + + # Verify the handler exists + handler_file = "handler.js" if language_name == "nodejs" else "handler.py" + package_path = os.path.join(directory, handler_file) + + if not os.path.exists(package_path): + if not os.path.exists(directory): + raise RuntimeError( + f"Package directory {directory} does not exist. " + "The benchmark build process may have failed to create the deployment package." + ) + raise RuntimeError( + f"Handler file {handler_file} not found in {directory}. " + f"Available files: {', '.join(os.listdir(directory)) if os.path.exists(directory) else 'none'}" + ) + + # Calculate total size of the package directory + total_size = 0 + for dirpath, dirnames, filenames in os.walk(directory): + for filename in filenames: + filepath = os.path.join(dirpath, filename) + total_size += os.path.getsize(filepath) + + mbytes = total_size / 1024.0 / 1024.0 + self.logging.info(f"Worker package size: {mbytes:.2f} MB (Python: missing vendored modules)") + + return (directory, total_size, "") + + def shutdown(self): + """Shutdown CLI container if initialized.""" + if self._cli is not None: + self._cli.shutdown() + self._cli = None From 865ca06862bc961a2787a4295826bdf161ecb47e Mon Sep 17 00:00:00 2001 From: laurin Date: Sun, 18 Jan 2026 16:46:15 +0100 Subject: [PATCH 66/69] use toml writer, cleaner approach to write wrangler.toml --- sebs/cloudflare/containers.py | 133 +++++++++++++--------------- sebs/cloudflare/durable_objects.py | 2 +- sebs/cloudflare/workers.py | 134 ++++++++++++++--------------- templates/wrangler-container.toml | 25 ++++++ templates/wrangler-worker.toml | 16 ++++ 5 files changed, 166 insertions(+), 144 deletions(-) create mode 100644 templates/wrangler-container.toml create mode 100644 templates/wrangler-worker.toml diff --git a/sebs/cloudflare/containers.py b/sebs/cloudflare/containers.py index 842679adc..df077ce68 100644 --- a/sebs/cloudflare/containers.py +++ b/sebs/cloudflare/containers.py @@ -12,6 +12,15 @@ import re import time import tarfile +try: + import tomllib # Python 3.11+ +except ImportError: + import tomli as tomllib # Fallback for older Python +try: + import tomli_w +except ImportError: + # Fallback to basic TOML writing if tomli_w not available + import toml as tomli_w from typing import Optional, Tuple import docker @@ -74,102 +83,80 @@ def generate_wrangler_toml( Returns: Path to the generated wrangler.toml file """ - instance_type = "" - if benchmark_name and ("411.image-recognition" in benchmark_name or "311.compression" in benchmark_name or "504.dna-visualisation" in benchmark_name): + # Load template + template_path = os.path.join( + os.path.dirname(__file__), + "../..", + "templates", + "wrangler-container.toml" + ) + with open(template_path, 'rb') as f: + config = tomllib.load(f) + + # Update basic configuration + config['name'] = worker_name + config['account_id'] = account_id + + # Update container configuration with instance type if needed + if benchmark_name and ("411.image-recognition" in benchmark_name or + "311.compression" in benchmark_name or + "504.dna-visualisation" in benchmark_name): self.logging.warning("Using standard-4 instance type for high resource benchmark") - instance_type = '\ninstance_type = "standard-4" # 20GB Disk, 12GB Memory\n' + config['containers'][0]['instance_type'] = "standard-4" - toml_content = f"""name = "{worker_name}" -main = "worker.js" -compatibility_date = "2025-11-18" -account_id = "{account_id}" -compatibility_flags = ["nodejs_compat"] - -[observability] -enabled = true - -[[containers]] -max_instances = 10 -class_name = "ContainerWorker" -image = "./Dockerfile"{instance_type} - -# Durable Object binding for Container class (required by @cloudflare/containers) -[[durable_objects.bindings]] -name = "CONTAINER_WORKER" -class_name = "ContainerWorker" - -""" # Add nosql table bindings if benchmark uses them if code_package and code_package.uses_nosql: # Get registered nosql tables for this benchmark nosql_storage = self.system_resources.get_nosql_storage() if nosql_storage.retrieve_cache(benchmark_name): nosql_tables = nosql_storage._tables.get(benchmark_name, {}) + + # Add durable object bindings for each nosql table for table_name in nosql_tables.keys(): - toml_content += f"""# Durable Object binding for NoSQL table: {table_name} -[[durable_objects.bindings]] -name = "{table_name.upper()}" -class_name = "KVApiObject" - -""" - - # Add migrations for both ContainerWorker and KVApiObject - # Both need new_sqlite_classes (Container requires SQLite DO backend) - toml_content += """[[migrations]] -tag = "v1" -new_sqlite_classes = ["ContainerWorker", "KVApiObject"] - -""" - else: - # Container without nosql - only ContainerWorker migration - toml_content += """[[migrations]] -tag = "v1" -new_sqlite_classes = ["ContainerWorker"] - -""" - + config['durable_objects']['bindings'].append({ + 'name': table_name.upper(), + 'class_name': 'KVApiObject' + }) + + # Update migrations to include KVApiObject + config['migrations'][0]['new_sqlite_classes'].append('KVApiObject') + # Add environment variables - vars_content = "" - if benchmark_name: - vars_content += f'BENCHMARK_NAME = "{benchmark_name}"\n' - - # Add nosql configuration if benchmark uses it - if code_package and code_package.uses_nosql: - vars_content += 'NOSQL_STORAGE_DATABASE = "durable_objects"\n' - - if vars_content: - toml_content += f"""# Environment variables -[vars] -{vars_content} -""" - - # Add R2 bucket binding for benchmarking files - r2_bucket_configured = False + if benchmark_name or (code_package and code_package.uses_nosql): + config['vars'] = {} + if benchmark_name: + config['vars']['BENCHMARK_NAME'] = benchmark_name + if code_package and code_package.uses_nosql: + config['vars']['NOSQL_STORAGE_DATABASE'] = "durable_objects" + + # Add R2 bucket binding try: from sebs.faas.config import Resources storage = self.system_resources.get_storage() bucket_name = storage.get_bucket(Resources.StorageBucketType.BENCHMARKS) if bucket_name: - toml_content += f"""# R2 bucket binding for benchmarking files -# This bucket is used by fs and path polyfills to read benchmark data -[[r2_buckets]] -binding = "R2" -bucket_name = "{bucket_name}" - -""" - r2_bucket_configured = True + config['r2_buckets'] = [{ + 'binding': 'R2', + 'bucket_name': bucket_name + }] self.logging.info(f"R2 bucket '{bucket_name}' will be bound to worker as 'R2'") except Exception as e: self.logging.warning( f"R2 bucket binding not configured: {e}. " f"Benchmarks requiring file access will not work properly." ) - + # Write wrangler.toml to package directory toml_path = os.path.join(package_dir, "wrangler.toml") - with open(toml_path, 'w') as f: - f.write(toml_content) - + try: + # Try tomli_w (writes binary) + with open(toml_path, 'wb') as f: + tomli_w.dump(config, f) + except TypeError: + # Fallback to toml library (writes text) + with open(toml_path, 'w') as f: + f.write(tomli_w.dumps(config)) + self.logging.info(f"Generated wrangler.toml at {toml_path}") return toml_path diff --git a/sebs/cloudflare/durable_objects.py b/sebs/cloudflare/durable_objects.py index 4bb99c11e..258886cf3 100644 --- a/sebs/cloudflare/durable_objects.py +++ b/sebs/cloudflare/durable_objects.py @@ -180,7 +180,7 @@ def clear_table(self, name: str) -> str: :param name: table name :return: table name """ - self.logging.info(f"Durable Objects data is managed within the Worker") + self.logging.warning(f"Durable Objects data is managed within the Worker") return name def remove_table(self, name: str) -> str: diff --git a/sebs/cloudflare/workers.py b/sebs/cloudflare/workers.py index da4a5073d..f78f0aad1 100644 --- a/sebs/cloudflare/workers.py +++ b/sebs/cloudflare/workers.py @@ -10,6 +10,15 @@ import json import io import tarfile +try: + import tomllib # Python 3.11+ +except ImportError: + import tomli as tomllib # Fallback for older Python +try: + import tomli_w +except ImportError: + # Fallback to basic TOML writing if tomli_w not available + import toml as tomli_w from typing import Optional, Tuple from sebs.benchmark import Benchmark @@ -68,92 +77,77 @@ def generate_wrangler_toml( Returns: Path to the generated wrangler.toml file """ - # Native worker configuration - main_file = "dist/handler.js" if language == "nodejs" else "handler.py" - - # Build wrangler.toml content - toml_content = f"""name = "{worker_name}" -main = "{main_file}" -compatibility_date = "2025-11-18" -account_id = "{account_id}" -""" - + # Load template + template_path = os.path.join( + os.path.dirname(__file__), + "../..", + "templates", + "wrangler-worker.toml" + ) + with open(template_path, 'rb') as f: + config = tomllib.load(f) + + # Update basic configuration + config['name'] = worker_name + config['main'] = "dist/handler.js" if language == "nodejs" else "handler.py" + config['account_id'] = account_id + + # Add language-specific configuration if language == "nodejs": - toml_content += """# Use nodejs_compat for Node.js built-in support -compatibility_flags = ["nodejs_compat"] -no_bundle = true - -[build] -command = "node build.js" - -[[rules]] -type = "ESModule" -globs = ["**/*.js"] -fallthrough = true - -[[rules]] -type = "Text" -globs = ["**/*.html"] -fallthrough = true - -""" + config['compatibility_flags'] = ["nodejs_compat"] + config['no_bundle'] = True + config['build'] = {'command': 'node build.js'} + config['rules'] = [ + { + 'type': 'ESModule', + 'globs': ['**/*.js'], + 'fallthrough': True + }, + { + 'type': 'Text', + 'globs': ['**/*.html'], + 'fallthrough': True + } + ] elif language == "python": - toml_content += """# Enable Python Workers runtime -compatibility_flags = ["python_workers"] -""" - - toml_content += """ -[[durable_objects.bindings]] -name = "DURABLE_STORE" -class_name = "KVApiObject" - -[[migrations]] -tag = "v3" -new_classes = ["KVApiObject"] -""" - + config['compatibility_flags'] = ["python_workers"] + # Add environment variables - vars_content = "" - if benchmark_name: - vars_content += f'BENCHMARK_NAME = "{benchmark_name}"\n' - - # Add nosql configuration if benchmark uses it - if code_package and code_package.uses_nosql: - vars_content += 'NOSQL_STORAGE_DATABASE = "durable_objects"\n' - - if vars_content: - toml_content += f"""# Environment variables -[vars] -{vars_content} -""" - - # Add R2 bucket binding for benchmarking files - r2_bucket_configured = False + if benchmark_name or (code_package and code_package.uses_nosql): + config['vars'] = {} + if benchmark_name: + config['vars']['BENCHMARK_NAME'] = benchmark_name + if code_package and code_package.uses_nosql: + config['vars']['NOSQL_STORAGE_DATABASE'] = "durable_objects" + + # Add R2 bucket binding try: from sebs.faas.config import Resources storage = self.system_resources.get_storage() bucket_name = storage.get_bucket(Resources.StorageBucketType.BENCHMARKS) if bucket_name: - toml_content += f"""# R2 bucket binding for benchmarking files -# This bucket is used by fs and path polyfills to read benchmark data -[[r2_buckets]] -binding = "R2" -bucket_name = "{bucket_name}" - -""" - r2_bucket_configured = True + config['r2_buckets'] = [{ + 'binding': 'R2', + 'bucket_name': bucket_name + }] self.logging.info(f"R2 bucket '{bucket_name}' will be bound to worker as 'R2'") except Exception as e: self.logging.warning( f"R2 bucket binding not configured: {e}. " f"Benchmarks requiring file access will not work properly." ) - + # Write wrangler.toml to package directory toml_path = os.path.join(package_dir, "wrangler.toml") - with open(toml_path, 'w') as f: - f.write(toml_content) - + try: + # Try tomli_w (writes binary) + with open(toml_path, 'wb') as f: + tomli_w.dump(config, f) + except TypeError: + # Fallback to toml library (writes text) + with open(toml_path, 'w') as f: + f.write(tomli_w.dumps(config)) + self.logging.info(f"Generated wrangler.toml at {toml_path}") return toml_path diff --git a/templates/wrangler-container.toml b/templates/wrangler-container.toml new file mode 100644 index 000000000..d8e08fe33 --- /dev/null +++ b/templates/wrangler-container.toml @@ -0,0 +1,25 @@ +# Template for Cloudflare Container Workers +# This file is read and modified by the deployment system + +name = "PLACEHOLDER_WORKER_NAME" +main = "worker.js" +compatibility_date = "2025-11-18" +account_id = "PLACEHOLDER_ACCOUNT_ID" +compatibility_flags = ["nodejs_compat"] + +[observability] +enabled = true + +[[containers]] +max_instances = 10 +class_name = "ContainerWorker" +image = "./Dockerfile" + +# Durable Object binding for Container class (required by @cloudflare/containers) +[[durable_objects.bindings]] +name = "CONTAINER_WORKER" +class_name = "ContainerWorker" + +[[migrations]] +tag = "v1" +new_sqlite_classes = ["ContainerWorker"] diff --git a/templates/wrangler-worker.toml b/templates/wrangler-worker.toml new file mode 100644 index 000000000..b11821281 --- /dev/null +++ b/templates/wrangler-worker.toml @@ -0,0 +1,16 @@ +# Template for native Cloudflare Workers +# This file is read and modified by the deployment system + +name = "PLACEHOLDER_WORKER_NAME" +main = "PLACEHOLDER_MAIN_FILE" +compatibility_date = "2025-11-18" +account_id = "PLACEHOLDER_ACCOUNT_ID" + +# Durable Object binding for NoSQL storage +[[durable_objects.bindings]] +name = "DURABLE_STORE" +class_name = "KVApiObject" + +[[migrations]] +tag = "v3" +new_classes = ["KVApiObject"] From 20eb8db129102f06a7b0f88dd918daff49c44519 Mon Sep 17 00:00:00 2001 From: laurin Date: Sun, 18 Jan 2026 16:55:12 +0100 Subject: [PATCH 67/69] accidental capitalization of the table name resulting in errors in 130 --- sebs/cloudflare/containers.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sebs/cloudflare/containers.py b/sebs/cloudflare/containers.py index df077ce68..5b1fd9fd4 100644 --- a/sebs/cloudflare/containers.py +++ b/sebs/cloudflare/containers.py @@ -114,7 +114,7 @@ def generate_wrangler_toml( # Add durable object bindings for each nosql table for table_name in nosql_tables.keys(): config['durable_objects']['bindings'].append({ - 'name': table_name.upper(), + 'name': table_name, 'class_name': 'KVApiObject' }) From ebe07946df7d95bcab37e7b5d9b30ef7409d75a3 Mon Sep 17 00:00:00 2001 From: laurin Date: Sun, 18 Jan 2026 16:57:45 +0100 Subject: [PATCH 68/69] warning that locationHint is not supported --- docs/storage.md | 3 +++ sebs/cloudflare/r2.py | 8 +++++++- 2 files changed, 10 insertions(+), 1 deletion(-) diff --git a/docs/storage.md b/docs/storage.md index bf33ca071..1a4ee4573 100644 --- a/docs/storage.md +++ b/docs/storage.md @@ -146,6 +146,9 @@ Cloudflare R2 provides S3-compatible object storage for benchmarks that require **Configuration:** R2 configuration is handled automatically by SeBS when deploying to Cloudflare Workers. The storage resources are defined in your deployment configuration and SeBS manages bucket creation and access. +**Limitations:** +- Geographic location hints (locationHint) are not currently supported. R2 buckets are created with Cloudflare's automatic location selection, which places data near where it's most frequently accessed. + ### Durable Objects for NoSQL Cloudflare Durable Objects provide stateful storage for NoSQL operations required by benchmarks like the CRUD API (130.crud-api). diff --git a/sebs/cloudflare/r2.py b/sebs/cloudflare/r2.py index 660588e1f..ebc2d684d 100644 --- a/sebs/cloudflare/r2.py +++ b/sebs/cloudflare/r2.py @@ -75,8 +75,14 @@ def _create_bucket( # R2 API only accepts "name" parameter - locationHint is optional and must be one of: # "apac", "eeur", "enam", "weur", "wnam" - # For now, just send the name without locationHint + # WARNING: locationHint is not currently supported by SeBS. Buckets are created + # with Cloudflare's automatic location selection. params = {"name": name} + + self.logging.warning( + f"Creating R2 bucket '{name}' without locationHint. " + "Geographic location is determined automatically by Cloudflare." + ) try: create_bucket_response = requests.post( From 9dd0a6e2290207a217ea443daa580c07f41df689 Mon Sep 17 00:00:00 2001 From: laurin Date: Sun, 18 Jan 2026 17:12:13 +0100 Subject: [PATCH 69/69] s3 client for r2 storage code duplication removed. and also removed librarytrigger --- sebs/cloudflare/cloudflare.py | 14 +--- sebs/cloudflare/function.py | 11 +-- sebs/cloudflare/r2.py | 128 ++++++++++++++-------------------- sebs/cloudflare/triggers.py | 53 -------------- 4 files changed, 59 insertions(+), 147 deletions(-) diff --git a/sebs/cloudflare/cloudflare.py b/sebs/cloudflare/cloudflare.py index e61b4d4aa..a9b9a7be4 100644 --- a/sebs/cloudflare/cloudflare.py +++ b/sebs/cloudflare/cloudflare.py @@ -514,11 +514,7 @@ def cached_function(self, function: Function): Args: function: The cached function """ - from sebs.cloudflare.triggers import LibraryTrigger, HTTPTrigger - - for trigger in function.triggers(Trigger.TriggerType.LIBRARY): - trigger.logging_handlers = self.logging_handlers - cast(LibraryTrigger, trigger).deployment_client = self + from sebs.cloudflare.triggers import HTTPTrigger for trigger in function.triggers(Trigger.TriggerType.HTTP): trigger.logging_handlers = self.logging_handlers @@ -779,15 +775,11 @@ def create_trigger( Returns: The created trigger """ - from sebs.cloudflare.triggers import LibraryTrigger, HTTPTrigger + from sebs.cloudflare.triggers import HTTPTrigger worker = cast(CloudflareWorker, function) - if trigger_type == Trigger.TriggerType.LIBRARY: - trigger = LibraryTrigger(worker.name, self) - trigger.logging_handlers = self.logging_handlers - return trigger - elif trigger_type == Trigger.TriggerType.HTTP: + if trigger_type == Trigger.TriggerType.HTTP: account_id = worker.account_id or self.config.credentials.account_id worker_url = self._build_workers_dev_url(worker.name, account_id) trigger = HTTPTrigger(worker.name, worker_url) diff --git a/sebs/cloudflare/function.py b/sebs/cloudflare/function.py index c3773818f..cd422dc30 100644 --- a/sebs/cloudflare/function.py +++ b/sebs/cloudflare/function.py @@ -40,7 +40,7 @@ def serialize(self) -> dict: @staticmethod def deserialize(cached_config: dict) -> "CloudflareWorker": from sebs.faas.function import Trigger - from sebs.cloudflare.triggers import LibraryTrigger, HTTPTrigger + from sebs.cloudflare.triggers import HTTPTrigger cfg = FunctionConfig.deserialize(cached_config["config"]) ret = CloudflareWorker( @@ -54,14 +54,7 @@ def deserialize(cached_config: dict) -> "CloudflareWorker": ) for trigger in cached_config["triggers"]: - mapping = { - LibraryTrigger.typename(): LibraryTrigger, - HTTPTrigger.typename(): HTTPTrigger - } - trigger_type = cast( - Trigger, - mapping.get(trigger["type"]), - ) + trigger_type = HTTPTrigger if trigger["type"] == HTTPTrigger.typename() else None assert trigger_type, "Unknown trigger type {}".format(trigger["type"]) ret.add_trigger(trigger_type.deserialize(trigger)) diff --git a/sebs/cloudflare/r2.py b/sebs/cloudflare/r2.py index ebc2d684d..45a1167c6 100644 --- a/sebs/cloudflare/r2.py +++ b/sebs/cloudflare/r2.py @@ -35,6 +35,7 @@ def __init__( ): super().__init__(region, cache_client, resources, replace_existing) self._credentials = credentials + self._s3_client = None def _get_auth_headers(self) -> dict[str, str]: """Get authentication headers for Cloudflare API requests.""" @@ -52,6 +53,46 @@ def _get_auth_headers(self) -> dict[str, str]: else: raise RuntimeError("Invalid Cloudflare credentials configuration") + def _get_s3_client(self): + """ + Get or initialize the S3-compatible client for R2 operations. + + :return: boto3 S3 client or None if credentials not available + """ + if self._s3_client is not None: + return self._s3_client + + # Check if we have S3-compatible credentials + if not self._credentials.r2_access_key_id or not self._credentials.r2_secret_access_key: + self.logging.warning( + "R2 S3-compatible API credentials not configured. " + "Set CLOUDFLARE_R2_ACCESS_KEY_ID and CLOUDFLARE_R2_SECRET_ACCESS_KEY environment variables." + ) + return None + + try: + import boto3 + from botocore.config import Config + + account_id = self._credentials.account_id + + self._s3_client = boto3.client( + 's3', + endpoint_url=f'https://{account_id}.r2.cloudflarestorage.com', + aws_access_key_id=self._credentials.r2_access_key_id, + aws_secret_access_key=self._credentials.r2_secret_access_key, + config=Config(signature_version='s3v4'), + region_name='auto' + ) + + return self._s3_client + + except ImportError: + self.logging.warning( + "boto3 not available. Install with: pip install boto3" + ) + return None + def correct_name(self, name: str) -> str: return name @@ -142,33 +183,12 @@ def upload(self, bucket_name: str, filepath: str, key: str): :param filepath: local source filepath :param key: R2 destination key/path """ + s3_client = self._get_s3_client() + if s3_client is None: + self.logging.warning(f"Cannot upload {filepath} to R2 - S3 client not available") + return + try: - import boto3 - from botocore.config import Config - - account_id = self._credentials.account_id - - # R2 uses S3-compatible API, but requires special configuration - # The endpoint is: https://.r2.cloudflarestorage.com - # You need to create R2 API tokens in the Cloudflare dashboard - - # Check if we have S3-compatible credentials - if not self._credentials.r2_access_key_id or not self._credentials.r2_secret_access_key: - self.logging.warning( - "R2 upload requires S3-compatible API credentials (r2_access_key_id, r2_secret_access_key). " - "File upload skipped. Set CLOUDFLARE_R2_ACCESS_KEY_ID and CLOUDFLARE_R2_SECRET_ACCESS_KEY." - ) - return - - s3_client = boto3.client( - 's3', - endpoint_url=f'https://{account_id}.r2.cloudflarestorage.com', - aws_access_key_id=self._credentials.r2_access_key_id, - aws_secret_access_key=self._credentials.r2_secret_access_key, - config=Config(signature_version='s3v4'), - region_name='auto' - ) - with open(filepath, 'rb') as f: s3_client.put_object( Bucket=bucket_name, @@ -178,11 +198,6 @@ def upload(self, bucket_name: str, filepath: str, key: str): self.logging.debug(f"Uploaded {filepath} to R2 bucket {bucket_name} as {key}") - except ImportError: - self.logging.warning( - "boto3 not available. Install with: pip install boto3. " - "File upload to R2 skipped." - ) except Exception as e: self.logging.warning(f"Failed to upload {filepath} to R2: {e}") @@ -194,28 +209,12 @@ def upload_bytes(self, bucket_name: str, key: str, data: bytes): :param key: R2 destination key/path :param data: bytes to upload """ + s3_client = self._get_s3_client() + if s3_client is None: + self.logging.warning(f"Cannot upload bytes to R2 - S3 client not available") + return + try: - import boto3 - from botocore.config import Config - - account_id = self._credentials.account_id - - if not self._credentials.r2_access_key_id or not self._credentials.r2_secret_access_key: - self.logging.warning( - "R2 upload requires S3-compatible API credentials (r2_access_key_id, r2_secret_access_key). " - "Upload skipped. Set CLOUDFLARE_R2_ACCESS_KEY_ID and CLOUDFLARE_R2_SECRET_ACCESS_KEY environment variables." - ) - return - - s3_client = boto3.client( - 's3', - endpoint_url=f'https://{account_id}.r2.cloudflarestorage.com', - aws_access_key_id=self._credentials.r2_access_key_id, - aws_secret_access_key=self._credentials.r2_secret_access_key, - config=Config(signature_version='s3v4'), - region_name='auto' - ) - s3_client.put_object( Bucket=bucket_name, Key=key, @@ -224,10 +223,6 @@ def upload_bytes(self, bucket_name: str, key: str, data: bytes): self.logging.debug(f"Uploaded {len(data)} bytes to R2 bucket {bucket_name} as {key}") - except ImportError: - self.logging.warning( - "boto3 not available. Install with: pip install boto3" - ) except Exception as e: self.logging.warning(f"Failed to upload bytes to R2: {e}") @@ -246,27 +241,12 @@ def list_bucket(self, bucket_name: str, prefix: str = "") -> List[str]: :param prefix: optional prefix filter :return: list of files in a given bucket """ - # Use S3-compatible API with R2 credentials - if not self._credentials.r2_access_key_id or not self._credentials.r2_secret_access_key: - self.logging.warning(f"R2 S3 credentials not configured, cannot list bucket {bucket_name}") + s3_client = self._get_s3_client() + if s3_client is None: + self.logging.warning(f"Cannot list R2 bucket {bucket_name} - S3 client not available") return [] try: - import boto3 - from botocore.config import Config - - account_id = self._credentials.account_id - r2_endpoint = f"https://{account_id}.r2.cloudflarestorage.com" - - s3_client = boto3.client( - 's3', - endpoint_url=r2_endpoint, - aws_access_key_id=self._credentials.r2_access_key_id, - aws_secret_access_key=self._credentials.r2_secret_access_key, - config=Config(signature_version='s3v4'), - region_name='auto' - ) - # List objects with optional prefix paginator = s3_client.get_paginator('list_objects_v2') page_iterator = paginator.paginate(Bucket=bucket_name, Prefix=prefix) diff --git a/sebs/cloudflare/triggers.py b/sebs/cloudflare/triggers.py index f4b926379..cecd0338f 100644 --- a/sebs/cloudflare/triggers.py +++ b/sebs/cloudflare/triggers.py @@ -4,59 +4,6 @@ from sebs.faas.function import Trigger, ExecutionResult -class LibraryTrigger(Trigger): - """ - Library trigger for Cloudflare Workers. - Allows invoking workers programmatically via the Cloudflare API. - """ - - def __init__(self, worker_name: str, deployment_client=None): - super().__init__() - self.worker_name = worker_name - self.deployment_client = deployment_client - - @staticmethod - def typename() -> str: - return "Cloudflare.LibraryTrigger" - - @staticmethod - def trigger_type() -> Trigger.TriggerType: - return Trigger.TriggerType.LIBRARY - - def sync_invoke(self, payload: dict) -> ExecutionResult: - """ - Synchronously invoke a Cloudflare Worker. - - Args: - payload: The payload to send to the worker - - Returns: - ExecutionResult with performance metrics - """ - # This will be implemented when we have the deployment client - raise NotImplementedError("Cloudflare Worker invocation not yet implemented") - - def async_invoke(self, payload: dict) -> concurrent.futures.Future: - """ - Asynchronously invoke a Cloudflare Worker. - Not typically supported for Cloudflare Workers. - """ - raise NotImplementedError("Cloudflare Workers do not support async invocation") - - def serialize(self) -> dict: - """Serialize the LibraryTrigger.""" - return { - "type": self.typename(), - "worker_name": self.worker_name, - } - - @staticmethod - def deserialize(cached_config: dict) -> "LibraryTrigger": - """Deserialize a LibraryTrigger from cached config.""" - from sebs.cloudflare.triggers import LibraryTrigger - return LibraryTrigger(cached_config["worker_name"]) - - class HTTPTrigger(Trigger): """ HTTP trigger for Cloudflare Workers.