Apply suggestions

Author: gememma

mirrord/cli/src/config.rs

@@ -802,7 +802,7 @@ pub(super) struct ListTargetArgs {
 
     /// Specify the type of target to be retrieved. If `None`, all types are retrieved.
     #[arg(short = 't', long)]
-    pub target_type: Option<TargetType>,
+    pub target_type: Option<Vec<TargetType>>,
 }
 
 impl ListTargetArgs {

mirrord/cli/src/list.rs

@@ -1,4 +1,4 @@
-use std::{str::FromStr, sync::LazyLock, time::Instant};
+use std::{sync::LazyLock, time::Instant};
 
 use futures::TryStreamExt;
 use k8s_openapi::api::core::v1::Namespace;
@@ -12,7 +12,6 @@ use mirrord_kube::{
 use mirrord_operator::client::OperatorApi;
 use semver::VersionReq;
 use serde::{ser::SerializeSeq, Serialize, Serializer};
-use serde_json::Value;
 use tracing::Level;
 
 use crate::{util, CliError, CliResult, Format, ListTargetArgs};
@@ -245,17 +244,13 @@ pub(super) async fn print_targets(args: ListTargetArgs, rich_output: bool) -> Cl
     }
 
     let target_types = if let Some(target_type) = args.target_type {
-        Some(vec![target_type])
+        Some(target_type)
     } else {
         match std::env::var(LS_TARGET_TYPES_ENV)
             .ok()
-            .map(|val| serde_json::from_str::<Vec<Value>>(val.as_ref()))
+            .map(|val| serde_json::from_str::<Vec<TargetType>>(val.as_ref()))
             .transpose()?
             .unwrap_or_default()
-            .into_iter()
-            .filter_map(|value| value.as_str().map(|str| str.to_string()))
-            .filter_map(|string| TargetType::from_str(&string).ok())
-            .collect::<Vec<TargetType>>()
         {
             vec if vec.is_empty() => None,
             vec => Some(vec),

mirrord/config/src/target.rs

@@ -277,9 +277,10 @@ mirrord-layer failed to parse the provided target!
     Serialize, Deserialize, Clone, Eq, PartialEq, Hash, Debug, JsonSchema, EnumDiscriminants,
 )]
 #[serde(untagged, deny_unknown_fields)]
-#[strum_discriminants(derive(EnumString, Serialize))]
+#[strum_discriminants(derive(EnumString, Serialize, Deserialize))]
 #[strum_discriminants(name(TargetType))]
 #[strum_discriminants(strum(serialize_all = "lowercase"))]
+#[strum_discriminants(serde(rename_all="lowercase"))]
 pub enum Target {
     /// <!--${internal}-->
     /// [Deployment](https://kubernetes.io/docs/concepts/workloads/controllers/deployment/).
@@ -370,7 +371,7 @@ impl Target {
 
 impl fmt::Display for TargetType {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        let stringifed = match self {
+        let stringified = match self {
             TargetType::Targetless => "targetless",
             TargetType::Pod => "pod",
             TargetType::Deployment => "deployment",
@@ -382,7 +383,7 @@ impl fmt::Display for TargetType {
             TargetType::ReplicaSet => "replicaset",
         };
 
-        f.write_str(stringifed)
+        f.write_str(stringified)
     }
 }
 

mirrord/kube/src/api/kubernetes/seeker.rs

@@ -81,11 +81,13 @@ impl KubeResourceSeeker<'_> {
         resource_types: Vec<TargetType>,
         operator_active: bool,
     ) -> Result<Vec<String>> {
-        let mut targets = vec![];
-        for resource_type in resource_types {
-            targets.extend(self.filtered_single(resource_type, operator_active).await?);
-        }
-        Ok(targets)
+        Ok(futures::future::try_join_all(
+            resource_types
+                .into_iter()
+                .map(|resource_type| self.filtered_single(resource_type, operator_active)),
+        )
+        .await?
+        .concat())
     }
 
     async fn filtered_single(
@@ -114,27 +116,11 @@ impl KubeResourceSeeker<'_> {
             TargetType::ReplicaSet if operator_active => {
                 self.simple_list_resource::<ReplicaSet>("replicaset").await
             }
-            TargetType::Targetless => {
-                tracing::error!("Cannot list targets with resource type 'targetless'");
-                Err(KubeApiError::InvalidListTargetType(
-                    resource_type,
-                    "cannot list targets with resource type 'targetless'.".to_string(),
-                ))
-            }
+            TargetType::Targetless => Err(KubeApiError::InvalidTargetType(resource_type)),
             resource_type if !operator_active => {
-                tracing::warn!("Cannot list targets with resource type '{resource_type}' unless the operator is enabled.");
-                Err(KubeApiError::InvalidListTargetType(
-                    resource_type,
-                    "this type requires the operator to be enabled.".to_string(),
-                ))
-            }
-            resource_type => {
-                tracing::error!("Cannot list targets with resource type '{resource_type}' due to a missing implementation. This is a bug.");
-                Err(KubeApiError::InvalidListTargetType(
-                    resource_type,
-                    "this type cannot be listed. This is a bug.".to_string(),
-                ))
+                Err(KubeApiError::TargetTypeRequiresOperator(resource_type))
             }
+            resource_type => Err(KubeApiError::InvalidTargetTypeBug(resource_type)),
         }
     }
 

mirrord/kube/src/error.rs

@@ -59,10 +59,22 @@ pub enum KubeApiError {
         String,
     ),
 
+    /// Attempted to list a specific resource type with `mirrord ls` but was unable to because the
+    /// operator was required.
+    #[error(
+        "The requested resource type `{0}` could not be listed because it requires the operator."
+    )]
+    TargetTypeRequiresOperator(TargetType),
+
+    /// Attempted to list a specific resource type with `mirrord ls` but was unable to because that
+    /// type cannot be listed (for example, cannot list targets of type "targetless".
+    #[error("Targets of type `{0}` cannot be listed.")]
+    InvalidTargetType(TargetType),
+
     /// Attempted to list a specific resource type with `mirrord ls` but was unable to because
-    /// either the operator required but is not enabled, or the type was invalid.
-    #[error("The requested resource type `{0}` could not be listed: {1}")]
-    InvalidListTargetType(TargetType, String),
+    /// listing that type has not been implemented.
+    #[error("Targets of type `{0}` cannot be listed. This is a bug.")]
+    InvalidTargetTypeBug(TargetType),
 }
 
 impl KubeApiError {