@rivetkit/engine 1.0.0

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

@@ -0,0 +1,87 @@
+use anyhow::Result;
+use gas::prelude::*;
+use rivet_api_builder::ApiCtx;
+use rivet_util::Id;
+use serde::{Deserialize, Serialize};
+use utoipa::{IntoParams, ToSchema};
+
+#[derive(Debug, Deserialize, Serialize, IntoParams)]
+#[serde(deny_unknown_fields)]
+#[into_params(parameter_in = Query)]
+pub struct DeleteQuery {
+	pub namespace: Option<String>,
+}
+
+#[derive(Serialize, ToSchema)]
+#[schema(as = ActorsDeleteResponse)]
+pub struct DeleteResponse {}
+
+#[derive(Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct DeletePath {
+	pub actor_id: Id,
+}
+
+#[utoipa::path(
+    delete,
+	operation_id = "actors_delete",
+    path = "/actors/{actor_id}",
+    params(
+        ("actor_id" = Id, Path),
+        DeleteQuery,
+    ),
+    responses(
+        (status = 200, body = DeleteResponse),
+    ),
+)]
+#[tracing::instrument(skip_all)]
+pub async fn delete(ctx: ApiCtx, path: DeletePath, query: DeleteQuery) -> Result<DeleteResponse> {
+	// Get the actor first to verify it exists
+	let actors_res = ctx
+		.op(pegboard::ops::actor::get::Input {
+			actor_ids: vec![path.actor_id],
+		})
+		.await?;
+
+	let actor = actors_res
+		.actors
+		.into_iter()
+		.next()
+		.ok_or_else(|| pegboard::errors::Actor::NotFound.build())?;
+
+	// If namespace is provided, verify the actor belongs to it
+	if let Some(namespace_name) = query.namespace {
+		let namespace = ctx
+			.op(namespace::ops::resolve_for_name_global::Input {
+				name: namespace_name,
+			})
+			.await?
+			.ok_or_else(|| namespace::errors::Namespace::NotFound.build())?;
+
+		if actor.namespace_id != namespace.namespace_id {
+			return Err(pegboard::errors::Actor::NotFound.build());
+		}
+	}
+
+	let res = ctx
+		.signal(pegboard::workflows::actor::Destroy {})
+		.to_workflow::<pegboard::workflows::actor::Workflow>()
+		.tag("actor_id", path.actor_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=?path.actor_id,
+			"actor workflow not found, likely already stopped"
+		);
+	} else {
+		res?;
+	}
+
+	Ok(DeleteResponse {})
+}

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

@@ -0,0 +1,67 @@
+use anyhow::*;
+use base64::Engine;
+use base64::prelude::BASE64_STANDARD;
+use pegboard_actor_kv as actor_kv;
+use rivet_api_builder::ApiCtx;
+use rivet_util::Id;
+use serde::{Deserialize, Serialize};
+use utoipa::ToSchema;
+
+#[derive(Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct KvGetPath {
+	pub actor_id: Id,
+	pub key: String,
+}
+
+#[derive(Debug, Deserialize, Serialize)]
+#[serde(deny_unknown_fields)]
+pub struct KvGetQuery {}
+
+#[derive(Serialize, ToSchema)]
+#[schema(as = ActorsKvGetResponse)]
+pub struct KvGetResponse {
+	/// Value encoded in base 64.
+	pub value: String,
+	pub update_ts: i64,
+}
+
+#[utoipa::path(
+	get,
+	operation_id = "actors_kv_get",
+	path = "/actors/{actor_id}/kv/keys/{key}",
+	params(
+		("actor_id" = Id, Path),
+		("key" = String, Path),
+	),
+	responses(
+		(status = 200, body = KvGetResponse),
+	),
+)]
+#[tracing::instrument(skip_all)]
+pub async fn kv_get(ctx: ApiCtx, path: KvGetPath, _query: KvGetQuery) -> Result<KvGetResponse> {
+	// Decode base64 key
+	let key_bytes = BASE64_STANDARD
+		.decode(&path.key)
+		.context("failed to decode base64 key")?;
+
+	// Get the KV value
+	let udb = ctx.pools().udb()?;
+	let (keys, values, metadata) =
+		actor_kv::get(&*udb, path.actor_id, vec![key_bytes.clone()]).await?;
+
+	// Check if key was found
+	if keys.is_empty() {
+		return Err(pegboard::errors::Actor::KvKeyNotFound.build());
+	}
+
+	// Encode value as base64
+	let value_base64 = BASE64_STANDARD.encode(&values[0]);
+
+	Ok(KvGetResponse {
+		value: value_base64,
+		// NOTE: Intentionally uses different name in public API. `create_ts` is actually
+		// `update_ts`.
+		update_ts: metadata[0].create_ts,
+	})
+}

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

