Report drone name in connect response (#592)

* Report drone name in connect response

* Print drone in CLI

plane/src/admin.rs

@@ -187,6 +187,10 @@ pub async fn run_admin_command_inner(opts: AdminOpts) -> Result<(), PlaneClientE
             println!("URL: {}", response.url.bright_white());
             println!("Status URL: {}", response.status_url.bright_white());
 
+            if let Some(drone) = response.drone {
+                println!("Drone: {}", drone.to_string().bright_green());
+            }
+
             if wait {
                 let mut stream = client.backend_status_stream(&response.backend_id).await?;
 

plane/src/database/connect.rs

@@ -224,6 +224,7 @@ async fn attempt_connect(
                     token,
                     secret_token,
                     client,
+                    None,
                 );
 
                 return Ok(connect_response);
@@ -284,6 +285,7 @@ async fn attempt_connect(
         token,
         secret_token,
         client,
+        Some(drone.drone),
     );
 
     Ok(connect_response)

plane/src/database/drone.rs

@@ -1,9 +1,10 @@
 use crate::{
     heartbeat_consts::UNHEALTHY_SECONDS,
+    names::DroneName,
     types::{ClusterName, NodeId},
 };
 use chrono::{DateTime, Utc};
-use sqlx::{postgres::types::PgInterval, query, query_as, PgPool};
+use sqlx::{postgres::types::PgInterval, query, PgPool};
 use std::time::Duration;
 
 pub struct DroneDatabase<'a> {
@@ -72,11 +73,11 @@ impl<'a> DroneDatabase<'a> {
         &self,
         cluster: &ClusterName,
     ) -> sqlx::Result<Option<DroneForSpawn>> {
-        let result = query_as!(
-            DroneForSpawn,
+        let result = query!(
             r#"
             select
                 drone.id,
+                node.name,
                 drone.last_local_time as "last_local_time!"
             from node
             left join drone
@@ -108,11 +109,27 @@ impl<'a> DroneDatabase<'a> {
         .fetch_optional(self.pool)
         .await?;
 
+        let result = match result {
+            Some(result) => {
+                let id = NodeId::from(result.id);
+                let drone = DroneName::try_from(result.name).expect("valid drone name");
+                let last_local_time = result.last_local_time;
+
+                Some(DroneForSpawn {
+                    id,
+                    drone,
+                    last_local_time,
+                })
+            }
+            None => return Ok(None),
+        };
+
         Ok(result)
     }
 }
 
 pub struct DroneForSpawn {
     pub id: NodeId,
+    pub drone: DroneName,
     pub last_local_time: DateTime<Utc>,
 }

plane/src/types/mod.rs

@@ -1,4 +1,8 @@
-use crate::{client::PlaneClient, names::BackendName, util::random_prefixed_string};
+use crate::{
+    client::PlaneClient,
+    names::{BackendName, DroneName},
+    util::random_prefixed_string,
+};
 pub use backend_state::{BackendState, BackendStatus, TerminationKind, TerminationReason};
 use bollard::auth::DockerCredentials;
 use serde::{Deserialize, Serialize};
@@ -305,6 +309,9 @@ pub struct ConnectResponse {
     pub secret_token: SecretToken,
 
     pub status_url: String,
+
+    /// The drone that spawned this backend, if the request resulted in a spawn.
+    pub drone: Option<DroneName>,
 }
 
 impl ConnectResponse {
@@ -316,6 +323,7 @@ impl ConnectResponse {
         token: BearerToken,
         secret_token: SecretToken,
         client: &PlaneClient,
+        drone: Option<DroneName>,
     ) -> Self {
         let url = if cluster.is_https() {
             format!("https://{}/{}/", cluster, token)
@@ -333,6 +341,7 @@ impl ConnectResponse {
             url,
             secret_token,
             status_url,
+            drone,
         }
     }
 }