feat components: implement ResourceScope

commit_hash:74196010ff67780c95ef08d1ba3eb81046385982

Author: segoon

.mapping.json

@@ -871,6 +871,7 @@
   "core/include/userver/components/process_starter.hpp":"taxi/uservices/userver/core/include/userver/components/process_starter.hpp",
   "core/include/userver/components/raw_component_base.hpp":"taxi/uservices/userver/core/include/userver/components/raw_component_base.hpp",
   "core/include/userver/components/run.hpp":"taxi/uservices/userver/core/include/userver/components/run.hpp",
+  "core/include/userver/components/scope.hpp":"taxi/uservices/userver/core/include/userver/components/scope.hpp",
   "core/include/userver/components/single_threaded_task_processors.hpp":"taxi/uservices/userver/core/include/userver/components/single_threaded_task_processors.hpp",
   "core/include/userver/components/state.hpp":"taxi/uservices/userver/core/include/userver/components/state.hpp",
   "core/include/userver/components/static_config_validator.hpp":"taxi/uservices/userver/core/include/userver/components/static_config_validator.hpp",
@@ -1323,6 +1324,7 @@
   "core/src/components/minimal_server_component_list_test.cpp":"taxi/uservices/userver/core/src/components/minimal_server_component_list_test.cpp",
   "core/src/components/process_starter.cpp":"taxi/uservices/userver/core/src/components/process_starter.cpp",
   "core/src/components/process_starter.yaml":"taxi/uservices/userver/core/src/components/process_starter.yaml",
+  "core/src/components/resource_scope_test.cpp":"taxi/uservices/userver/core/src/components/resource_scope_test.cpp",
   "core/src/components/run.cpp":"taxi/uservices/userver/core/src/components/run.cpp",
   "core/src/components/single_threaded_task_processors.cpp":"taxi/uservices/userver/core/src/components/single_threaded_task_processors.cpp",
   "core/src/components/single_threaded_task_processors.yaml":"taxi/uservices/userver/core/src/components/single_threaded_task_processors.yaml",

core/include/userver/components/component_context.hpp

@@ -59,6 +59,11 @@ class ComponentsLoadCancelledException : public std::runtime_error {
     explicit ComponentsLoadCancelledException(std::string_view message);
 };
 
+namespace impl {
+class ScopeBase;
+}
+using ScopePtr = std::unique_ptr<impl::ScopeBase>;
+
 /// @brief Class to retrieve other components.
 ///
 /// Only the const member functions of this class are meant for usage in
