chore: add build get endpoint

fern/definition/servers/__package__.yml

@@ -28,7 +28,7 @@ service:
       request:
         name: GetServersRequest
         query-parameters:
-          tags: optional<string>
+          tags_json: optional<string>
           game: optional<uuid>
       response: ListServersResponse
 
@@ -66,9 +66,7 @@ types:
 
   CreateServerRequest:
     properties:
-      datacenter:
-        docs: The name ID of the datacenter
-        type: string
+      datacenter: uuid
       tags: unknown
       image: uuid
       arguments: optional<list<string>>

fern/definition/servers/builds.yml

@@ -11,16 +11,31 @@ service:
   path-parameters:
     game_id: uuid
   endpoints:
+    getBuild:
+      path: /{build_id}
+      method: GET
+      docs: >-
+        Lists all builds of the game associated with the token used. Can be
+        filtered by tags in the query string.
+      path-parameters:
+        build_id: uuid
+      request:
+        name: GetBuildRequest
+        query-parameters:
+          tags_json: optional<string>
+          game_id: optional<uuid>
+      response: GetBuildResponse
+
     listBuilds:
       path: ""
       method: GET
       docs: >-
         Lists all builds of the game associated with the token used. Can be
         filtered by tags in the query string.
       request:
-        name: GetBuildsRequest
+        name: ListBuildsRequest
         query-parameters:
-          tags: optional<string>
+          tags_json: optional<string>
           game_id: optional<uuid>
       response: ListBuildsResponse
 
@@ -37,10 +52,13 @@ service:
       method: POST
       docs: Marks an upload as complete.
       path-parameters:
-        build_id:
-          type: uuid
+        build_id: uuid
 
 types:
+  GetBuildResponse:
+    properties:
+      build: localCommons.Build
+
   ListBuildsResponse:
     properties:
       builds:

fern/definition/servers/common.yml

@@ -8,7 +8,7 @@ types:
     properties:
       id: uuid
       game: uuid
-      datacenter: string
+      datacenter: uuid
       cluster: uuid
       tags: unknown
       image: uuid

lib/convert/src/impls/ds.rs

@@ -3,28 +3,15 @@ use std::collections::HashMap;
 use proto::backend;
 use rivet_api::models;
 use rivet_operation::prelude::*;
+use util::timestamp;
 
 use crate::{ApiFrom, ApiInto, ApiTryFrom, ApiTryInto};
 use serde_json::{json, to_value};
 
