@rivetkit/engine 1.0.0 → 2.2.1-pr.4600.b74ff3b

package/packages/guard/src/routing/pegboard_gateway.rs

@@ -1,260 +0,0 @@
-use std::time::Duration;
-
-use anyhow::Result;
-use gas::prelude::*;
-use hyper::header::HeaderName;
-use rivet_guard_core::proxy_service::{RouteConfig, RouteTarget, RoutingOutput, RoutingTimeout};
-
-use super::{SEC_WEBSOCKET_PROTOCOL, WS_PROTOCOL_ACTOR, WS_PROTOCOL_TOKEN, X_RIVET_TOKEN};
-use crate::{errors, shared_state::SharedState};
-
-const ACTOR_FORCE_WAKE_PENDING_TIMEOUT: i64 = util::duration::seconds(60);
-const ACTOR_READY_TIMEOUT: Duration = Duration::from_secs(10);
-pub const X_RIVET_ACTOR: HeaderName = HeaderName::from_static("x-rivet-actor");
-
-/// Route requests to actor services using path-based routing
-#[tracing::instrument(skip_all)]
-pub async fn route_request_path_based(
-	ctx: &StandaloneCtx,
-	shared_state: &SharedState,
-	actor_id_str: &str,
-	token: Option<&str>,
-	path: &str,
-	_headers: &hyper::HeaderMap,
-	_is_websocket: bool,
-) -> Result<Option<RoutingOutput>> {
-	// Parse actor ID
-	let actor_id = Id::parse(actor_id_str).context("invalid actor id in path")?;
-
-	route_request_inner(ctx, shared_state, actor_id, path, token).await
-}
-
-/// Route requests to actor services based on headers
-#[tracing::instrument(skip_all)]
-pub async fn route_request(
-	ctx: &StandaloneCtx,
-	shared_state: &SharedState,
-	target: &str,
-	_host: &str,
-	path: &str,
-	headers: &hyper::HeaderMap,
-	is_websocket: bool,
-) -> Result<Option<RoutingOutput>> {
-	// Check target
-	if target != "actor" {
-		return Ok(None);
-	}
-
-	// Extract actor ID and token from WebSocket protocol or HTTP headers
-	let (actor_id_str, token) = if is_websocket {
-		// For WebSocket, parse the sec-websocket-protocol header
-		let protocols_header = headers
-			.get(SEC_WEBSOCKET_PROTOCOL)
-			.and_then(|protocols| protocols.to_str().ok())
-			.ok_or_else(|| {
-				crate::errors::MissingHeader {
-					header: "sec-websocket-protocol".to_string(),
-				}
-				.build()
-			})?;
-
-		let protocols: Vec<&str> = protocols_header.split(',').map(|p| p.trim()).collect();
-
-		let actor_id_raw = protocols
-			.iter()
-			.find_map(|p| p.strip_prefix(WS_PROTOCOL_ACTOR))
-			.ok_or_else(|| {
-				crate::errors::MissingHeader {
-					header: "`rivet_actor.*` protocol in sec-websocket-protocol".to_string(),
-				}
-				.build()
-			})?;
-
-		let actor_id = urlencoding::decode(actor_id_raw)
-			.context("invalid url encoding in actor id")?
-			.to_string();
-
-		let token = protocols
-			.iter()
-			.find_map(|p| p.strip_prefix(WS_PROTOCOL_TOKEN));
-
-		(actor_id, token)
-	} else {
-		// For HTTP, use headers
-		let actor_id = headers
-			.get(X_RIVET_ACTOR)
-			.map(|x| x.to_str())
-			.transpose()
-			.context("invalid x-rivet-actor header")?
-			.ok_or_else(|| {
-				crate::errors::MissingHeader {
-					header: X_RIVET_ACTOR.to_string(),
-				}
-				.build()
-			})?;
-
-		let token = headers
-			.get(X_RIVET_TOKEN)
-			.map(|x| x.to_str())
-			.transpose()
-			.context("invalid x-rivet-token header")?;
-
-		(actor_id.to_string(), token)
-	};
-
-	// Find actor to route to
-	let actor_id = Id::parse(&actor_id_str).context("invalid x-rivet-actor header")?;
-
-	route_request_inner(ctx, shared_state, actor_id, path, token).await
-}
-
-async fn route_request_inner(
-	ctx: &StandaloneCtx,
-	shared_state: &SharedState,
-	actor_id: Id,
-	path: &str,
-	_token: Option<&str>,
-) -> Result<Option<RoutingOutput>> {
-	// NOTE: Token validation implemented in EE
-
-	// Route to peer dc where the actor lives
-	if actor_id.label() != ctx.config().dc_label() {
-		tracing::debug!(peer_dc_label=?actor_id.label(), "re-routing actor to peer dc");
-
-		let peer_dc = ctx
-			.config()
-			.dc_for_label(actor_id.label())
-			.context("dc with the given label not found")?;
-
-		return Ok(Some(RoutingOutput::Route(RouteConfig {
-			targets: vec![RouteTarget {
-				actor_id: Some(actor_id),
-				host: peer_dc
-					.proxy_url_host()
-					.context("bad peer dc proxy url host")?
-					.to_string(),
-				port: peer_dc
-					.proxy_url_port()
-					.context("bad peer dc proxy url port")?,
-				path: path.to_owned(),
-			}],
-			timeout: RoutingTimeout {
-				routing_timeout: 10,
-			},
-		})));
-	}
-
-	// Create subs before checking if actor exists/is not destroyed
-	let mut ready_sub = ctx
-		.subscribe::<pegboard::workflows::actor::Ready>(("actor_id", actor_id))
-		.await?;
-	let mut stopped_sub = ctx
-		.subscribe::<pegboard::workflows::actor::Stopped>(("actor_id", actor_id))
-		.await?;
-	let mut fail_sub = ctx
-		.subscribe::<pegboard::workflows::actor::Failed>(("actor_id", actor_id))
-		.await?;
-	let mut destroy_sub = ctx
-		.subscribe::<pegboard::workflows::actor::DestroyStarted>(("actor_id", actor_id))
-		.await?;
-
-	// Fetch actor info
-	let Some(actor) = ctx
-		.op(pegboard::ops::actor::get_for_gateway::Input { actor_id })
-		.await?
-	else {
-		return Err(pegboard::errors::Actor::NotFound.build());
-	};
-
-	if actor.destroyed {
-		return Err(pegboard::errors::Actor::NotFound.build());
-	}
-
-	// Wake actor if sleeping
-	if actor.sleeping {
-		tracing::debug!(?actor_id, "actor sleeping, waking");
-
-		ctx.signal(pegboard::workflows::actor::Wake {
-			allocation_override: pegboard::workflows::actor::AllocationOverride::DontSleep {
-				pending_timeout: Some(ACTOR_FORCE_WAKE_PENDING_TIMEOUT),
-			},
-		})
-		.to_workflow_id(actor.workflow_id)
-		.send()
-		.await?;
-	}
-
-	let runner_id = if let (Some(runner_id), true) = (actor.runner_id, actor.connectable) {
-		runner_id
-	} else {
-		tracing::debug!(?actor_id, "waiting for actor to become ready");
-
-		let mut wake_retries = 0;
-
-		// Wait for ready, fail, or destroy
-		loop {
-			tokio::select! {
-				res = ready_sub.next() => break res?.runner_id,
-				res = stopped_sub.next() => {
-					res?;
-
-					if wake_retries < 16 {
-						tracing::debug!(?actor_id, ?wake_retries, "actor stopped while we were waiting for it to become ready, attempting rewake");
-						wake_retries += 1;
-
-						let res = ctx.signal(pegboard::workflows::actor::Wake {
-							allocation_override: pegboard::workflows::actor::AllocationOverride::DontSleep {
-								pending_timeout: Some(ACTOR_FORCE_WAKE_PENDING_TIMEOUT),
-							},
-						})
-						.to_workflow_id(actor.workflow_id)
-						.send()
-						.await;
-
-						if let Some(WorkflowError::WorkflowNotFound) = res
-							.as_ref()
-							.err()
-							.and_then(|x| x.chain().find_map(|x| x.downcast_ref::<WorkflowError>()))
-						{
-							tracing::warn!(
-								?actor_id,
-								"actor workflow not found for rewake"
-							);
-						} else {
-							res?;
-						}
-					} else {
-						tracing::warn!("actor retried waking 16 times, has not yet started");
-						return Err(rivet_guard_core::errors::ServiceUnavailable.build());
-					}
-				}
-				res = fail_sub.next() => {
-					let msg = res?;
-					return Err(msg.error.clone().build());
-				}
-				res = destroy_sub.next() => {
-					res?;
-					return Err(pegboard::errors::Actor::DestroyedWhileWaitingForReady.build());
-				}
-				// Ready timeout
-				_ = tokio::time::sleep(ACTOR_READY_TIMEOUT) => {
-					return Err(errors::ActorReadyTimeout { actor_id }.build());
-				}
-			}
-		}
-	};
-
-	tracing::debug!(?actor_id, ?runner_id, "actor ready");
-
-	// Return pegboard-gateway instance with path
-	let gateway = pegboard_gateway::PegboardGateway::new(
-		ctx.clone(),
-		shared_state.pegboard_gateway.clone(),
-		runner_id,
-		actor_id,
-		path.to_string(),
-	);
-	Ok(Some(RoutingOutput::CustomServe(std::sync::Arc::new(
-		gateway,
-	))))
-}

