feat components: implement Container for simple data

commit_hash:69ee6deb0b0dfa10135ed8669b82dabff251e829

Author: segoon

.mapping.json

@@ -863,6 +863,7 @@
   "core/include/userver/components/component_context.hpp":"taxi/uservices/userver/core/include/userver/components/component_context.hpp",
   "core/include/userver/components/component_fwd.hpp":"taxi/uservices/userver/core/include/userver/components/component_fwd.hpp",
   "core/include/userver/components/component_list.hpp":"taxi/uservices/userver/core/include/userver/components/component_list.hpp",
+  "core/include/userver/components/container.hpp":"taxi/uservices/userver/core/include/userver/components/container.hpp",
   "core/include/userver/components/dump_configurator.hpp":"taxi/uservices/userver/core/include/userver/components/dump_configurator.hpp",
   "core/include/userver/components/fs_cache.hpp":"taxi/uservices/userver/core/include/userver/components/fs_cache.hpp",
   "core/include/userver/components/loggable_component_base.hpp":"taxi/uservices/userver/core/include/userver/components/loggable_component_base.hpp",
@@ -1307,6 +1308,7 @@
   "core/src/components/component_sample_test.hpp":"taxi/uservices/userver/core/src/components/component_sample_test.hpp",
   "core/src/components/config_not_required_test.cpp":"taxi/uservices/userver/core/src/components/config_not_required_test.cpp",
   "core/src/components/config_schema_validation_test.cpp":"taxi/uservices/userver/core/src/components/config_schema_validation_test.cpp",
+  "core/src/components/container_test.cpp":"taxi/uservices/userver/core/src/components/container_test.cpp",
   "core/src/components/dump_configurator.cpp":"taxi/uservices/userver/core/src/components/dump_configurator.cpp",
   "core/src/components/dump_configurator.yaml":"taxi/uservices/userver/core/src/components/dump_configurator.yaml",
   "core/src/components/fs_cache.cpp":"taxi/uservices/userver/core/src/components/fs_cache.cpp",

core/include/userver/components/component_base.hpp

@@ -70,6 +70,10 @@ class ComponentBase : public RawComponentBase {
 /// @deprecated use @ref components::ComponentBase instead.
 using LoggableComponentBase = ComponentBase;
 
+/// @see @ref components::LocateDependency
+template <typename T>
+struct WithType {};
+
 }  // namespace components
 
 USERVER_NAMESPACE_END

core/include/userver/components/container.hpp