@@ -0,0 +1,98 @@
+use anyhow::{Result, bail};
+use rivet_api_builder::ApiCtx;
+use rivet_api_types::{actors::list::*, pagination::Pagination};
+
+#[utoipa::path(
+    get,
+	operation_id = "actors_list",
+    path = "/actors",
+    params(ListQuery),
+    responses(
+        (status = 200, body = ListResponse),
+    ),
+)]
+#[tracing::instrument(skip_all)]
+pub async fn list(ctx: ApiCtx, _path: (), query: ListQuery) -> Result<ListResponse> {
+	let key = query.key;
+	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 include_destroyed = query.include_destroyed.unwrap_or(false);
+
+	// TODO: Update api-peer to require including the reservation ID in the query if querying with
+	// key in order to assert the request was sent to the correct datacenter
+
+	// If actor_ids are provided, fetch actors directly by ID
+	if let Some(actor_ids) = actor_ids {
+		// Resolve namespace to verify actors belong to it
+		let namespace = ctx
+			.op(namespace::ops::resolve_for_name_global::Input {
+				name: query.namespace.clone(),
+			})
+			.await?
+			.ok_or_else(|| namespace::errors::Namespace::NotFound.build())?;
+
+		// Fetch actors by their IDs
+		let get_res = ctx
+			.op(pegboard::ops::actor::get::Input {
+				actor_ids: actor_ids.clone(),
+			})
+			.await?;
+
+		// Filter actors by namespace
+		let mut actors: Vec<rivet_types::actors::Actor> = get_res
+			.actors
+			.into_iter()
+			.filter(|actor| actor.namespace_id == namespace.namespace_id)
+			.collect();
+
+		// Sort by create ts desc
+		actors.sort_by_cached_key(|x| std::cmp::Reverse(x.create_ts));
+
+		// Apply limit
+		actors.truncate(query.limit.unwrap_or(100));
+
+		let cursor = actors.last().map(|x| x.create_ts.to_string());
+
+		Ok(ListResponse {
+			actors,
+			pagination: Pagination { cursor },
+		})
+	} else {
+		// Original list logic for name/key
+		if query.name.is_none() {
+			bail!("name is required when not using actor_ids")
+		}
+
+		let namespace = ctx
+			.op(namespace::ops::resolve_for_name_global::Input {
+				name: query.namespace.clone(),
+			})
+			.await?
+			.ok_or_else(|| namespace::errors::Namespace::NotFound.build())?;
+
+		let list_res = ctx
+			.op(pegboard::ops::actor::list_for_ns::Input {
+				namespace_id: namespace.namespace_id,
+				name: query.name.unwrap(),
+				key,
+				include_destroyed,
+				created_before: query
+					.cursor
+					.as_deref()
+					.map(|c| c.parse::<i64>())
+					.transpose()?,
+				limit: query.limit.unwrap_or(100),
+			})
+			.await?;
+
+		let cursor = list_res.actors.last().map(|x| x.create_ts.to_string());
+
+		Ok(ListResponse {
+			actors: list_res.actors,
+			pagination: Pagination { cursor },
+		})
+	}
+}

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

@@ -0,0 +1,56 @@
+use anyhow::Result;
+use rivet_api_builder::ApiCtx;
+use rivet_api_types::{actors::list_names::*, pagination::Pagination};
+use rivet_types::actors::ActorName;
+
+#[utoipa::path(
+    get,
+	operation_id = "actors_list_names",
+    path = "/actors/names",
+    params(ListNamesQuery),
+    responses(
+        (status = 200, body = ListNamesResponse),
+    ),
+)]
+#[tracing::instrument(skip_all)]
+pub async fn list_names(
+	ctx: ApiCtx,
+	_path: (),
+	query: ListNamesQuery,
+) -> Result<ListNamesResponse> {
+	let namespace = ctx
+		.op(namespace::ops::resolve_for_name_global::Input {
+			name: query.namespace.clone(),
+		})
+		.await?
+		.ok_or_else(|| namespace::errors::Namespace::NotFound.build())?;
+
+	let list_names_res = ctx
+		.op(pegboard::ops::actor::list_names::Input {
+			namespace_id: namespace.namespace_id,
+			after_name: query.cursor.clone(),
+			limit: query.limit.unwrap_or(100),
+		})
+		.await?;
+
+	let cursor = list_names_res
+		.names
+		.last()
+		.map(|(name, _)| name.to_string());
+
+	Ok(ListNamesResponse {
+		names: list_names_res
+			.names
+			.into_iter()
+			.map(|(name, data)| {
+				(
+					name,
+					ActorName {
+						metadata: data.metadata,
+					},
+				)
+			})
+			.collect(),
+		pagination: Pagination { cursor },
+	})
+}

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