package/packages/guard-core/src/analytics.rs

@@ -1,46 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-// Properties not currently collected but should be added in future iterations:
-// - client_ssl_cipher: Requires TLS connection introspection
-// - client_ssl_protocol: Requires TLS connection introspection
-// - client_tcp_rtt_ms: Requires network-level measurements
-// - client_request_bytes: Total request size including headers
-// - service_dns_response_time_ms: Requires DNS timing instrumentation
-// - service_ssl_protocol: Requires upstream TLS introspection
-// - service_tcp_handshake_duration_ms: Requires connection-level timing
-// - service_tls_handshake_duration_ms: Requires TLS handshake timing
-// - service_request_header_send_duration_ms: Requires granular timing
-// - service_response_header_receive_duration_ms: Requires granular timing
-// - guard_response_bytes: Total response size including headers
-// - guard_time_to_first_byte_ms: Requires granular timing
-// - security_rule_id: Requires security/firewall rule integration
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct GuardHttpRequest {
-	// TODO:
-	// pub request_id: Id,
-	// pub ray_id: Id,
-	pub client_ip: String,
-	pub client_request_body_bytes: u64,
-	pub client_request_host: String,
-	pub client_request_method: String,
-	pub client_request_path: String,
-	pub client_request_protocol: String,
-	pub client_request_referer: String,
-	pub client_request_scheme: String,
-	pub client_request_uri: String,
-	pub client_request_user_agent: String,
-	pub client_src_port: u16,
-	pub client_x_requested_with: String,
-	pub guard_end_timestamp: u64,
-	pub guard_response_body_bytes: u64,
-	pub guard_response_content_type: String,
-	pub guard_response_status: u16,
-	pub guard_start_timestamp: u64,
-	pub service_ip: String,
-	pub service_response_duration_ms: u32,
-	pub service_response_http_expires: String,
-	pub service_response_http_last_modified: String,
-	pub service_response_status: u16,
-	pub service_actor_id: String,
-}

