Register data per application and allow arbitrary registration

refs idaholab#29141

framework/doc/content/source/interfaces/DataFileInterface.md

@@ -19,8 +19,13 @@ If the provided path is absolute, no searching will take place and the absolute
 path will be used. Otherwise, `getDataFileName` will search (in this order)
 
 - relative to the input file
-- relative to the running binary in the shared directory (assuming the application is installed)
-- relative to all registered data file directories (which are determined by the source file locations when compiling and registered using the `registerDataFilePath` macro in `Registry.h`)
+- relative to all installed and registered data file directories (for an installed application)
+- relative to all in-tree registered data file directories (for an in-tree build)
+
+The "registered" data file directories are directories that are registered via:
+
+- the `registerAppDataFilePath` macro in `Registry.h`, where an applications data in its root `data` directory is registered
+- the `registerDataFilePath` macro in `Registry.h`, where a general data directory is registered
 
 ## `getDataFileNameByName`
 

framework/include/base/Registry.h

@@ -19,6 +19,8 @@
 
 #include "libmesh/utility.h"
 
+#include <gtest/gtest.h>
+
 #define combineNames1(X, Y) X##Y
 #define combineNames(X, Y) combineNames1(X, Y)
 
@@ -76,7 +78,12 @@
 #define registerADMooseObjectRenamed(app, orig_class, time, new_class)                             \
   registerMooseObjectRenamed(app, orig_class, time, new_class)
 
-#define registerDataFilePath() Registry::addDataFilePath(__FILE__)
+/// Register a data file path (folder name must be data)
+#define registerDataFilePath(name, path) Registry::addDataFilePath(name, path)
+/// Register a data file path for an application. Uses the current file to register
+/// ../../data as a path. The app name must be the APPLICATION_NAME used to build
+/// the app (solid_mechanics instead of SolidMechanicsApp, for example)
+#define registerAppDataFilePath(app) Registry::addAppDataFilePath(app, __FILE__)
 
 #define registerRepository(repo_name, repo_url) Registry::addRepository(repo_name, repo_url);
 
@@ -198,8 +205,11 @@ class Registry
   /// addKnownLabel whitelists a label as valid for purposes of the checkLabels function.
   static char addKnownLabel(const std::string & label);
 
-  /// register search paths for built-in data files
-  static void addDataFilePath(const std::string & path);
+  /// register general search paths (folder name must be data)
+  static void addDataFilePath(const std::string & name, const std::string & path);
+  /// register search paths for an application (path determined relative to app_path);
+  /// app_path should be passed as __FILE__ from the application source file
+  static void addAppDataFilePath(const std::string & app_name, const std::string & app_path);
 
   /// register a repository
   static void addRepository(const std::string & repo_name, const std::string & repo_url);
@@ -226,11 +236,18 @@ class Registry
   }
 
   /// Returns a vector of all registered data file paths
-  static const std::vector<std::string> & getDataFilePaths()
+  static const std::map<std::string, std::string> & getDataFilePaths()
   {
     return getRegistry()._data_file_paths;
   }
 
+  /**
+   * Gets a data path for the registered name.
+   *
+   * Finds either the installed path or the in-tree path.
+   */
+  static std::string getDataPath(const std::string & name);
+
   /// Returns the repository URL associated with \p repo_name
   static const std::string & getRepositoryURL(const std::string & repo_name);
 
@@ -247,13 +264,16 @@ class Registry
   ///@}
 
 private:
+  FRIEND_TEST(RegistryTest, getDataPathFailed);
+
   Registry(){};
 
   std::map<std::string, std::shared_ptr<RegistryEntryBase>> _name_to_entry;
   std::map<std::string, std::vector<std::shared_ptr<RegistryEntryBase>>> _per_label_objects;
   std::map<std::string, std::vector<std::shared_ptr<RegistryEntryBase>>> _per_label_actions;
   std::set<std::string> _known_labels;
-  std::vector<std::string> _data_file_paths;
+  /// Data file registry; name -> in-tree path
+  std::map<std::string, std::string> _data_file_paths;
   /// Repository name -> repository URL; used for mooseDocumentedError
   std::map<std::string, std::string> _repos;
   std::map<std::string, std::string> _type_to_classname;

framework/src/base/Moose.C

@@ -59,7 +59,7 @@ registerAll(Factory & f, ActionFactory & af, Syntax & s)
   registerObjects(f, {"MooseApp"});
   associateSyntaxInner(s, af);
   registerActions(s, af, {"MooseApp"});
-  registerDataFilePath();
+  registerAppDataFilePath("moose");
   registerRepository("moose", "github.com/idaholab/moose");
 }
 

framework/src/base/Registry.C

@@ -16,6 +16,7 @@
 #include "libmesh/libmesh_common.h"
 
 #include <memory>
