fix: configure runner config per runner name

Author: MasterPtato

Cargo.lock

@@ -7,14 +7,14 @@ use udb_util::prelude::*;
 #[derive(Debug)]
 pub struct OutboundDesiredSlotsKey {
 	pub namespace_id: Id,
-	pub runner_name_selector: String,
+	pub runner_name: String,
 }
 
 impl OutboundDesiredSlotsKey {
-	pub fn new(namespace_id: Id, runner_name_selector: String) -> Self {
+	pub fn new(namespace_id: Id, runner_name: String) -> Self {
 		OutboundDesiredSlotsKey {
 			namespace_id,
-			runner_name_selector,
+			runner_name,
 		}
 	}
 
@@ -53,20 +53,20 @@ impl TuplePack for OutboundDesiredSlotsKey {
 			OUTBOUND,
 			DESIRED_SLOTS,
 			self.namespace_id,
-			&self.runner_name_selector,
+			&self.runner_name,
 		);
 		t.pack(w, tuple_depth)
 	}
 }
 
 impl<'de> TupleUnpack<'de> for OutboundDesiredSlotsKey {
 	fn unpack(input: &[u8], tuple_depth: TupleDepth) -> PackResult<(&[u8], Self)> {
-		let (input, (_, _, _, namespace_id, runner_name_selector)) =
+		let (input, (_, _, _, namespace_id, runner_name)) =
 			<(usize, usize, usize, Id, String)>::unpack(input, tuple_depth)?;
 
 		let v = OutboundDesiredSlotsKey {
 			namespace_id,
-			runner_name_selector,
+			runner_name,
 		};
 
 		Ok((input, v))

out/openapi.json

@@ -121,5 +121,4 @@ define_keys! {
 	(93, INSTANCE_BALLOT, "instance_ballot"),
 	(94, OUTBOUND, "outbound"),
 	(95, DESIRED_SLOTS, "desired_slots"),
-	(96, RUNNER_KIND, "runner_kind"),
 }

packages/common/types/src/keys/pegboard/ns.rs

@@ -4,7 +4,7 @@ use std::time::Duration;
 
 use anyhow::*;
 use async_trait::async_trait;
-use tokio::sync::{mpsc, RwLock};
+use tokio::sync::{RwLock, mpsc};
 use uuid::Uuid;
 
 use crate::driver::{PubSubDriver, SubscriberDriver, SubscriberDriverHandle};

packages/common/udb-util/src/keys.rs

@@ -1,7 +1,6 @@
 use anyhow::Result;
 use gas::prelude::*;
 use rivet_api_builder::ApiCtx;
-use rivet_util::Id;
 use serde::{Deserialize, Serialize};
 
 #[derive(Serialize, Deserialize)]

packages/common/universalpubsub/src/driver/memory/mod.rs

@@ -29,7 +29,6 @@ pub async fn get(ctx: ApiCtx, path: GetPath, _query: GetQuery) -> Result<GetResp
 			namespace_ids: vec![path.namespace_id],
 		})
 		.await?
-		.namespaces
 		.into_iter()
 		.next()
 		.ok_or_else(|| namespace::errors::Namespace::NotFound.build())?;
@@ -188,69 +187,68 @@ pub async fn create(
 			namespace_ids: vec![namespace_id],
 		})
 		.await?
-		.namespaces
 		.into_iter()
 		.next()
 		.ok_or_else(|| namespace::errors::Namespace::NotFound.build())?;
 
 	Ok(CreateResponse { namespace })
 }
 