package/packages/internal/README.md

@@ -1 +0,0 @@
-TODO: move somewhere else

package/packages/internal/src/lib.rs

@@ -1 +0,0 @@
-pub mod ops;

package/packages/internal/src/ops/bump_serverless_autoscaler_global.rs

@@ -1,64 +0,0 @@
-use std::fmt::Debug;
-
-use futures_util::StreamExt;
-use gas::prelude::*;
-use rivet_api_util::{Method, request_remote_datacenter};
-
-#[derive(Clone, Debug, Default)]
-pub struct Input {}
-
-#[operation]
-pub async fn bump_serverless_autoscaler_global(ctx: &OperationCtx, input: &Input) -> Result<()> {
-	let dcs = &ctx.config().topology().datacenters;
-
-	let results = futures_util::stream::iter(dcs.clone().into_iter().map(|dc| {
-		let ctx = ctx.clone();
-
-		async move {
-			if dc.datacenter_label == ctx.config().dc_label() {
-				// Local datacenter
-				ctx.msg(rivet_types::msgs::pegboard::BumpServerlessAutoscaler {})
-					.send()
-					.await
-			} else {
-				// Remote datacenter - HTTP request
-				request_remote_datacenter::<BumpServerlessAutoscalerResponse>(
-					ctx.config(),
-					dc.datacenter_label,
-					"/bump-serverless-autoscaler",
-					Method::POST,
-					Option::<&()>::None,
-					Option::<&()>::None,
-				)
-				.await
-				.map(|_| ())
-			}
-		}
-	}))
-	.buffer_unordered(16)
-	.collect::<Vec<_>>()
-	.await;
-
-	// Aggregate results
-	let result_count = results.len();
-	let mut errors = Vec::new();
-	for res in results {
-		if let Err(err) = res {
-			tracing::error!(?err, "failed to request edge dc");
-			errors.push(err);
-		}
-	}
-
-	// Error only if all requests failed
-	if result_count == errors.len() {
-		if let Some(res) = errors.into_iter().next() {
-			return Err(res).context("all datacenter requests failed");
-		}
-	}
-
-	Ok(())
-}
-
-// TODO: This is cloned from api-peer because of a cyclical dependency
-#[derive(Deserialize)]
-pub struct BumpServerlessAutoscalerResponse {}