@@ -0,0 +1,201 @@
+#pragma once
+
+/// @file
+/// @brief @copybrief components::Container
+
+#include <userver/components/component_base.hpp>
+#include <userver/components/component_config.hpp>
+#include <userver/components/component_context.hpp>
+#include <userver/formats/common/meta.hpp>
+
+USERVER_NAMESPACE_BEGIN
+
+namespace components {
+
+template <typename T>
+struct Of {};
+
+/// @cond
+constexpr std::string_view ContainerName(Of<void>) { return {}; }
+/// @endcond
+
+template <typename T>
+class Container;
+
+namespace impl {
+
+template <typename T, typename = void>
+struct ContainerHasName : std::false_type {};
+
+template <typename T>
+struct ContainerHasName<T, utils::void_t<decltype(ContainerName(Of<T>()))>> : std::true_type {};
+
+template <typename T>
+constexpr std::string_view GetContainerName()
+{
+    if constexpr (ContainerHasName<T>::value) {
+        return ContainerName(Of<T>());
+    } else {
+        static_assert(!sizeof(T), "Container name is not registered. Forgot to define ContainerName(Of<T>)?");
+        return {};
+    }
+}
+
+template <typename U>
+struct DependencyLocator {
+    const ComponentConfig& config;
+    const ComponentContext& context;
+
+    template <typename T>
+    using LocateDependencyResult = decltype(LocateDependency(
+        WithType<std::decay_t<T>>{},
+        std::declval<const ComponentConfig&>(),
+        std::declval<const ComponentContext&>()
+    ));
+
+    template <typename T>
+    static constexpr bool kIsReference = std::is_reference_v<LocateDependencyResult<T>>;
+
+    template <typename T>
+    static constexpr bool kIsLocatable =
+        !std::is_same_v<std::decay_t<T>, std::decay_t<U>>  // 1) skip U::U(const U&)
+        && !!sizeof(LocateDependencyResult<T>)             // 2) U is locate'able
+        ;
+
+    template <typename T, typename = std::enable_if_t<!kIsReference<T> && kIsLocatable<T>>>
+    operator T() const {
+        return LocateDependency(WithType<std::decay_t<T>>{}, config, context);
+    }
+
+    template <typename T, typename = std::enable_if_t<kIsReference<T> && kIsLocatable<T>>>
+    operator T&() const {
+        return LocateDependency(WithType<std::decay_t<T>>{}, config, context);
+    }
+};
+
+}  // namespace impl
+
+/// @brief A function that extracts an in-component-stored data
+/// (probably, reference) of type `T`, `T&`, or `const T&` from
+/// @ref components::ComponentContext.
+///
+/// You may define your own version of `LocateDependency` for a custom type `T`
+/// either in T's namespace or (if T's namespace is not extendable for some
+/// reason) in `USERVER_NAMESPACE::components` namespace. Usually it is defined
+/// for a component `C` that returns `T` from `C::GetSomeT()` as following:
+///
+/// @snippet core/src/dynamic_config/storage/component.cpp LocateDependency example
+template <typename T>
+std::enable_if_t<formats::common::impl::kHasParse<yaml_config::YamlConfig, T> && std::is_class_v<T>, T>
+LocateDependency(WithType<T>, const ComponentConfig& config, const ComponentContext&)
+{
+    return config.As<T>();
+}
+
+template <typename T>
+std::enable_if_t<impl::ContainerHasName<T>::value, T&> LocateDependency(
+    WithType<T>,
+    const ComponentConfig&,
+    const ComponentContext& context
+)
+{
+    return context.FindComponent<Container<T>>().Get();
+}
+
+template <typename T>
+std::enable_if_t<std::is_base_of_v<RawComponentBase, T>, T&> LocateDependency(
+    WithType<T>,
+    const ComponentConfig&,
+    const ComponentContext& context
+)
+{
+    return context.FindComponent<T>();
+}
+
+/// @brief A simple Component that creates, hold, and distributes
+/// an object of user type `T`. The component has a name equal to the constexpr
+/// std::string_view result of user-defined `ContainerName(Of<T>{})`.
+///
+/// Every dependency of type `X` is resolved by the component using
+/// @ref components::LocateDependency. By default, it is able to resolve
+/// the following types of dependencies:
+/// - `X` that was previously registered via defining `ContainerName(Of<X>)`. That is
+///   a containerized dependency.
+/// - `X` that declares `Parse(const yaml_config::YamlConfig& value, formats::parse::To<X>)`.
+///   This is a static config dependency.
+///
+/// Besides that, you may define our own specialization for
+/// @ref components::LocateDependency to allow fetching dependencies
+/// from non-container components. E.g. userver already defines
+/// @ref dynamic_config::Source from @ref components::DynamicConfig.
+///
+/// The core limitation of a type `T` registered via `ContainerName(Of<T>)` is
+/// that it is not able to explicitly use
+/// @ref components::ComponentContext in the consturctor.
+/// But if you want to only "fetch" something from the context,
+/// you're always able to define your own @ref components::LocateDependency
+/// that fetches everything you need from @ref components::ComponentContext.
+///
+/// Example:
+///
+/// @snippet core/src/components/container_test.cpp definition
+/// @snippet core/src/components/container_test.cpp registration
+template <typename T>
+class Container final : public ComponentBase {
+public:
+    Container(const ComponentConfig& config, const ComponentContext& context)
+        : ComponentBase(config, context),
+          content_(Build(config, context))
+    {}
+
+    T& Get() { return content_; }
+
+    static constexpr auto kConfigFileMode = ConfigFileMode::kNotRequired;
+
+    static constexpr std::string_view kName = impl::GetContainerName<T>();
+
+private:
+    static T Build(const ComponentConfig& config, const ComponentContext& context)
+    {
+        using Arg = impl::DependencyLocator<T>;
+        Arg arg{config, context};
+
+        // A kind of copy-paste, but a more generic solution would be too template-ish
+        // and absolutely non-readable :(
+        if constexpr (std::is_constructible<T>::value) {
+            return T();
+        } else if constexpr (std::is_constructible<T, Arg>::value) {
+            return T(arg);
+        } else if constexpr (std::is_constructible<T, Arg, Arg>::value) {
+            return T(arg, arg);
+        } else if constexpr (std::is_constructible<T, Arg, Arg, Arg>::value) {
+            return T(arg, arg, arg);
+        } else if constexpr (std::is_constructible<T, Arg, Arg, Arg, Arg>::value) {
+            return T(arg, arg, arg, arg);
+        } else if constexpr (std::is_constructible<T, Arg, Arg, Arg, Arg, Arg>::value) {
+            return T(arg, arg, arg, arg, arg);
+        } else if constexpr (std::is_constructible<T, Arg, Arg, Arg, Arg, Arg, Arg>::value) {
+            return T(arg, arg, arg, arg, arg, arg);
+        } else if constexpr (std::is_constructible<T, Arg, Arg, Arg, Arg, Arg, Arg, Arg>::value) {
+            return T(arg, arg, arg, arg, arg, arg, arg);
+        } else if constexpr (std::is_constructible<T, Arg, Arg, Arg, Arg, Arg, Arg, Arg, Arg>::value) {
+            return T(arg, arg, arg, arg, arg, arg, arg, arg);
+        } else if constexpr (std::is_constructible<T, Arg, Arg, Arg, Arg, Arg, Arg, Arg, Arg, Arg>::value) {
+            return T(arg, arg, arg, arg, arg, arg, arg, arg, arg);
+        } else if constexpr (std::is_constructible<T, Arg, Arg, Arg, Arg, Arg, Arg, Arg, Arg, Arg, Arg>::value) {
+            return T(arg, arg, arg, arg, arg, arg, arg, arg, arg, arg);
+        } else {
+            static_assert(
+                !sizeof(T),
+                "Failed to find an appropriate version of T::T(...). Please check that T has a constructor with "
+                "arguments of containerized types or locatable via LocateDependency()."
+            );
+        }
+    }
+
+    T content_;
+};
+
+}  // namespace components
+
+USERVER_NAMESPACE_END