-impl ApiTryFrom<backend::build::Build> for models::GamesServersBuild {
+impl ApiTryFrom<backend::ds::Server> for models::ServersServer {
 	type Error = GlobalError;
-	fn api_try_from(value: backend::build::Build) -> GlobalResult<models::GamesServersBuild> {
-		Ok(models::GamesServersBuild {
-			id: unwrap!(value.build_id).as_uuid(),
-			upload: unwrap!(value.upload_id).as_uuid(),
-			created_at: timestamp::to_string(value.create_ts)?,
-			content_length: value.content_length,
-			completed_at: value.completed_at.map(timestamp::to_string).transpose()?,
-			tags: value.tags,
-		})
-	}
-}
-
-impl ApiTryFrom<backend::ds::Server> for models::GamesServersServer {
-	type Error = GlobalError;
-	fn api_try_from(value: backend::ds::Server) -> GlobalResult<models::GamesServersServer> {
-		Ok(models::GamesServersServer {
+	fn api_try_from(value: backend::ds::Server) -> GlobalResult<models::ServersServer> {
+		Ok(models::ServersServer {
 			id: unwrap!(value.server_id).as_uuid(),
 			cluster: unwrap!(value.cluster_id).as_uuid(),
 			created_at: value.create_ts,
@@ -38,7 +25,7 @@ impl ApiTryFrom<backend::ds::Server> for models::GamesServersServer {
 			arguments: Some(value.args),
 			environment: Some(value.environment),
 			image: unwrap!(value.image_id).as_uuid(),
-			network: Box::new(models::GamesServersNetwork {
+			network: Box::new(models::ServersNetwork {
 				mode: Some(
 					unwrap!(backend::ds::NetworkMode::from_i32(value.network_mode)).api_into(),
 				),
@@ -52,46 +39,46 @@ impl ApiTryFrom<backend::ds::Server> for models::GamesServersServer {
 	}
 }
 
-impl ApiFrom<models::GamesServersResources> for backend::ds::ServerResources {
-	fn api_from(value: models::GamesServersResources) -> backend::ds::ServerResources {
+impl ApiFrom<models::ServersResources> for backend::ds::ServerResources {
+	fn api_from(value: models::ServersResources) -> backend::ds::ServerResources {
 		backend::ds::ServerResources {
 			cpu_millicores: value.cpu,
 			memory_mib: value.memory,
 		}
 	}
 }
 
-impl ApiFrom<backend::ds::ServerResources> for models::GamesServersResources {
-	fn api_from(value: backend::ds::ServerResources) -> models::GamesServersResources {
-		models::GamesServersResources {
+impl ApiFrom<backend::ds::ServerResources> for models::ServersResources {
+	fn api_from(value: backend::ds::ServerResources) -> models::ServersResources {
+		models::ServersResources {
 			cpu: value.cpu_millicores,
 			memory: value.memory_mib,
 		}
 	}
 }
 
-impl ApiFrom<models::GamesServersNetworkMode> for backend::ds::NetworkMode {
-	fn api_from(value: models::GamesServersNetworkMode) -> backend::ds::NetworkMode {
+impl ApiFrom<models::ServersNetworkMode> for backend::ds::NetworkMode {
+	fn api_from(value: models::ServersNetworkMode) -> backend::ds::NetworkMode {
 		match value {
-			models::GamesServersNetworkMode::Bridge => backend::ds::NetworkMode::Bridge,
-			models::GamesServersNetworkMode::Host => backend::ds::NetworkMode::Host,
+			models::ServersNetworkMode::Bridge => backend::ds::NetworkMode::Bridge,
+			models::ServersNetworkMode::Host => backend::ds::NetworkMode::Host,
 		}
 	}
 }
 
-impl ApiFrom<backend::ds::NetworkMode> for models::GamesServersNetworkMode {
-	fn api_from(value: backend::ds::NetworkMode) -> models::GamesServersNetworkMode {
+impl ApiFrom<backend::ds::NetworkMode> for models::ServersNetworkMode {
+	fn api_from(value: backend::ds::NetworkMode) -> models::ServersNetworkMode {
 		match value {
-			backend::ds::NetworkMode::Bridge => models::GamesServersNetworkMode::Bridge,
-			backend::ds::NetworkMode::Host => models::GamesServersNetworkMode::Host,
+			backend::ds::NetworkMode::Bridge => models::ServersNetworkMode::Bridge,
+			backend::ds::NetworkMode::Host => models::ServersNetworkMode::Host,
 		}
 	}
 }
 
-impl ApiTryFrom<backend::ds::Port> for models::GamesServersPort {
+impl ApiTryFrom<backend::ds::Port> for models::ServersPort {
 	type Error = GlobalError;
 
-	fn api_try_from(value: backend::ds::Port) -> GlobalResult<models::GamesServersPort> {
+	fn api_try_from(value: backend::ds::Port) -> GlobalResult<models::ServersPort> {
 		let protocol = match unwrap!(&value.routing) {
 			backend::ds::port::Routing::GameGuard(x) => {
 				unwrap!(backend::ds::GameGuardProtocol::from_i32(x.protocol)).api_into()
@@ -101,7 +88,7 @@ impl ApiTryFrom<backend::ds::Port> for models::GamesServersPort {
 			}
 		};
 
-		let routing = models::GamesServersPortRouting {
+		let routing = models::ServersPortRouting {
 			game_guard: if let Some(backend::ds::port::Routing::GameGuard(_)) = &value.routing {
 				Some(json!({}))
 			} else {
@@ -114,7 +101,7 @@ impl ApiTryFrom<backend::ds::Port> for models::GamesServersPort {
 			},
 		};
 
-		Ok(models::GamesServersPort {
+		Ok(models::ServersPort {
 			protocol,
 			internal_port: value.internal_port,
 			public_hostname: value.public_hostname,
@@ -124,48 +111,46 @@ impl ApiTryFrom<backend::ds::Port> for models::GamesServersPort {
 	}
 }
 
-impl ApiFrom<models::GamesServersPortProtocol> for backend::ds::GameGuardProtocol {
-	fn api_from(value: models::GamesServersPortProtocol) -> backend::ds::GameGuardProtocol {
+impl ApiFrom<models::ServersPortProtocol> for backend::ds::GameGuardProtocol {
+	fn api_from(value: models::ServersPortProtocol) -> backend::ds::GameGuardProtocol {
 		match value {
-			models::GamesServersPortProtocol::Udp => backend::ds::GameGuardProtocol::Udp,
-			models::GamesServersPortProtocol::Tcp => backend::ds::GameGuardProtocol::Tcp,
-			models::GamesServersPortProtocol::Http => backend::ds::GameGuardProtocol::Http,
-			models::GamesServersPortProtocol::Https => backend::ds::GameGuardProtocol::Https,
-			models::GamesServersPortProtocol::TcpTls => backend::ds::GameGuardProtocol::TcpTls,
+			models::ServersPortProtocol::Udp => backend::ds::GameGuardProtocol::Udp,
+			models::ServersPortProtocol::Tcp => backend::ds::GameGuardProtocol::Tcp,
+			models::ServersPortProtocol::Http => backend::ds::GameGuardProtocol::Http,
+			models::ServersPortProtocol::Https => backend::ds::GameGuardProtocol::Https,
+			models::ServersPortProtocol::TcpTls => backend::ds::GameGuardProtocol::TcpTls,
 		}
 	}
 }
 
-impl ApiFrom<backend::ds::GameGuardProtocol> for models::GamesServersPortProtocol {
-	fn api_from(value: backend::ds::GameGuardProtocol) -> models::GamesServersPortProtocol {
+impl ApiFrom<backend::ds::GameGuardProtocol> for models::ServersPortProtocol {
+	fn api_from(value: backend::ds::GameGuardProtocol) -> models::ServersPortProtocol {
 		match value {
-			backend::ds::GameGuardProtocol::Udp => models::GamesServersPortProtocol::Udp,
-			backend::ds::GameGuardProtocol::Tcp => models::GamesServersPortProtocol::Tcp,
-			backend::ds::GameGuardProtocol::Http => models::GamesServersPortProtocol::Http,
-			backend::ds::GameGuardProtocol::Https => models::GamesServersPortProtocol::Https,
-			backend::ds::GameGuardProtocol::TcpTls => models::GamesServersPortProtocol::TcpTls,
+			backend::ds::GameGuardProtocol::Udp => models::ServersPortProtocol::Udp,
+			backend::ds::GameGuardProtocol::Tcp => models::ServersPortProtocol::Tcp,
+			backend::ds::GameGuardProtocol::Http => models::ServersPortProtocol::Http,
+			backend::ds::GameGuardProtocol::Https => models::ServersPortProtocol::Https,
+			backend::ds::GameGuardProtocol::TcpTls => models::ServersPortProtocol::TcpTls,
 		}
 	}
 }
 
-impl ApiTryFrom<models::GamesServersPortProtocol> for backend::ds::HostProtocol {
+impl ApiTryFrom<models::ServersPortProtocol> for backend::ds::HostProtocol {
 	type Error = GlobalError;
-	fn api_try_from(
-		value: models::GamesServersPortProtocol,
-	) -> GlobalResult<backend::ds::HostProtocol> {
+	fn api_try_from(value: models::ServersPortProtocol) -> GlobalResult<backend::ds::HostProtocol> {
 		Ok(match value {
-			models::GamesServersPortProtocol::Udp => backend::ds::HostProtocol::HostUdp,
-			models::GamesServersPortProtocol::Tcp => backend::ds::HostProtocol::HostTcp,
+			models::ServersPortProtocol::Udp => backend::ds::HostProtocol::HostUdp,
+			models::ServersPortProtocol::Tcp => backend::ds::HostProtocol::HostTcp,
 			_ => bail_with!(SERVERS_UNSUPPORTED_HOST_PROTOCOL),
 		})
 	}
 }
 
-impl ApiFrom<backend::ds::HostProtocol> for models::GamesServersPortProtocol {
-	fn api_from(value: backend::ds::HostProtocol) -> models::GamesServersPortProtocol {
+impl ApiFrom<backend::ds::HostProtocol> for models::ServersPortProtocol {
+	fn api_from(value: backend::ds::HostProtocol) -> models::ServersPortProtocol {
 		match value {
-			backend::ds::HostProtocol::HostUdp => models::GamesServersPortProtocol::Udp,
-			backend::ds::HostProtocol::HostTcp => models::GamesServersPortProtocol::Tcp,
+			backend::ds::HostProtocol::HostUdp => models::ServersPortProtocol::Udp,
+			backend::ds::HostProtocol::HostTcp => models::ServersPortProtocol::Tcp,
 		}
 	}
 }

scripts/openapi/gen_rust.sh

@@ -21,7 +21,7 @@ docker run --rm \
 if [ "$FERN_GROUP" == "full" ]; then
 	# Fix OpenAPI bug (https://github.com/OpenAPITools/openapi-generator/issues/14171)
 	sed -i 's/CloudGamesLogStream/crate::models::CloudGamesLogStream/' "$GEN_PATH_RUST/src/apis/cloud_games_matchmaker_api.rs"
-	sed -i 's/GamesServersLogStream/crate::models::GamesServersLogStream/' "$GEN_PATH_RUST/src/apis/games_servers_logs_api.rs"
+	sed -i 's/ServersLogStream/crate::models::ServersLogStream/' "$GEN_PATH_RUST/src/apis/servers_logs_api.rs"
 	sed -i 's/AdminClustersPoolType/crate::models::AdminClustersPoolType/' "$GEN_PATH_RUST/src/apis/admin_clusters_servers_api.rs"
 
 	# Create variant specifically for the CLI