@@ -0,0 +1,5 @@
+pub mod create;
+pub mod delete;
+pub mod kv_get;
+pub mod list;
+pub mod list_names;

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

@@ -0,0 +1,186 @@
+use anyhow::*;
+use gas::prelude::*;
+use rivet_api_builder::ApiCtx;
+use serde::{Deserialize, Serialize};
+use universalpubsub::PublishOpts;
+
+#[derive(Serialize, Deserialize)]
+pub struct CachePurgeRequest {
+	pub base_key: String,
+	pub keys: Vec<rivet_cache::RawCacheKey>,
+}
+
+#[derive(Serialize)]
+#[serde(deny_unknown_fields)]
+pub struct CachePurgeResponse {}
+
+pub async fn cache_purge(
+	ctx: ApiCtx,
+	_path: (),
+	_query: (),
+	body: CachePurgeRequest,
+) -> Result<CachePurgeResponse> {
+	ctx.cache()
+		.clone()
+		.request()
+		.purge(&body.base_key, body.keys)
+		.await?;
+
+	Ok(CachePurgeResponse {})
+}
+
+#[derive(Serialize)]
+#[serde(deny_unknown_fields)]
+pub struct BumpServerlessAutoscalerResponse {}
+
+pub async fn bump_serverless_autoscaler(
+	ctx: ApiCtx,
+	_path: (),
+	_query: (),
+	_body: (),
+) -> Result<BumpServerlessAutoscalerResponse> {
+	ctx.msg(rivet_types::msgs::pegboard::BumpServerlessAutoscaler {})
+		.send()
+		.await?;
+
+	Ok(BumpServerlessAutoscalerResponse {})
+}
+
+#[derive(Serialize, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct SetTracingConfigRequest {
+	#[serde(default, skip_serializing_if = "Option::is_none")]
+	pub filter: Option<Option<String>>,
+	#[serde(default, skip_serializing_if = "Option::is_none")]
+	pub sampler_ratio: Option<Option<f64>>,
+}
+
+#[derive(Serialize)]
+#[serde(deny_unknown_fields)]
+pub struct SetTracingConfigResponse {}
+
+#[tracing::instrument(skip_all)]
+pub async fn set_tracing_config(
+	ctx: ApiCtx,
+	_path: (),
+	_query: (),
+	body: SetTracingConfigRequest,
+) -> Result<SetTracingConfigResponse> {
+	// Broadcast message to all services via UPS
+	let subject = "rivet.debug.tracing.config";
+	let message = serde_json::to_vec(&body)?;
+
+	ctx.ups()?
+		.publish(subject, &message, PublishOpts::broadcast())
+		.await?;
+
+	tracing::info!(
+		filter = ?body.filter,
+		sampler_ratio = ?body.sampler_ratio,
+		"broadcasted tracing config update"
+	);
+
+	Ok(SetTracingConfigResponse {})
+}
+
+#[derive(Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct ReplicaReconfigureRequest {}
+
+#[derive(Serialize)]
+#[serde(deny_unknown_fields)]
+pub struct ReplicaReconfigureResponse {}
+
+/// Triggers the epoxy coordinator to reconfigure all replicas.
+///
+/// Useful when a replica's configuration is outdated for any reason and needs to be re-notified of
+/// changes.
+///
+/// This should never need to be called manually if everything is operating correctly.
+pub async fn epoxy_replica_reconfigure(
+	ctx: ApiCtx,
+	_path: (),
+	_query: (),
+	_body: ReplicaReconfigureRequest,
+) -> Result<ReplicaReconfigureResponse> {
+	if ctx.config().is_leader() {
+		ctx.signal(epoxy::workflows::coordinator::ReplicaReconfigure {})
+			.to_workflow::<epoxy::workflows::coordinator::Workflow>()
+			.tag("replica", ctx.config().epoxy_replica_id())
+			.send()
+			.await?;
+	}
+
+	Ok(ReplicaReconfigureResponse {})
+}
+
+#[derive(Serialize)]
+#[serde(deny_unknown_fields)]
+pub struct GetEpoxyStateResponse {
+	pub config: epoxy::types::ClusterConfig,
+}
+
+/// Returns the current epoxy coordinator cluster configuration.
+///
+/// Useful for inspecting the current state of the epoxy cluster, including all replicas and their statuses.
+pub async fn get_epoxy_state(ctx: ApiCtx, _path: (), _query: ()) -> Result<GetEpoxyStateResponse> {
+	let workflow_id = ctx
+		.find_workflow::<epoxy::workflows::coordinator::Workflow>((
+			"replica",
+			ctx.config().epoxy_replica_id(),
+		))
+		.await?
+		.ok_or_else(|| anyhow!("epoxy coordinator workflow not found"))?;
+
+	let wfs = ctx.get_workflows(vec![workflow_id]).await?;
+	let wf = wfs.first().ok_or_else(|| anyhow!("workflow not found"))?;
+
+	let state: epoxy::workflows::coordinator::State =
+		wf.parse_state().context("failed to parse workflow state")?;
+
+	Ok(GetEpoxyStateResponse {
+		config: state.config,
+	})
+}
+
+#[derive(Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct SetEpoxyStateRequest {
+	pub config: epoxy::types::ClusterConfig,
+}
+
+#[derive(Serialize)]
+#[serde(deny_unknown_fields)]
+pub struct SetEpoxyStateResponse {}
+
+/// Overrides the epoxy coordinator cluster configuration and triggers reconfiguration.
+///
+/// Useful for manually adjusting the cluster state in case the replica status drifts from the
+/// state in the coordinator. This will automatically trigger a reconfigure when called.
+///
+/// This should never need to be called manually if everything is operating correctly.
+pub async fn set_epoxy_state(
+	ctx: ApiCtx,
+	_path: (),
+	_query: (),
+	body: SetEpoxyStateRequest,
+) -> Result<SetEpoxyStateResponse> {
+	ensure!(
+		body.config.coordinator_replica_id == ctx.config().epoxy_replica_id(),
+		"config coordinator_replica_id ({}) does not match current replica id ({})",
+		body.config.coordinator_replica_id,
+		ctx.config().epoxy_replica_id()
+	);
+
+	if ctx.config().is_leader() {
+		ctx.signal(epoxy::workflows::coordinator::OverrideState {
+			config: body.config,
+		})
+		.to_workflow::<epoxy::workflows::coordinator::Workflow>()
+		.tag("replica", ctx.config().epoxy_replica_id())
+		.send()
+		.await?;
+	}
+
+	Ok(SetEpoxyStateResponse {})
+}

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

