Merge pull request #31756 from loganharbour/webserver_remote

Rework runner strategy in `MooseControl`, add testing

Author: loganharbour

.gitignore

@@ -249,6 +249,9 @@ python/peacock/tests/postprocessor_tab/TestPostprocessorPluginManager_test_scrip
 peacock_tmp_diff.exo
 *.e.diff
 
+# Python
+.coverage
+
 # configure
 _configs.sed
 autom4te.cache

CODEOWNERS

@@ -14,6 +14,7 @@
 /conf_vars.mk.in @lindsayad
 /configure @lindsayad
 /configure.ac @lindsayad
+/pyproject.toml @loganharbour @zachmprince
 
 /.github @permcody
 

framework/contrib/tinyhttp/src/tinyhttp/http.C

@@ -355,7 +355,7 @@ void HttpServer::startListening(const std::variant<uint16_t, std::string> listen
         const auto filename = std::get<std::string>(listen_on);
         struct sockaddr_un remote;
         remote.sun_family = AF_LOCAL;
-        strncpy (remote.sun_path, filename.c_str(), sizeof (remote.sun_path));
+        strcpy(remote.sun_path, filename.c_str());
         remote.sun_path[sizeof (remote.sun_path) - 1] = '\0';
         const auto remote_size = offsetof (struct sockaddr_un, sun_path) + strlen (remote.sun_path);
         const auto retval = bind(mSocket, reinterpret_cast<struct sockaddr*>(&remote), remote_size);

framework/doc/content/source/actions/StartWebServerControlServerAction.md

@@ -0,0 +1,3 @@
+# StartWebServerControlAction
+
+Starts the webserver for all [WebServerControl.md] objects.

framework/doc/content/source/controls/WebServerControl.md

@@ -4,7 +4,7 @@ The `WebServerControl` object is designed to allow an external process to contro
 
 The server can either listen on a port via the [!param](/Controls/WebServerControl/port) parameter, or on a unix file socket via the [!param](/Controls/WebServerControl/file_socket) parameter. One of these two parameters must be provided.
 
-It can then be managed via the [MooseControl](MooseControl/index.md optional=true) python utility.
+It can then be managed via the [MooseControl](moosecontrol/index.md optional=true) python utility.
 
 ## API
 
@@ -49,7 +49,7 @@ where `<EXEC_ON_FLAG>` is the current execution flag. If the control is not curr
 }
 ```
 
-This endpoint can be accessed via the [MooseControl](MooseControl/index.md optional=true) python utility via the following methods:
+This endpoint can be accessed via the [MooseControl](moosecontrol/index.md optional=true) python utility via the following methods:
 
 - `wait()`: Waits for the control to be waiting
 - `getWaitingFlag()`: Gets the current flag that the control is waiting on, if any
@@ -124,7 +124,7 @@ where `<NAME>` is the string path to the controllable parameter, `<TYPE>` is the
 
 On success, the response will be empty with a status code of 201.
 
-This endpoint can be accessed via the [MooseControl](MooseControl/index.md optional=true) python utility via the following methods:
+This endpoint can be accessed via the [MooseControl](moosecontrol/index.md optional=true) python utility via the following methods:
 
 - `setControllableBool()`: Sets a controllable `bool` parameter
 - `setControllableReal()`: Sets a controllable `Real` parameter
@@ -137,13 +137,13 @@ This endpoint can be accessed via the [MooseControl](MooseControl/index.md optio
 
 Tells a waiting control to continue with the execution. The control must be waiting in order to access this endpoint.
 
-Interact with this endpoint by a `GET` request to `/continue`. On success, the response will be empty with a status code of 200. This endpoint can be accessed via the [MooseControl](MooseControl/index.md optional=true) python utility via `setContinue()`.
+Interact with this endpoint by a `GET` request to `/continue`. On success, the response will be empty with a status code of 200. This endpoint can be accessed via the [MooseControl](moosecontrol/index.md optional=true) python utility via `setContinue()`.
 
 ### `terminate`
 
 Tells a waiting control to terminate the simulation at the end of the current timestep. Any other execution points in the control during the timestep will be skipped. The control must be waiting in order to access this endpoint.
 
-Interact with this endpoint by a `GET` request to `/terminate`. On success, the response will be empty with a status code of 200. This endpoint can be accessed via the [MooseControl](MooseControl/index.md optional=true) python utility via `setTerminate()`.
+Interact with this endpoint by a `GET` request to `/terminate`. On success, the response will be empty with a status code of 200. This endpoint can be accessed via the [MooseControl](moosecontrol/index.md optional=true) python utility via `setTerminate()`.
 
 !syntax parameters /Controls/WebServerControl
 

framework/include/actions/StartWebServerControlAction.h

@@ -0,0 +1,25 @@
+//* This file is part of the MOOSE framework
+//* https://mooseframework.inl.gov
+//*
+//* All rights reserved, see COPYRIGHT for full restrictions
+//* https://github.com/idaholab/moose/blob/master/COPYRIGHT
+//*
+//* Licensed under LGPL 2.1, please see LICENSE for details
+//* https://www.gnu.org/licenses/lgpl-2.1.html
+
+#pragma once
+
+#include "Action.h"
+
+/**
+ * Starts the web server(s) for the WebServerControl objects.
+ */
+class StartWebServerControlAction : public Action
+{
+public:
+  static InputParameters validParams();
+
+  StartWebServerControlAction(const InputParameters & parameters);
+
+  virtual void act() override final;
+};

framework/include/base/Factory.h

@@ -167,6 +167,46 @@ class Factory
   const InputParameters * currentlyConstructing() const;
 
 private:
+  /**
+   * Internal method for checking if the created smart pointer is of the correct expected type.
+   *
+   * Used in create<T> and createUnique<T>.
+   */
+  template <class T, class SmartPtr>
+  void createCheckObjectType(const SmartPtr & object, const std::string & obj_name) const;
+
+  /**
+   * Internal method for creating a MooseObject, either as a
+   * shared_ptr or as a unique_ptr.
+   *
+   * This is needed because we need to explicitly create objects
+   * that are requested as a shared_ptr with make_shared, so that
+   * the std::enable_shared_from_this interface will work for
+   * those objects.
+   *
+   * We avoid code duplication by putting the creation logic
+   * for shared_ptr and unique_ptr in the same method.
+   *
+   * This is explicitly instantiated for
+   * std::unique_ptr<MooseObject> and std::shared_ptr<MooseObject>
+   * in Factory.C.
+   *
+   * @param obj_name Type of the object being constructed
+   * @param name Name for the object
+   * @param parameters Parameters this object should have
+   * @param tid The thread id that this copy will be created for
+   * @param deprecated_method_name The name of the method to throw a deprecated warning for, if
+   * any
+   * @return The created MooseObject
+   */
+  ///@{
+  template <class ptr_type>
+  ptr_type createTempl(const std::string & obj_name,
+                       const std::string & name,
+                       const InputParameters & parameters,
+                       const THREAD_ID tid,
+                       const std::optional<std::string> & deprecated_method_name);
+
   /**
    * Parse time string (mm/dd/yyyy HH:MM)
    * @param t_str String with the object expiration date, this must be in the form mm/dd/yyyy
@@ -244,6 +284,16 @@ class Factory
   std::map<const MooseObject *, unsigned int> _clone_counter;
 };
 
+template <class T, class SmartPtr>
+void
+Factory::createCheckObjectType(const SmartPtr & object, const std::string & obj_name) const
+{
+  if (!dynamic_cast<T *>(object.get()))
+    mooseError("We expected to create an object of type '" + MooseUtils::prettyCppType<T>() +
+               "'.\nInstead we received a parameters object for type '" + obj_name +
+               "'.\nDid you call the wrong \"add\" method in your Action?");
+}
+
 template <typename T>
 std::unique_ptr<T>
 Factory::createUnique(const std::string & obj_name,
@@ -252,11 +302,7 @@ Factory::createUnique(const std::string & obj_name,
                       const THREAD_ID tid)
 {
   auto object = createUnique(obj_name, name, parameters, tid, false);
-  if (!dynamic_cast<T *>(object.get()))
-    mooseError("We expected to create an object of type '" + libMesh::demangle(typeid(T).name()) +
-               "'.\nInstead we received a parameters object for type '" + obj_name +
-               "'.\nDid you call the wrong \"add\" method in your Action?");
-
+  createCheckObjectType<T>(object, obj_name);
   return std::unique_ptr<T>(static_cast<T *>(object.release()));
 }
 
@@ -267,7 +313,9 @@ Factory::create(const std::string & obj_name,
                 const InputParameters & parameters,
                 const THREAD_ID tid)
 {
-  return std::move(createUnique<T>(obj_name, name, parameters, tid));
+  auto object = create(obj_name, name, parameters, tid, false);
+  createCheckObjectType<T>(object, obj_name);
+  return std::static_pointer_cast<T>(object);
 }
 
 template <typename T>

framework/include/base/Registry.h

@@ -126,6 +126,7 @@ struct RegistryEntryBase : public RegistryEntryData
   virtual ~RegistryEntryBase() {}
   /// proxy functions
   virtual std::unique_ptr<MooseObject> build(const InputParameters & parameters) = 0;
+  virtual std::shared_ptr<MooseObject> buildShared(const InputParameters & parameters) = 0;
   virtual std::shared_ptr<Action> buildAction(const InputParameters & parameters) = 0;
   virtual InputParameters buildParameters() = 0;
   /// resolve the name from _classname, _alias, and _name
@@ -143,8 +144,9 @@ struct RegistryEntryBase : public RegistryEntryData
 template <typename T>
 struct RegistryEntry : public RegistryEntryBase
 {
-  RegistryEntry(const RegistryEntryData & data) : RegistryEntryBase(data) {}
+  RegistryEntry(const RegistryEntryData & data);
   virtual std::unique_ptr<MooseObject> build(const InputParameters & parameters) override;
+  virtual std::shared_ptr<MooseObject> buildShared(const InputParameters & parameters) override;
   virtual std::shared_ptr<Action> buildAction(const InputParameters & parameters) override;
   virtual InputParameters buildParameters() override;
 };
@@ -281,7 +283,7 @@ class Registry
   FRIEND_TEST(RegistryTest, appNameFromAppPathFailed);
   ///@}
 
-  Registry(){};
+  Registry() {};
 
   /**
    * Manually set the data file paths.
@@ -329,13 +331,28 @@ Registry::getRegisteredName()
   return getClassName<T>();
 }
 
+template <typename T>
+RegistryEntry<T>::RegistryEntry(const RegistryEntryData & data) : RegistryEntryBase(data)
+{
+  static_assert(std::is_base_of_v<MooseObject, T> || std::is_base_of_v<Action, T>,
+                "Not derived from MooseObject or Action");
+}
+
 template <typename T>
 std::unique_ptr<MooseObject>
 RegistryEntry<T>::build(const InputParameters & parameters)
 {
   if constexpr (std::is_base_of_v<MooseObject, T>)
     return std::make_unique<T>(parameters);
-  mooseError("The object to be built is not derived from MooseObject.");
+  mooseError(MooseUtils::prettyCppType<T>(), " to be built is not a MooseObject.");
+}
+template <typename T>
+std::shared_ptr<MooseObject>
+RegistryEntry<T>::buildShared(const InputParameters & parameters)
+{
+  if constexpr (std::is_base_of_v<MooseObject, T>)
+    return std::make_shared<T>(parameters);
+  mooseError(MooseUtils::prettyCppType<T>(), " to be built is not a MooseObject.");
 }
 
 template <typename T>