WebServerControl.h

Go to the documentation of this file.

//* 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 "Control.h"
 
#include <atomic>
#include <memory>
#include <thread>
 
#include "WebServerControlTypeRegistry.h"
 
class StartWebServerControlAction;
class HttpServer;
 
class WebServerControl : public Control
{
public:
  static InputParameters validParams();
 
  WebServerControl(const InputParameters & parameters);
  ~WebServerControl();
 
  void startServer(const Moose::PassKey<StartWebServerControlAction>);
 
  virtual void execute() override final;
 
  using ControlledValueBase = Moose::WebServerControlTypeRegistry::ControlledValueBase;
 
  template <class T>
  class ControlledValue : public ControlledValueBase
  {
  public:
    ControlledValue(const std::string & name, const std::string & type)
      : ControlledValueBase(name, type)
    {
    }
    ControlledValue(const std::string & name, const std::string & type, const T & value)
      : ControlledValueBase(name, type), _value(value)
    {
    }
 
    using value_type = T;
 
    virtual void setControllableValue(WebServerControl & control) override final
    {
      control.comm().broadcast(_value);
      control.setControllableValueByName<T>(name(), _value);
    }
 
  private:
    T _value;
  };
 
protected:
  enum class RequestMethod
  {
    GET,
    POST
  };
 
  struct Request
  {
    Request() = default;
 
    bool hasJSON() const { return _json.has_value(); }
 
    const nlohmann::json & getJSON() const;
 
    void setJSON(const nlohmann::json & json, const Moose::PassKey<WebServerControl>)
    {
      _json = json;
    }
 
  private:
    std::optional<nlohmann::json> _json;
  };
 
  struct Response
  {
    Response() = default;
 
    Response(const unsigned int status_code);
    Response(const unsigned int status_code, const nlohmann::json & json);
 
    unsigned int getStatusCode() const { return _status_code; }
 
    bool hasJSON() const { return _json.has_value(); }
    const nlohmann::json & getJSON() const;
 
    bool hasError() const { return _error.has_value(); }
    const std::string & getError() const;
 
  protected:
    void setError(const std::string & error) { _error = error; }
 
  private:
    unsigned int _status_code = 0;
    std::optional<nlohmann::json> _json;
    std::optional<std::string> _error;
  };
 
  struct ErrorResponse : public Response
  {
    ErrorResponse(const std::string & error, const unsigned int status_code = 400);
  };
 
  struct ServerActionOptions
  {
    ServerActionOptions() : _require_waiting(true), _require_initialized(true) {}
 
    bool getRequireWaiting() const { return _require_waiting; }
    void setRequireWaiting(const bool value, const Moose::PassKey<WebServerControl>)
    {
      _require_waiting = value;
    }
 
    bool getRequireInitialized() const { return _require_initialized; }
    void setRequireInitialized(const bool value, const Moose::PassKey<WebServerControl>)
    {
      _require_initialized = value;
    }
 
    const std::set<std::string> getRequiredJSONKeys() const { return _required_json_keys; }
    void requireJSONKey(const std::string & key) { _required_json_keys.insert(key); }
    void requireJSONKeys(std::initializer_list<std::string> && keys)
    {
      _required_json_keys.insert(keys);
    }
 
  private:
    bool _require_waiting;
    bool _require_initialized;
    std::set<std::string> _required_json_keys;
  };
 
  template <RequestMethod method>
  void addServerAction(const std::string & path,
                       std::function<Response(const Request &, WebServerControl &)> && action,
                       const ServerActionOptions & options = {});
 
  virtual void addServerActions() {}
 
  template <class value_T, class key_T>
  static value_T convertJSON(const nlohmann::json & json_value, const key_T & key);
 
  bool isCurrentlyWaiting() const { return _currently_waiting.load(); }
 
  struct ClientInfo
  {
    std::string name;
    std::string host;
    std::string user;
    nlohmann::json data;
  };
 
  ClientInfo getClientInfo() const;
 
  void outputMessage(const std::string & message) const;
 
private:
  void addServerActionsInternal();
 
  void setClientInfo(const ClientInfo & info);
 
  void clientPoke();
 
  bool isClientInitialized() const { return _client_initialized.load(); }
  void setClientInitialized() { _client_initialized.store(true); }
 
  void setCurrentlyWaiting(const bool value = true) { _currently_waiting.store(value); }
 
  bool isTerminateRequested() const { return _terminate_requested.load(); }
  void setTerminateRequested(const bool value = true) { _terminate_requested.store(value); }
 
  bool isKillRequested() const { return _kill_requested.load(); }
  void setKillRequested() { _kill_requested.store(true); }
 
  void outputClientTiming(const std::string & message,
                          const std::chrono::time_point<std::chrono::steady_clock> & start) const;
 
  std::string clientTimeoutErrorMessage(const Real timeout,
                                        const std::string & timeout_param_name,
                                        const std::optional<std::string> & suffix = {}) const;
 
  void stopServer();
 
  const unsigned int * const _port;
  const FileName * const _file_socket;
  const Real _initial_client_timeout;
  const Real _client_timeout;
 
  std::atomic<bool> _client_initialized = false;
  std::atomic<bool> _currently_waiting = false;
  std::atomic<bool> _terminate_requested = false;
  std::atomic<bool> _kill_requested = false;
  std::atomic<int64_t> _last_client_poke = 0;
 
  std::optional<ClientInfo> _client_info;
  mutable std::mutex _client_info_lock;
 
  std::weak_ptr<HttpServer> _server_weak_ptr;
  std::unique_ptr<std::thread> _server_thread_ptr;
 
  std::vector<std::unique_ptr<ControlledValueBase>> _controlled_values;
  std::mutex _controlled_values_mutex;
};
 
template <class value_T, class key_T>
value_T
WebServerControl::convertJSON(const nlohmann::json & json_value, const key_T & key)
{
  try
  {
    return json_value[key].template get<value_T>();
  }
  catch (const std::exception & e)
  {
    std::ostringstream message;
    message << "While parsing '" << key << "' " << e.what();
    throw std::runtime_error(message.str());
  }
}