@@ -152,6 +157,19 @@ class ComponentContext final {
     /// as an `std::string` if needed.
     std::string_view GetComponentName() const;
 
+    /// @brief Registers a functor to register some resource that will be
+    /// called after the component is succesfully created (including all
+    /// class descendants). The functor must return a RAII-style handle object
+    /// that unregisters the previously registered resource. The returned handle's
+    /// destructor is called just before the component destructor is called.
+    ///
+    /// @note callback is not called if the component is not created OR
+    /// any previously registered callback throws an exception.
+    /// @note if you don't have an existing RAII-ish class, but still want
+    /// to do a cleanup, you might want to use @ref utils::FastScopeGuard
+    /// to wrap the cleanup function.
+    void RegisterScope(ScopePtr) const;
+
     /// @cond
     // For internal use only.
     ComponentContext(utils::impl::InternalTag, impl::ComponentContextImpl& impl, impl::ComponentInfo& component_info)

core/include/userver/components/scope.hpp

@@ -0,0 +1,77 @@
+#pragma once
+
+/// @file userver/components/scope.hpp
+/// @brief @copybrief components::MakeScope
+
+#include <functional>
+#include <memory>
+#include <optional>
+
+#include <userver/utils/assert.hpp>
+
+USERVER_NAMESPACE_BEGIN
+
+namespace components {
+
+namespace impl {
+class ScopeBase {
+public:
+    virtual ~ScopeBase() = default;
+
+    virtual void AfterConstruction() = 0;
+};
+
+template <typename Handle>
+class Scope final : public ScopeBase {
+public:
+    using AfterConstructionCallback = std::function<Handle()>;
+
+    explicit Scope(AfterConstructionCallback after_construction)
+        : after_construction_(std::move(after_construction))
+    {}
+
+    void AfterConstruction() override { before_destruction_.emplace(after_construction_()); }
+
+private:
+    AfterConstructionCallback after_construction_;
+    std::optional<Handle> before_destruction_;
+};
+
+template <>
+class Scope<void> final : public ScopeBase {
+public:
+    using AfterConstructionCallback = std::function<void()>;
+
+    explicit Scope(AfterConstructionCallback after_construction)
+        : after_construction_(std::move(after_construction))
+    {}
+
+    void AfterConstruction() override { after_construction_(); }
+
+private:
+    AfterConstructionCallback after_construction_;
+};
+
+}  // namespace impl
+
+/// @brief An object of ScopePtr defines actions to do after
+/// a component is constructed and just before it is destroyed.
+///
+/// @see @ref components::ComponentContext::RegisterScope
+using ScopePtr = std::unique_ptr<impl::ScopeBase>;
+
+/// @brief Constructs an object of type @ref ScopePtr from
+/// a registration callback. The callback must return an object that undoes
+/// the registration in its destructor.
+///
+/// @see @ref components::ComponentContext::RegisterScope
+template <typename AfterConstructionCallback>
+ScopePtr MakeScope(AfterConstructionCallback after_construction)
+{
+    using Handle = std::invoke_result_t<AfterConstructionCallback>;
+    return std::make_unique<impl::Scope<Handle>>(std::move(after_construction));
+}
+
+}  // namespace components
+
+USERVER_NAMESPACE_END

core/include/userver/components/tcp_acceptor_base.hpp

@@ -61,8 +61,8 @@ class TcpAcceptorBase : public ComponentBase {
 
     void KeepAccepting(engine::io::Socket& listen_sock);
 
-    void OnAllComponentsLoaded() final;
-    void OnAllComponentsAreStopping() final;
+    void Start();
+    void Stop() noexcept;
 
     struct SocketData {
         engine::io::Socket listen_sock;

core/src/components/component_context.cpp

@@ -1,6 +1,7 @@
 #include <userver/components/component_context.hpp>
 
 #include <components/component_context_impl.hpp>
+#include <userver/components/scope.hpp>
 
 USERVER_NAMESPACE_BEGIN
 
@@ -25,6 +26,10 @@ engine::TaskProcessor& ComponentContext::GetTaskProcessor(std::string_view name)
 
 std::string_view ComponentContext::GetComponentName() const { return component_info_.GetName(); }
 
+void ComponentContext::RegisterScope(ScopePtr resource_scope) const {
+    component_info_.RegisterScope(std::move(resource_scope));
+}
+
 impl::ComponentContextImpl& ComponentContext::GetImpl(utils::impl::InternalTag) const { return impl_; }
 
 const impl::Manager& ComponentContext::GetManager(utils::impl::InternalTag) const { return impl_.GetManager(); }

core/src/components/component_context_component_info.cpp

@@ -2,6 +2,7 @@
 
 #include <fmt/format.h>
 #include <fmt/ranges.h>
+#include <boost/range/adaptor/reversed.hpp>
 #include <boost/range/adaptor/transformed.hpp>
 
 #include <userver/components/component_context.hpp>
@@ -46,12 +47,28 @@ void ComponentInfo::SetComponent(std::unique_ptr<RawComponentBase>&& component)
             call_on_loading_cancelled = true;
         }
     }
+
+    AfterConstruction();
+
     if (call_on_loading_cancelled) {
         OnLoadingCancelled();
     }
     cv_.NotifyAll();
 }
 
