Config

mirrord/cli/src/connection.rs

@@ -95,8 +95,8 @@ where
             AgentConnection { sender: session.tx, receiver: session.rx },
         ))
     } else {
-        if config.feature.copy_target {
-            return Err(CliError::FeatureRequiresOperatorError("copy pod".into()));
+        if config.feature.copy_target.enabled {
+            return Err(CliError::FeatureRequiresOperatorError("copy target".into()));
         }
 
         if matches!(config.target, mirrord_config::target::TargetConfig{ path: Some(mirrord_config::target::Target::Deployment{..}), ..}) {

mirrord/config/src/feature.rs

@@ -2,9 +2,9 @@ use mirrord_analytics::CollectAnalytics;
 use mirrord_config_derive::MirrordConfig;
 use schemars::JsonSchema;
 
-use self::{env::EnvConfig, fs::FsConfig, network::NetworkConfig};
-use crate::MirrordConfigSource;
+use self::{copy_target::CopyTargetConfig, env::EnvConfig, fs::FsConfig, network::NetworkConfig};
 
+pub mod copy_target;
 pub mod env;
 pub mod fs;
 pub mod network;
@@ -83,15 +83,15 @@ pub struct FeatureConfig {
     ///
     /// Creates a new copy of the target. mirrord will use this copy instead of the original target
     /// (e.g. intercept network traffic). This feature requires a [mirrord operator](https://mirrord.dev/docs/teams/introduction/).
-    #[config(default = false, unstable)]
-    pub copy_target: bool,
+    #[config(nested, toggleable, unstable)]
+    pub copy_target: CopyTargetConfig,
 }
 
 impl CollectAnalytics for &FeatureConfig {
     fn collect_analytics(&self, analytics: &mut mirrord_analytics::Analytics) {
         analytics.add("env", &self.env);
         analytics.add("fs", &self.fs);
         analytics.add("network", &self.network);
-        analytics.add("copy_target", self.copy_target);
+        analytics.add("copy_target", &self.copy_target);
     }
 }

mirrord/config/src/feature/copy_target.rs

@@ -0,0 +1,52 @@
+use mirrord_analytics::CollectAnalytics;
+use schemars::JsonSchema;
+use serde::Deserialize;
+
+use crate::{
+    config::{ConfigContext, ConfigError, FromMirrordConfig, MirrordConfig, Result},
+    util::MirrordToggleableConfig,
+};
+
+/// TODO json schema
+#[derive(Clone, Debug, Deserialize, JsonSchema, Default)]
+#[cfg_attr(test, derive(PartialEq, Eq))]
+pub struct CopyTargetFileConfig {
+    pub scale_down: Option<bool>,
+}
+
+impl MirrordConfig for CopyTargetFileConfig {
+    type Generated = CopyTargetConfig;
+
+    fn generate_config(self, _context: &mut ConfigContext) -> Result<Self::Generated> {
+        Ok(Self::Generated {
+            enabled: true,
+            scale_down: self.scale_down.unwrap_or_default(),
+        })
+    }
+}
+
+impl MirrordToggleableConfig for CopyTargetFileConfig {
+    fn disabled_config(_context: &mut ConfigContext) -> Result<Self::Generated, ConfigError> {
+        Ok(Self::Generated {
+            enabled: false,
+            scale_down: false,
+        })
+    }
+}
+
+impl FromMirrordConfig for CopyTargetConfig {
+    type Generator = CopyTargetFileConfig;
+}
+
+#[derive(Clone, Debug)]
+pub struct CopyTargetConfig {
+    pub enabled: bool,
+    pub scale_down: bool,
+}
+
+impl CollectAnalytics for &CopyTargetConfig {
+    fn collect_analytics(&self, analytics: &mut mirrord_analytics::Analytics) {
+        analytics.add("enabled", self.enabled);
+        analytics.add("scale_down", self.scale_down);
+    }
+}

mirrord/config/src/lib.rs

@@ -419,7 +419,7 @@ impl LayerConfig {
             }
         }
 
-        if self.feature.copy_target {
+        if self.feature.copy_target.enabled {
             if !self.operator {
                 return Err(ConfigError::Conflict(
                     "The copy target feature requires a mirrord operator, \

mirrord/operator/src/client.rs

@@ -159,7 +159,7 @@ impl OperatorApi {
 
     /// Checks used config against operator specification.
     fn check_config(config: &LayerConfig, operator: &MirrordOperatorCrd) -> Result<()> {
-        if config.feature.copy_target {
+        if config.feature.copy_target.enabled {
             let feature_enabled = operator.spec.copy_target_enabled.unwrap_or(false);
 
             if !feature_enabled {
@@ -243,9 +243,11 @@ impl OperatorApi {
             .await?
             .ok_or(OperatorApiError::InvalidTarget)?;
 
-        let target_to_connect = if config.feature.copy_target {
+        let target_to_connect = if config.feature.copy_target.enabled {
             let mut copy_progress = progress.subtask("copying target");
-            let copied = operator_api.copy_target(&metadata, raw_target).await?;
+            let copied = operator_api
+                .copy_target(&metadata, raw_target, config.feature.copy_target.scale_down)
+                .await?;
             copy_progress.success(None);
 
             OperatorSessionTarget::Copied(copied)
@@ -465,6 +467,7 @@ impl OperatorApi {
         &self,
         session_metadata: &OperatorSessionMetadata,
         target: TargetCrd,
+        scale_down: bool,
     ) -> Result<CopyTargetCrd> {
         let raw_target = target
             .spec
@@ -477,6 +480,7 @@ impl OperatorApi {
             CopyTargetSpec {
                 target: raw_target,
                 idle_ttl: Some(Self::COPIED_POD_IDLE_TTL),
+                scale_down: scale_down.into(),
             },
         );
 

mirrord/operator/src/crd.rs

@@ -140,4 +140,6 @@ pub struct CopyTargetSpec {
     /// How long should the operator keep this pod alive after its creation.
     /// The pod is deleted when this timout has expired and there are no connected clients.
     pub idle_ttl: Option<u32>,
+    /// Should the operator scale down target deployment while this pod is alive.
+    pub scale_down: Option<bool>,
 }