@@ -0,0 +1,28 @@
+use std::net::SocketAddr;
+
+use anyhow::*;
+
+pub mod actors;
+pub mod internal;
+pub mod namespaces;
+pub mod router;
+pub mod runner_configs;
+pub mod runners;
+
+pub use router::router as create_router;
+
+#[tracing::instrument(skip_all)]
+pub async fn start(config: rivet_config::Config, pools: rivet_pools::Pools) -> Result<()> {
+	let host = config.api_peer().host();
+	let port = config.api_peer().port();
+	let addr = SocketAddr::from((host, port));
+
+	let router = router::router("api-peer", config, pools).await?;
+
+	let listener = tokio::net::TcpListener::bind(addr).await?;
+	tracing::info!(?host, ?port, "api-peer server listening");
+
+	axum::serve(listener, router).await?;
+
+	Ok(())
+}

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

@@ -0,0 +1,122 @@
+use anyhow::Result;
+use gas::prelude::*;
+use rivet_api_builder::ApiCtx;
+use rivet_api_types::{namespaces::list::*, pagination::Pagination};
+use rivet_util::Id;
+use serde::{Deserialize, Serialize};
+use utoipa::ToSchema;
+
+#[tracing::instrument(skip_all)]
+pub async fn list(ctx: ApiCtx, _path: (), query: ListQuery) -> Result<ListResponse> {
+	let namespace_ids = query.namespace_ids.as_ref().map(|x| {
+		x.split(',')
+			.filter_map(|s| s.trim().parse::<rivet_util::Id>().ok())
+			.collect::<Vec<_>>()
+	});
+
+	// If name filter is provided, resolve and return only that namespace
+	if let Some(name) = query.name {
+		let namespace = ctx
+			.op(namespace::ops::resolve_for_name_global::Input { name })
+			.await?;
+
+		let namespaces = if let Some(namespace) = namespace {
+			vec![namespace]
+		} else {
+			vec![]
+		};
+
+		Ok(ListResponse {
+			namespaces,
+			pagination: Pagination { cursor: None },
+		})
+	} else if let Some(namespace_ids) = namespace_ids {
+		let namespaces = ctx
+			.op(namespace::ops::get_global::Input { namespace_ids })
+			.await?;
+
+		Ok(ListResponse {
+			namespaces,
+			pagination: Pagination { cursor: None },
+		})
+	} else {
+		// Normal list operation without filter
+		let namespaces_res = ctx
+			.op(namespace::ops::list::Input { limit: query.limit })
+			.await?;
+
+		// For cursor-based pagination, we'll use the last namespace's create timestamp
+		let cursor = namespaces_res
+			.namespaces
+			.last()
+			.map(|ns| ns.create_ts.to_string());
+
+		Ok(ListResponse {
+			namespaces: namespaces_res.namespaces,
+			pagination: Pagination { cursor },
+		})
+	}
+}
+
+#[derive(Deserialize, Serialize, ToSchema)]
+#[serde(deny_unknown_fields)]
+#[schema(as = NamespacesCreateRequest)]
+pub struct CreateRequest {
+	name: String,
+	display_name: String,
+}
+
+#[derive(Serialize, Deserialize, ToSchema)]
+#[serde(deny_unknown_fields)]
+#[schema(as = NamespacesCreateResponse)]
+pub struct CreateResponse {
+	pub namespace: rivet_types::namespaces::Namespace,
+}
+
+#[tracing::instrument(skip_all)]
+pub async fn create(
+	ctx: ApiCtx,
+	_path: (),
+	_query: (),
+	body: CreateRequest,
+) -> Result<CreateResponse> {
+	let namespace_id = Id::new_v1(ctx.config().dc_label());
+
+	ctx.workflow(namespace::workflows::namespace::Input {
+		namespace_id,
+		name: body.name.clone(),
+		display_name: body.display_name.clone(),
+	})
+	.tag("namespace_id", namespace_id)
+	.dispatch()
+	.await?;
+
+	let mut create_sub = ctx
+		.subscribe::<namespace::workflows::namespace::CreateComplete>((
+			"namespace_id",
+			namespace_id,
+		))
+		.await?;
+	let mut fail_sub = ctx
+		.subscribe::<namespace::workflows::namespace::Failed>(("namespace_id", namespace_id))
+		.await?;
+
+	tokio::select! {
+		res = create_sub.next() => { res?; },
+		res = fail_sub.next() => {
+			let msg = res?;
+			return Err(msg.into_body().error.build());
+		}
+	}
+
+	let namespace = ctx
+		.op(namespace::ops::get_local::Input {
+			namespace_ids: vec![namespace_id],
+		})
+		.await?
+		.into_iter()
+		.next()
+		.ok_or_else(|| namespace::errors::Namespace::NotFound.build())?;
+
+	Ok(CreateResponse { namespace })
+}

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