-#[derive(Debug, Serialize, Deserialize, IntoParams)]
-#[serde(deny_unknown_fields)]
-#[into_params(parameter_in = Query)]
-pub struct UpdateQuery {}
-
-#[derive(Deserialize)]
-#[serde(deny_unknown_fields)]
-pub struct UpdatePath {
-	pub namespace_id: Id,
-}
-
-#[derive(Deserialize, Serialize, ToSchema)]
-#[serde(deny_unknown_fields)]
-#[schema(as = NamespacesUpdateRequest)]
-pub struct UpdateRequest(namespace::workflows::namespace::Update);
-
-#[derive(Serialize, ToSchema)]
-#[schema(as = NamespacesUpdateResponse)]
-pub struct UpdateResponse {}
-
-pub async fn update(
-	ctx: ApiCtx,
-	path: UpdatePath,
-	_query: UpdateQuery,
-	body: UpdateRequest,
-) -> Result<UpdateResponse> {
-	let mut sub = ctx
-		.subscribe::<namespace::workflows::namespace::UpdateResult>((
-			"namespace_id",
-			path.namespace_id,
-		))
-		.await?;
-
-	let res = ctx
-		.signal(body.0)
-		.to_workflow::<namespace::workflows::namespace::Workflow>()
-		.tag("namespace_id", path.namespace_id)
-		.send()
-		.await;
-
-	if let Some(WorkflowError::WorkflowNotFound) = res
-		.as_ref()
-		.err()
-		.and_then(|x| x.chain().find_map(|x| x.downcast_ref::<WorkflowError>()))
-	{
-		return Err(namespace::errors::Namespace::NotFound.build());
-	} else {
-		res?;
-	}
-
-	sub.next()
-		.await?
-		.into_body()
-		.res
-		.map_err(|err| err.build())?;
-
-	Ok(UpdateResponse {})
-}
+// #[derive(Debug, Serialize, Deserialize, IntoParams)]
+// #[serde(deny_unknown_fields)]
+// #[into_params(parameter_in = Query)]
+// pub struct UpdateQuery {}
+
+// #[derive(Deserialize)]
+// #[serde(deny_unknown_fields)]
+// pub struct UpdatePath {
+// 	pub namespace_id: Id,
+// }
+
+// #[derive(Deserialize, Serialize, ToSchema)]
+// #[serde(deny_unknown_fields)]
+// #[schema(as = NamespacesUpdateRequest)]
+// pub struct UpdateRequest(namespace::workflows::namespace::Update);
+
+// #[derive(Serialize, ToSchema)]
+// #[schema(as = NamespacesUpdateResponse)]
+// pub struct UpdateResponse {}
+
+// pub async fn update(
+// 	ctx: ApiCtx,
+// 	path: UpdatePath,
+// 	_query: UpdateQuery,
+// 	body: UpdateRequest,
+// ) -> Result<UpdateResponse> {
+// 	let mut sub = ctx
+// 		.subscribe::<namespace::workflows::namespace::UpdateResult>((
+// 			"namespace_id",
+// 			path.namespace_id,
+// 		))
+// 		.await?;
+
+// 	let res = ctx
+// 		.signal(body.0)
+// 		.to_workflow::<namespace::workflows::namespace::Workflow>()
+// 		.tag("namespace_id", path.namespace_id)
+// 		.send()
+// 		.await;
+
+// 	if let Some(WorkflowError::WorkflowNotFound) = res
+// 		.as_ref()
+// 		.err()
+// 		.and_then(|x| x.chain().find_map(|x| x.downcast_ref::<WorkflowError>()))
+// 	{
+// 		return Err(namespace::errors::Namespace::NotFound.build());
+// 	} else {
+// 		res?;
+// 	}
+
+// 	sub.next()
+// 		.await?
+// 		.into_body()
+// 		.res
+// 		.map_err(|err| err.build())?;
+
+// 	Ok(UpdateResponse {})
+// }

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

@@ -14,11 +14,15 @@ pub async fn router(
 			.route("/namespaces", get(namespaces::list))
 			.route("/namespaces", post(namespaces::create))
 			.route("/namespaces/{namespace_id}", get(namespaces::get))
-			.route("/namespaces/{namespace_id}", put(namespaces::update))
 			.route(
 				"/namespaces/resolve/{name}",
 				get(namespaces::resolve_for_name),
 			)
+			// MARK: Runner configs
+			// .route("/namespaces/{namespace_id}/runner-configs", get(namespaces::runner_configs::list))
+			// .route("/namespaces/{namespace_id}/runner-configs/{runner_name}", put(namespaces::runner_configs::upsert))
+			// .route("/namespaces/{namespace_id}/runner-configs/{runner_name}", get(namespaces::runner_configs::get))
+			// .route("/namespaces/{namespace_id}/runner-configs/{runner_name}", delete(namespaces::runner_configs::delete))
 			// MARK: Actors
 			.route("/actors", get(actors::list::list))
 			.route("/actors", post(actors::create::create))
@@ -31,6 +35,7 @@ pub async fn router(
 			.route("/runners/names", get(runners::list_names))
 			// MARK: Internal
 			.route("/cache/purge", post(internal::cache_purge))
+		// .route("/bump-autoscaler", post(internal::bump_autoscaler))
 	})
 	.await
 }