Allow backend id to be passed in spawn request (#591)

* Allow backend id to be passed in spawn request

* fix tests

* fix typo

plane/plane-tests/tests/backend_actions.rs

@@ -18,6 +18,7 @@ mod common;
 fn connect_request(cluster: &ClusterName) -> ConnectRequest {
     ConnectRequest {
         spawn_config: Some(SpawnConfig {
+            id: None,
             cluster: Some(cluster.clone()),
             executable: ExecutorConfig::from_image_with_defaults("alpine"),
             lifetime_limit_seconds: None,

plane/plane-tests/tests/backend_lifecycle.rs

@@ -25,6 +25,7 @@ async fn backend_lifecycle(env: TestEnvironment) {
     tracing::info!("Requesting backend.");
     let connect_request = ConnectRequest {
         spawn_config: Some(SpawnConfig {
+            id: None,
             cluster: Some(env.cluster.clone()),
             executable: ExecutorConfig {
                 image: "ghcr.io/drifting-in-space/demo-image-drop-four".to_string(),

plane/plane-tests/tests/backend_status_in_response.rs

@@ -22,6 +22,7 @@ async fn backend_status_in_response(env: TestEnvironment) {
     tracing::info!("Requesting backend.");
     let connect_request = ConnectRequest {
         spawn_config: Some(SpawnConfig {
+            id: None,
             cluster: Some(env.cluster.clone()),
             executable: ExecutorConfig {
                 image: "ghcr.io/drifting-in-space/demo-image-drop-four".to_string(),

plane/plane-tests/tests/reuse_key.rs

@@ -22,6 +22,7 @@ async fn reuse_key(env: TestEnvironment) {
     tracing::info!("Requesting backend.");
     let connect_request = ConnectRequest {
         spawn_config: Some(SpawnConfig {
+            id: None,
             cluster: Some(env.cluster.clone()),
             executable: ExecutorConfig {
                 image: "ghcr.io/drifting-in-space/demo-image-drop-four".to_string(),

plane/src/admin.rs

@@ -102,6 +102,11 @@ enum AdminCommand {
         /// The number of seconds without any connected clients to wait before terminating the backend.
         #[clap(long)]
         max_idle_seconds: Option<i32>,
+
+        /// An optional backend to assign the string (not recommended and may be removed. Omit to allow Plane to auto-assign
+        /// one instead).
+        #[clap(long)]
+        id: Option<BackendName>,
     },
     Terminate {
         #[clap(long)]
@@ -144,10 +149,12 @@ pub async fn run_admin_command_inner(opts: AdminOpts) -> Result<(), PlaneClientE
             key,
             wait,
             max_idle_seconds,
+            id,
         } => {
             let executor_config = ExecutorConfig::from_image_with_defaults(image);
             let max_idle_seconds = max_idle_seconds.unwrap_or(500);
             let spawn_config = SpawnConfig {
+                id,
                 cluster: cluster.clone(),
                 executable: executor_config.clone(),
                 lifetime_limit_seconds: None,

plane/src/database/connect.rs

@@ -10,7 +10,7 @@ use crate::{
         drone::DroneDatabase,
     },
     log_types::LoggableTime,
-    names::{BackendName, Name},
+    names::{BackendName, OrRandom},
     protocol::{AcquiredKey, BackendAction, KeyDeadlines},
     types::{
         BackendState, BackendStatus, BearerToken, ClusterName, ConnectRequest, ConnectResponse,
@@ -81,7 +81,7 @@ async fn create_backend_with_key(
     cluster: &ClusterName,
     drone_for_spawn: &DroneForSpawn,
 ) -> Result<Option<BackendName>> {
-    let backend_id = BackendName::new_random();
+    let backend_id = spawn_config.id.clone().or_random();
     let mut txn = pool.begin().await?;
 
     let result = sqlx::query!(

plane/src/names.rs

@@ -29,11 +29,11 @@ pub trait Name:
 
     fn new_random() -> Self;
 
-    fn prefix() -> &'static str;
+    fn prefix() -> Option<&'static str>;
 }
 
 macro_rules! entity_name {
-    ($name:ident, $prefix:literal) => {
+    ($name:ident, $prefix:expr) => {
         #[derive(
             Debug,
             Clone,
@@ -52,11 +52,14 @@ macro_rules! entity_name {
             }
 
             fn new_random() -> Self {
-                let st = crate::util::random_prefixed_string($prefix);
-                Self(st)
+                if let Some(prefix) = $prefix {
+                    Self(crate::util::random_prefixed_string(prefix))
+                } else {
+                    Self(crate::util::random_string())
+                }
             }
 
-            fn prefix() -> &'static str {
+            fn prefix() -> Option<&'static str> {
                 $prefix
             }
         }
@@ -71,8 +74,10 @@ macro_rules! entity_name {
             type Error = NameError;
 
             fn try_from(s: String) -> Result<Self, NameError> {
-                if !s.starts_with($prefix) {
-                    return Err(NameError::InvalidPrefix(s, $prefix.to_string()));
+                if let Some(prefix) = $prefix {
+                    if !s.starts_with(prefix) {
+                        return Err(NameError::InvalidPrefix(s, prefix.to_string()));
+                    }
                 }
 
                 if s.len() > MAX_NAME_LENGTH {
@@ -146,12 +151,12 @@ impl<T: Name> clap::builder::TypedValueParser for NameParser<T> {
     }
 }
 
-entity_name!(ControllerName, "co");
-entity_name!(BackendName, "ba");
-entity_name!(ProxyName, "pr");
-entity_name!(DroneName, "dr");
-entity_name!(AcmeDnsServerName, "ns");
-entity_name!(BackendActionName, "ak");
+entity_name!(ControllerName, Some("co"));
+entity_name!(BackendName, None::<&'static str>);
+entity_name!(ProxyName, Some("pr"));
+entity_name!(DroneName, Some("dr"));
+entity_name!(AcmeDnsServerName, Some("ns"));
+entity_name!(BackendActionName, Some("ak"));
 
 pub trait NodeName: Name {
     fn kind(&self) -> NodeKind;
@@ -195,11 +200,11 @@ impl TryFrom<String> for AnyNodeName {
     type Error = NameError;
 
     fn try_from(s: String) -> Result<Self, Self::Error> {
-        if s.starts_with(ProxyName::prefix()) {
+        if s.starts_with(ProxyName::prefix().expect("has prefix")) {
             Ok(AnyNodeName::Proxy(ProxyName::try_from(s)?))
-        } else if s.starts_with(DroneName::prefix()) {
+        } else if s.starts_with(DroneName::prefix().expect("has prefix")) {
             Ok(AnyNodeName::Drone(DroneName::try_from(s)?))
-        } else if s.starts_with(AcmeDnsServerName::prefix()) {
+        } else if s.starts_with(AcmeDnsServerName::prefix().expect("has prefix")) {
             Ok(AnyNodeName::AcmeDnsServer(AcmeDnsServerName::try_from(s)?))
         } else {
             Err(NameError::InvalidAnyPrefix(s))

plane/src/types/mod.rs

@@ -189,6 +189,12 @@ impl ExecutorConfig {
 
 #[derive(Clone, Serialize, Deserialize, Debug)]
 pub struct SpawnConfig {
+    /// ID to assign to the new backend. Must be unique.
+    /// This should only be used if you really need it, otherwise you can leave it blank
+    /// and let Plane assign a unique ID automatically. This may be removed from
+    /// future versions of Plane.
+    pub id: Option<BackendName>,
+
     /// Cluster to spawn to. Uses the controller default if not provided.
     pub cluster: Option<ClusterName>,