core/include/userver/components/raw_component_base.hpp

@@ -3,6 +3,9 @@
 /// @file userver/components/raw_component_base.hpp
 /// @brief @copybrief components::RawComponentBase
 
+#include <type_traits>
+#include <userver/utils/void_t.hpp>
+
 USERVER_NAMESPACE_BEGIN
 
 namespace yaml_config {
@@ -71,11 +74,21 @@ inline constexpr bool kHasValidate = false;
 template <typename Component>
 inline constexpr bool kForceNoValidation = false;
 
+namespace impl {
+
+template <typename Component, typename = void>
+inline constexpr auto kDefaultConfigFileMode = ConfigFileMode::kRequired;
+
+template <typename Component>
+inline constexpr auto
+    kDefaultConfigFileMode<Component, utils::void_t<decltype(Component::kConfigFileMode)>> = Component::kConfigFileMode;
+}  // namespace impl
+
 /// Specialize this to customize the loading of component settings
 ///
 /// @see @ref select-config-file-mode "Setup config file mode"
 template <typename Component>
-inline constexpr auto kConfigFileMode = ConfigFileMode::kRequired;
+inline constexpr auto kConfigFileMode = impl::kDefaultConfigFileMode<Component>;
 
 }  // namespace components
 

core/include/userver/dynamic_config/storage/component.hpp

@@ -112,6 +112,12 @@ inline constexpr bool kHasValidate<DynamicConfig> = true;
 template <>
 inline constexpr auto kConfigFileMode<DynamicConfig> = ConfigFileMode::kNotRequired;
 
+dynamic_config::Source LocateDependency(
+    const components::WithType<dynamic_config::Source>&,
+    const components::ComponentConfig& config,
+    const components::ComponentContext& context
+);
+
 }  // namespace components
 
 USERVER_NAMESPACE_END

