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

package/packages/api-public/src/actors/list.rs

@@ -1,37 +1,14 @@
 use anyhow::{Context, Result};
 use axum::response::{IntoResponse, Response};
 use rivet_api_builder::{
-	ApiError,
+	ApiBadRequest, ApiError,
 	extract::{Extension, Json, Query},
 };
-use rivet_api_types::pagination::Pagination;
+use rivet_api_types::{actors::list::*, pagination::Pagination};
 use rivet_api_util::fanout_to_datacenters;
-use serde::{Deserialize, Serialize};
-use utoipa::{IntoParams, ToSchema};
 
 use crate::{actors::utils::fetch_actors_by_ids, ctx::ApiCtx, errors};
 
-#[derive(Debug, Serialize, Deserialize, Clone, IntoParams)]
-#[serde(deny_unknown_fields)]
-#[into_params(parameter_in = Query)]
-pub struct ListQuery {
-	pub namespace: String,
-	pub name: Option<String>,
-	pub key: Option<String>,
-	pub actor_ids: Option<String>,
-	pub include_destroyed: Option<bool>,
-	pub limit: Option<usize>,
-	pub cursor: Option<String>,
-}
-
-#[derive(Serialize, Deserialize, ToSchema)]
-#[serde(deny_unknown_fields)]
-#[schema(as = ActorsListResponse)]
-pub struct ListResponse {
-	pub actors: Vec<rivet_types::actors::Actor>,
-	pub pagination: Pagination,
-}
-
 /// ## Datacenter Round Trips
 ///
 /// **If key is some & `include_destroyed` is false**
