correction

ivanmorozov333 · ivanmorozov333 · commit d0516f3e77f0 · 2024-05-09T19:06:10.000+03:00
diff --git a/ydb/core/tx/columnshard/bg_tasks/abstract/adapter.h b/ydb/core/tx/columnshard/bg_tasks/abstract/adapter.h
@@ -9,12 +9,20 @@ namespace NKikimr::NOlap::NBackground {
 
 class ITabletAdapter {
 private:
+    YDB_READONLY_DEF(NActors::TActorId, TabletActorId);
+    YDB_READONLY(TTabletId, TabletId, TTabletId(0));
     virtual bool DoLoadSessionsFromLocalDatabase(NTabletFlatExecutor::TTransactionContext& txc, std::deque<TSessionRecord>& records) = 0;
     virtual void DoSaveProgressToLocalDatabase(NTabletFlatExecutor::TTransactionContext& txc, const TSessionRecord& container) = 0;
     virtual void DoSaveStateToLocalDatabase(NTabletFlatExecutor::TTransactionContext& txc, const TSessionRecord& container) = 0;
     virtual void DoSaveSessionToLocalDatabase(NTabletFlatExecutor::TTransactionContext& txc, const TSessionRecord& container) = 0;
     virtual void DoRemoveSessionFromLocalDatabase(NTabletFlatExecutor::TTransactionContext& txc, const TString& className, const TString& identifier) = 0;
 public:
+    ITabletAdapter(const NActors::TActorId& tabletActorId, const TTabletId tabletId)
+        : TabletActorId(tabletActorId)
+        , TabletId(tabletId)
+    {
+
+    }
     virtual ~ITabletAdapter() = default;
 
     void RemoveSessionFromLocalDatabase(NTabletFlatExecutor::TTransactionContext& txc, const TString& className, const TString& identifier) {
diff --git a/ydb/core/tx/columnshard/bg_tasks/abstract/session.cpp b/ydb/core/tx/columnshard/bg_tasks/abstract/session.cpp
@@ -1,5 +1,10 @@
 #include "session.h"
+#include "adapter.h"
 
 namespace NKikimr::NOlap::NBackground {
 
+NKikimr::NOlap::TTabletId TStartContext::GetTabletId() const {
+    return Adapter->GetTabletId();
+}
+
 }
diff --git a/ydb/core/tx/columnshard/bg_tasks/abstract/session.h b/ydb/core/tx/columnshard/bg_tasks/abstract/session.h
@@ -16,21 +16,23 @@ class ITabletAdapter;
 
 class TStartContext {
 private:
-    YDB_READONLY_DEF(TTabletId, TabletId);
     YDB_READONLY_DEF(NActors::TActorId, TabletActorId);
     YDB_READONLY_DEF(TStatusChannelContainer, Channel);
     YDB_READONLY_DEF(std::shared_ptr<TSession>, SessionSelfPtr);
     YDB_READONLY_DEF(std::shared_ptr<ITabletAdapter>, Adapter);
 public:
-    TStartContext(const TTabletId tabletId, const NActors::TActorId& tabletActorId, const TStatusChannelContainer channel, const std::shared_ptr<TSession>& sessionSelfPtr,
+    TTabletId GetTabletId() const;
+
+    TStartContext(const NActors::TActorId& tabletActorId, const TStatusChannelContainer channel, const std::shared_ptr<TSession>& sessionSelfPtr,
         const std::shared_ptr<ITabletAdapter>& adapter)
-        : TabletId(tabletId)
-        , TabletActorId(tabletActorId)
+        : TabletActorId(tabletActorId)
         , Channel(channel)
         , SessionSelfPtr(sessionSelfPtr)
         , Adapter(adapter)
     {
-
+        AFL_VERIFY(!!Channel);
+        AFL_VERIFY(!!SessionSelfPtr);
+        AFL_VERIFY(!!Adapter);
     }
 };
 
diff --git a/ydb/core/tx/columnshard/bg_tasks/events/events.h b/ydb/core/tx/columnshard/bg_tasks/events/events.h
@@ -9,8 +9,8 @@ namespace NKikimr::NOlap::NBackground {
 class TEvents {
 public:
     enum EEv {
-        EvExecuteGeneralTransaction = EventSpaceBegin(TKikimrEvents::ES_TX_BACKGROUND),
-        EvTransactionComplete,
+        EvExecuteGeneralLocalTransaction = EventSpaceBegin(TKikimrEvents::ES_TX_BACKGROUND),
+        EvLocalTransactionComplete,
         EvSessionControl,
         EvRemoveSession,
 
@@ -20,11 +20,11 @@ class TEvents {
     static_assert(EvEnd < EventSpaceEnd(TKikimrEvents::ES_TX_BACKGROUND), "expect EvEnd < EventSpaceEnd(TKikimrEvents::ES_TX_BACKGROUND)");
 };
 
-class TEvExecuteGeneralTransaction: public TEventLocal<TEvExecuteGeneralTransaction, TEvents::EvExecuteGeneralTransaction> {
+class TEvExecuteGeneralLocalTransaction: public TEventLocal<TEvExecuteGeneralLocalTransaction, TEvents::EvExecuteGeneralLocalTransaction> {
 private:
     std::unique_ptr<NTabletFlatExecutor::ITransaction> Transaction;
 public:
-    TEvExecuteGeneralTransaction(std::unique_ptr<NTabletFlatExecutor::ITransaction>&& transaction)
+    TEvExecuteGeneralLocalTransaction(std::unique_ptr<NTabletFlatExecutor::ITransaction>&& transaction)
         : Transaction(std::move(transaction))
     {
         AFL_VERIFY(!!Transaction);
@@ -36,11 +36,11 @@ class TEvExecuteGeneralTransaction: public TEventLocal<TEvExecuteGeneralTransact
     }
 };
 
-class TEvTransactionCompleted: public TEventLocal<TEvTransactionCompleted, TEvents::EvTransactionComplete> {
+class TEvLocalTransactionCompleted: public TEventLocal<TEvLocalTransactionCompleted, TEvents::EvLocalTransactionComplete> {
 private:
     const ui64 InternalTxId;
 public:
-    TEvTransactionCompleted(const ui64 internalTxId)
+    TEvLocalTransactionCompleted(const ui64 internalTxId)
         : InternalTxId(internalTxId) {
     }
 
diff --git a/ydb/core/tx/columnshard/bg_tasks/manager/actor.cpp b/ydb/core/tx/columnshard/bg_tasks/manager/actor.cpp
@@ -9,18 +9,18 @@ void TSessionActor::SaveSessionProgress() {
     const ui64 txId = GetNextTxId();
     SaveSessionProgressTx.emplace(txId);
     auto tx = std::make_unique<TTxSaveSessionProgress>(Session, SelfId(), Adapter, txId);
-    AFL_VERIFY(Send<TEvExecuteGeneralTransaction>(TabletActorId, std::move(tx)));
+    AFL_VERIFY(Send<TEvExecuteGeneralLocalTransaction>(TabletActorId, std::move(tx)));
 }
 
 void TSessionActor::SaveSessionState() {
     AFL_VERIFY(!SaveSessionStateTx);
     const ui64 txId = GetNextTxId();
     SaveSessionStateTx.emplace(txId);
     auto tx = std::make_unique<TTxSaveSessionState>(Session, SelfId(), Adapter, txId);
-    AFL_VERIFY(Send<TEvExecuteGeneralTransaction>(TabletActorId, std::move(tx)));
+    AFL_VERIFY(Send<TEvExecuteGeneralLocalTransaction>(TabletActorId, std::move(tx)));
 }
 
-void TSessionActor::Handle(TEvTransactionCompleted::TPtr& ev) {
+void TSessionActor::Handle(TEvLocalTransactionCompleted::TPtr& ev) {
     if (SaveSessionProgressTx && *SaveSessionProgressTx == ev->Get()->GetInternalTxId()) {
         SaveSessionProgressTx.reset();
         OnSessionProgressSaved();
diff --git a/ydb/core/tx/columnshard/bg_tasks/manager/actor.h b/ydb/core/tx/columnshard/bg_tasks/manager/actor.h
@@ -28,7 +28,7 @@ class TSessionActor: public NActors::TActorBootstrapped<TSessionActor> {
     }
 protected:
     void ExecuteTransaction(std::unique_ptr<NTabletFlatExecutor::ITransaction>&& tx) {
-        AFL_VERIFY(Send<TEvExecuteGeneralTransaction>(TabletActorId, std::move(tx)));
+        AFL_VERIFY(Send<TEvExecuteGeneralLocalTransaction>(TabletActorId, std::move(tx)));
     }
 
     void SaveSessionProgress();
@@ -45,14 +45,14 @@ class TSessionActor: public NActors::TActorBootstrapped<TSessionActor> {
         AFL_VERIFY(!!Adapter);
     }
 
-    void Handle(TEvTransactionCompleted::TPtr& ev);
+    void Handle(TEvLocalTransactionCompleted::TPtr& ev);
 
     void Handle(TEvSessionControl::TPtr& ev);
 
     STATEFN(StateInProgress) {
         const NActors::TLogContextGuard gLogging = NActors::TLogContextBuilder::Build(NKikimrServices::TX_BACKGROUND)("SelfId", SelfId())("TabletId", TabletId);
         switch (ev->GetTypeRewrite()) {
-            hFunc(TEvTransactionCompleted, Handle);
+            hFunc(TEvLocalTransactionCompleted, Handle);
             hFunc(TEvSessionControl, Handle);
             cFunc(NActors::TEvents::TEvPoisonPill::EventType, PassAway);
         default:
diff --git a/ydb/core/tx/columnshard/bg_tasks/manager/manager.cpp b/ydb/core/tx/columnshard/bg_tasks/manager/manager.cpp
@@ -40,6 +40,10 @@ std::unique_ptr<NKikimr::NTabletFlatExecutor::ITransaction> TSessionsManager::Ad
         task.GetChannelContainer()->OnFail(conclusion.GetErrorMessage());
         return nullptr;
     }
+    return AddTask(task);
+}
+
+std::unique_ptr<NKikimr::NTabletFlatExecutor::ITransaction> TSessionsManager::AddTask(const TTask& task) {
     auto session = Storage->GetSession(task.GetDescriptionContainer().GetClassName(), task.GetIdentifier());
     if (!!session) {
         task.GetChannelContainer()->OnFail("session exists already");
diff --git a/ydb/core/tx/columnshard/bg_tasks/manager/manager.h b/ydb/core/tx/columnshard/bg_tasks/manager/manager.h
@@ -28,6 +28,7 @@ class TSessionsManager {
 
     bool LoadIdempotency(NTabletFlatExecutor::TTransactionContext& txc);
 
+    [[nodiscard]] std::unique_ptr<NTabletFlatExecutor::ITransaction> AddTask(const TTask& task);
     [[nodiscard]] std::unique_ptr<NTabletFlatExecutor::ITransaction> AddTaskFromProto(const NKikimrTxBackgroundProto::TTaskContainer& taskProto);
     [[nodiscard]] std::unique_ptr<NTabletFlatExecutor::ITransaction> Remove(const TString& className, const TString& identifier);
     [[nodiscard]] std::unique_ptr<NTabletFlatExecutor::ITransaction> ApplyControlFromProto(const NKikimrTxBackgroundProto::TSessionControlContainer& controlProto);
diff --git a/ydb/core/tx/columnshard/bg_tasks/transactions/tx_add.cpp b/ydb/core/tx/columnshard/bg_tasks/transactions/tx_add.cpp
@@ -4,15 +4,15 @@
 namespace NKikimr::NOlap::NBackground {
 
 bool TTxAddSession::Execute(TTransactionContext& txc, const TActorContext& /*ctx*/) {
-    Adapter->SaveSessionToLocalDatabase(txc, Session->SerializeToLocalDatabaseRecord()).Validate("on AddSession");
+    Adapter->SaveSessionToLocalDatabase(txc, Session->SerializeToLocalDatabaseRecord());
     return true;
 }
 
 void TTxAddSession::Complete(const TActorContext& ctx) {
     Sessions->AddSession(Session).Validate("on add background session");
     Session->GetChannelContainer()->OnAdded();
     if (Session->GetLogicContainer()->IsReadyForStart()) {
-        TStartContext context(ctx.SelfID, Session->GetChannelContainer());
+        TStartContext context(ctx.SelfID, Session->GetChannelContainer(), Session, Adapter);
         Session->StartActor(context);
     }
 }
diff --git a/ydb/core/tx/columnshard/bg_tasks/transactions/tx_general.cpp b/ydb/core/tx/columnshard/bg_tasks/transactions/tx_general.cpp
@@ -6,7 +6,7 @@ namespace NKikimr::NOlap::NBackground {
 void TTxGeneral::Complete(const TActorContext& ctx) {
     DoComplete(ctx);
     if (!!ProgressActorId) {
-        ctx.Send(*ProgressActorId, new TEvTransactionCompleted(TxInternalId));
+        ctx.Send(*ProgressActorId, new TEvLocalTransactionCompleted(TxInternalId));
     }
 }
 
diff --git a/ydb/core/tx/columnshard/bg_tasks/transactions/tx_remove.cpp b/ydb/core/tx/columnshard/bg_tasks/transactions/tx_remove.cpp
@@ -4,7 +4,7 @@
 namespace NKikimr::NOlap::NBackground {
 
 bool TTxRemoveSession::Execute(NTabletFlatExecutor::TTransactionContext& txc, const TActorContext& /*ctx*/) {
-    Adapter->RemoveSessionFromLocalDatabase(txc, ClassName, Identifier).Validate();
+    Adapter->RemoveSessionFromLocalDatabase(txc, ClassName, Identifier);
     return true;
 }
 
diff --git a/ydb/core/tx/columnshard/bg_tasks/transactions/tx_save_progress.cpp b/ydb/core/tx/columnshard/bg_tasks/transactions/tx_save_progress.cpp
@@ -4,7 +4,7 @@
 namespace NKikimr::NOlap::NBackground {
 
 bool TTxSaveSessionProgress::Execute(NTabletFlatExecutor::TTransactionContext& txc, const TActorContext& /*ctx*/) {
-    Adapter->SaveProgressToLocalDatabase(txc, Session->SerializeToLocalDatabaseRecord()).Validate();
+    Adapter->SaveProgressToLocalDatabase(txc, Session->SerializeToLocalDatabaseRecord());
     return true;
 }
 
diff --git a/ydb/core/tx/columnshard/bg_tasks/transactions/tx_save_state.cpp b/ydb/core/tx/columnshard/bg_tasks/transactions/tx_save_state.cpp
@@ -4,15 +4,15 @@
 namespace NKikimr::NOlap::NBackground {
 
 bool TTxSaveSessionState::Execute(NTabletFlatExecutor::TTransactionContext& txc, const TActorContext& /*ctx*/) {
-    Adapter->SaveStateToLocalDatabase(txc, Session->SerializeToLocalDatabaseRecord()).Validate();
+    Adapter->SaveStateToLocalDatabase(txc, Session->SerializeToLocalDatabaseRecord());
     return true;
 }
 
 void TTxSaveSessionState::DoComplete(const TActorContext& ctx) {
     if (Session->GetLogicContainer()->IsReadyForRemove()) {
         ctx.Send(Adapter->GetTabletActorId(), new TEvRemoveSession(Session->GetLogicClassName(), Session->GetIdentifier()));
     } else if (Session->GetLogicContainer()->IsReadyForStart()) {
-        TStartContext context(ctx.SelfID, Session->GetChannelContainer());
+        TStartContext context(ctx.SelfID, Session->GetChannelContainer(), Session, Adapter);
         Session->StartActor(context);
     }
 }
diff --git a/ydb/core/tx/columnshard/bg_tasks/transactions/ya.make b/ydb/core/tx/columnshard/bg_tasks/transactions/ya.make
@@ -1,6 +1,7 @@
 LIBRARY()
 
 SRCS(
+    tx_general.cpp
     tx_save_progress.cpp
     tx_save_state.cpp
     tx_remove.cpp
diff --git a/ydb/core/tx/schemeshard/olap/bg_tasks/adapter/adapter.h b/ydb/core/tx/schemeshard/olap/bg_tasks/adapter/adapter.h
@@ -4,11 +4,15 @@
 namespace NKikimr::NSchemeShard::NBackground {
 
 class TAdapter: public NKikimr::NOlap::NBackground::ITabletAdapter {
+private:
+    using TBase = NKikimr::NOlap::NBackground::ITabletAdapter;
 protected:
     virtual bool DoLoadSessionsFromLocalDatabase(NTabletFlatExecutor::TTransactionContext& txc, std::deque<NKikimr::NOlap::NBackground::TSessionRecord>& records) override;
     virtual void DoSaveProgressToLocalDatabase(NTabletFlatExecutor::TTransactionContext& txc, const NKikimr::NOlap::NBackground::TSessionRecord& container) override;
     virtual void DoSaveStateToLocalDatabase(NTabletFlatExecutor::TTransactionContext& txc, const NKikimr::NOlap::NBackground::TSessionRecord& container) override;
     virtual void DoSaveSessionToLocalDatabase(NTabletFlatExecutor::TTransactionContext& txc, const NKikimr::NOlap::NBackground::TSessionRecord& container) override;
     virtual void DoRemoveSessionFromLocalDatabase(NTabletFlatExecutor::TTransactionContext& txc, const TString& className, const TString& identifier) override;;
+public:
+    using TBase::TBase;
 };
 }
diff --git a/ydb/core/tx/schemeshard/olap/bg_tasks/tx_chain/common.h b/ydb/core/tx/schemeshard/olap/bg_tasks/tx_chain/common.h
@@ -8,7 +8,7 @@ namespace NKikimr::NSchemeShard::NOlap::NBackground {
 class TTxChainData {
 private:
     YDB_READONLY_DEF(TString, TablePath);
-    YDB_READONLY_DEF(std::vector<NKikimrSchemeOp::TModifyScheme>, Transactions);
+    YDB_ACCESSOR_DEF(std::vector<NKikimrSchemeOp::TModifyScheme>, Transactions);
 public:
     using TProtoStorage = NKikimrSchemeShardTxBackgroundProto::TTxChainCommonData;
     TConclusionStatus DeserializeFromProto(const TProtoStorage& proto);
diff --git a/ydb/core/tx/schemeshard/olap/bg_tasks/tx_chain/task.h b/ydb/core/tx/schemeshard/olap/bg_tasks/tx_chain/task.h
@@ -29,6 +29,13 @@ class TTxChainTask: public NBackgroundTasks::TInterfaceProtoAdapter<NKikimrSchem
     virtual std::shared_ptr<NKikimr::NOlap::NBackground::ISessionLogic> DoBuildSession() const override;
     static const inline TFactory::TRegistrator<TTxChainTask> Registrator = TFactory::TRegistrator<TTxChainTask>(GetStaticClassName());
 public:
+    TTxChainTask() = default;
+
+    TTxChainTask(const TTxChainData& data)
+        : TxData(data)
+    {
+
+    }
     virtual TString GetClassName() const override {
         return GetStaticClassName();
     }
diff --git a/ydb/core/tx/schemeshard/olap/bg_tasks/ya.make b/ydb/core/tx/schemeshard/olap/bg_tasks/ya.make
@@ -1,6 +1,7 @@
 LIBRARY()
 
 PEERDIR(
+    ydb/core/tx/columnshard/bg_tasks
     ydb/core/tx/schemeshard/olap/bg_tasks/adapter
     ydb/core/tx/schemeshard/olap/bg_tasks/protos
     ydb/core/tx/schemeshard/olap/bg_tasks/tx_chain
diff --git a/ydb/core/tx/schemeshard/schemeshard_impl.cpp b/ydb/core/tx/schemeshard/schemeshard_impl.cpp
@@ -14,6 +14,7 @@
 #include <ydb/core/statistics/events.h>
 #include <ydb/core/statistics/stat_service.h>
 #include <ydb/core/scheme/scheme_types_proto.h>
+#include <ydb/core/tx/columnshard/bg_tasks/events/events.h>
 #include <ydb/core/tx/scheme_board/events_schemeshard.h>
 #include <ydb/library/yql/minikql/mkql_type_ops.h>
 #include <ydb/library/yql/providers/common/proto/gateways_config.pb.h>
@@ -408,7 +409,7 @@ void TSchemeShard::Clear() {
     Views.clear();
 
     ColumnTables = { };
-    BackgroundSessionsManager = std::make_shared<NKikimr::NOlap::NBackground::TSessionsManager>(std::make_shared<NSchemeShard::NBackground::TAdapter>());
+    BackgroundSessionsManager = std::make_shared<NKikimr::NOlap::NBackground::TSessionsManager>(std::make_shared<NSchemeShard::NBackground::TAdapter>(SelfId(), NKikimr::NOlap::TTabletId(TabletID())));
 
     RevertedMigrations.clear();
 
@@ -4233,7 +4234,7 @@ TSchemeShard::TSchemeShard(const TActorId &tablet, TTabletStorageInfo *info)
     TabletCounters = TabletCountersPtr.Get();
 
     SelfPinger = new TSelfPinger(SelfTabletId(), TabletCounters);
-    BackgroundSessionsManager = std::make_shared<NKikimr::NOlap::NBackground::TSessionsManager>(std::make_shared<NBackground::TAdapter>());
+    BackgroundSessionsManager = std::make_shared<NKikimr::NOlap::NBackground::TSessionsManager>(std::make_shared<NBackground::TAdapter>(tablet, NKikimr::NOlap::TTabletId(TabletID())));
 }
 
 const TDomainsInfo::TDomain& TSchemeShard::GetDomainDescription(const TActorContext &ctx) const {
@@ -4421,6 +4422,7 @@ void TSchemeShard::StateConfigure(STFUNC_SIG) {
     switch (ev->GetTypeRewrite()) {
         HFuncTraced(TEvents::TEvUndelivered, Handle);
 
+        HFuncTraced(NKikimr::NOlap::NBackground::TEvExecuteGeneralLocalTransaction, Handle);
         HFuncTraced(TEvSchemeShard::TEvInitRootShard, Handle);
         HFuncTraced(TEvSchemeShard::TEvInitTenantSchemeShard, Handle);
         HFuncTraced(TEvSchemeShard::TEvMigrateSchemeShard, Handle);
@@ -4463,6 +4465,7 @@ void TSchemeShard::StateWork(STFUNC_SIG) {
     switch (ev->GetTypeRewrite()) {
         HFuncTraced(TEvents::TEvUndelivered, Handle);
         HFuncTraced(TEvSchemeShard::TEvInitRootShard, Handle);
+        HFuncTraced(NKikimr::NOlap::NBackground::TEvExecuteGeneralLocalTransaction, Handle);
 
         HFuncTraced(TEvSchemeShard::TEvMeasureSelfResponseTime, SelfPinger->Handle);
         HFuncTraced(TEvSchemeShard::TEvWakeupToMeasureSelfResponseTime, SelfPinger->Handle);
@@ -5151,10 +5154,14 @@ void TSchemeShard::Handle(TEvSchemeShard::TEvNotifyTxCompletion::TPtr &ev, const
     Execute(CreateTxNotifyTxCompletion(ev), ctx);
 }
 
-void TSchemeShard::Handle(TEvSchemeShard::TEvInitRootShard::TPtr &ev, const TActorContext &ctx) {
+void TSchemeShard::Handle(TEvSchemeShard::TEvInitRootShard::TPtr& ev, const TActorContext& ctx) {
     Execute(CreateTxInitRootCompatibility(ev), ctx);
 }
 
+void TSchemeShard::Handle(NKikimr::NOlap::NBackground::TEvExecuteGeneralLocalTransaction::TPtr& ev, const TActorContext& ctx) {
+    Execute(ev->Get()->ExtractTransaction().release(), ctx);
+}
+
 void TSchemeShard::Handle(TEvSchemeShard::TEvInitTenantSchemeShard::TPtr &ev, const TActorContext &ctx) {
     Execute(CreateTxInitTenantSchemeShard(ev), ctx);
 }
diff --git a/ydb/core/tx/schemeshard/schemeshard_impl.h b/ydb/core/tx/schemeshard/schemeshard_impl.h
@@ -64,6 +64,10 @@
 
 #include <util/generic/ptr.h>
 
+namespace NKikimr::NOlap::NBackground {
+class TEvExecuteGeneralLocalTransaction;
+}
+
 namespace NKikimr {
 namespace NSchemeShard {
 
@@ -1005,6 +1009,8 @@ class TSchemeShard
     void DescribeBlobDepot(const TPathId& pathId, const TString& name, NKikimrSchemeOp::TBlobDepotDescription& desc);
     static void FillTableBoundaries(const TTableInfo::TPtr tableInfo, google::protobuf::RepeatedPtrField<NKikimrSchemeOp::TSplitBoundary>& boundaries);
 
+    void Handle(TAutoPtr<TEventHandle<NKikimr::NOlap::NBackground::TEvExecuteGeneralLocalTransaction>>& ev, const TActorContext& ctx);
+
     void Handle(TEvSchemeShard::TEvInitRootShard::TPtr &ev, const TActorContext &ctx);
     void Handle(TEvSchemeShard::TEvInitTenantSchemeShard::TPtr &ev, const TActorContext &ctx);
 

Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,10 @@`
`1`	`1`	`#include "session.h"`
	`2`	`+#include "adapter.h"`
`2`	`3`
`3`	`4`	`namespace NKikimr::NOlap::NBackground {`
`4`	`5`
	`6`	`+NKikimr::NOlap::TTabletId TStartContext::GetTabletId() const {`
	`7`	`+ return Adapter->GetTabletId();`
	`8`	`+}`
	`9`	`+`
`5`	`10`	`}`
Original file line number	Diff line number	Diff line change
`@@ -4,15 +4,15 @@`
`4`	`4`	`namespace NKikimr::NOlap::NBackground {`
`5`	`5`
`6`	`6`	`bool TTxAddSession::Execute(TTransactionContext& txc, const TActorContext& /ctx/) {`
`7`		`- Adapter->SaveSessionToLocalDatabase(txc, Session->SerializeToLocalDatabaseRecord()).Validate("on AddSession");`
	`7`	`+ Adapter->SaveSessionToLocalDatabase(txc, Session->SerializeToLocalDatabaseRecord());`
`8`	`8`	`return true;`
`9`	`9`	`}`
`10`	`10`
`11`	`11`	`void TTxAddSession::Complete(const TActorContext& ctx) {`
`12`	`12`	`Sessions->AddSession(Session).Validate("on add background session");`
`13`	`13`	`Session->GetChannelContainer()->OnAdded();`
`14`	`14`	`if (Session->GetLogicContainer()->IsReadyForStart()) {`
`15`		`- TStartContext context(ctx.SelfID, Session->GetChannelContainer());`
	`15`	`+ TStartContext context(ctx.SelfID, Session->GetChannelContainer(), Session, Adapter);`
`16`	`16`	`Session->StartActor(context);`
`17`	`17`	`}`
`18`	`18`	`}`
Original file line number	Diff line number	Diff line change
`@@ -6,7 +6,7 @@ namespace NKikimr::NOlap::NBackground {`
`6`	`6`	`void TTxGeneral::Complete(const TActorContext& ctx) {`
`7`	`7`	`DoComplete(ctx);`
`8`	`8`	`if (!!ProgressActorId) {`
`9`		`- ctx.Send(*ProgressActorId, new TEvTransactionCompleted(TxInternalId));`
	`9`	`+ ctx.Send(*ProgressActorId, new TEvLocalTransactionCompleted(TxInternalId));`
`10`	`10`	`}`
`11`	`11`	`}`
`12`	`12`