feat: basic auth, headers in serverless config

Author: MasterPtato

Cargo.lock

@@ -1,4 +1,3 @@
-use rivet_util::Id;
 use serde::{Deserialize, Serialize};
 use utoipa::{IntoParams, ToSchema};
 

out/openapi.json

@@ -0,0 +1,16 @@
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
+#[serde(deny_unknown_fields)]
+pub struct Auth {
+	pub admin_token: String,
+}
+
+impl Default for Auth {
+	fn default() -> Self {
+		Auth {
+			admin_token: "admin".to_string(),
+		}
+	}
+}

packages/common/api-types/src/runners/list.rs

@@ -5,6 +5,7 @@ use std::sync::LazyLock;
 
 pub mod api_peer;
 pub mod api_public;
+pub mod auth;
 pub mod cache;
 pub mod clickhouse;
 pub mod db;
@@ -17,6 +18,7 @@ pub mod vector;
 
 pub use api_peer::*;
 pub use api_public::*;
+pub use auth::*;
 pub use cache::*;
 pub use clickhouse::*;
 pub use db::Database;
@@ -58,6 +60,9 @@ pub use vector::*;
 #[derive(Debug, Serialize, Deserialize, Clone, JsonSchema)]
 #[serde(rename_all = "snake_case", deny_unknown_fields)]
 pub struct Root {
+	#[serde(default)]
+	pub auth: Option<Auth>,
+
 	#[serde(default)]
 	pub guard: Option<Guard>,
 
@@ -95,6 +100,7 @@ pub struct Root {
 impl Default for Root {
 	fn default() -> Self {
 		Root {
+			auth: None,
 			guard: None,
 			api_public: None,
 			api_peer: None,

packages/common/config/src/config/auth.rs

@@ -1,3 +1,5 @@
+use std::collections::HashMap;
+
 use gas::prelude::*;
 use utoipa::ToSchema;
 
@@ -9,11 +11,12 @@ pub struct Namespace {
 	pub create_ts: i64,
 }
 
-#[derive(Debug, Clone, Serialize, Deserialize, Hash, ToSchema)]
+#[derive(Debug, Clone, Serialize, Deserialize, ToSchema)]
 #[serde(rename_all = "snake_case")]
 pub enum RunnerConfig {
 	Serverless {
 		url: String,
+		headers: HashMap<String, String>,
 		/// Seconds.
 		request_lifespan: u32,
 		slots_per_runner: u32,
@@ -28,6 +31,7 @@ impl From<RunnerConfig> for rivet_data::generated::namespace_runner_config_v1::D
 		match value {
 			RunnerConfig::Serverless {
 				url,
+				headers,
 				request_lifespan,
 				slots_per_runner,
 				min_runners,
@@ -36,6 +40,7 @@ impl From<RunnerConfig> for rivet_data::generated::namespace_runner_config_v1::D
 			} => rivet_data::generated::namespace_runner_config_v1::Data::Serverless(
 				rivet_data::generated::namespace_runner_config_v1::Serverless {
 					url,
+					headers: headers.into(),
 					request_lifespan,
 					slots_per_runner,
 					min_runners,
@@ -53,6 +58,7 @@ impl From<rivet_data::generated::namespace_runner_config_v1::Data> for RunnerCon
 			rivet_data::generated::namespace_runner_config_v1::Data::Serverless(o) => {
 				RunnerConfig::Serverless {
 					url: o.url,
+					headers: o.headers.into(),
 					request_lifespan: o.request_lifespan,
 					slots_per_runner: o.slots_per_runner,
 					min_runners: o.min_runners,

packages/common/config/src/config/mod.rs

@@ -4,7 +4,6 @@ use anyhow::Result;
 use namespace::utils::runner_config_variant;
 use rivet_api_builder::ApiCtx;
 use rivet_api_types::pagination::Pagination;
-use rivet_util::Id;
 use serde::{Deserialize, Serialize};
 use utoipa::{IntoParams, ToSchema};
 

packages/common/types/src/namespaces.rs

@@ -4,13 +4,14 @@ use axum::{
 	http::HeaderMap,
 	response::{IntoResponse, Json, Response},
 };
-use rivet_api_builder::{ApiCtx, ApiError};
+use rivet_api_builder::ApiError;
 use rivet_api_types::actors::create::{CreateRequest, CreateResponse};
 use rivet_api_util::request_remote_datacenter;
-use rivet_types::actors::CrashPolicy;
 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)]
@@ -63,6 +64,8 @@ async fn create_inner(
 	query: CreateQuery,
 	body: CreateRequest,
 ) -> Result<CreateResponse> {
+	ctx.skip_auth();
+
 	// Determine which datacenter to create the actor in
 	let target_dc_label = if let Some(dc_name) = &query.datacenter {
 		ctx.config()
@@ -78,7 +81,7 @@ async fn create_inner(
 	};
 
 	if target_dc_label == ctx.config().dc_label() {
-		rivet_api_peer::actors::create::create(ctx, (), query, body).await
+		rivet_api_peer::actors::create::create(ctx.into(), (), query, body).await
 	} else {
 		request_remote_datacenter::<CreateResponse>(
 			ctx.config(),

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

@@ -4,12 +4,14 @@ use axum::{
 	http::HeaderMap,
 	response::{IntoResponse, Json, Response},
 };
-use rivet_api_builder::{ApiCtx, ApiError};
+use rivet_api_builder::ApiError;
 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)]
@@ -62,14 +64,16 @@ async fn delete_inner(
 	path: DeletePath,
 	query: DeleteQuery,
 ) -> Result<Response> {
+	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, peer_path, peer_query).await?;
+		let res = rivet_api_peer::actors::delete::delete(ctx.into(), peer_path, peer_query).await?;
 
 		Ok(Json(res).into_response())
 	} else {

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

@@ -4,13 +4,14 @@ use axum::{
 	http::HeaderMap,
 	response::{IntoResponse, Json, Response},
 };
-use rivet_api_builder::{ApiCtx, ApiError};
+use rivet_api_builder::ApiError;
 use rivet_types::actors::CrashPolicy;
 use rivet_util::Id;
 use serde::{Deserialize, Serialize};
 use utoipa::{IntoParams, ToSchema};
 
 use crate::actors::utils;
+use crate::ctx::ApiCtx;
 use crate::errors;
 
 #[derive(Debug, Deserialize, IntoParams)]
@@ -91,6 +92,8 @@ async fn get_or_create_inner(
 	query: GetOrCreateQuery,
 	body: GetOrCreateRequest,
 ) -> Result<GetOrCreateResponse> {
+	ctx.skip_auth();
+
 	// Resolve namespace
 	let namespace = ctx
 		.op(namespace::ops::resolve_for_name_global::Input {