@@ -0,0 +1,51 @@
+use rivet_api_builder::{create_router, prelude::*};
+
+use crate::{actors, internal, namespaces, runner_configs, runners};
+
+#[tracing::instrument(skip_all)]
+pub async fn router(
+	name: &'static str,
+	config: rivet_config::Config,
+	pools: rivet_pools::Pools,
+) -> anyhow::Result<axum::Router> {
+	create_router(name, config, pools, |mut router| {
+		router = epoxy::http_routes::mount_routes(router);
+		router
+			// MARK: Namespaces
+			.route("/namespaces", get(namespaces::list))
+			.route("/namespaces", post(namespaces::create))
+			// MARK: Runner configs
+			.route("/runner-configs", get(runner_configs::list))
+			.route("/runner-configs/{runner_name}", put(runner_configs::upsert))
+			.route(
+				"/runner-configs/{runner_name}",
+				delete(runner_configs::delete),
+			)
+			// MARK: Actors
+			.route("/actors", get(actors::list::list))
+			.route("/actors", post(actors::create::create))
+			.route("/actors/{actor_id}", delete(actors::delete::delete))
+			.route("/actors/names", get(actors::list_names::list_names))
+			.route(
+				"/actors/{actor_id}/kv/keys/{key}",
+				get(actors::kv_get::kv_get),
+			)
+			// MARK: Runners
+			.route("/runners", get(runners::list))
+			.route("/runners/names", get(runners::list_names))
+			// MARK: Internal
+			.route("/cache/purge", post(internal::cache_purge))
+			.route(
+				"/bump-serverless-autoscaler",
+				post(internal::bump_serverless_autoscaler),
+			)
+			.route(
+				"/epoxy/coordinator/replica-reconfigure",
+				post(internal::epoxy_replica_reconfigure),
+			)
+			.route("/epoxy/coordinator/state", get(internal::get_epoxy_state))
+			.route("/epoxy/coordinator/state", post(internal::set_epoxy_state))
+			.route("/debug/tracing/config", put(internal::set_tracing_config))
+	})
+	.await
+}