core/src/components/component_context_impl.cpp

@@ -502,8 +502,9 @@ void ComponentContextImpl::CheckForDependencyCycle(
 
     if (FindDependencyPathDfs(new_dependency_from, new_dependency_to, handled, &dependency_chain, data)) {
         dependency_chain.push_back(new_dependency_to);
-        LOG_ERROR() << "Found circular dependency between components: " << JoinNamesFromInfo(dependency_chain, " -> ");
-        throw std::runtime_error("circular components dependency");
+        auto msg = JoinNamesFromInfo(dependency_chain, " -> ");
+        LOG_ERROR() << "Found circular dependency between components: " << msg;
+        throw std::runtime_error("circular components dependency: " + msg);
     }
 }
 

core/src/components/container_test.cpp

@@ -0,0 +1,98 @@
+#include <userver/utest/utest.hpp>
+
+#include <components/component_list_test.hpp>
+#include <userver/components/component_base.hpp>
+#include <userver/components/container.hpp>
+#include <userver/components/minimal_component_list.hpp>
+#include <userver/components/run.hpp>
+#include <userver/components/statistics_storage.hpp>
+#include <userver/dynamic_config/storage/component.hpp>
+#include <userver/logging/component.hpp>
+
+#include <userver/utest/using_namespace_userver.hpp>  // only for tests
+
+namespace {
+
+/// [definition]
+// A simple containerized type
+struct X {
+    // Default ctr => the container creates `X` with no external dependencies
+    X() = default;
+    X(const X&) = delete;
+};
+
+// Register a container with name "x" that stores an object of type X
+constexpr std::string_view ContainerName(components::Of<X>) { return "x"; }
+
+// A containerized type that has a dependency of type `X`
+struct Y {
+    // Container<Y> will use a dependency of type `X`.
+    // `X` is a containerized type, so it will be searched by
+    // `FindComponent<Container<X>>().Get()`.
+    Y(X&) {}
+};
+
+// Register a container with name "y" that stores an object of type Y
+constexpr std::string_view ContainerName(components::Of<Y>) { return "y"; }
+/// [definition]
+
+struct UsingDynamicConfig {
+    explicit UsingDynamicConfig(USERVER_NAMESPACE::dynamic_config::Source) {}
+};
+
+constexpr std::string_view ContainerName(components::Of<UsingDynamicConfig>) { return "udc"; }
+
+struct MyConfig {
+    int value{};
+};
+
+MyConfig Parse(const yaml_config::YamlConfig& value, formats::parse::To<MyConfig>)
+{
+    MyConfig cfg;
+    cfg.value = value["value"].As<int>(123);
+    return cfg;
+}
+
+struct MyStruct {
+    MyStruct(const MyConfig&, const X&) {}
+};
+
+constexpr std::string_view ContainerName(components::Of<MyStruct>) { return "with-config"; }
+
+}  // namespace
+
+TEST(ComponentsContainer, NoDependencies)
+{
+    components::RunOnce(
+        components::InMemoryConfig{std::string{tests::kMinimalStaticConfig}},
+        components::MinimalComponentList().Append<components::Container<X>>()
+    );
+}
+
+TEST(ComponentsContainer, OneDependency)
+{
+    /// [registration]
+    // Register all containerized types in the component system as `Container<T>`
+    auto component_list =
+        components::MinimalComponentList()  //
+            .Append<components::Container<X>>()
+            .Append<components::Container<Y>>();
+    /// [registration]
+    components::RunOnce(components::InMemoryConfig{std::string{tests::kMinimalStaticConfig}}, component_list);
+}
+
+TEST(ComponentsContainer, DynamicConfigSource)
+{
+    components::RunOnce(
+        components::InMemoryConfig{std::string{tests::kMinimalStaticConfig}},
+        components::MinimalComponentList().Append<components::Container<UsingDynamicConfig>>()
+    );
+}
+
+TEST(ComponentsContainer, WithConfig)
+{
+    components::RunOnce(
+        components::InMemoryConfig{std::string{tests::kMinimalStaticConfig}},
+        components::MinimalComponentList().Append<components::Container<X>>().Append<components::Container<MyStruct>>()
+    );
+}