Add support for tedge_config to prefer separate mapper config by default

Signed-off-by: James Rhodes <jarhodes314@gmail.com>

Author: jarhodes314

crates/common/tedge_config/src/lib.rs

@@ -27,6 +27,20 @@ impl TEdgeConfig {
         config_location.load().await
     }
 
+    /// Load [TEdgeConfig], using a separate mapper config file as the default
+    /// behaviour if no clouds are already configured
+    /// 
+    /// As of 2026-01-05, this is only used for testing how the new default will
+    /// work before we fully adopt the new format. When we do this, we should
+    /// probably also include `tedge-mapper config-migrate` commands in the
+    /// relevant package postinstall scripts.
+    #[cfg(feature = "test")]
+    pub async fn load_prefer_separate_mapper_config(config_dir: impl AsRef<StdPath>) -> Result<Self, TEdgeConfigError> {
+        let mut config_location = TEdgeConfigLocation::from_custom_root(config_dir.as_ref());
+        config_location.default_to_mapper_config_dir();
+        config_location.load().await
+    }
+
     pub async fn update_toml(
         self,
         update: &impl Fn(&mut TEdgeConfigDto, &TEdgeConfigReader) -> ConfigSettingResult<()>,

crates/common/tedge_config/src/tedge_toml/tedge_config_location.rs

@@ -59,6 +59,14 @@ pub(crate) struct TEdgeConfigLocation {
 
     /// Full path to the `tedge.toml` file.
     tedge_config_file_path: Utf8PathBuf,
+
+    mapper_config_default_location: MapperConfigLocation,
+}
+
+#[derive(Debug, Copy, Clone, Eq, PartialEq)]
+pub(crate) enum MapperConfigLocation {
+    TedgeToml,
+    SeparateFile,
 }
 
 impl Default for TEdgeConfigLocation {
@@ -77,9 +85,15 @@ impl TEdgeConfigLocation {
             tedge_config_file_path: Utf8Path::from_path(tedge_config_root_path.as_ref())
                 .unwrap()
                 .join(TEDGE_CONFIG_FILE),
+            mapper_config_default_location: MapperConfigLocation::TedgeToml,
         }
     }
 
+    #[cfg(feature = "test")]
+    pub(crate) fn default_to_mapper_config_dir(&mut self) {
+        self.mapper_config_default_location = MapperConfigLocation::SeparateFile;
+    }
+
     pub(crate) fn tedge_config_root_path(&self) -> &Utf8Path {
         &self.tedge_config_root_path
     }
@@ -94,7 +108,14 @@ impl TEdgeConfigLocation {
     /// 1. New format (`mappers/[cloud].toml` or `mappers/[cloud].d/[profile].toml`) takes precedence
     /// 2. If new format exists for some profiles but not the requested one, returns NotFound
     /// 3. If the config directory is inaccessible due to a permissions error, return Error
-    /// 4. If no new format exists at all, fall back to legacy tedge.toml format
+    /// 
+    /// If no new format exists, we then look at the
+    /// `mapper_config_default_location` field of [TEdgeConfigLocation]:
+    /// 1. If this is set to [MapperConfigLocation::TedgeToml], we fall back to tedge.toml
+    /// 2. If this is set to [MapperConfigLocation::SeparateFile] and no cloud configurations
+    ///    exist in tedge.toml, we use the new mapper config format
+    /// 3. If cloud configurations (for any cloud) do already exist in tedge.toml, we use
+    ///    tedge.toml until the configuration is explicitly migrated 
     pub async fn decide_config_source<T>(&self, profile: Option<&ProfileName>) -> ConfigDecision
     where
         T: ExpectedCloudType,
@@ -122,7 +143,20 @@ impl TEdgeConfigLocation {
             (Ok(true), _, _) | (_, Ok(true), _) => ConfigDecision::NotFound { path },
 
             // No new format configs exist for this cloud, use legacy
-            (Ok(false), Ok(false), _) => ConfigDecision::LoadLegacy,
+            (Ok(false), Ok(false), _) => {
+                // TODO tidy this up
+                let toml = tokio::fs::read_to_string(self.toml_path()).await.unwrap_or_default();
+                let tedge_toml: toml::Table = toml::from_str(&toml).unwrap();
+                let non_migrated_cloud_exists = ["c8y", "az", "aws"].iter().any(|key| tedge_toml.contains_key(*key));
+
+                if self.mapper_config_default_location == MapperConfigLocation::SeparateFile
+                && !non_migrated_cloud_exists
+                {
+                    ConfigDecision::LoadNew { path }
+                } else {
+                    ConfigDecision::LoadLegacy
+                }
+            }
 
             // Permission error accessing mapper config directory
             (Err(err), _, _) | (_, Err(err), _) => ConfigDecision::PermissionError {

crates/common/tedge_config/tests/mapper_config.rs

@@ -36,3 +36,177 @@ async fn empty_new_config_uses_tedge_toml_defaults() {
         "Device ID should come from tedge.toml defaults"
     );
 }
+
+mod default_location_mode {
+        use super::*;
+
+    mod prefers_tedge_toml {
+        use tedge_config::models::CloudType;
+
+        use super::*;
+
+        #[tokio::test]
+        async fn mapper_config_is_not_created_if_tedge_toml_does_not_exist() {
+            let ttd = TempTedgeDir::new();
+
+            let tedge_config = TEdgeConfig::load(ttd.path()).await.unwrap();
+            tedge_config
+                .update_toml(&|dto, _rdr| {
+                    dto.c8y.try_get_mut(None, "c8y").unwrap().url =
+                        Some("example.com".parse().unwrap());
+                    Ok(())
+                })
+                .await
+                .unwrap();
+
+            assert!(
+                !ttd.path().join("mappers").exists(),
+                "mappers dir should not have been created"
+            );
+        }
+
+        #[tokio::test]
+        async fn mapper_config_is_created_for_new_profile_of_existing_separate_config_cloud() {
+            let ttd = TempTedgeDir::new();
+
+            let tedge_config = TEdgeConfig::load(ttd.path())
+                .await
+                .unwrap();
+            tedge_config
+                .update_toml(&|dto, _rdr| {
+                    dto.c8y.try_get_mut(None, "c8y").unwrap().url =
+                        Some("example.com".parse().unwrap());
+                    Ok(())
+                })
+                .await
+                .unwrap();
+
+            let tedge_config = TEdgeConfig::load(ttd.path())
+                .await
+                .unwrap();
+            tedge_config.migrate_mapper_config(CloudType::C8y).await.unwrap();
+
+            let tedge_config = TEdgeConfig::load(ttd.path())
+                .await
+                .unwrap();
+            tedge_config
+                .update_toml(&|dto, _rdr| {
+                    dto.c8y.try_get_mut(Some("new-profile"), "c8y").unwrap().url =
+                        Some("new.example.com".parse().unwrap());
+                    Ok(())
+                })
+                .await
+                .unwrap();
+
+            assert!(
+                ttd.path().join("mappers").exists(),
+                "mappers dir should exist"
+            );
+            let c8y_toml = tokio::fs::read_to_string(ttd.path().join("mappers/c8y.toml"))
+                .await
+                .unwrap();
+            assert_eq!(c8y_toml.trim(), "url = \"example.com\"");
+        }
+    }
+
+    mod prefers_separate_config {
+        use super::*;
+
+        #[tokio::test]
+        async fn mapper_config_is_created_if_tedge_toml_does_not_exist() {
+            let ttd = TempTedgeDir::new();
+
+            let tedge_config = TEdgeConfig::load_prefer_separate_mapper_config(ttd.path())
+                .await
+                .unwrap();
+            tedge_config
+                .update_toml(&|dto, _rdr| {
+                    dto.c8y.try_get_mut(None, "c8y").unwrap().url =
+                        Some("example.com".parse().unwrap());
+                    Ok(())
+                })
+                .await
+                .unwrap();
+
+            assert!(
+                ttd.path().join("mappers").exists(),
+                "mappers dir should have been created"
+            );
+
+            let tedge_toml = tokio::fs::read_to_string(ttd.path().join("tedge.toml"))
+                .await
+                .unwrap();
+            let c8y_toml = tokio::fs::read_to_string(ttd.path().join("mappers/c8y.toml"))
+                .await
+                .unwrap();
+            assert_eq!(tedge_toml, "");
+            assert_eq!(c8y_toml.trim(), "url = \"example.com\"");
+        }
+
+        #[tokio::test]
+        async fn mapper_config_is_created_if_tedge_toml_has_no_cloud_configs() {
+            let ttd = TempTedgeDir::new();
+            ttd.file("tedge.toml").with_toml_content(toml::toml!(
+                device.type = "my-fancy-device"
+            ));
+
+            let tedge_config = TEdgeConfig::load_prefer_separate_mapper_config(ttd.path())
+                .await
+                .unwrap();
+            tedge_config
+                .update_toml(&|dto, _rdr| {
+                    dto.c8y.try_get_mut(None, "c8y").unwrap().url =
+                        Some("example.com".parse().unwrap());
+                    Ok(())
+                })
+                .await
+                .unwrap();
+
+            assert!(
+                ttd.path().join("mappers").exists(),
+                "mappers dir should have been created"
+            );
+
+            let tedge_toml = tokio::fs::read_to_string(ttd.path().join("tedge.toml"))
+                .await
+                .unwrap();
+            let c8y_toml = tokio::fs::read_to_string(ttd.path().join("mappers/c8y.toml"))
+                .await
+                .unwrap();
+            assert!(!tedge_toml.contains("c8y"));
+            assert_eq!(c8y_toml.trim(), "url = \"example.com\"");
+        }
+
+        #[tokio::test]
+        async fn mapper_config_is_not_created_for_new_profile_of_existing_tedge_toml_cloud() {
+            let ttd = TempTedgeDir::new();
+            ttd.file("tedge.toml")
+                .with_toml_content(toml::toml!(c8y.url = "example.com"));
+
+            let tedge_config = TEdgeConfig::load_prefer_separate_mapper_config(ttd.path())
+                .await
+                .unwrap();
+            tedge_config
+                .update_toml(&|dto, _rdr| {
+                    dto.c8y.try_get_mut(Some("new-profile"), "c8y").unwrap().url =
+                        Some("new.example.com".parse().unwrap());
+                    Ok(())
+                })
+                .await
+                .unwrap();
+
+            assert!(
+                !ttd.path().join("mappers").exists(),
+                "mappers dir should not have been created"
+            );
+        }
+    }
+}
+
+// TEST PLAN
+// no tedge.toml, old mode -> no migration
+// tedge.toml with c8y, old mode -> no migration
+// tedge.toml with az, old mode -> no migration
+// no tedge.toml, new mode -> migrate
+// tedge.toml without c8y, new mode -> migrate
+// tedge.toml cannot be read -> do nothing