+#include <filesystem>
 
 Registry &
 Registry::getRegistry()
@@ -86,21 +87,63 @@ Registry::addKnownLabel(const std::string & label)
 }
 
 void
-Registry::addDataFilePath(const std::string & fullpath)
+Registry::addDataFilePath(const std::string & name, const std::string & path)
 {
+  mooseAssert(std::filesystem::path(path).parent_path().filename() == "data", "Must end with data");
+
+  const std::string abs_path = std::filesystem::weakly_canonical(path).c_str();
+  if (!MooseUtils::pathIsDirectory(abs_path))
+    mooseError("While registering data file path '",
+               abs_path,
+               "' for '",
+               name,
+               "': the path was not found");
+
   auto & dfp = getRegistry()._data_file_paths;
+  const auto it = dfp.find(name);
+  // Not registered yet
+  if (it == dfp.end())
+    dfp.emplace(name, abs_path);
+  // Registered, but with a different value
+  else if (it->second != abs_path)
+    mooseError("While registering data file path '",
+               abs_path,
+               "' for '",
+               name,
+               "': the path '",
+               it->second,
+               "' is already registered");
+}
 
+void
+Registry::addAppDataFilePath(const std::string & app_name, const std::string & app_path)
+{
   // split the *App.C filename from its containing directory
-  const auto path = MooseUtils::splitFileName(fullpath).first;
-
+  const auto dir = MooseUtils::splitFileName(app_path).first;
   // This works for both build/unity_src/ and src/base/ as the *App.C file location,
   // in case __FILE__ doesn't get overriden in unity build
-  const auto data_dir = MooseUtils::pathjoin(path, "../../data");
+  addDataFilePath(app_name, MooseUtils::pathjoin(dir, "../../data"));
+}
+
+std::string
+Registry::getDataPath(const std::string & name)
+{
+  const auto & dfps = getRegistry()._data_file_paths;
+  const auto it = dfps.find(name);
+  if (it == dfps.end())
+    mooseError("Registry::getDataPath(): A data path for '", name, "' is not registered");
+
+  // Installed data
+  const auto installed_path =
+      MooseUtils::pathjoin(Moose::getExecutablePath(), "..", "share", name, "data");
+  if (MooseUtils::checkFileReadable(installed_path, false, false, false))
+    return std::filesystem::weakly_canonical(installed_path).c_str();
+
+  // In tree data
+  if (MooseUtils::checkFileReadable(it->second, false, false, false))
+    return it->second;
 
-  // if the data directory exists and hasn't been added before, add it
-  if (MooseUtils::pathIsDirectory(data_dir) &&
-      std::find(dfp.begin(), dfp.end(), data_dir) == dfp.end())
-    dfp.push_back(data_dir);
+  mooseError("Registry::getDataPath(): Failed to determine data path for '", name, "'");
 }
 
 void

framework/src/interfaces/DataFileInterface.C

@@ -33,7 +33,8 @@ DataFileInterface::getDataFileName(const std::string & param) const
 
   // Look relative to the input file
   const auto base = _parent.parameters().getParamFileBase(param);
