chore: remove port name

Author: MasterPtato

frontend/src/queries/actor-engine.ts

@@ -18,7 +18,6 @@ export const createEngineActorContext = ({
 				headers: {
 					"x-rivet-actor": actorId,
 					"x-rivet-target": "actor",
-					"x-rivet-port": "main",
 					...(token ? { authorization: `Bearer ${token}` } : {}),
 				},
 			};

packages/core/guard/server/src/cache/actor.rs

@@ -6,7 +6,7 @@ use std::{
 use anyhow::Result;
 use gas::prelude::*;
 
-use crate::routing::pegboard_gateway::{X_RIVET_ACTOR, X_RIVET_PORT};
+use crate::routing::pegboard_gateway::X_RIVET_ACTOR;
 
 #[tracing::instrument(skip_all)]
 pub fn build_cache_key(target: &str, path: &str, headers: &hyper::HeaderMap) -> Result<u64> {
@@ -22,19 +22,10 @@ pub fn build_cache_key(target: &str, path: &str, headers: &hyper::HeaderMap) ->
 	})?;
 	let actor_id = Id::parse(actor_id_str.to_str()?)?;
 
-	let port_name = headers.get(X_RIVET_PORT).ok_or_else(|| {
-		crate::errors::MissingHeader {
-			header: X_RIVET_PORT.to_string(),
-		}
-		.build()
-	})?;
-	let port_name = port_name.to_str()?;
-
-	// Create a hash using target, actor_id and port_name
+	// Create a hash using target, actor_id, and path
 	let mut hasher = DefaultHasher::new();
 	target.hash(&mut hasher);
 	actor_id.hash(&mut hasher);
-	port_name.hash(&mut hasher);
 	path.hash(&mut hasher);
 	let hash = hasher.finish();
 

packages/core/guard/server/src/errors.rs

@@ -43,11 +43,10 @@ pub struct WrongAddrProtocol {
 	"guard",
 	"actor_not_found",
 	"Actor not found.",
-	"Actor with ID {actor_id} and port {port_name} not found."
+	"Actor with ID {actor_id} not found."
 )]
 pub struct ActorNotFound {
 	pub actor_id: Id,
-	pub port_name: String,
 }
 
 #[derive(RivetError, Serialize)]

packages/core/guard/server/src/routing/pegboard_gateway.rs

@@ -10,7 +10,6 @@ use crate::errors;
 
 const ACTOR_READY_TIMEOUT: Duration = Duration::from_secs(10);
 pub const X_RIVET_ACTOR: HeaderName = HeaderName::from_static("x-rivet-actor");
-pub const X_RIVET_PORT: HeaderName = HeaderName::from_static("x-rivet-port");
 
 /// Route requests to actor services based on hostname and path
 #[tracing::instrument(skip_all)]
@@ -64,16 +63,8 @@ pub async fn route_request(
 		})));
 	}
 
-	let port_name = headers.get(X_RIVET_PORT).ok_or_else(|| {
-		crate::errors::MissingHeader {
-			header: X_RIVET_PORT.to_string(),
-		}
-		.build()
-	})?;
-	let port_name = port_name.to_str()?;
-
 	// Lookup actor
-	find_actor(ctx, actor_id, port_name, path).await
+	find_actor(ctx, actor_id, path).await
 }
 
 struct FoundActor {
@@ -82,12 +73,11 @@ struct FoundActor {
 	destroyed: bool,
 }
 
-/// Find an actor by actor_id and port_name
-#[tracing::instrument(skip_all, fields(%actor_id, %port_name, %path))]
+/// Find an actor by actor_id
+#[tracing::instrument(skip_all, fields(%actor_id, %path))]
 async fn find_actor(
 	ctx: &StandaloneCtx,
 	actor_id: Id,
-	port_name: &str,
 	path: &str,
 ) -> Result<Option<RoutingOutput>> {
 	// TODO: Optimize this down to a single FDB call
@@ -134,11 +124,7 @@ async fn find_actor(
 	.await??;
 
 	let Some(actor) = actor_res else {
-		return Err(errors::ActorNotFound {
-			actor_id,
-			port_name: port_name.to_string(),
-		}
-		.build());
+		return Err(errors::ActorNotFound { actor_id }.build());
 	};
 
 	if actor.destroyed {
@@ -186,12 +172,7 @@ async fn find_actor(
 	tracing::debug!(?actor_id, ?runner_id, "actor ready");
 
 	// Return pegboard-gateway instance
-	let gateway = pegboard_gateway::PegboardGateway::new(
-		ctx.clone(),
-		actor_id,
-		runner_id,
-		port_name.to_string(),
-	);
+	let gateway = pegboard_gateway::PegboardGateway::new(ctx.clone(), actor_id, runner_id);
 	Ok(Some(RoutingOutput::CustomServe(std::sync::Arc::new(
 		gateway,
 	))))

packages/core/pegboard-gateway/src/lib.rs

@@ -44,17 +44,15 @@ pub struct PegboardGateway {
 	request_counter: AtomicU64,
 	actor_id: Id,
 	runner_id: Id,
-	port_name: String,
 }
 
 impl PegboardGateway {
-	pub fn new(ctx: StandaloneCtx, actor_id: Id, runner_id: Id, port_name: String) -> Self {
+	pub fn new(ctx: StandaloneCtx, actor_id: Id, runner_id: Id) -> Self {
 		Self {
 			ctx,
 			request_counter: AtomicU64::new(0),
 			actor_id,
 			runner_id,
-			port_name,
 		}
 	}
 }
@@ -173,13 +171,12 @@ impl PegboardGateway {
 			.map_err(|e| anyhow!("failed to serialize message: {}", e))?;
 
 		// Build pubsub topic
-		let tunnel_subject = TunnelHttpRunnerSubject::new(self.runner_id, &self.port_name);
+		let tunnel_subject = TunnelHttpRunnerSubject::new(self.runner_id);
 		let topic = tunnel_subject.to_string();
 
 		tracing::info!(
 			%topic,
 			?self.runner_id,
-			%self.port_name,
 			?request_id,
 			"publishing request to pubsub"
 		);
@@ -190,8 +187,7 @@ impl PegboardGateway {
 		response_map.lock().await.insert(request_id, response_tx);
 
 		// Subscribe to response topic
-		let response_subject =
-			TunnelHttpResponseSubject::new(self.runner_id, &self.port_name, request_id);
+		let response_subject = TunnelHttpResponseSubject::new(self.runner_id, request_id);
 		let response_topic = response_subject.to_string();
 
 		tracing::info!(
@@ -327,16 +323,15 @@ impl PegboardGateway {
 
 		// Subscribe to messages from server before informing server that a client websocket is connecting to
 		// prevent race conditions.
-		let ws_subject =
-			TunnelHttpWebSocketSubject::new(self.runner_id, &self.port_name, websocket_id);
+		let ws_subject = TunnelHttpWebSocketSubject::new(self.runner_id, websocket_id);
 		let response_topic = ws_subject.to_string();
 		let mut subscriber = match ups.subscribe(&response_topic).await {
 			Result::Ok(sub) => sub,
 			Err(err) => return Err((client_ws, err.into())),
 		};
 
 		// Build pubsub topic
-		let tunnel_subject = TunnelHttpRunnerSubject::new(self.runner_id, &self.port_name);
+		let tunnel_subject = TunnelHttpRunnerSubject::new(self.runner_id);
 		let topic = tunnel_subject.to_string();
 
 		// Send WebSocket open message