+void ComponentInfo::AfterConstruction()
+{
+    // A tweak to be sure in case of parial initialization only
+    // already initialized scopes' before_dtr() are called
+    auto tmp_resource_scopes = std::move(resource_scopes_);
+    resource_scopes_.clear();  // for clang-static-analyzer
+    for (auto& resource_scope : tmp_resource_scopes) {
+        resource_scope->AfterConstruction();
+
+        resource_scopes_.push_back(std::move(resource_scope));
+    }
+}
+
 void ComponentInfo::ClearComponent() {
     if (!HasComponent()) {
         return;
@@ -61,6 +78,13 @@ void ComponentInfo::ClearComponent() {
 
     auto component = ExtractComponent();
     LOG_DEBUG() << "Stopping component";
+
+    // Call Scopes' pre-destruction callbacks in reverse order
+    for (auto& scope : resource_scopes_ | boost::adaptors::reversed) {
+        scope.reset();
+    }
+    resource_scopes_.clear();
+
     component.reset();
     LOG_DEBUG() << "Stopped component";
 }
@@ -190,6 +214,11 @@ std::string ComponentInfo::GetDependencies() const {
     return fmt::format(R"("{}" -> "{}" )", name_, JoinNamesFromInfo(it_depends_on_, delimiter));
 }
 
+void ComponentInfo::RegisterScope(ScopePtr resource_scope)
+{
+    resource_scopes_.push_back(std::move(resource_scope));
+}
+
 bool ComponentInfo::HasComponent() const {
     const std::lock_guard lock{mutex_};
     return !!component_;

core/src/components/component_context_component_info.hpp

@@ -7,7 +7,9 @@
 #include <string>
 #include <unordered_set>
 
+#include <userver/components/component_context.hpp>
 #include <userver/components/raw_component_base.hpp>
+#include <userver/components/scope.hpp>
 #include <userver/engine/condition_variable.hpp>
 #include <userver/engine/mutex.hpp>
 #include <userver/utils/not_null.hpp>
@@ -96,15 +98,19 @@ class ComponentInfo final {
 
     std::string GetDependencies() const;
 
+    void RegisterScope(ScopePtr);
+
 private:
     bool HasComponent() const;
     std::unique_ptr<RawComponentBase> ExtractComponent();
+    void AfterConstruction();
 
     const std::string name_;
 
     mutable engine::Mutex mutex_;
     mutable engine::ConditionVariable cv_;
     std::unique_ptr<RawComponentBase> component_;
+    std::vector<ScopePtr> resource_scopes_;
     std::set<ComponentInfoRef> it_depends_on_;
     std::set<ComponentInfoRef> depends_on_it_;
     ComponentLifetimeStage stage_ = ComponentLifetimeStage::kNull;

core/src/components/resource_scope_test.cpp

@@ -0,0 +1,149 @@
+#include <userver/utest/utest.hpp>
+
+#include <userver/components/component_base.hpp>
+#include <userver/components/component_context.hpp>
+#include <userver/components/minimal_component_list.hpp>
+#include <userver/components/run.hpp>
+#include <userver/components/scope.hpp>
+#include <userver/logging/log.hpp>
+#include <userver/utils/fast_scope_guard.hpp>
+
+USERVER_NAMESPACE_BEGIN
+
+namespace {
+
+const std::string kConfig = R"(
+components_manager:
+  coro_pool:
+    initial_size: 50
+    max_size: 500
+  default_task_processor: main-task-processor
+  fs_task_processor: main-task-processor
+  event_thread_pool:
+    threads: 1
+  task_processors:
+    main-task-processor:
+      worker_threads: 1
+  components:
+    component: {}
+    logging:
+      loggers: {}
+)";
+
+}  // namespace
+
+TEST(ComponentsScope, Smoke)
+{
+    static bool init_called = false;
+    static bool destroy_called = false;
+
+    class ComponentWithResource final : public components::ComponentBase {
+    public:
+        ComponentWithResource(const components::ComponentConfig& config, const components::ComponentContext& context)
+            : components::ComponentBase(config, context)
+        {
+            context.RegisterScope(components::MakeScope([] {
+                init_called = true;
+                return utils::FastScopeGuard([]() noexcept { destroy_called = true; });
+            }));
+        }
+    };
+
+    auto component_list = components::MinimalComponentList().Append<ComponentWithResource>("component");
+    components::RunOnce(components::InMemoryConfig{kConfig}, component_list);
+
+    EXPECT_TRUE(init_called);
+    EXPECT_TRUE(destroy_called);
+}
+
+TEST(ComponentsScope, HappyPathOrder)
+{
+    static std::vector<int> trace;
+
+    class ComponentWithResource final : public components::ComponentBase {
+    public:
+        ComponentWithResource(const components::ComponentConfig& config, const components::ComponentContext& context)
+            : components::ComponentBase(config, context)
+        {
+            trace.push_back(0);
+
+            context.RegisterScope(components::MakeScope([] {
+                trace.push_back(1);
+                return utils::FastScopeGuard([]() noexcept { trace.push_back(2); });
+            }));
+
+            context.RegisterScope(components::MakeScope([] {
+                trace.push_back(3);
+                return utils::FastScopeGuard([]() noexcept { trace.push_back(4); });
+            }));
+        }
+    };
+
+    auto component_list = components::MinimalComponentList().Append<ComponentWithResource>("component");
+    components::RunOnce(components::InMemoryConfig{kConfig}, component_list);
+
+    EXPECT_EQ(trace, (std::vector{0, 1, 3, 4, 2}));
+}
+
+TEST(ComponentsScope, CtrThrow)
+{
+    static std::vector<int> trace;
+
+    class ComponentWithResource final : public components::ComponentBase {
+    public:
+        ComponentWithResource(const components::ComponentConfig& config, const components::ComponentContext& context)
+            : components::ComponentBase(config, context)
+        {
+            trace.push_back(0);
+
+            context.RegisterScope(components::MakeScope([] {
+                trace.push_back(1);
+                return utils::FastScopeGuard([]() noexcept { trace.push_back(2); });
+            }));
+
+            context.RegisterScope(components::MakeScope([] {
+                trace.push_back(3);
+                return utils::FastScopeGuard([]() noexcept { trace.push_back(4); });
+            }));
+
+            throw std::runtime_error("1");
+        }
+    };
+
+    auto component_list = components::MinimalComponentList().Append<ComponentWithResource>("component");
+    EXPECT_THROW(components::RunOnce(components::InMemoryConfig{kConfig}, component_list), std::runtime_error);
+
+    EXPECT_EQ(trace, (std::vector{0}));
+}
+
+TEST(ComponentsScope, CallbackThrow)
+{
+    static std::vector<int> trace;
+
+    class ComponentWithResource final : public components::ComponentBase {
+    public:
+        ComponentWithResource(const components::ComponentConfig& config, const components::ComponentContext& context)
+            : components::ComponentBase(config, context)
+        {
+            trace.push_back(0);
+
+            context.RegisterScope(components::MakeScope([] {
+                trace.push_back(1);
+                return utils::FastScopeGuard([]() noexcept { trace.push_back(2); });
+            }));
+
+            context.RegisterScope(components::MakeScope([] {
+                trace.push_back(3);
+                throw std::runtime_error("1");
+                return utils::FastScopeGuard([]() noexcept { trace.push_back(4); });
+            }));
+        }
+    };
+
+    auto component_list = components::MinimalComponentList().Append<ComponentWithResource>("component");
+    EXPECT_THROW(components::RunOnce(components::InMemoryConfig{kConfig}, component_list), std::runtime_error);
+
+    EXPECT_EQ(trace, (std::vector{0, 1, 3, 2}));
+}
+
+USERVER_NAMESPACE_END