chore(core): update default region name to default

Author: NathanFlurry

out/errors/actor.no_runners_available.json

@@ -48,19 +48,20 @@ impl Default for Topology {
 		Topology {
 			datacenter_label: 1,
 			datacenters: vec![Datacenter {
-				name: "local".into(),
+				name: "default".into(),
 				datacenter_label: 1,
 				is_leader: true,
-				api_peer_url: Url::parse(&format!(
+				public_url: Url::parse(&format!(
 					"http://127.0.0.1:{}",
-					crate::defaults::ports::API_PEER
+					crate::defaults::ports::GUARD
 				))
 				.unwrap(),
-				guard_url: Url::parse(&format!(
+				api_peer_url: Url::parse(&format!(
 					"http://127.0.0.1:{}",
-					crate::defaults::ports::GUARD
+					crate::defaults::ports::API_PEER
 				))
 				.unwrap(),
+				valid_hosts: None,
 			}],
 		}
 	}
@@ -72,8 +73,28 @@ pub struct Datacenter {
 	pub name: String,
 	pub datacenter_label: u16,
 	pub is_leader: bool,
-	/// Url of the api-peer service
+	/// Public origin that can be used to connect to this region.
+	pub public_url: Url,
+	/// URL of the api-peer service
 	pub api_peer_url: Url,
-	/// Url of the peer's guard server
-	pub guard_url: Url,
+	/// List of hosts that are valid to connect to this region with. This is used in regional
+	/// endpoints to validate that incoming requests to this datacenter are going to a
+	/// region-specific domain.
+	///
+	/// IMPORTANT: Do not use a global origin that routes to multiple different regions. This will
+	/// cause unpredictable behavior when requests are expected to go to a specific region.
+	#[serde(default)]
+	pub valid_hosts: Option<Vec<String>>,
+}
+
+impl Datacenter {
+	pub fn is_valid_regional_host(&self, host: &str) -> bool {
+		if let Some(valid_hosts) = &self.valid_hosts {
+			// Check if host is in the valid_hosts list
+			valid_hosts.iter().any(|valid_host| valid_host == host)
+		} else {
+			// Check if host matches the origin of public_url
+			self.public_url.host_str() == Some(host)
+		}
+	}
 }

out/errors/guard.invalid_regional_host.json

@@ -48,8 +48,9 @@ impl TestDeps {
 				name: format!("dc-{dc_id}"),
 				datacenter_label: dc_id,
 				is_leader: dc_id == dc_ids[0], // First DC in list is leader
+				public_url: Url::parse(&format!("http://127.0.0.1:{guard_port}"))?,
 				api_peer_url: Url::parse(&format!("http://127.0.0.1:{api_peer_port}"))?,
-				guard_url: Url::parse(&format!("http://127.0.0.1:{guard_port}"))?,
+				valid_hosts: None,
 			});
 			ports.push((api_peer_port, guard_port));
 		}

out/errors/guard.must_use_regional_host.json

@@ -4,6 +4,7 @@ use utoipa::ToSchema;
 #[derive(Debug, Clone, Serialize, Deserialize, ToSchema)]
 #[serde(deny_unknown_fields)]
 pub struct Datacenter {
-	pub datacenter_label: u16,
+	pub label: u16,
 	pub name: String,
+	pub url: String,
 }

out/openapi.json

@@ -68,15 +68,21 @@ async fn create_inner(
 ) -> 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()
-			.dc_for_name(dc_name)
-			.ok_or_else(|| crate::errors::Datacenter::NotFound.build())?
-			.datacenter_label
-	} else {
-		ctx.config().dc_label()
-	};
+	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 target_dc_label = super::utils::find_dc_for_actor_creation(
+		&ctx,
+		namespace.namespace_id,
+		&query.namespace,
+		&body.runner_name_selector,
+		query.datacenter.as_ref().map(String::as_str),
+	)
+	.await?;
 
 	let query = rivet_api_types::actors::create::CreateQuery {
 		namespace: query.namespace,

packages/common/config/src/config/topology.rs

@@ -14,7 +14,6 @@ use utoipa::{IntoParams, ToSchema};
 
 use crate::actors::utils;
 use crate::ctx::ApiCtx;
-use crate::errors;
 
 #[derive(Debug, Deserialize, IntoParams)]
 #[serde(deny_unknown_fields)]
@@ -123,15 +122,14 @@ async fn get_or_create_inner(
 	}
 
 	// Actor doesn't exist for any key, create it
-	// Determine which datacenter to create the actor in
-	let target_dc_label = if let Some(dc_name) = &query.datacenter {
-		ctx.config()
-			.dc_for_name(dc_name)
-			.ok_or_else(|| errors::Datacenter::NotFound.build())?
-			.datacenter_label
-	} else {
-		ctx.config().dc_label()
-	};
+	let target_dc_label = super::utils::find_dc_for_actor_creation(
+		&ctx,
+		namespace.namespace_id,
+		&query.namespace,
+		&body.runner_name_selector,
+		query.datacenter.as_ref().map(String::as_str),
+	)
+	.await?;
 
 	let actor_id = Id::new_v1(target_dc_label);
 

packages/common/test-deps/src/lib.rs

@@ -184,3 +184,39 @@ pub fn extract_duplicate_key_error(err: &anyhow::Error) -> Option<Id> {
 
 	None
 }
+
+/// Determine the datacenter label to create the actor in.
+pub async fn find_dc_for_actor_creation(
+	ctx: &ApiCtx,
+	namespace_id: Id,
+	namespace_name: &str,
+	runner_name: &str,
+	dc_name: Option<&str>,
+) -> Result<u16> {
+	let target_dc_label = if let Some(dc_name) = &dc_name {
+		// Use user-configured DC
+		ctx.config()
+			.dc_for_name(dc_name)
+			.ok_or_else(|| crate::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(),
+			})
+			.await?;
+		if let Some(dc_label) = res.dc_label {
+			dc_label
+		} else {
+			return Err(pegboard::errors::Actor::NoRunnersAvailable {
+				namespace: namespace_name.into(),
+				runner_name: runner_name.into(),
+			}
+			.build());
+		}
+	};
+
+	Ok(target_dc_label)
+}