package/packages/internal/src/ops/cache/mod.rs

@@ -1 +0,0 @@
-pub mod purge_global;

package/packages/internal/src/ops/cache/purge_global.rs

@@ -1,81 +0,0 @@
-use std::fmt::Debug;
-
-use futures_util::StreamExt;
-use gas::prelude::*;
-use rivet_api_util::{Method, request_remote_datacenter};
-use rivet_cache::RawCacheKey;
-use serde::Serialize;
-
-#[derive(Clone, Debug, Default)]
-pub struct Input {
-	pub base_key: String,
-	pub keys: Vec<RawCacheKey>,
-}
-
-#[operation]
-pub async fn cache_purge_global(ctx: &OperationCtx, input: &Input) -> Result<()> {
-	let dcs = &ctx.config().topology().datacenters;
-
-	let results = futures_util::stream::iter(dcs.clone().into_iter().map(|dc| {
-		let ctx = ctx.clone();
-		let input = input.clone();
-
-		async move {
-			if dc.datacenter_label == ctx.config().dc_label() {
-				// Local datacenter
-				ctx.cache()
-					.clone()
-					.request()
-					.purge(input.base_key, input.keys)
-					.await
-			} else {
-				// Remote datacenter - HTTP request
-				request_remote_datacenter::<CachePurgeResponse>(
-					ctx.config(),
-					dc.datacenter_label,
-					"/cache/purge",
-					Method::POST,
-					Option::<&()>::None,
-					Some(&CachePurgeRequest {
-						base_key: input.base_key,
-						keys: input.keys,
-					}),
-				)
-				.await
-				.map(|_| ())
-			}
-		}
-	}))
-	.buffer_unordered(16)
-	.collect::<Vec<_>>()
-	.await;
-
-	// Aggregate results
-	let result_count = results.len();
-	let mut errors = Vec::new();
-	for res in results {
-		if let Err(err) = res {
-			tracing::error!(?err, "failed to request edge dc");
-			errors.push(err);
-		}
-	}
-
-	// Error only if all requests failed
-	if result_count == errors.len() {
-		if let Some(res) = errors.into_iter().next() {
-			return Err(res).context("all datacenter requests failed");
-		}
-	}
-
-	Ok(())
-}
-
-// TODO: This is cloned from api-peer because of a cyclical dependency
-#[derive(Serialize)]
-pub struct CachePurgeRequest {
-	pub base_key: String,
-	pub keys: Vec<rivet_cache::RawCacheKey>,
-}
-
-#[derive(Deserialize)]
-pub struct CachePurgeResponse {}

