[modular] Support reading config from /pkg/data/startup.config

basemgr will read config from /pkg/data/startup.config if it exists
and fall back to the previously default /config/data/startup.config.

Overridden/persistent config takes precedence as before.

Fixed: 91317
Change-Id: I3888cfdfaff5884c0b2542371b66feb553b09ce8
Reviewed-on: https://fuchsia-review.googlesource.com/c/fuchsia/+/635901
Reviewed-by: Yaar Schnitman <[email protected]>
Reviewed-by: Gabe Schine <[email protected]>
Commit-Queue: Yegor Pomortsev <[email protected]>

Author: ypomortsev

src/modular/lib/modular_config/modular_config.cc

@@ -94,14 +94,17 @@ ModularConfigReader::ModularConfigReader(fbl::unique_fd root_dir) : root_dir_(st
   FX_CHECK(root_dir_.is_valid());
 
   // 1. Figure out where the config file is.
-  std::string config_path = GetDefaultConfigPath();
+  std::string config_path = GetConfigDataConfigPath();
   if (OverriddenConfigExists()) {
     config_path = GetOverriddenConfigPath();
   } else if (PersistentConfigOverrideAllowed() && PersistentConfigExists()) {
     config_path = GetPersistentConfigPath();
-    FX_LOGS(INFO) << "Reading persistent configuration from /" << config_path;
+  } else if (PackagedConfigExists()) {
+    config_path = GetPackagedConfigPath();
   }
 
+  FX_LOGS(INFO) << "Reading configuration from /" << config_path;
+
   // 2. Read the file
   std::string config;
   if (!files::ReadFileToStringAt(root_dir_.get(), config_path, &config)) {
@@ -120,8 +123,8 @@ ModularConfigReader ModularConfigReader::CreateFromNamespace() {
 }
 
 // static
-std::string ModularConfigReader::GetDefaultConfigPath() {
-  return files::JoinPath(StripLeadingSlash(modular_config::kDefaultConfigDir),
+std::string ModularConfigReader::GetConfigDataConfigPath() {
+  return files::JoinPath(StripLeadingSlash(modular_config::kConfigDataDir),
                          modular_config::kStartupConfigFilePath);
 }
 
@@ -137,9 +140,15 @@ std::string ModularConfigReader::GetPersistentConfigPath() {
                          modular_config::kStartupConfigFilePath);
 }
 
+// static
+std::string ModularConfigReader::GetPackagedConfigPath() {
+  return files::JoinPath(StripLeadingSlash(modular_config::kPackageDataDir),
+                         modular_config::kStartupConfigFilePath);
+}
+
 // static
 std::string ModularConfigReader::GetAllowPersistentConfigOverridePath() {
-  return files::JoinPath(StripLeadingSlash(modular_config::kDefaultConfigDir),
+  return files::JoinPath(StripLeadingSlash(modular_config::kConfigDataDir),
                          modular_config::kAllowPersistentConfigOverrideFilePath);
 }
 
@@ -151,6 +160,10 @@ bool ModularConfigReader::PersistentConfigExists() {
   return files::IsFileAt(root_dir_.get(), GetPersistentConfigPath());
 }
 
+bool ModularConfigReader::PackagedConfigExists() {
+  return files::IsFileAt(root_dir_.get(), GetPackagedConfigPath());
+}
+
 bool ModularConfigReader::PersistentConfigOverrideAllowed() {
   return files::IsFileAt(root_dir_.get(), GetAllowPersistentConfigOverridePath());
 }

src/modular/lib/modular_config/modular_config.h

@@ -69,24 +69,30 @@ class ModularConfigReader {
   // incoming namespace.
   static ModularConfigReader CreateFromNamespace();
 
-  // Returns the path to the default config file.
-  static std::string GetDefaultConfigPath();
+  // Returns the path to the config file in the /config/data directory.
+  static std::string GetConfigDataConfigPath();
 
   // Returns the path to the overridden config file.
   static std::string GetOverriddenConfigPath();
 
   // Returns the path to the persistent config file.
   static std::string GetPersistentConfigPath();
 
+  // Returns the path to the config file in the current package.
+  static std::string GetPackagedConfigPath();
+
   // Returns the path to the allow_persistent_config_override marker file.
   static std::string GetAllowPersistentConfigOverridePath();
 
-  // Returns true if configurations exist at the overridden config path.
+  // Returns true if a configuration file exists at the overridden config path.
   bool OverriddenConfigExists();
 
-  // Returns true if configuration exists at the persistent config path.
+  // Returns true if a configuration file exists at the persistent config path.
   bool PersistentConfigExists();
 
+  // Returns true if a configuration file exists in the current package.
+  bool PackagedConfigExists();
+
   // Returns true if the allow_persistent_config_override marker file exists.
   bool PersistentConfigOverrideAllowed();
 

src/modular/lib/modular_config/modular_config_constants.h

@@ -11,7 +11,8 @@ constexpr char kBasemgrConfigName[] = "basemgr";
 constexpr char kSessionmgrConfigName[] = "sessionmgr";
 constexpr char kSessionmgrUrl[] = "fuchsia-pkg://fuchsia.com/sessionmgr#meta/sessionmgr.cmx";
 
-constexpr char kDefaultConfigDir[] = "/config/data";
+constexpr char kConfigDataDir[] = "/config/data";
+constexpr char kPackageDataDir[] = "/pkg/data";
 constexpr char kOverriddenConfigDir[] = "/config_override/data";
 constexpr char kPersistentConfigDir[] = "/cache";
 

src/modular/lib/modular_config/modular_config_unittest.cc

@@ -42,8 +42,8 @@ bool CreateFileAt(int root_fd, const std::string& path, std::string_view data) {
 class ModularConfigReaderTest : public gtest::RealLoopFixture {};
 class ModularConfigWriterTest : public gtest::RealLoopFixture {};
 
-// Test that ModularConfigReader finds and reads the startup.config file given a
-// root directory that contains config data.
+// Test that ModularConfigReader finds and reads the startup.config file from the overridden
+// config directory.
 TEST_F(ModularConfigReaderTest, OverrideConfigDir) {
   constexpr char kSessionShellForTest[] =
       "fuchsia-pkg://example.com/ModularConfigReaderTest#meta/"
@@ -62,8 +62,35 @@ TEST_F(ModularConfigReaderTest, OverrideConfigDir) {
       kSessionShellForTest);
 
   modular::PseudoDirServer server(modular::MakeFilePathWithContents(
-      files::JoinPath(modular_config::kOverriddenConfigDir, modular_config::kStartupConfigFilePath),
-      config_contents));
+      modular::ModularConfigReader::GetOverriddenConfigPath(), config_contents));
+
+  modular::ModularConfigReader reader(server.OpenAt("."));
+  auto config = reader.GetBasemgrConfig();
+
+  // Verify that ModularConfigReader parsed the config value we gave it.
+  EXPECT_EQ(kSessionShellForTest, config.session_shell_map().at(0).config().app_config().url());
+}
+
+// Test that ModularConfigReader finds and reads the startup.config file in the package directory.
+TEST_F(ModularConfigReaderTest, PackagedConfigDir) {
+  constexpr char kSessionShellForTest[] =
+      "fuchsia-pkg://example.com/ModularConfigReaderTest#meta/"
+      "ModularConfigReaderTest.cmx";
+
+  std::string config_contents = fxl::Substitute(
+      R"({
+        "basemgr": {
+          "session_shells": [
+            {
+              "url": "$0"
+            }
+          ]
+        }
+      })",
+      kSessionShellForTest);
+
+  modular::PseudoDirServer server(modular::MakeFilePathWithContents(
+      modular::ModularConfigReader::GetPackagedConfigPath(), config_contents));
 
   modular::ModularConfigReader reader(server.OpenAt("."));
   auto config = reader.GetBasemgrConfig();
@@ -160,8 +187,7 @@ TEST_F(ModularConfigReaderTest, GetConfigAsString) {
 
   // Host |config_contents|, parse it into |first_reader|, and write configs into |read_config_str|
   modular::PseudoDirServer server(modular::MakeFilePathWithContents(
-      files::JoinPath(modular_config::kDefaultConfigDir, modular_config::kStartupConfigFilePath),
-      config_contents));
+      modular::ModularConfigReader::GetConfigDataConfigPath(), config_contents));
 
   modular::ModularConfigReader first_reader(server.OpenAt("."));
   auto basemgr_config = first_reader.GetBasemgrConfig();
@@ -171,8 +197,7 @@ TEST_F(ModularConfigReaderTest, GetConfigAsString) {
 
   // Host the new config string and parse it into |second_reader|
   modular::PseudoDirServer server_after_read(modular::MakeFilePathWithContents(
-      files::JoinPath(modular_config::kDefaultConfigDir, modular_config::kStartupConfigFilePath),
-      read_config_str));
+      modular::ModularConfigReader::GetConfigDataConfigPath(), read_config_str));
 
   modular::ModularConfigReader second_reader(server_after_read.OpenAt("."));
 
@@ -436,7 +461,7 @@ TEST_F(ModularConfigReaderTest, ReadPersistentConfig) {
 
   // The /config/data/startup.config file contains an empty config.
   ASSERT_TRUE(
-      CreateFileAt(root_fd.get(), modular::ModularConfigReader::GetDefaultConfigPath(), "{}"));
+      CreateFileAt(root_fd.get(), modular::ModularConfigReader::GetConfigDataConfigPath(), "{}"));
 
   // Allow persistent config_override.
   ASSERT_TRUE(CreateFileAt(root_fd.get(),