@@ -55,13 +32,13 @@ pub struct ListResponse {
 ///
 /// ## Optimized Alternative Routes
 #[utoipa::path(
-    get,
+	get,
 	operation_id = "actors_list",
-    path = "/actors",
-    params(ListQuery),
-    responses(
-        (status = 200, body = ListResponse),
-    ),
+	path = "/actors",
+	params(ListQuery),
+	responses(
+		(status = 200, body = ListResponse),
+	),
 )]
 pub async fn list(Extension(ctx): Extension<ApiCtx>, Query(query): Query<ListQuery>) -> Response {
 	match list_inner(ctx, query).await {
@@ -71,20 +48,41 @@ pub async fn list(Extension(ctx): Extension<ApiCtx>, Query(query): Query<ListQue
 }
 
 async fn list_inner(ctx: ApiCtx, query: ListQuery) -> Result<ListResponse> {
-	ctx.auth().await?;
+	// Reading is allowed, list requires auth
+	if query.actor_ids.is_none() && query.actor_id.is_empty() && query.key.is_none() {
+		ctx.auth().await?;
+	} else {
+		ctx.skip_auth();
+	}
 
 	// Parse query
-	let actor_ids = query.actor_ids.as_ref().map(|x| {
-		x.split(',')
-			.filter_map(|s| s.trim().parse::<rivet_util::Id>().ok())
-			.collect::<Vec<_>>()
-	});
+	let actor_ids = [
+		query.actor_id.clone(),
+		query
+			.actor_ids
+			.as_ref()
+			.map(|x| {
+				x.split(',')
+					.map(|s| {
+						s.trim().parse::<rivet_util::Id>().map_err(|e| {
+							ApiBadRequest {
+								reason: format!("invalid id in `actor_ids` query: {e}"),
+							}
+							.build()
+						})
+					})
+					.collect::<Result<Vec<_>>>()
+			})
+			.transpose()?
+			.unwrap_or_default(),
+	]
+	.concat();
 	let include_destroyed = query.include_destroyed.unwrap_or(false);
 
 	// Validate exclusive input: either (name + key) or actor_ids
-	if actor_ids.is_some() && (query.name.is_some() || query.key.is_some()) {
+	if !actor_ids.is_empty() && (query.name.is_some() || query.key.is_some()) {
 		return Err(errors::Validation::InvalidInput {
-			message: "Cannot provide both actor_ids and (name + key). Use either actor_ids or (name + key).".to_string(),
+			message: "Cannot provide both actor_id and (name + key). Use either actor_id or (name + key).".to_string(),
 		}
 		.build());
 	}
@@ -97,7 +95,7 @@ async fn list_inner(ctx: ApiCtx, query: ListQuery) -> Result<ListResponse> {
 		.build());
 	}
 
-	if let Some(actor_ids) = actor_ids {
+	if !actor_ids.is_empty() {
 		// Cap actor_ids count to 32
 		if actor_ids.len() > 32 {
 			return Err(errors::Validation::TooManyActorIds {
@@ -107,14 +105,6 @@ async fn list_inner(ctx: ApiCtx, query: ListQuery) -> Result<ListResponse> {
 			.build());
 		}
 
-		// If no actors specified, return empty result
-		if actor_ids.is_empty() {
-			return Ok(ListResponse {
-				actors: Vec::new(),
-				pagination: Pagination { cursor: None },
-			});
-		}
-
 		// Resolve namespace once to verify actors belong to it (namespace validation is done in api-peer)
 		ctx.op(namespace::ops::resolve_for_name_global::Input {
 			name: query.namespace.clone(),
@@ -122,16 +112,20 @@ async fn list_inner(ctx: ApiCtx, query: ListQuery) -> Result<ListResponse> {
 		.await?
 		.ok_or_else(|| namespace::errors::Namespace::NotFound.build())?;
 
+		let limit = query.limit.unwrap_or(100);
+
 		// Fetch actors
-		let actors = fetch_actors_by_ids(
+		let mut actors = fetch_actors_by_ids(
 			&ctx,
 			actor_ids,
 			query.namespace.clone(),
 			query.include_destroyed,
-			query.limit,
+			Some(limit),
 		)
 		.await?;
 
+		actors.truncate(limit);
+
 		let cursor = actors.last().map(|x| x.create_ts.to_string());
 
 		Ok(ListResponse {
@@ -157,6 +151,7 @@ async fn list_inner(ctx: ApiCtx, query: ListQuery) -> Result<ListResponse> {
 				namespace_id: namespace.namespace_id,
 				name: name.clone(),
 				key: key.clone(),
+				fetch_error: true,
 			})
 			.await?
 			.actor
@@ -196,40 +191,23 @@ async fn list_inner(ctx: ApiCtx, query: ListQuery) -> Result<ListResponse> {
 			.build());
 		}
 
-		// Prepare peer query for local handler
-		let peer_query = rivet_api_types::actors::list::ListQuery {
-			namespace: query.namespace.clone(),
-			name: Some(query.name.as_ref().unwrap().clone()),
-			key: query.key.clone(),
-			actor_ids: None,
-			include_destroyed: query.include_destroyed,
-			limit: query.limit,
-			cursor: query.cursor.clone(),
-		};
+		let limit = query.limit.unwrap_or(100);
 
 		// Fanout to all datacenters
-		let mut actors = fanout_to_datacenters::<
-			rivet_api_types::actors::list::ListResponse,
-			_,
-			_,
-			_,
-			_,
-			Vec<rivet_types::actors::Actor>,
-		>(
-			ctx.into(),
-			"/actors",
-			peer_query,
-			|ctx, query| async move { rivet_api_peer::actors::list::list(ctx, (), query).await },
-			|_, res, agg| agg.extend(res.actors),
-		)
-		.await?;
+		let mut actors =
+			fanout_to_datacenters::<ListResponse, _, _, _, _, Vec<rivet_types::actors::Actor>>(
+				ctx.into(),
+				"/actors",
+				query,
+				|ctx, query| async move { rivet_api_peer::actors::list::list(ctx, (), query).await },
+				|_, res, agg| agg.extend(res.actors),
+			)
+			.await?;
 
 		// Sort by create ts desc
 		actors.sort_by_cached_key(|x| std::cmp::Reverse(x.create_ts));
 
-		// Shorten array since returning all actors from all regions could end up returning `regions *
-		// limit` results, which is a lot.
-		actors.truncate(query.limit.unwrap_or(100));
+		actors.truncate(limit);
 
 		let cursor = actors.last().map(|x| x.create_ts.to_string());
 

package/packages/api-public/src/actors/list_names.rs

@@ -1,5 +1,6 @@
 use anyhow::Result;
 use axum::response::{IntoResponse, Response};
+use indexmap::IndexMap;
 use rivet_api_builder::{
 	ApiError,
 	extract::{Extension, Json, Query},
@@ -16,13 +17,13 @@ use crate::ctx::ApiCtx;
 /// - GET /actors/names (fanout)
 /// - [api-peer] namespace::ops::resolve_for_name_global
 #[utoipa::path(
-    get,
+	get,
 	operation_id = "actors_list_names",
-    path = "/actors/names",
-    params(ListNamesQuery),
-    responses(
-        (status = 200, body = ListNamesResponse),
-    ),
+	path = "/actors/names",
+	params(ListNamesQuery),
+	responses(
+		(status = 200, body = ListNamesResponse),
+	),
 	security(("bearer_auth" = [])),
 )]
 #[tracing::instrument(skip_all)]
@@ -49,7 +50,7 @@ async fn list_names_inner(ctx: ApiCtx, query: ListNamesQuery) -> Result<ListName
 
 	// Fanout to all datacenters
 	let mut all_names =
-		fanout_to_datacenters::<ListNamesResponse, _, _, _, _, Vec<(String, ActorName)>>(
+		fanout_to_datacenters::<ListNamesResponse, _, _, _, _, IndexMap<String, ActorName>>(
 			ctx.into(),
 			"/actors/names",
 			peer_query,
@@ -58,18 +59,18 @@ async fn list_names_inner(ctx: ApiCtx, query: ListNamesQuery) -> Result<ListName
 			},
 			|_, res, agg| agg.extend(res.names),
 		)
-		.await?;
+		.await?
+		.into_iter()
+		// Apply limit
+		.take(query.limit.unwrap_or(100))
+		.collect::<IndexMap<_, _>>();
 
-	// Sort by name for consistency
-	all_names.sort_by(|a, b| a.0.cmp(&b.0));
-
-	// Truncate to the requested limit
-	all_names.truncate(query.limit.unwrap_or(100));
+	// Sort for consistency
+	all_names.sort_keys();
 
 	let cursor = all_names.last().map(|(name, _)| name.to_string());
 
 	Ok(ListNamesResponse {
-		// TODO: Implement ComposeSchema for FakeMap so we don't have to reallocate
 		names: all_names.into_iter().collect(),
 		pagination: Pagination { cursor },
 	})

package/packages/api-public/src/actors/mod.rs

@@ -4,4 +4,6 @@ pub mod get_or_create;
 pub mod kv_get;
 pub mod list;
 pub mod list_names;
+pub mod reschedule;
+pub mod sleep;
 pub mod utils;

package/packages/api-public/src/actors/reschedule.rs

@@ -0,0 +1,65 @@
+use anyhow::Result;
+use axum::response::{IntoResponse, Response};
+use rivet_api_builder::{
+	ApiError,
+	extract::{Extension, Json, Path, Query},
+};
+use rivet_api_types::actors::reschedule::*;
+use rivet_api_util::request_remote_datacenter_raw;
+use rivet_util::Id;
+
+use crate::ctx::ApiCtx;
+
+#[utoipa::path(
+	post,
+	operation_id = "actors_reschedule",
+	path = "/actors/{actor_id}/reschedule",
+	params(
+		("actor_id" = Id, Path),
+		RescheduleQuery,
+	),
+	request_body(content = RescheduleRequest, content_type = "application/json"),
+	responses(
+		(status = 200, body = RescheduleResponse),
+	),
+	security(("bearer_auth" = [])),
+)]
+#[tracing::instrument(skip_all)]
+pub async fn reschedule(
+	Extension(ctx): Extension<ApiCtx>,
+	Path(path): Path<ReschedulePath>,
+	Query(query): Query<RescheduleQuery>,
+	Json(body): Json<RescheduleRequest>,
+) -> Response {
+	match reschedule_inner(ctx, path, query, body).await {
+		Ok(response) => response,
+		Err(err) => ApiError::from(err).into_response(),
+	}
+}
+
+#[tracing::instrument(skip_all)]
+async fn reschedule_inner(
+	ctx: ApiCtx,
+	path: ReschedulePath,
+	query: RescheduleQuery,
+	body: RescheduleRequest,
+) -> Result<Response> {
+	ctx.auth().await?;
+
+	if path.actor_id.label() == ctx.config().dc_label() {
+		let res =
+			rivet_api_peer::actors::reschedule::reschedule(ctx.into(), path, query, body).await?;
+
+		Ok(Json(res).into_response())
+	} else {
+		request_remote_datacenter_raw(
+			&ctx,
+			path.actor_id.label(),
+			&format!("/actors/{}/reschedule", path.actor_id),
+			axum::http::Method::POST,
+			Some(&query),
+			Some(&body),
+		)
+		.await
+	}
+}

package/packages/api-public/src/actors/sleep.rs

@@ -0,0 +1,64 @@
+use anyhow::Result;
+use axum::response::{IntoResponse, Response};
+use rivet_api_builder::{
+	ApiError,
+	extract::{Extension, Json, Path, Query},
+};
+use rivet_api_types::actors::sleep::*;
+use rivet_api_util::request_remote_datacenter_raw;
+use rivet_util::Id;
+
+use crate::ctx::ApiCtx;
+
+#[utoipa::path(
+	post,
+	operation_id = "actors_sleep",
+	path = "/actors/{actor_id}/sleep",
+	params(
+		("actor_id" = Id, Path),
+		SleepQuery,
+	),
+	request_body(content = SleepRequest, content_type = "application/json"),
+	responses(
+		(status = 200, body = SleepResponse),
+	),
+	security(("bearer_auth" = [])),
+)]
+#[tracing::instrument(skip_all)]
+pub async fn sleep(
+	Extension(ctx): Extension<ApiCtx>,
+	Path(path): Path<SleepPath>,
+	Query(query): Query<SleepQuery>,
+	Json(body): Json<SleepRequest>,
+) -> Response {
+	match sleep_inner(ctx, path, query, body).await {
+		Ok(response) => response,
+		Err(err) => ApiError::from(err).into_response(),
+	}
+}
+
+#[tracing::instrument(skip_all)]
+async fn sleep_inner(
+	ctx: ApiCtx,
+	path: SleepPath,
+	query: SleepQuery,
+	body: SleepRequest,
+) -> Result<Response> {
+	ctx.auth().await?;
+
+	if path.actor_id.label() == ctx.config().dc_label() {
+		let res = rivet_api_peer::actors::sleep::sleep(ctx.into(), path, query, body).await?;
+
+		Ok(Json(res).into_response())
+	} else {
+		request_remote_datacenter_raw(
+			&ctx,
+			path.actor_id.label(),
+			&format!("/actors/{}/sleep", path.actor_id),
+			axum::http::Method::POST,
+			Some(&query),
+			Some(&body),
+		)
+		.await
+	}
+}

package/packages/api-public/src/actors/utils.rs

@@ -2,7 +2,6 @@ use anyhow::Result;
 use axum::http::Method;
 use rivet_api_builder::ApiCtx;
 use rivet_api_util::request_remote_datacenter;
-use rivet_error::RivetError;
 use rivet_types::actors::Actor;
 use rivet_util::Id;
 use std::collections::HashMap;
@@ -79,19 +78,13 @@ pub async fn fetch_actors_by_ids(
 		let limit = limit;
 
 		async move {
-			// Convert actor IDs to comma-separated string
-			let actor_ids_str = dc_actor_ids
-				.iter()
-				.map(|id| id.to_string())
-				.collect::<Vec<_>>()
-				.join(",");
-
 			// Prepare peer query with actor_ids
 			let peer_query = rivet_api_types::actors::list::ListQuery {
 				namespace: namespace.clone(),
 				name: None,
 				key: None,
-				actor_ids: Some(actor_ids_str),
+				actor_ids: None,
+				actor_id: dc_actor_ids,
 				include_destroyed,
 				limit,
 				cursor: None,
@@ -135,49 +128,6 @@ pub async fn fetch_actors_by_ids(
 	Ok(actors)
 }
 
-/// Helper function to extract the existing actor ID from a duplicate key error
-///
-/// Returns Some(actor_id) if the error is a duplicate key error with metadata, None otherwise
-pub fn extract_duplicate_key_error(err: &anyhow::Error) -> Option<Id> {
-	// Try to downcast to RivetError first (local calls)
-	let rivet_err = err.chain().find_map(|x| x.downcast_ref::<RivetError>());
-	if let Some(rivet_err) = rivet_err {
-		if rivet_err.group() == "actor" && rivet_err.code() == "duplicate_key" {
-			// Extract existing_actor_id from metadata
-			if let Some(metadata) = rivet_err.metadata() {
-				if let Some(actor_id_str) =
-					metadata.get("existing_actor_id").and_then(|v| v.as_str())
-				{
-					if let Ok(actor_id) = actor_id_str.parse::<Id>() {
-						return Some(actor_id);
-					}
-				}
-			}
-		}
-	}
-
-	// Try to downcast to RawErrorResponse (for remote API calls)
-	let raw_err = err
-		.chain()
-		.find_map(|x| x.downcast_ref::<rivet_api_builder::error_response::RawErrorResponse>());
-	if let Some(raw_err) = raw_err {
-		if raw_err.1.group == "actor" && raw_err.1.code == "duplicate_key" {
-			// Extract existing_actor_id from metadata (now available in ErrorResponse)
-			if let Some(metadata) = &raw_err.1.metadata {
-				if let Some(actor_id_str) =
-					metadata.get("existing_actor_id").and_then(|v| v.as_str())
-				{
-					if let Ok(actor_id) = actor_id_str.parse::<Id>() {
-						return Some(actor_id);
-					}
-				}
-			}
-		}
-	}
-
-	None
-}
-
 /// Determine the datacenter label to create the actor in.
 #[tracing::instrument(skip_all)]
 pub async fn find_dc_for_actor_creation(
@@ -191,22 +141,24 @@ pub async fn find_dc_for_actor_creation(
 		// Use user-configured DC
 		ctx.config()
 			.dc_for_name(dc_name)
-			.ok_or_else(|| crate::errors::Datacenter::NotFound.build())?
+			.ok_or_else(|| rivet_api_util::errors::Datacenter::NotFound.build())?
 			.datacenter_label
 	} else {
 		// Find the nearest DC with runners
 		let res = ctx
-			.op(pegboard::ops::runner::find_dc_with_runner::Input {
-				namespace_id,
-				runner_name: runner_name.into(),
-			})
+			.op(
+				pegboard::ops::runner::list_runner_config_enabled_dcs::Input {
+					namespace_id,
+					runner_name: runner_name.into(),
+				},
+			)
 			.await?;
-		if let Some(dc_label) = res.dc_label {
+		if let Some(dc_label) = res.dc_labels.into_iter().next() {
 			dc_label
 		} else {
-			return Err(pegboard::errors::Actor::NoRunnersAvailable {
+			return Err(pegboard::errors::Actor::NoRunnerConfigConfigured {
 				namespace: namespace_name.into(),
-				runner_name: runner_name.into(),
+				pool_name: runner_name.into(),
 			}
 			.build());
 		}

package/packages/api-public/src/ctx.rs

@@ -1,3 +1,4 @@
+use anyhow::Result;
 use std::{
 	ops::Deref,
 	sync::{
@@ -5,8 +6,7 @@ use std::{
 		atomic::{AtomicBool, Ordering},
 	},
 };
-
-use anyhow::Result;
+use subtle::ConstantTimeEq;
 
 #[derive(Clone)]
 pub struct ApiCtx {
@@ -31,11 +31,19 @@ impl ApiCtx {
 
 		self.authentication_handled.store(true, Ordering::Relaxed);
 
-		if self.token.as_ref() == Some(auth.admin_token.read()) {
-			Ok(())
-		} else {
-			Err(rivet_api_builder::ApiForbidden.build())
+		let Some(token) = &self.token else {
+			return Err(rivet_api_builder::ApiForbidden.build());
+		};
+
+		if token
+			.as_bytes()
+			.ct_ne(auth.admin_token.read().as_bytes())
+			.into()
+		{
+			return Err(rivet_api_builder::ApiForbidden.build());
 		}
+
+		Ok(())
 	}
 
 	pub fn skip_auth(&self) {

package/packages/api-public/src/datacenters.rs

@@ -7,12 +7,12 @@ use rivet_types::datacenters::Datacenter;
 use crate::ctx::ApiCtx;
 
 #[utoipa::path(
-    get,
+	get,
 	operation_id = "datacenters_list",
-    path = "/datacenters",
-    responses(
-        (status = 200, body = ListResponse),
-    ),
+	path = "/datacenters",
+	responses(
+		(status = 200, body = ListResponse),
+	),
 	security(("bearer_auth" = [])),
 )]
 #[tracing::instrument(skip_all)]

package/packages/api-public/src/envoys.rs

@@ -0,0 +1,57 @@
+use anyhow::Result;
+use axum::response::{IntoResponse, Response};
+use rivet_api_builder::{
+	ApiError,
+	extract::{Extension, Json, Query},
+};
+use rivet_api_types::{envoys::list::*, pagination::Pagination};
+use rivet_api_util::fanout_to_datacenters;
+
+use crate::ctx::ApiCtx;
+
+#[utoipa::path(
+	get,
+	operation_id = "envoys_list",
+	path = "/envoys",
+	params(ListQuery),
+	responses(
+		(status = 200, body = ListResponse),
+	),
+	security(("bearer_auth" = [])),
+)]
+#[tracing::instrument(skip_all)]
+pub async fn list(Extension(ctx): Extension<ApiCtx>, Query(query): Query<ListQuery>) -> Response {
+	match list_inner(ctx, query).await {
+		Ok(response) => Json(response).into_response(),
+		Err(err) => ApiError::from(err).into_response(),
+	}
+}
+
+async fn list_inner(ctx: ApiCtx, query: ListQuery) -> Result<ListResponse> {
+	ctx.auth().await?;
+
+	// Fanout to all datacenters
+	let mut envoys =
+		fanout_to_datacenters::<ListResponse, _, _, _, _, Vec<rivet_types::envoys::Envoy>>(
+			ctx.into(),
+			"/envoys",
+			query.clone(),
+			|ctx, query| async move { rivet_api_peer::envoys::list(ctx, (), query).await },
+			|_, res, agg| agg.extend(res.envoys),
+		)
+		.await?;
+
+	// Sort by create ts desc
+	envoys.sort_by_cached_key(|x| std::cmp::Reverse(x.create_ts));
+
+	// Shorten array since returning all envoys from all regions could end up returning `regions *
+	// limit` results, which is a lot.
+	envoys.truncate(query.limit.unwrap_or(100));
+
+	let cursor = envoys.last().map(|x| x.create_ts.to_string());
+
+	Ok(ListResponse {
+		envoys,
+		pagination: Pagination { cursor },
+	})
+}

package/packages/api-public/src/errors.rs

@@ -1,13 +1,6 @@
 use rivet_error::*;
 use serde::{Deserialize, Serialize};
 
-#[derive(RivetError, Debug, Deserialize, Serialize)]
-#[error("datacenter")]
-pub enum Datacenter {
-	#[error("not_found", "The provided datacenter does not exist.")]
-	NotFound,
-}
-
 #[derive(RivetError, Debug, Deserialize, Serialize)]
 #[error("validation")]
 pub enum Validation {