package/packages/internal/src/ops/mod.rs

@@ -1,2 +0,0 @@
-pub mod bump_serverless_autoscaler_global;
-pub mod cache;

package/packages/namespace/src/ops/runner_config/mod.rs

@@ -1,4 +0,0 @@
-pub mod delete;
-pub mod get;
-pub mod list;
-pub mod upsert;

package/packages/namespace/src/ops/runner_config/upsert.rs

@@ -1,148 +0,0 @@
-use gas::prelude::*;
-use rivet_types::runner_configs::{RunnerConfig, RunnerConfigKind};
-use universaldb::{options::MutationType, utils::IsolationLevel::*};
-
-use crate::{errors, keys, utils::runner_config_variant};
-
-#[derive(Debug)]
-pub struct Input {
-	pub namespace_id: Id,
-	pub name: String,
-	pub config: RunnerConfig,
-}
-
-#[operation]
-pub async fn namespace_runner_config_upsert(ctx: &OperationCtx, input: &Input) -> Result<bool> {
-	let endpoint_config_changed = ctx
-		.udb()?
-		.run(|tx| async move {
-			let tx = tx.with_subspace(keys::subspace());
-
-			let runner_config_key =
-				keys::runner_config::DataKey::new(input.namespace_id, input.name.clone());
-
-			// Check if config changed (for serverless, compare URL and headers)
-			let endpoint_config_changed = if let Some(existing_config) =
-				tx.read_opt(&runner_config_key, Serializable).await?
-			{
-				// Delete previous index
-				tx.delete(&keys::runner_config::ByVariantKey::new(
-					input.namespace_id,
-					runner_config_variant(&existing_config),
-					input.name.clone(),
-				));
-
-				// Check if serverless endpoint config changed
-				match (&existing_config.kind, &input.config.kind) {
-					(
-						RunnerConfigKind::Serverless {
-							url: old_url,
-							headers: old_headers,
-							..
-						},
-						RunnerConfigKind::Serverless {
-							url: new_url,
-							headers: new_headers,
-							..
-						},
-					) => old_url != new_url || old_headers != new_headers,
-					_ => {
-						// Config type changed or is not serverless
-						true
-					}
-				}
-			} else {
-				// New config
-				true
-			};
-
-			// Write new config
-			tx.write(&runner_config_key, input.config.clone())?;
-			tx.write(
-				&keys::runner_config::ByVariantKey::new(
-					input.namespace_id,
-					runner_config_variant(&input.config),
-					input.name.clone(),
-				),
-				input.config.clone(),
-			)?;
-
-			match &input.config.kind {
-				RunnerConfigKind::Normal { .. } => {}
-				RunnerConfigKind::Serverless {
-					url,
-					headers,
-					slots_per_runner,
-					..
-				} => {
-					// Validate url
-					if let Err(err) = url::Url::parse(url) {
-						return Ok(Err(errors::RunnerConfig::Invalid {
-							reason: format!("invalid serverless url: {err}"),
-						}));
-					}
-
-					if headers.len() > 16 {
-						return Ok(Err(errors::RunnerConfig::Invalid {
-							reason: "too many headers (max 16)".to_string(),
-						}));
-					}
-
-					for (n, v) in headers {
-						if n.len() > 128 {
-							return Ok(Err(errors::RunnerConfig::Invalid {
-								reason: format!("invalid header name: too long (max 128)"),
-							}));
-						}
-						if let Err(err) = n.parse::<reqwest::header::HeaderName>() {
-							return Ok(Err(errors::RunnerConfig::Invalid {
-								reason: format!("invalid header name: {err}"),
-							}));
-						}
-						if v.len() > 4096 {
-							return Ok(Err(errors::RunnerConfig::Invalid {
-								reason: format!("invalid header value: too long (max 4096)"),
-							}));
-						}
-						if let Err(err) = v.parse::<reqwest::header::HeaderValue>() {
-							return Ok(Err(errors::RunnerConfig::Invalid {
-								reason: format!("invalid header value: {err}"),
-							}));
-						}
-					}
-
-					// Validate slots per runner
-					if *slots_per_runner == 0 {
-						return Ok(Err(errors::RunnerConfig::Invalid {
-							reason: "`slots_per_runner` cannot be 0".to_string(),
-						}));
-					}
-
-					// Sets desired count to 0 if it doesn't exist
-					let tx = tx.with_subspace(rivet_types::keys::pegboard::subspace());
-					tx.atomic_op(
-						&rivet_types::keys::pegboard::ns::ServerlessDesiredSlotsKey::new(
-							input.namespace_id,
-							input.name.clone(),
-						),
-						&0i64.to_le_bytes(),
-						MutationType::Add,
-					);
-				}
-			}
-
-			Ok(Ok(endpoint_config_changed))
-		})
-		.custom_instrument(tracing::info_span!("runner_config_upsert_tx"))
-		.await?
-		.map_err(|err| err.build())?;
-
-	// Bump autoscaler
-	if input.config.affects_autoscaler() {
-		ctx.msg(rivet_types::msgs::pegboard::BumpServerlessAutoscaler {})
-			.send()
-			.await?;
-	}
-
-	Ok(endpoint_config_changed)
-}

