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

package/packages/api-peer/src/runner_configs.rs

@@ -1,9 +1,13 @@
 use anyhow::Result;
 use namespace::utils::runner_config_variant;
 use rivet_api_builder::ApiCtx;
-use rivet_api_types::{pagination::Pagination, runner_configs::list::*};
+use rivet_api_types::{
+	pagination::Pagination,
+	runner_configs::{RunnerConfigResponse, list::*},
+};
 use rivet_types::keys::namespace::runner_config::RunnerConfigVariant;
 use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
 use utoipa::{IntoParams, ToSchema};
 
 #[tracing::instrument(skip_all)]
@@ -15,25 +19,33 @@ pub async fn list(ctx: ApiCtx, _path: ListPath, query: ListQuery) -> Result<List
 		.await?
 		.ok_or_else(|| namespace::errors::Namespace::NotFound.build())?;
 
-	if let Some(runner_names) = query.runner_names {
+	let runner_names = [
+		query.runner_name,
+		query
+			.runner_names
+			.map(|x| x.split(',').map(|x| x.to_string()).collect::<Vec<_>>())
+			.unwrap_or_default(),
+	]
+	.concat();
+
+	let runner_configs = if !runner_names.is_empty() {
 		let runner_configs = ctx
-			.op(namespace::ops::runner_config::get::Input {
+			.op(pegboard::ops::runner_config::get::Input {
 				runners: runner_names
-					.split(',')
-					.map(|name| (namespace.namespace_id, name.to_string()))
+					.into_iter()
+					.map(|name| (namespace.namespace_id, name))
 					.collect(),
 				bypass_cache: false,
 			})
 			.await?;
 
-		Ok(ListResponse {
-			// TODO: Implement ComposeSchema for FakeMap so we don't have to reallocate
-			runner_configs: runner_configs
+		(
+			runner_configs
 				.into_iter()
 				.map(|c| (c.name, c.config))
-				.collect(),
-			pagination: Pagination { cursor: None },
-		})
+				.collect::<Vec<_>>(),
+			None,
+		)
 	} else {
 		// Parse variant from cursor if needed
 		let (variant, after_name) = if let Some(cursor) = query.cursor {
@@ -54,7 +66,7 @@ pub async fn list(ctx: ApiCtx, _path: ListPath, query: ListQuery) -> Result<List
 		};
 
 		let runner_configs = ctx
-			.op(namespace::ops::runner_config::list::Input {
+			.op(pegboard::ops::runner_config::list::Input {
 				namespace_id: namespace.namespace_id,
 				variant,
 				after_name,
@@ -66,12 +78,47 @@ pub async fn list(ctx: ApiCtx, _path: ListPath, query: ListQuery) -> Result<List
 			.last()
 			.map(|(name, config)| format!("{}:{}", runner_config_variant(&config), name));
 
-		Ok(ListResponse {
-			// TODO: Implement ComposeSchema for FakeMap so we don't have to reallocate
-			runner_configs: runner_configs.into_iter().collect(),
-			pagination: Pagination { cursor },
+		(runner_configs, cursor)
+	};
+
+	// Fetch pool errors
+	let runner_pool_errors: HashMap<String, _> = if !runner_configs.0.is_empty() {
+		let runners = runner_configs
+			.0
+			.iter()
+			.map(|(name, _)| (namespace.namespace_id, name.clone()))
+			.collect();
+		ctx.op(pegboard::ops::runner_config::get_error::Input { runners })
+			.await?
+			.into_iter()
+			.map(|e| (e.runner_name, e.error))
+			.collect()
+	} else {
+		HashMap::new()
+	};
+
+	// Build response with pool errors
+	let runner_configs_with_errors: HashMap<String, RunnerConfigResponse> = runner_configs
+		.0
+		.into_iter()
+		.map(|(name, config)| {
+			let runner_pool_error = runner_pool_errors.get(&name).cloned();
+			(
+				name,
+				RunnerConfigResponse {
+					config,
+					runner_pool_error,
+				},
+			)
 		})
-	}
+		.collect();
+
+	Ok(ListResponse {
+		runner_configs: runner_configs_with_errors,
+		pagination: Pagination {
+			cursor: runner_configs.1,
+		},
+	})
 }
 
 #[derive(Debug, Serialize, Deserialize, Clone, IntoParams)]
@@ -112,7 +159,7 @@ pub async fn upsert(
 		.ok_or_else(|| namespace::errors::Namespace::NotFound.build())?;
 
 	let endpoint_config_changed = ctx
-		.op(namespace::ops::runner_config::upsert::Input {
+		.op(pegboard::ops::runner_config::upsert::Input {
 			namespace_id: namespace.namespace_id,
 			name: path.runner_name,
 			config: body.0.into(),
@@ -150,7 +197,7 @@ pub async fn delete(ctx: ApiCtx, path: DeletePath, query: DeleteQuery) -> Result
 		.await?
 		.ok_or_else(|| namespace::errors::Namespace::NotFound.build())?;
 
-	ctx.op(namespace::ops::runner_config::delete::Input {
+	ctx.op(pegboard::ops::runner_config::delete::Input {
 		namespace_id: namespace.namespace_id,
 		name: path.runner_name,
 	})

package/packages/api-peer/src/runners.rs

@@ -1,17 +1,15 @@
 use anyhow::Result;
-use rivet_api_builder::ApiCtx;
-use rivet_api_types::{pagination::Pagination, runners::list::*};
-use serde::{Deserialize, Serialize};
-use utoipa::{IntoParams, ToSchema};
+use rivet_api_builder::{ApiBadRequest, ApiCtx};
+use rivet_api_types::{pagination::Pagination, runners::list::*, runners::list_names::*};
 
 #[utoipa::path(
-    get,
+	get,
 	operation_id = "runners_list",
-    path = "/runners",
-    params(ListQuery),
-    responses(
-        (status = 200, body = ListResponse),
-    ),
+	path = "/runners",
+	params(ListQuery),
+	responses(
+		(status = 200, body = ListResponse),
+	),
 )]
 #[tracing::instrument(skip_all)]
 pub async fn list(ctx: ApiCtx, _path: (), query: ListQuery) -> Result<ListResponse> {
@@ -22,11 +20,28 @@ pub async fn list(ctx: ApiCtx, _path: (), query: ListQuery) -> Result<ListRespon
 		.await?
 		.ok_or_else(|| namespace::errors::Namespace::NotFound.build())?;
 
-	if let Some(runner_ids) = query.runner_ids {
-		let runner_ids = runner_ids
-			.split(',')
-			.filter_map(|s| s.trim().parse::<rivet_util::Id>().ok())
-			.collect::<Vec<_>>();
+	let runner_ids = [
+		query.runner_id,
+		query
+			.runner_ids
+			.map(|x| {
+				x.split(',')
+					.map(|s| {
+						s.trim().parse::<rivet_util::Id>().map_err(|e| {
+							ApiBadRequest {
+								reason: format!("invalid id in `runner_ids` query: {e}"),
+							}
+							.build()
+						})
+					})
+					.collect::<Result<Vec<_>>>()
+			})
+			.transpose()?
+			.unwrap_or_default(),
+	]
+	.concat();
+
+	if !runner_ids.is_empty() {
 		let runners = ctx
 			.op(pegboard::ops::runner::get::Input { runner_ids })
 			.await?
@@ -60,23 +75,6 @@ pub async fn list(ctx: ApiCtx, _path: (), query: ListQuery) -> Result<ListRespon
 	}
 }
 
-#[derive(Debug, Serialize, Deserialize, Clone, IntoParams)]
-#[serde(deny_unknown_fields)]
-#[into_params(parameter_in = Query)]
-pub struct ListNamesQuery {
-	pub namespace: String,
-	pub limit: Option<usize>,
-	pub cursor: Option<String>,
-}
-
-#[derive(Serialize, Deserialize, ToSchema)]
-#[serde(deny_unknown_fields)]
-#[schema(as = RunnersListNamesResponse)]
-pub struct ListNamesResponse {
-	pub names: Vec<String>,
-	pub pagination: Pagination,
-}
-
 #[tracing::instrument(skip_all)]
 pub async fn list_names(
 	ctx: ApiCtx,

package/packages/api-public/Cargo.toml

@@ -12,6 +12,7 @@ epoxy.workspace = true
 futures-util.workspace = true
 gas.workspace = true
 include_dir.workspace = true
+indexmap.workspace = true
 namespace.workspace = true
 pegboard.workspace = true
 reqwest.workspace = true
@@ -27,6 +28,7 @@ rivet-types.workspace = true
 rivet-util.workspace = true
 serde_json.workspace = true
 serde.workspace = true
+subtle.workspace = true
 tokio.workspace = true
 tower-http.workspace = true
 tracing.workspace = true

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

@@ -4,20 +4,11 @@ use rivet_api_builder::{
 	ApiError,
 	extract::{Extension, Json, Query},
 };
-use rivet_api_types::actors::create::{CreateRequest, CreateResponse};
+use rivet_api_types::actors::create::*;
 use rivet_api_util::request_remote_datacenter;
-use serde::{Deserialize, Serialize};
-use utoipa::IntoParams;
 
 use crate::ctx::ApiCtx;
 
-#[derive(Debug, Serialize, Deserialize, IntoParams)]
-#[serde(deny_unknown_fields)]
-#[into_params(parameter_in = Query)]
-pub struct CreateQuery {
-	pub namespace: String,
-}
-
 /// ## Datacenter Round Trips
 ///
 /// **If actor is created in the current datacenter:**
@@ -35,14 +26,14 @@ pub struct CreateQuery {
 ///
 /// actor::get will always be in the same datacenter.
 #[utoipa::path(
-    post,
+	post,
 	operation_id = "actors_create",
-    path = "/actors",
-    params(CreateQuery),
-    request_body(content = CreateRequest, content_type = "application/json"),
-    responses(
-        (status = 200, body = CreateResponse),
-    ),
+	path = "/actors",
+	params(CreateQuery),
+	request_body(content = CreateRequest, content_type = "application/json"),
+	responses(
+		(status = 200, body = CreateResponse),
+	),
 )]
 pub async fn create(
 	Extension(ctx): Extension<ApiCtx>,

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

@@ -4,46 +4,28 @@ use rivet_api_builder::{
 	ApiError,
 	extract::{Extension, Json, Path, Query},
 };
+use rivet_api_types::actors::delete::*;
 use rivet_api_util::request_remote_datacenter_raw;
 use rivet_util::Id;
-use serde::{Deserialize, Serialize};
-use utoipa::{IntoParams, ToSchema};
 
 use crate::ctx::ApiCtx;
 
-#[derive(Debug, Deserialize, Serialize, IntoParams)]
-#[serde(deny_unknown_fields)]
-#[into_params(parameter_in = Query)]
-pub struct DeleteQuery {
-	pub namespace: Option<String>,
-}
-
-#[derive(Deserialize)]
-#[serde(deny_unknown_fields)]
-pub struct DeletePath {
-	pub actor_id: Id,
-}
-
-#[derive(Serialize, ToSchema)]
-#[schema(as = ActorsDeleteResponse)]
-pub struct DeleteResponse {}
-
 /// ## Datacenter Round Trips
 ///
 /// 2 round trip:
 /// - DELETE /actors/{}
 /// - [api-peer] namespace::ops::resolve_for_name_global
 #[utoipa::path(
-    delete,
+	delete,
 	operation_id = "actors_delete",
-    path = "/actors/{actor_id}",
-    params(
-        ("actor_id" = Id, Path),
-        DeleteQuery,
-    ),
-    responses(
-        (status = 200, body = DeleteResponse),
-    ),
+	path = "/actors/{actor_id}",
+	params(
+		("actor_id" = Id, Path),
+		DeleteQuery,
+	),
+	responses(
+		(status = 200, body = DeleteResponse),
+	),
 	security(("bearer_auth" = [])),
 )]
 #[tracing::instrument(skip_all)]
@@ -63,13 +45,7 @@ async fn delete_inner(ctx: ApiCtx, path: DeletePath, query: DeleteQuery) -> Resu
 	ctx.auth().await?;
 
 	if path.actor_id.label() == ctx.config().dc_label() {
-		let peer_path = rivet_api_peer::actors::delete::DeletePath {
-			actor_id: path.actor_id,
-		};
-		let peer_query = rivet_api_peer::actors::delete::DeleteQuery {
-			namespace: query.namespace,
-		};
-		let res = rivet_api_peer::actors::delete::delete(ctx.into(), peer_path, peer_query).await?;
+		let res = rivet_api_peer::actors::delete::delete(ctx.into(), path, query).await?;
 
 		Ok(Json(res).into_response())
 	} else {

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

@@ -4,40 +4,11 @@ use rivet_api_builder::{
 	ApiError,
 	extract::{Extension, Json, Query},
 };
-use rivet_types::actors::CrashPolicy;
-use rivet_util::Id;
-use serde::{Deserialize, Serialize};
-use utoipa::{IntoParams, ToSchema};
+use rivet_api_types::actors::get_or_create::*;
+use rivet_api_util::request_remote_datacenter;
 
-use crate::actors::utils;
 use crate::ctx::ApiCtx;
 
-#[derive(Debug, Deserialize, IntoParams)]
-#[serde(deny_unknown_fields)]
-#[into_params(parameter_in = Query)]
-pub struct GetOrCreateQuery {
-	pub namespace: String,
-}
-
-#[derive(Deserialize, ToSchema)]
-#[serde(deny_unknown_fields)]
-#[schema(as = ActorsGetOrCreateRequest)]
-pub struct GetOrCreateRequest {
-	pub datacenter: Option<String>,
-	pub name: String,
-	pub key: String,
-	pub input: Option<String>,
-	pub runner_name_selector: String,
-	pub crash_policy: CrashPolicy,
-}
-
-#[derive(Serialize, ToSchema)]
-#[schema(as = ActorsGetOrCreateResponse)]
-pub struct GetOrCreateResponse {
-	pub actor: rivet_types::actors::Actor,
-	pub created: bool,
-}
-
 /// ## Datacenter Round Trips
 ///
 /// **If actor exists**
@@ -63,14 +34,14 @@ pub struct GetOrCreateResponse {
 ///
 /// ## Optimized Alternative Routes
 #[utoipa::path(
-    put,
+	put,
 	operation_id = "actors_get_or_create",
-    path = "/actors",
-    params(GetOrCreateQuery),
-    request_body(content = GetOrCreateRequest, content_type = "application/json"),
-    responses(
-        (status = 200, body = GetOrCreateResponse),
-    ),
+	path = "/actors",
+	params(GetOrCreateQuery),
+	request_body(content = GetOrCreateRequest, content_type = "application/json"),
+	responses(
+		(status = 200, body = GetOrCreateResponse),
+	),
 )]
 pub async fn get_or_create(
 	Extension(ctx): Extension<ApiCtx>,
@@ -91,7 +62,6 @@ async fn get_or_create_inner(
 ) -> Result<GetOrCreateResponse> {
 	ctx.skip_auth();
 
-	// Resolve namespace
 	let namespace = ctx
 		.op(namespace::ops::resolve_for_name_global::Input {
 			name: query.namespace.clone(),
@@ -99,25 +69,6 @@ async fn get_or_create_inner(
 		.await?
 		.ok_or_else(|| namespace::errors::Namespace::NotFound.build())?;
 
-	// Check if actor already exists for the key
-	// The get_for_key op uses global consistency and handles datacenter routing
-	let existing = ctx
-		.op(pegboard::ops::actor::get_for_key::Input {
-			namespace_id: namespace.namespace_id,
-			name: body.name.clone(),
-			key: body.key.clone(),
-		})
-		.await?;
-
-	if let Some(actor) = existing.actor {
-		// Actor exists, return it
-		return Ok(GetOrCreateResponse {
-			actor,
-			created: false,
-		});
-	}
-
-	// Actor doesn't exist for any key, create it
 	let target_dc_label = super::utils::find_dc_for_actor_creation(
 		&ctx,
 		namespace.namespace_id,
@@ -127,44 +78,21 @@ async fn get_or_create_inner(
 	)
 	.await?;
 
-	let actor_id = Id::new_v1(target_dc_label);
+	let query = GetOrCreateQuery {
+		namespace: query.namespace,
+	};
 
-	match ctx
-		.op(pegboard::ops::actor::create::Input {
-			actor_id,
-			namespace_id: namespace.namespace_id,
-			name: body.name.clone(),
-			key: Some(body.key.clone()),
-			runner_name_selector: body.runner_name_selector,
-			input: body.input.clone(),
-			crash_policy: body.crash_policy,
-			forward_request: true,
-			datacenter_name: body.datacenter.clone(),
-		})
+	if target_dc_label == ctx.config().dc_label() {
+		rivet_api_peer::actors::get_or_create::get_or_create(ctx.into(), (), query, body).await
+	} else {
+		request_remote_datacenter::<GetOrCreateResponse>(
+			ctx.config(),
+			target_dc_label,
+			"/actors",
+			axum::http::Method::PUT,
+			Some(&query),
+			Some(&body),
+		)
 		.await
-	{
-		Ok(res) => Ok(GetOrCreateResponse {
-			actor: res.actor,
-			created: true,
-		}),
-		Err(err) => {
-			// Check if this is a DuplicateKey error and extract the existing actor ID
-			if let Some(existing_actor_id) = utils::extract_duplicate_key_error(&err) {
-				tracing::info!(
-					?existing_actor_id,
-					"received duplicate key error, returning existing actor id"
-				);
-				let actor =
-					utils::fetch_actor_by_id(&ctx, existing_actor_id, query.namespace.clone())
-						.await?;
-				return Ok(GetOrCreateResponse {
-					actor,
-					created: false,
-				});
-			}
-
-			// Re-throw the original error if it's not a DuplicateKey
-			Err(err)
-		}
 	}
 }

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

@@ -2,29 +2,14 @@ use anyhow::Result;
 use axum::response::{IntoResponse, Response};
 use rivet_api_builder::{
 	ApiError,
-	extract::{Extension, Path},
+	extract::{Extension, Json, Path, Query},
 };
+use rivet_api_types::actors::kv_get::*;
 use rivet_api_util::request_remote_datacenter_raw;
 use rivet_util::Id;
-use serde::{Deserialize, Serialize};
-use utoipa::ToSchema;
 
 use crate::ctx::ApiCtx;
 
-#[derive(Deserialize)]
-#[serde(deny_unknown_fields)]
-pub struct KvGetPath {
-	pub actor_id: Id,
-	pub key: String,
-}
-
-#[derive(Serialize, ToSchema)]
-#[schema(as = ActorsKvGetResponse)]
-pub struct KvGetResponse {
-	pub value: String,
-	pub update_ts: i64,
-}
-
 #[utoipa::path(
 	get,
 	operation_id = "actors_kv_get",
@@ -32,6 +17,7 @@ pub struct KvGetResponse {
 	params(
 		("actor_id" = Id, Path),
 		("key" = String, Path),
+		KvGetQuery,
 	),
 	responses(
 		(status = 200, body = KvGetResponse),
@@ -39,26 +25,23 @@ pub struct KvGetResponse {
 	security(("bearer_auth" = [])),
 )]
 #[tracing::instrument(skip_all)]
-pub async fn kv_get(Extension(ctx): Extension<ApiCtx>, Path(path): Path<KvGetPath>) -> Response {
-	match kv_get_inner(ctx, path).await {
+pub async fn kv_get(
+	Extension(ctx): Extension<ApiCtx>,
+	Path(path): Path<KvGetPath>,
+	Query(query): Query<KvGetQuery>,
+) -> Response {
+	match kv_get_inner(ctx, path, query).await {
 		Ok(response) => response,
 		Err(err) => ApiError::from(err).into_response(),
 	}
 }
 
 #[tracing::instrument(skip_all)]
-async fn kv_get_inner(ctx: ApiCtx, path: KvGetPath) -> Result<Response> {
-	use axum::Json;
-
+async fn kv_get_inner(ctx: ApiCtx, path: KvGetPath, query: KvGetQuery) -> Result<Response> {
 	ctx.auth().await?;
 
 	if path.actor_id.label() == ctx.config().dc_label() {
-		let peer_path = rivet_api_peer::actors::kv_get::KvGetPath {
-			actor_id: path.actor_id,
-			key: path.key,
-		};
-		let peer_query = rivet_api_peer::actors::kv_get::KvGetQuery {};
-		let res = rivet_api_peer::actors::kv_get::kv_get(ctx.into(), peer_path, peer_query).await?;
+		let res = rivet_api_peer::actors::kv_get::kv_get(ctx.into(), path, query).await?;
 
 		Ok(Json(res).into_response())
 	} else {
@@ -71,7 +54,7 @@ async fn kv_get_inner(ctx: ApiCtx, path: KvGetPath) -> Result<Response> {
 				urlencoding::encode(&path.key)
 			),
 			axum::http::Method::GET,
-			Option::<&()>::None,
+			Some(&query),
 			Option::<&()>::None,
 		)
 		.await