actors object model

15 files changed, 255 insertions, 65 deletions

diff --git a/library/cpp/actors/core/CMakeLists.txt b/library/cpp/actors/core/CMakeLists.txt
index 385c419b3a5..ee3cc959912 100644
--- a/library/cpp/actors/core/CMakeLists.txt
+++ b/library/cpp/actors/core/CMakeLists.txt
@@ -25,11 +25,14 @@ target_link_libraries(cpp-actors-core PUBLIC
   cpp-threading-future
 )
 target_sources(cpp-actors-core PRIVATE
+  ${CMAKE_SOURCE_DIR}/library/cpp/actors/core/actor_bootstrapped.cpp
   ${CMAKE_SOURCE_DIR}/library/cpp/actors/core/actor_coroutine.cpp
   ${CMAKE_SOURCE_DIR}/library/cpp/actors/core/actor.cpp
+  ${CMAKE_SOURCE_DIR}/library/cpp/actors/core/actor_virtual.cpp
   ${CMAKE_SOURCE_DIR}/library/cpp/actors/core/actorid.cpp
   ${CMAKE_SOURCE_DIR}/library/cpp/actors/core/actorsystem.cpp
   ${CMAKE_SOURCE_DIR}/library/cpp/actors/core/ask.cpp
+  ${CMAKE_SOURCE_DIR}/library/cpp/actors/core/av_bootstrapped.cpp
   ${CMAKE_SOURCE_DIR}/library/cpp/actors/core/balancer.cpp
   ${CMAKE_SOURCE_DIR}/library/cpp/actors/core/buffer.cpp
   ${CMAKE_SOURCE_DIR}/library/cpp/actors/core/callstack.cpp
diff --git a/library/cpp/actors/core/actor.cpp b/library/cpp/actors/core/actor.cpp
index 42b47f38215..865eea89515 100644
--- a/library/cpp/actors/core/actor.cpp
+++ b/library/cpp/actors/core/actor.cpp
@@ -1,4 +1,5 @@
 #include "actor.h"
+#include "actor_virtual.h"
 #include "executor_thread.h"
 #include <library/cpp/actors/util/datetime.h>
 
@@ -180,4 +181,16 @@ namespace NActors {
     double IActor::GetElapsedTicksAsSeconds() const {
         return NHPTimer::GetSeconds(ElapsedTicks);
     }
+
+    void TActorCallbackBehaviour::Receive(IActor* actor, TAutoPtr<IEventHandle>& ev, const TActorContext& ctx) {
+        (actor->*StateFunc)(ev, ctx);
+    }
+
+    void TActorVirtualBehaviour::Receive(IActor* actor, TAutoPtr<IEventHandle>& ev, const TActorContext& ctx) {
+        Y_VERIFY(!!ev);
+        Y_ASSERT(dynamic_cast<IEventBehavioral*>(ev->GetBase()));
+        IEventBehavioral* eActor = static_cast<IEventBehavioral*>(ev->GetBase());
+        eActor->Execute(actor, ev, ctx);
+    }
+
 }
diff --git a/library/cpp/actors/core/actor.h b/library/cpp/actors/core/actor.h
index 267107da846..66451712a54 100644
--- a/library/cpp/actors/core/actor.h
+++ b/library/cpp/actors/core/actor.h
@@ -220,20 +220,58 @@ namespace NActors {
 
     class TDecorator;
 
-    class IActor : protected IActorOps {
+    class TActorVirtualBehaviour {
     public:
-        typedef void (IActor::*TReceiveFunc)(TAutoPtr<IEventHandle>& ev, const TActorContext& ctx);
+        static void Receive(IActor* actor, TAutoPtr<IEventHandle>& ev, const TActorContext& ctx);
+    public:
+    };
+
+    class TActorCallbackBehaviour {
+    private:
+        using TBase = IActor;
+        friend class TDecorator;
+    public:
+        typedef void (IActor::* TReceiveFunc)(TAutoPtr<IEventHandle>& ev, const TActorContext& ctx);
 
     private:
         TReceiveFunc StateFunc;
+    public:
+        TActorCallbackBehaviour() = default;
+        TActorCallbackBehaviour(TReceiveFunc stateFunc)
+            : StateFunc(stateFunc) {
+        }
+        // NOTE: exceptions must not escape state function but if an exception hasn't be caught
+        // by the actor then we want to crash an see the stack
+        void Receive(IActor* actor, TAutoPtr<IEventHandle>& ev, const TActorContext& ctx);
+
+        template <typename T>
+        void Become(T stateFunc) {
+            StateFunc = static_cast<TReceiveFunc>(stateFunc);
+        }
+
+        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;
+        }
+
+    };
+
+    class IActor: protected IActorOps {
+    private:
         TActorIdentity SelfActorId;
         i64 ElapsedTicks;
-        ui64 HandledEvents;
-
         friend void DoActorInit(TActorSystem*, IActor*, const TActorId&, const TActorId&);
         friend class TDecorator;
-
+        const bool VirtualUsage = false;
+    protected:
+        TActorCallbackBehaviour CImpl;
     public:
+        using TReceiveFunc = TActorCallbackBehaviour::TReceiveFunc;
         /// @sa services.proto NKikimrServices::TActivity::EType
         enum EActorActivity {
             OTHER = 0,
@@ -264,13 +302,22 @@ namespace NActors {
         ui32 ActivityType;
 
     protected:
-        IActor(TReceiveFunc stateFunc, ui32 activityType = OTHER)
-            : StateFunc(stateFunc)
-            , SelfActorId(TActorId())
+        ui64 HandledEvents;
+
+        IActor(TActorCallbackBehaviour&& cImpl, ui32 activityType = OTHER)
+            : SelfActorId(TActorId())
             , ElapsedTicks(0)
-            , HandledEvents(0)
+            , CImpl(std::move(cImpl))
             , ActivityType(activityType)
-        {
+            , HandledEvents(0) {
+        }
+
+        IActor(ui32 activityType = OTHER)
+            : SelfActorId(TActorId())
+            , ElapsedTicks(0)
+            , VirtualUsage(true)
+            , ActivityType(activityType)
+            , HandledEvents(0) {
         }
 
     public:
@@ -281,51 +328,21 @@ namespace NActors {
         virtual void Die(const TActorContext& ctx); // would unregister actor so call exactly once and only from inside of message processing
         virtual void PassAway();
 
-    public:
-        template <typename T>
-        void Become(T stateFunc) {
-            StateFunc = static_cast<TReceiveFunc>(stateFunc);
-        }
-
-        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)...);
-        }
-
-        template <typename T, typename... TArgs>
-        void Become(T stateFunc, TArgs&&... args) {
-            StateFunc = static_cast<TReceiveFunc>(stateFunc);
-            Schedule(std::forward<TArgs>(args)...);
-        }
-
     protected:
         void SetActivityType(ui32 activityType) {
             ActivityType = activityType;
         }
 
     public:
-        TReceiveFunc CurrentStateFunc() const {
-            return StateFunc;
-        }
-
-        // NOTE: exceptions must not escape state function but if an exception hasn't be caught
-        // by the actor then we want to crash an see the stack
-        void Receive(TAutoPtr<IEventHandle>& ev, const TActorContext& ctx) {
-            (this->*StateFunc)(ev, ctx);
-            HandledEvents++;
-        }
-
         // must be called to wrap any call trasitions from one actor to another
         template<typename TActor, typename TMethod, typename... TArgs>
         static decltype((std::declval<TActor>().*std::declval<TMethod>())(std::declval<TArgs>()...))
-                InvokeOtherActor(TActor& actor, TMethod&& method, TArgs&&... args) {
-            struct TRecurseContext : TActorContext {
-                TActivationContext *Prev;
+            InvokeOtherActor(TActor& actor, TMethod&& method, TArgs&&... args) {
+            struct TRecurseContext: TActorContext {
+                TActivationContext* Prev;
                 TRecurseContext(const TActorId& actorId)
                     : TActorContext(TActivationContext::ActorContextFor(actorId))
-                    , Prev(TlsActivationContext)
-                {
+                    , Prev(TlsActivationContext) {
                     TlsActivationContext = this;
                 }
                 ~TRecurseContext() {
@@ -350,7 +367,7 @@ namespace NActors {
         void AddElapsedTicks(i64 ticks) {
             ElapsedTicks += ticks;
         }
-        auto GetActivityType() const {
+        ui32 GetActivityType() const {
             return ActivityType;
         }
         ui64 GetHandledEvents() const {
@@ -359,6 +376,14 @@ namespace NActors {
         TActorIdentity SelfId() const {
             return SelfActorId;
         }
+        void Receive(TAutoPtr<IEventHandle>& ev, const TActorContext& ctx) {
+            ++HandledEvents;
+            if (Y_UNLIKELY(VirtualUsage)) {
+                TActorVirtualBehaviour::Receive(this, ev, ctx);
+            } else {
+                CImpl.Receive(this, ev, ctx);
+            }
+        }
 
     protected:
         void Describe(IOutputStream&) const noexcept override;
@@ -383,7 +408,7 @@ namespace NActors {
         // Register new actor in ActorSystem on same _mailbox_ as current actor.
         // There is one thread per mailbox to execute actor, which mean
         // no _cpu core scalability_ for such actors.
-        // This method of registration can be usefull if multiple actors share
+        // This method of registration can be useful if multiple actors share
         // some memory.
         TActorId RegisterWithSameMailbox(IActor* actor) const noexcept final;
 
@@ -405,8 +430,44 @@ namespace NActors {
         return TLocalProcessKeyState<TActorActivityTag>::GetInstance().GetNameByIndex(index);
     }
 
+    class IActorCallback: public IActor {
+    public:
+        IActorCallback(TReceiveFunc stateFunc, ui32 activityType = OTHER)
+            : IActor(TActorCallbackBehaviour(stateFunc), activityType) {
+
+        }
+
+        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();
+        }
+    };
+
+    class IActorVirtual: public IActor {
+    public:
+        IActorVirtual(ui32 activityType = OTHER)
+            : IActor(activityType) {
+
+        }
+    };
+
     template <typename TDerived>
-    class TActor: public IActor {
+    class TActor: public IActorCallback {
     private:
         template <typename T, typename = const char*>
         struct HasActorName: std::false_type { };
@@ -438,7 +499,7 @@ namespace NActors {
         // static constexpr char ActorName[] = "UNNAMED";
 
         TActor(void (TDerived::*func)(TAutoPtr<IEventHandle>& ev, const TActorContext& ctx), ui32 activityType = GetActivityTypeIndex())
-            : IActor(static_cast<TReceiveFunc>(func), activityType)
+            : IActorCallback(static_cast<TReceiveFunc>(func), activityType)
         { }
 
     public:
@@ -486,13 +547,13 @@ namespace NActors {
         return TActorContext(tls.Mailbox, tls.ExecutorThread, tls.EventStart, id);
     }
 
-    class TDecorator : public IActor {
+    class TDecorator : public IActorCallback {
     protected:
         THolder<IActor> Actor;
 
     public:
         TDecorator(THolder<IActor>&& actor)
-            : IActor(static_cast<TReceiveFunc>(&TDecorator::State), actor->GetActivityType())
+            : IActorCallback(static_cast<TReceiveFunc>(&TDecorator::State), actor->GetActivityType())
             , Actor(std::move(actor))
         {
         }
diff --git a/library/cpp/actors/core/actor_bootstrapped.cpp b/library/cpp/actors/core/actor_bootstrapped.cpp
new file mode 100644
index 00000000000..8c1effcd5d5
--- /dev/null
+++ b/library/cpp/actors/core/actor_bootstrapped.cpp
@@ -0,0 +1,4 @@
+#include "actor_bootstrapped.h"
+
+namespace NActors {
+}
diff --git a/library/cpp/actors/core/actor_bootstrapped.h b/library/cpp/actors/core/actor_bootstrapped.h
index a37887c9398..46266fea78e 100644
--- a/library/cpp/actors/core/actor_bootstrapped.h
+++ b/library/cpp/actors/core/actor_bootstrapped.h
@@ -2,12 +2,13 @@
 
 #include "actor.h"
 #include "events.h"
+#include <util/generic/noncopyable.h>
 
 namespace NActors {
     template<typename T> struct dependent_false : std::false_type {};
 
     template<typename TDerived>
-    class TActorBootstrapped : public TActor<TDerived> {
+    class TActorBootstrapped: public TActor<TDerived> {
     protected:
         TAutoPtr<IEventHandle> AfterRegister(const TActorId& self, const TActorId& parentId) override {
             return new IEventHandle(TEvents::TSystem::Bootstrap, 0, self, parentId, {}, 0);
@@ -31,7 +32,7 @@ namespace NActors {
         }
 
         TActorBootstrapped()
-            : TActor<TDerived>(&TDerived::StateBootstrap)
-        {}
+            : TActor<TDerived>(&TDerived::StateBootstrap) {
+        }
     };
 }
diff --git a/library/cpp/actors/core/actor_coroutine.h b/library/cpp/actors/core/actor_coroutine.h
index a2e2863c910..9aac2433030 100644
--- a/library/cpp/actors/core/actor_coroutine.h
+++ b/library/cpp/actors/core/actor_coroutine.h
@@ -150,12 +150,12 @@ namespace NActors {
         void DoRun() override final;
     };
 
-    class TActorCoro : public IActor {
+    class TActorCoro : public IActorCallback {
         THolder<TActorCoroImpl> Impl;
 
     public:
         TActorCoro(THolder<TActorCoroImpl> impl, ui32 activityType = IActor::ACTOR_COROUTINE)
-            : IActor(static_cast<TReceiveFunc>(&TActorCoro::StateFunc), activityType)
+            : IActorCallback(static_cast<TReceiveFunc>(&TActorCoro::StateFunc), activityType)
             , Impl(std::move(impl))
         {}
 
diff --git a/library/cpp/actors/core/actor_virtual.cpp b/library/cpp/actors/core/actor_virtual.cpp
new file mode 100644
index 00000000000..709cd7be15e
--- /dev/null
+++ b/library/cpp/actors/core/actor_virtual.cpp
@@ -0,0 +1,6 @@
+#include "actor_virtual.h"
+
+namespace NActors {
+

+

+}
diff --git a/library/cpp/actors/core/actor_virtual.h b/library/cpp/actors/core/actor_virtual.h
new file mode 100644
index 00000000000..c8c2aebd7eb
--- /dev/null
+++ b/library/cpp/actors/core/actor_virtual.h
@@ -0,0 +1,62 @@
+#pragma once
+#include "event.h"
+#include "actor.h"
+
+namespace NActors {
+
+class IEventBehavioral: public IEventBase {
+protected:
+    virtual bool DoExecute(IActor* actor, TAutoPtr<IEventHandle>& eventPtr, const NActors::TActorContext& ctx) = 0;
+public:
+    bool Execute(IActor* actor, TAutoPtr<IEventHandle>& eventPtr, const NActors::TActorContext& ctx) {
+        return DoExecute(actor, eventPtr, ctx);
+    }
+};
+
+template <class TEvent, class TExpectedActor>
+class IEventForActor: public IEventBehavioral {
+protected:
+    virtual bool DoExecute(IActor* actor, TAutoPtr<IEventHandle>& eventPtr, const NActors::TActorContext& ctx) override {
+        Y_ASSERT(dynamic_cast<TExpectedActor*>(actor));
+        Y_ASSERT(dynamic_cast<TEvent*>(eventPtr->GetBase()));
+        auto* actorCorrect = static_cast<TExpectedActor*>(actor);
+        TEvent* evPtrLocal(static_cast<TEvent*>(eventPtr->GetBase()));
+        actorCorrect->ProcessEvent(evPtrLocal, eventPtr, ctx);
+        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_FAIL("Serialization of local event %s->%s", typeid(TEvent).name(), typeid(TActor).name());
+    }
+
+    virtual bool IsSerializable() const override {
+        return false;
+    }
+
+    static IEventBase* Load(TEventSerializedData*) {
+        Y_FAIL("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();
+
+}
diff --git a/library/cpp/actors/core/actorsystem.h b/library/cpp/actors/core/actorsystem.h
index dc0bdc370fa..b24e923e085 100644
--- a/library/cpp/actors/core/actorsystem.h
+++ b/library/cpp/actors/core/actorsystem.h
@@ -270,6 +270,11 @@ namespace NActors {
         bool SendWithContinuousExecution(TAutoPtr<IEventHandle> ev) const;
         bool Send(const TActorId& recipient, IEventBase* ev, ui32 flags = 0) const;
 
+        template <class TEvent, class... Types>
+        bool SendToActorId(const TActorId& recipient, Types... args) const {
+            return Send(recipient, new TEvent(args...), 0);
+        }
+
         /**
          * Schedule one-shot event that will be send at given time point in the future.
          *
diff --git a/library/cpp/actors/core/av_bootstrapped.cpp b/library/cpp/actors/core/av_bootstrapped.cpp
new file mode 100644
index 00000000000..ec37611d987
--- /dev/null
+++ b/library/cpp/actors/core/av_bootstrapped.cpp
@@ -0,0 +1,17 @@
+#include "av_bootstrapped.h"
+
+namespace NActors {
+
+class TEventForStart: public TEventLocalForActor<TEventForStart, TActorAutoStart> {
+public:
+};
+
+TAutoPtr<NActors::IEventHandle> TActorAutoStart::AfterRegister(const TActorId& self, const TActorId& parentId) {
+    return new IEventHandle(self, parentId, new TEventForStart, 0);
+}
+
+void TActorAutoStart::ProcessEvent(TEventForStart* /*ev*/, TAutoPtr<IEventHandle>& handle, const NActors::TActorContext& ctx) {
+    DoOnStart(handle->Sender, ctx);
+}
+
+}
diff --git a/library/cpp/actors/core/av_bootstrapped.h b/library/cpp/actors/core/av_bootstrapped.h
new file mode 100644
index 00000000000..16c110d4bea
--- /dev/null
+++ b/library/cpp/actors/core/av_bootstrapped.h
@@ -0,0 +1,18 @@
+#pragma once
+#include "actor_virtual.h"
+
+namespace NActors {
+
+class TEventForStart;
+
+class TActorAutoStart: public IActorVirtual {
+protected:
+    virtual void DoOnStart(const TActorId& senderActorId, const ::NActors::TActorContext& ctx) = 0;
+    TAutoPtr<IEventHandle> AfterRegister(const TActorId& self, const TActorId& parentId) override;
+public:
+    void ProcessEvent(TEventForStart* ev, TAutoPtr<IEventHandle>& handle, const NActors::TActorContext& ctx);
+
+    TActorAutoStart() {
+    }
+};
+}
diff --git a/library/cpp/actors/core/executor_pool_basic_ut.cpp b/library/cpp/actors/core/executor_pool_basic_ut.cpp
index 76dff693af5..3ef5808d725 100644
--- a/library/cpp/actors/core/executor_pool_basic_ut.cpp
+++ b/library/cpp/actors/core/executor_pool_basic_ut.cpp
@@ -18,7 +18,7 @@ struct TEvMsg : public NActors::TEventBase<TEvMsg, 10347> {
 
 ////////////////////////////////////////////////////////////////////////////////
 
-class TTestSenderActor : public IActor {
+class TTestSenderActor : public IActorCallback {
 private:
     using EActivityType = IActor::EActivityType ;
     using EActorActivity = IActor::EActorActivity;
@@ -32,7 +32,7 @@ private:
 public:
     TTestSenderActor(std::function<void(void)> action = [](){},
                      EActivityType activityType =  EActorActivity::OTHER)
-        : IActor(static_cast<TReceiveFunc>(&TTestSenderActor::Execute), activityType)
+        : IActorCallback(static_cast<TReceiveFunc>(&TTestSenderActor::Execute), activityType)
         , Action(action)
     {}
 
diff --git a/library/cpp/actors/core/executor_pool_united_ut.cpp b/library/cpp/actors/core/executor_pool_united_ut.cpp
index a1595d85883..8a59bef9743 100644
--- a/library/cpp/actors/core/executor_pool_united_ut.cpp
+++ b/library/cpp/actors/core/executor_pool_united_ut.cpp
@@ -30,7 +30,7 @@ inline ui64 DoTimedWork(ui64 workUs) {
     return nowUs - startUs;
 }
 
-class TTestSenderActor : public IActor {
+class TTestSenderActor : public IActorCallback {
 private:
     using EActivityType = IActor::EActivityType ;
     using EActorActivity = IActor::EActorActivity;
@@ -44,7 +44,7 @@ private:
 public:
     TTestSenderActor(std::function<void(void)> action = [](){},
                      EActivityType activityType =  EActorActivity::OTHER)
-        : IActor(static_cast<TReceiveFunc>(&TTestSenderActor::Execute), activityType)
+        : IActorCallback(static_cast<TReceiveFunc>(&TTestSenderActor::Execute), activityType)
         , Action(action)
     {}
 
diff --git a/library/cpp/actors/helpers/flow_controlled_queue.cpp b/library/cpp/actors/helpers/flow_controlled_queue.cpp
index d75cc540236..41e0944c628 100644
--- a/library/cpp/actors/helpers/flow_controlled_queue.cpp
+++ b/library/cpp/actors/helpers/flow_controlled_queue.cpp
@@ -12,7 +12,7 @@ namespace NActors {
 
 class TFlowControlledRequestQueue;
 
-class TFlowControlledRequestActor : public IActor {
+class TFlowControlledRequestActor : public IActorCallback {
     TFlowControlledRequestQueue * const QueueActor;
 
     void HandleReply(TAutoPtr<IEventHandle> &ev);
@@ -24,7 +24,7 @@ public:
     const ui64 StartCounter;
 
     TFlowControlledRequestActor(ui32 activity, TFlowControlledRequestQueue *queue, TActorId source, ui64 cookie, ui32 flags)
-        : IActor(static_cast<TReceiveFunc>(&TFlowControlledRequestActor::StateWait), activity)
+        : IActorCallback(static_cast<TReceiveFunc>(&TFlowControlledRequestActor::StateWait), activity)
         , QueueActor(queue)
         , Source(source)
         , Cookie(cookie)
@@ -48,7 +48,7 @@ public:
     using IActor::PassAway;
 };
 
-class TFlowControlledRequestQueue : public IActor {
+class TFlowControlledRequestQueue : public IActorCallback {
     const TActorId Target;
     const TFlowControlledQueueConfig Config;
 
@@ -154,7 +154,7 @@ class TFlowControlledRequestQueue : public IActor {
     }
 public:
     TFlowControlledRequestQueue(TActorId target, ui32 activity, const TFlowControlledQueueConfig &config)
-        : IActor(static_cast<TReceiveFunc>(&TFlowControlledRequestQueue::StateWork), activity)
+        : IActorCallback(static_cast<TReceiveFunc>(&TFlowControlledRequestQueue::StateWork), activity)
         , Target(target)
         , Config(config)
         , MinimalSeenLatency(TDuration::Seconds(1))
diff --git a/library/cpp/actors/interconnect/interconnect_proxy_wrapper.cpp b/library/cpp/actors/interconnect/interconnect_proxy_wrapper.cpp
index 1c44b4c59b4..a450d168719 100644
--- a/library/cpp/actors/interconnect/interconnect_proxy_wrapper.cpp
+++ b/library/cpp/actors/interconnect/interconnect_proxy_wrapper.cpp
@@ -4,7 +4,7 @@
 
 namespace NActors {
 
-    class TInterconnectProxyWrapper : public IActor {
+    class TInterconnectProxyWrapper : public IActorCallback {
         TIntrusivePtr<TInterconnectProxyCommon> Common;
         const ui32 NodeId;
         TInterconnectMock *Mock;
@@ -12,7 +12,7 @@ namespace NActors {
 
     public:
         TInterconnectProxyWrapper(TIntrusivePtr<TInterconnectProxyCommon> common, ui32 nodeId, TInterconnectMock *mock)
-            : IActor(static_cast<TReceiveFunc>(&TInterconnectProxyWrapper::StateFunc), INTERCONNECT_PROXY_WRAPPER)
+            : IActorCallback(static_cast<TReceiveFunc>(&TInterconnectProxyWrapper::StateFunc), INTERCONNECT_PROXY_WRAPPER)
             , Common(std::move(common))
             , NodeId(nodeId)
             , Mock(mock)