package/packages/pegboard/src/ops/actor/get_runner.rs

@@ -1,64 +0,0 @@
-use futures_util::{StreamExt, TryStreamExt};
-use gas::prelude::*;
-use universaldb::utils::{FormalKey, IsolationLevel::*};
-
-use crate::keys;
-
-#[derive(Debug)]
-pub struct Input {
-	pub actor_ids: Vec<Id>,
-}
-
-#[derive(Debug)]
-pub struct Output {
-	pub actors: Vec<Actor>,
-}
-
-#[derive(Debug)]
-pub struct Actor {
-	pub actor_id: Id,
-	pub runner_id: Id,
-	pub is_connectable: bool,
-}
-
-// TODO: Add cache (remember to purge cache when runner changes)
-#[operation]
-pub async fn pegboard_actor_get_runner(ctx: &OperationCtx, input: &Input) -> Result<Output> {
-	let actors = ctx
-		.udb()?
-		.run(|tx| async move {
-			futures_util::stream::iter(input.actor_ids.clone())
-				.map(|actor_id| {
-					let tx = tx.clone();
-					async move {
-						let runner_id_key = keys::actor::RunnerIdKey::new(actor_id);
-						let connectable_key = keys::actor::ConnectableKey::new(actor_id);
-
-						let (runner_id_entry, connectable_entry) = tokio::try_join!(
-							tx.get(&keys::subspace().pack(&runner_id_key), Serializable),
-							tx.get(&keys::subspace().pack(&connectable_key), Serializable),
-						)?;
-
-						let Some(runner_id_entry) = runner_id_entry else {
-							return Ok(None);
-						};
-
-						let runner_id = runner_id_key.deserialize(&runner_id_entry)?;
-
-						Ok(Some(Actor {
-							actor_id,
-							runner_id,
-							is_connectable: connectable_entry.is_some(),
-						}))
-					}
-				})
-				.buffer_unordered(1024)
-				.try_filter_map(|x| std::future::ready(Ok(x)))
-				.try_collect::<Vec<_>>()
-				.await
-		})
-		.custom_instrument(tracing::info_span!("actor_get_runner_tx"))
-		.await?;
-
-	Ok(Output { actors })
-}