-  const std::string relative_to_context = std::filesystem::absolute(base / value_path).c_str();
+  const std::string relative_to_context =
+      std::filesystem::weakly_canonical(base / value_path).c_str();
   if (MooseUtils::checkFileReadable(relative_to_context, false, false, false))
   {
     _parent.paramInfo(param, "Data file '", value, "' found relative to the input file.");
@@ -48,37 +49,20 @@ std::string
 DataFileInterface::getDataFileNameByName(const std::string & relative_path,
                                          const std::string * param) const
 {
-  /// - relative to the running binary (assuming the application is installed)
-  const auto share_dir = MooseUtils::pathjoin(Moose::getExecutablePath(), "..", "share");
-  if (MooseUtils::pathIsDirectory(share_dir))
+  // Search each registered data path for the relative path
+  for (const auto & name_dir_path : Registry::getRegistry().getDataFilePaths())
   {
-    const auto dirs = MooseUtils::listDir(share_dir, false);
-    for (const auto & data_dir : dirs)
-    {
-      const auto path = MooseUtils::pathjoin(data_dir, "data", relative_path);
-      if (MooseUtils::checkFileReadable(path, false, false, false))
-      {
-        if (param)
-          _parent.paramInfo(
-              *param, "Data file '", path, "' found in an installed app distribution.");
-        else
-          mooseInfo("Data file '", path, "' found in an installed app distribution.");
-        return path;
-      }
-    }
-  }
-
-  /// - relative to all registered data file directories
-  for (const auto & data_dir : Registry::getRegistry().getDataFilePaths())
-  {
-    const auto path = MooseUtils::pathjoin(data_dir, relative_path);
+    const auto & name = name_dir_path.first;
+    const auto data_path = Registry::getRegistry().getDataPath(name);
+    const auto path = MooseUtils::pathjoin(data_path, relative_path);
     if (MooseUtils::checkFileReadable(path, false, false, false))
     {
+      const std::string abs_path = std::filesystem::weakly_canonical(path).c_str();
       if (param)
-        _parent.paramInfo(*param, "Data file '", path, "' found in a source repository.");
+        _parent.paramInfo(*param, "Data file '", abs_path, "' found from ", name);
       else
-        mooseInfo("Data file '", path, "' found in a source repository.");
-      return path;
+        mooseInfo("Data file '", abs_path, "' found from ", name);
+      return abs_path;
     }
   }
 

modules/solid_mechanics/src/base/SolidMechanicsApp.C

@@ -191,7 +191,7 @@ SolidMechanicsApp::registerAll(Factory & f, ActionFactory & af, Syntax & s)
   Registry::registerObjectsTo(f, {"SolidMechanicsApp"});
   Registry::registerActionsTo(af, {"SolidMechanicsApp"});
   associateSyntaxInner(s, af);
-  registerDataFilePath();
+  registerAppDataFilePath("solid_mechanics");
 }
 
 void

unit/other_data/data/README.md

@@ -0,0 +1 @@
+Used for RegistryTest.addDataFilePathMismatch

unit/src/RegistryTest.C

@@ -15,6 +15,8 @@
 #include "MaterialRealAux.h"
 #include "CheckOutputAction.h"
 
+#include <filesystem>
+
 TEST(RegistryTest, getClassName)
 {
   // This is a simple non-templated case
@@ -29,6 +31,111 @@ TEST(RegistryTest, getClassName)
   EXPECT_EQ(Registry::getClassName<CheckOutputAction>(), "CheckOutputAction");
 }
 
+TEST(RegistryTest, addDataFilePathMissing)
+{
+  const std::string name = "missing";
+  const std::string path = "../missing/data";
+  const std::string abs_path = std::filesystem::weakly_canonical(path).c_str();
+
+  EXPECT_THROW(
+      {
+        try
+        {
+          Registry::addDataFilePath(name, path);
+        }
+        catch (const std::exception & e)
+        {
+          EXPECT_EQ(std::string(e.what()),
+                    "While registering data file path '" + abs_path + "' for '" + name +
+                        "': the path was not found");
+          throw;
+        }
+      },
+      std::exception);
+}
+
+TEST(RegistryTest, addDataFilePathMismatch)
+{
+  const std::string name = "data_mismatch";
+  const std::string path = "data";
+  const std::string abs_path = std::filesystem::weakly_canonical(path).c_str();
+
+  Registry::addDataFilePath(name, path);
+
+  const std::string other_path = "other_data/data";
+  const std::string other_abs_path = std::filesystem::weakly_canonical(other_path).c_str();
+
+  EXPECT_THROW(
+      {
+        try
+        {
+          Registry::addDataFilePath(name, other_path);
+        }
+        catch (const std::exception & e)
+        {
+          EXPECT_EQ(std::string(e.what()),
+                    "While registering data file path '" + other_abs_path + "' for '" + name +
+                        "': the path '" + abs_path + "' is already registered");
+          throw;
+        }
+      },
+      std::exception);
+}
+
+TEST(RegistryTest, getDataPath)
+{
+  const std::string name = "data_working";
+  const std::string path = "data";
+  const std::string abs_path = std::filesystem::weakly_canonical(path).c_str();
+
+  Registry::addDataFilePath(name, path);
+  EXPECT_EQ(Registry::getDataPath(name), abs_path);
+
+  Registry::addDataFilePath(name, path);
+  EXPECT_EQ(Registry::getDataPath(name), abs_path);
+}
+
+TEST(RegistryTest, getDataPathUnregistered)
+{
+  const std::string name = "unregistered";
+  EXPECT_THROW(
+      {
+        try
+        {
+          Registry::getDataPath(name);
+        }
+        catch (const std::exception & e)
+        {
+          EXPECT_EQ(std::string(e.what()),
+                    "Registry::getDataPath(): A data path for '" + name + "' is not registered");
+          throw;
+        }
+      },
+      std::exception);
+}
+
+TEST(RegistryTest, getDataPathFailed)
+{
+  const std::string name = "data_changed";
+  Registry::addDataFilePath(name, "data");
+  Registry::getRegistry()._data_file_paths[name] = "foo";
+
+  EXPECT_THROW(
+      {
+        try
+        {
+          Registry::getDataPath(name);
+        }
+        catch (const std::exception & e)
+        {
+          EXPECT_EQ(std::string(e.what()),
+                    "Registry::getDataPath(): Failed to determine data path for '" + name + "'");
+          throw;
+        }
+      },
+      std::exception);
+}
+
 TEST(RegistryTest, repositoryURL)
 {
   const std::string repo_name = "bar";