Remove unused virtual actors and related logic (#15563)

Author: snaury

ydb/core/viewer/json_handlers.h

@@ -38,7 +38,11 @@ class TJsonHandler : public TJsonHandlerBase {
     {}
 
     IActor* CreateRequestActor(IViewer* viewer, NMon::TEvHttpInfo::TPtr& event) override {
-        return new ActorRequestType(viewer, event);
+        if constexpr (!std::is_same_v<ActorRequestType, void>) {
+            return new ActorRequestType(viewer, event);
+        } else {
+            return nullptr;
+        }
     }
 
     YAML::Node GetRequestSwagger() override {

ydb/core/viewer/scheme_directory.h

@@ -6,11 +6,6 @@
 
 namespace NKikimr::NViewer {
 
-class TSchemeDirectory : public IActor {
-public:
-    TSchemeDirectory(IViewer*, NMon::TEvHttpInfo::TPtr&) {}
-};
-
 using TSchemeDirectoryGetRpc = TJsonLocalRpc<Ydb::Scheme::ListDirectoryRequest,
                                              Ydb::Scheme::ListDirectoryResponse,
                                              Ydb::Scheme::ListDirectoryResult,
@@ -57,10 +52,10 @@ class TSchemeDirectoryRequest : public LocalRpcType {
     }
 };
 
-class TJsonSchemeDirectoryHandler : public TJsonHandler<TSchemeDirectory> {
+class TJsonSchemeDirectoryHandler : public TJsonHandler<void> {
 public:
     TJsonSchemeDirectoryHandler()
-        : TJsonHandler<TSchemeDirectory>(GetSwagger())
+        : TJsonHandler(GetSwagger())
     {}
 
     IActor* CreateRequestActor(IViewer* viewer, NMon::TEvHttpInfo::TPtr& event) override {

ydb/library/actors/core/actor.cpp

@@ -1,6 +1,5 @@
 #include "actor.h"
 #include "debug.h"
-#include "actor_virtual.h"
 #include "actorsystem.h"
 #include "executor_thread.h"
 #include <ydb/library/actors/util/datetime.h>
@@ -268,15 +267,6 @@ namespace NActors {
         return NHPTimer::GetSeconds(ElapsedTicks);
     }
 
-    void TActorCallbackBehaviour::Receive(IActor* actor, TAutoPtr<IEventHandle>& ev) {
-        (actor->*StateFunc)(ev);
-    }
-
-    void TActorVirtualBehaviour::Receive(IActor* actor, std::unique_ptr<IEventHandle> ev) {
-        Y_ABORT_UNLESS(!!ev && ev->GetBase());
-        ev->GetBase()->Execute(actor, std::move(ev));
-    }
-
     void IActor::Registered(TActorSystem* sys, const TActorId& owner) {
         // fallback to legacy method, do not use it anymore
         if (auto eh = AfterRegister(SelfId(), owner)) {

ydb/library/actors/core/actor.h

@@ -284,12 +284,6 @@ namespace NActors {
 
     class TDecorator;
 
-    class TActorVirtualBehaviour {
-    public:
-        static void Receive(IActor* actor, std::unique_ptr<IEventHandle> ev);
-    public:
-    };
-
     class TActorCallbackBehaviour {
     private:
         using TBase = IActor;
@@ -374,18 +368,14 @@ namespace NActors {
         friend class TExecutorPoolBaseMailboxed;
         friend class TExecutorThread;
 
-        IActor(const ui32 activityType)
-            : SelfActorId(TActorId())
-            , ElapsedTicks(0)
-            , ActivityType(activityType)
-            , HandledEvents(0) {
-        }
+    public:
+        using TReceiveFunc = void (IActor::*)(TAutoPtr<IEventHandle>& ev);
+
+    private:
+        TReceiveFunc StateFunc_;
 
-    protected:
-        TActorCallbackBehaviour CImpl;
     public:
         using TEventFlags = IEventHandle::TEventFlags;
-        using TReceiveFunc = TActorCallbackBehaviour::TReceiveFunc;
         /// @sa services.proto NKikimrServices::TActivity::EType
         using EActorActivity = EInternalActorType;
         using EActivityType = EActorActivity;
@@ -394,23 +384,39 @@ namespace NActors {
     protected:
         ui64 HandledEvents;
 
-        template <typename EEnum = EActivityType, typename std::enable_if<std::is_enum<EEnum>::value, bool>::type v = true>
-        IActor(const EEnum activityEnumType = EActivityType::OTHER)
-            : IActor(TEnumProcessKey<TActorActivityTag, EEnum>::GetIndex(activityEnumType)) {
-        }
-
-        IActor(TActorCallbackBehaviour&& cImpl, const ui32 activityType)
+        IActor(TReceiveFunc stateFunc, const ui32 activityType)
             : SelfActorId(TActorId())
             , ElapsedTicks(0)
-            , CImpl(std::move(cImpl))
+            , StateFunc_(stateFunc)
             , ActivityType(activityType)
             , HandledEvents(0)
         {
         }
 
         template <typename EEnum = EActivityType, typename std::enable_if<std::is_enum<EEnum>::value, bool>::type v = true>
-        IActor(TActorCallbackBehaviour&& cImpl, const EEnum activityEnumType = EActivityType::OTHER)
-            : IActor(std::move(cImpl), TEnumProcessKey<TActorActivityTag, EEnum>::GetIndex(activityEnumType)) {
+        IActor(TReceiveFunc stateFunc, const EEnum activityEnumType = EActivityType::OTHER)
+            : IActor(stateFunc, TEnumProcessKey<TActorActivityTag, EEnum>::GetIndex(activityEnumType)) {
+        }
+
+        template <typename T>
+        void Become(T stateFunc) {
+            StateFunc_ = static_cast<TReceiveFunc>(stateFunc);
+        }
+
+        template <typename T, typename... TArgs>
+        void Become(T stateFunc, TArgs&&... args) {
+            StateFunc_ = static_cast<TReceiveFunc>(stateFunc);
+            Schedule(std::forward<TArgs>(args)...);
+        }
+
+        template <typename T, typename... TArgs>
+        void Become(T stateFunc, const TActorContext& ctx, TArgs&&... args) {
+            StateFunc_ = static_cast<TReceiveFunc>(stateFunc);
+            ctx.Schedule(std::forward<TArgs>(args)...);
+        }
+
+        TReceiveFunc CurrentStateFunc() const {
+            return StateFunc_;
         }
 
     public:
@@ -549,11 +555,7 @@ namespace NActors {
 #endif
             ++HandledEvents;
             LastReceiveTimestamp = TActivationContext::Monotonic();
-            if (CImpl.Initialized()) {
-                CImpl.Receive(this, ev);
-            } else {
-                TActorVirtualBehaviour::Receive(this, std::unique_ptr<IEventHandle>(ev.Release()));
-            }
+            (this->*StateFunc_)(ev);
         }
 
         TActorContext ActorContext() const {
@@ -639,43 +641,11 @@ namespace NActors {
         return TLocalProcessKeyState<TActorActivityTag>::GetInstance().GetNameByIndex(index);
     }
 
-    class IActorCallback: public IActor {
-    protected:
-        template <class TEnum = IActor::EActivityType>
-        IActorCallback(TReceiveFunc stateFunc, const TEnum activityType = IActor::EActivityType::OTHER)
-            : IActor(TActorCallbackBehaviour(stateFunc), activityType) {
-
-        }
-
-        IActorCallback(TReceiveFunc stateFunc, const ui32 activityType)
-            : IActor(TActorCallbackBehaviour(stateFunc), activityType) {
-
-        }
-
-    public:
-        template <typename T>
-        void Become(T stateFunc) {
-            CImpl.Become(stateFunc);
-        }
-
-        template <typename T, typename... TArgs>
-        void Become(T stateFunc, const TActorContext& ctx, TArgs&&... args) {
-            CImpl.Become(stateFunc, ctx, std::forward<TArgs>(args)...);
-        }
-
-        template <typename T, typename... TArgs>
-        void Become(T stateFunc, TArgs&&... args) {
-            CImpl.Become(stateFunc);
-            Schedule(std::forward<TArgs>(args)...);
-        }
-
-        TReceiveFunc CurrentStateFunc() const {
-            return CImpl.CurrentStateFunc();
-        }
-    };
+    // For compatibility with existing code
+    using IActorCallback = IActor;
 
     template <typename TDerived>
-    class TActor: public IActorCallback {
+    class TActor: public IActor {
     private:
         using TDerivedReceiveFunc = void (TDerived::*)(TAutoPtr<IEventHandle>& ev);
 
@@ -729,36 +699,36 @@ namespace NActors {
         // UnsafeBecome methods don't verify the bindings of the stateFunc to the TDerived
         template <typename T>
         void UnsafeBecome(T stateFunc) {
-            this->IActorCallback::Become(stateFunc);
+            this->IActor::Become(stateFunc);
         }
 
         template <typename T, typename... TArgs>
         void UnsafeBecome(T stateFunc, const TActorContext& ctx, TArgs&&... args) {
-            this->IActorCallback::Become(stateFunc, ctx, std::forward<TArgs>(args)...);
+            this->IActor::Become(stateFunc, ctx, std::forward<TArgs>(args)...);
         }
 
         template <typename T, typename... TArgs>
         void UnsafeBecome(T stateFunc, TArgs&&... args) {
-            this->IActorCallback::Become(stateFunc, std::forward<TArgs>(args)...);
+            this->IActor::Become(stateFunc, std::forward<TArgs>(args)...);
         }
 
         template <typename T>
         void Become(T stateFunc) {
             // TODO(kruall): have to uncomment asserts after end of sync contrib/ydb
             // static_assert(std::is_convertible_v<T, TDerivedReceiveFunc>);
-            this->IActorCallback::Become(stateFunc);
+            this->IActor::Become(stateFunc);
         }
 
         template <typename T, typename... TArgs>
         void Become(T stateFunc, const TActorContext& ctx, TArgs&&... args) {
             // static_assert(std::is_convertible_v<T, TDerivedReceiveFunc>);
-            this->IActorCallback::Become(stateFunc, ctx, std::forward<TArgs>(args)...);
+            this->IActor::Become(stateFunc, ctx, std::forward<TArgs>(args)...);
         }
 
         template <typename T, typename... TArgs>
         void Become(T stateFunc, TArgs&&... args) {
             // static_assert(std::is_convertible_v<T, TDerivedReceiveFunc>);
-            this->IActorCallback::Become(stateFunc, std::forward<TArgs>(args)...);
+            this->IActor::Become(stateFunc, std::forward<TArgs>(args)...);
         }
     };
 

ydb/library/actors/core/actor_virtual.cpp

@@ -2,87 +2,4 @@
 #include "event.h"
 #include "actor.h"
 
-namespace NActors {
-
-template <class TEvent>
-class TEventContext {
-private:
-    TEvent* Event;
-    std::unique_ptr<IEventHandle> Handle;
-public:
-    const TEvent* operator->() const {
-        return Event;
-    }
-    const IEventHandle& GetHandle() const {
-        return *Handle;
-    }
-    TEventContext(std::unique_ptr<IEventHandle> handle)
-        : Handle(std::move(handle))
-    {
-        Y_DEBUG_ABORT_UNLESS(dynamic_cast<TEvent*>(Handle->GetBase()));
-        Event = static_cast<TEvent*>(Handle->GetBase());
-        Y_ABORT_UNLESS(Event);
-    }
-};
-
-template <class TEvent, class TExpectedActor>
-class IEventForActor: public IEventBase {
-protected:
-    virtual bool DoExecute(IActor* actor, std::unique_ptr<IEventHandle> eventPtr) override {
-        Y_DEBUG_ABORT_UNLESS(dynamic_cast<TExpectedActor*>(actor));
-        auto* actorCorrect = static_cast<TExpectedActor*>(actor);
-        TEventContext<TEvent> context(std::move(eventPtr));
-        actorCorrect->ProcessEvent(context);
-        return true;
-    }
-public:
-};
-
-template <class TBaseEvent, class TEvent, class TExpectedObject>
-class IEventForAnything: public TBaseEvent {
-protected:
-    virtual bool DoExecute(IActor* actor, std::unique_ptr<IEventHandle> eventPtr) override {
-        auto* objImpl = dynamic_cast<TExpectedObject*>(actor);
-        if (!objImpl) {
-            return false;
-        }
-        TEventContext<TEvent> context(std::move(eventPtr));
-        objImpl->ProcessEvent(context);
-        return true;
-    }
-public:
-};
-
-template <class TEvent, class TActor>
-class TEventLocalForActor: public IEventForActor<TEvent, TActor> {
-private:
-    using TBase = IEventForActor<TEvent, TActor>;
-    static TString GetClassTitle() {
-        return TStringBuilder() << typeid(TEvent).name() << "->" << typeid(TActor).name();
-    }
-    static i64 LocalClassId;
-public:
-    virtual ui32 Type() const override {
-        return LocalClassId;
-    }
-    virtual TString ToStringHeader() const override {
-        return GetClassTitle();
-    }
-
-    virtual bool SerializeToArcadiaStream(TChunkSerializer* /*serializer*/) const override {
-        Y_ABORT("Serialization of local event %s->%s", typeid(TEvent).name(), typeid(TActor).name());
-    }
-
-    virtual bool IsSerializable() const override {
-        return false;
-    }
-
-    static IEventBase* Load(TEventSerializedData*) {
-        Y_ABORT("Loading of local event %s->%s", typeid(TEvent).name(), typeid(TActor).name());
-    }
-};
-
-template <class TEvent, class TActor>
-i64 TEventLocalForActor<TEvent, TActor>::LocalClassId = Singleton<TAtomicCounter>()->Inc();
-
-}
+// NOTE: virtual actors with event callbacks are no longer supported

ydb/library/actors/core/actor_virtual.h

@@ -1,18 +1,4 @@
 #pragma once
 #include "actor_virtual.h"
 
-namespace NActors {
-
-class TEventForStart;
-
-class TActorAutoStart: public IActor {
-protected:
-    virtual void DoOnStart(const TActorId& senderActorId) = 0;
-    TAutoPtr<IEventHandle> AfterRegister(const TActorId& self, const TActorId& parentId) override;
-public:
-    void ProcessEvent(TEventContext<TEventForStart>& ev);
-
-    TActorAutoStart()
-    {}
-};
-}
+// NOTE: virtual actors with event callbacks are no longer supported

ydb/library/actors/core/av_bootstrapped.cpp

@@ -51,15 +51,6 @@ namespace NActors {
         return new TEventSerializedData;
     }
 
-    bool IEventBase::DoExecute(IActor* /*actor*/, std::unique_ptr<IEventHandle> /*eventPtr*/) {
-        Y_DEBUG_ABORT_UNLESS(false);
-        return false;
-    }
-
-    bool IEventBase::Execute(IActor* actor, std::unique_ptr<IEventHandle> eventPtr) {
-        return DoExecute(actor, std::move(eventPtr));
-    }
-
 #ifndef NDEBUG
     void IEventHandle::DoTrackNextEvent() {
         TrackNextEvent = true;