KIKIMR-19215: stop operators and correct gc actions

18 files changed, 132 insertions, 44 deletions

diff --git a/ydb/core/tx/columnshard/blobs_action/abstract/common.h b/ydb/core/tx/columnshard/blobs_action/abstract/common.h
index 65e1dcf1fe5..80ec48f7c95 100644
--- a/ydb/core/tx/columnshard/blobs_action/abstract/common.h
+++ b/ydb/core/tx/columnshard/blobs_action/abstract/common.h
@@ -1,13 +1,16 @@
 #pragma once
 #include <util/system/types.h>
 #include <ydb/library/accessor/accessor.h>
+#include <ydb/library/services/services.pb.h>
 #include <util/generic/string.h>
+#include <util/generic/guid.h>
 
 namespace NKikimr::NOlap {
 
 class ICommonBlobsAction {
 private:
     YDB_READONLY_DEF(TString, StorageId);
+    YDB_READONLY(TString, ActionGuid, TGUID::CreateTimebased().AsGuidString());
     const i64 ActionId = 0;
 public:
     i64 GetActionId() const {
diff --git a/ydb/core/tx/columnshard/blobs_action/abstract/gc.cpp b/ydb/core/tx/columnshard/blobs_action/abstract/gc.cpp
index 5ade97e6d66..8ba651b9de9 100644
--- a/ydb/core/tx/columnshard/blobs_action/abstract/gc.cpp
+++ b/ydb/core/tx/columnshard/blobs_action/abstract/gc.cpp
@@ -4,8 +4,31 @@
 namespace NKikimr::NOlap {
 
 void IBlobsGCAction::OnCompleteTxAfterCleaning(NColumnShard::TColumnShard& self, const std::shared_ptr<IBlobsGCAction>& taskAction) {
-    self.GetStoragesManager()->GetOperator(GetStorageId())->FinishGC();
-    return DoOnCompleteTxAfterCleaning(self, taskAction);
+    if (!AbortedFlag) {
+        AFL_DEBUG(NKikimrServices::TX_COLUMNSHARD)("event", "OnCompleteTxAfterCleaning")("action_guid", GetActionGuid());
+        if (!DoOnCompleteTxAfterCleaning(self, taskAction)) {
+            return;
+        }
+        taskAction->OnFinished();
+    }
+}
+
+void IBlobsGCAction::OnExecuteTxAfterCleaning(NColumnShard::TColumnShard& self, NColumnShard::TBlobManagerDb& dbBlobs) {
+    if (!AbortedFlag) {
+        AFL_DEBUG(NKikimrServices::TX_COLUMNSHARD)("event", "OnExecuteTxAfterCleaning")("action_guid", GetActionGuid());
+        return DoOnExecuteTxAfterCleaning(self, dbBlobs);
+    }
+}
+
+void IBlobsGCAction::Abort() {
+    Y_VERIFY(IsInProgress());
+    AFL_DEBUG(NKikimrServices::TX_COLUMNSHARD)("event", "gc_aborted")("action_guid", GetActionGuid());
+    AbortedFlag = true;
+}
+
+void IBlobsGCAction::OnFinished() {
+    Y_VERIFY(IsInProgress());
+    FinishedFlag = true;
 }
 
 }
diff --git a/ydb/core/tx/columnshard/blobs_action/abstract/gc.h b/ydb/core/tx/columnshard/blobs_action/abstract/gc.h
index fa4a462b698..e310b9c4e93 100644
--- a/ydb/core/tx/columnshard/blobs_action/abstract/gc.h
+++ b/ydb/core/tx/columnshard/blobs_action/abstract/gc.h
@@ -13,20 +13,27 @@ class IBlobsGCAction: public ICommonBlobsAction {
 private:
     using TBase = ICommonBlobsAction;
 protected:
+    bool AbortedFlag = false;
+    bool FinishedFlag = false;
 
     virtual void DoOnExecuteTxAfterCleaning(NColumnShard::TColumnShard& self, NColumnShard::TBlobManagerDb& dbBlobs) = 0;
-    virtual void DoOnCompleteTxAfterCleaning(NColumnShard::TColumnShard& self, const std::shared_ptr<IBlobsGCAction>& taskAction) = 0;
+    virtual bool DoOnCompleteTxAfterCleaning(NColumnShard::TColumnShard& self, const std::shared_ptr<IBlobsGCAction>& taskAction) = 0;
 public:
-    void OnExecuteTxAfterCleaning(NColumnShard::TColumnShard& self, NColumnShard::TBlobManagerDb& dbBlobs) {
-        return DoOnExecuteTxAfterCleaning(self, dbBlobs);
-    }
+    void OnExecuteTxAfterCleaning(NColumnShard::TColumnShard& self, NColumnShard::TBlobManagerDb& dbBlobs);
     void OnCompleteTxAfterCleaning(NColumnShard::TColumnShard& self, const std::shared_ptr<IBlobsGCAction>& taskAction);
 
+    bool IsInProgress() const {
+        return !AbortedFlag && !FinishedFlag;
+    }
+
     IBlobsGCAction(const TString& storageId)
         : TBase(storageId)
     {
 
     }
+
+    void Abort();
+    void OnFinished();
 };
 
 }
diff --git a/ydb/core/tx/columnshard/blobs_action/abstract/storage.cpp b/ydb/core/tx/columnshard/blobs_action/abstract/storage.cpp
index 501e6a82487..1dd4d034ab0 100644
--- a/ydb/core/tx/columnshard/blobs_action/abstract/storage.cpp
+++ b/ydb/core/tx/columnshard/blobs_action/abstract/storage.cpp
@@ -34,4 +34,12 @@ bool TCommonBlobsTracker::DoFreeBlob(const TUnifiedBlobId& blobId) {
     return true;
 }
 
+void IBlobsStorageOperator::Stop() {
+    if (CurrentGCAction && CurrentGCAction->IsInProgress()) {
+        CurrentGCAction->Abort();
+    }
+    AFL_VERIFY(DoStop());
+    Stopped = true;
+}
+
 }
diff --git a/ydb/core/tx/columnshard/blobs_action/abstract/storage.h b/ydb/core/tx/columnshard/blobs_action/abstract/storage.h
index 4e5b3c4739d..8e9df493bf6 100644
--- a/ydb/core/tx/columnshard/blobs_action/abstract/storage.h
+++ b/ydb/core/tx/columnshard/blobs_action/abstract/storage.h
@@ -2,6 +2,7 @@
 #include "remove.h"
 #include "write.h"
 #include "read.h"
+#include "gc.h"
 
 #include <ydb/core/tx/columnshard/blobs_action/blob_manager_db.h>
 #include <ydb/core/tx/columnshard/blobs_action/counters/storage.h>
@@ -28,25 +29,29 @@ public:
 class IBlobsStorageOperator {
 private:
     YDB_READONLY_DEF(TString, StorageId);
-    friend class IBlobsGCAction;
-    bool GCActivity = false;
 
-    void FinishGC() {
-        Y_VERIFY(GCActivity);
-        GCActivity = false;
-    }
+    std::shared_ptr<IBlobsGCAction> CurrentGCAction;
+    YDB_READONLY(bool, Stopped, false);
     std::shared_ptr<NBlobOperations::TStorageCounters> Counters;
 protected:
     virtual std::shared_ptr<IBlobsDeclareRemovingAction> DoStartDeclareRemovingAction() = 0;
     virtual std::shared_ptr<IBlobsWritingAction> DoStartWritingAction() = 0;
     virtual std::shared_ptr<IBlobsReadingAction> DoStartReadingAction() = 0;
-    virtual bool DoStartGC() = 0;
     virtual bool DoLoad(NColumnShard::IBlobManagerDb& dbBlobs) = 0;
+    virtual bool DoStop() {
+        return true;
+    }
 
     virtual void DoOnTieringModified(const std::shared_ptr<NColumnShard::TTiersManager>& tiers) = 0;
     virtual TString DoDebugString() const {
         return "";
     }
+
+    virtual std::shared_ptr<IBlobsGCAction> DoStartGCAction() const = 0;
+    std::shared_ptr<IBlobsGCAction> StartGCAction() const {
+        return DoStartGCAction();
+    }
+
 public:
     IBlobsStorageOperator(const TString& storageId)
         : StorageId(storageId)
@@ -54,6 +59,8 @@ public:
         Counters = std::make_shared<NBlobOperations::TStorageCounters>(storageId);
     }
 
+    void Stop();
+
     virtual std::shared_ptr<IBlobInUseTracker> GetBlobsTracker() const = 0;
 
     virtual ~IBlobsStorageOperator() = default;
@@ -83,11 +90,18 @@ public:
         return result;
     }
     bool StartGC() {
-        if (!GCActivity) {
-            GCActivity = DoStartGC();
-            return GCActivity;
+        if (CurrentGCAction && CurrentGCAction->IsInProgress()) {
+            return false;
+        }
+        if (Stopped) {
+            return false;
+        }
+        auto task = StartGCAction();
+        if (!task) {
+            return false;
         }
-        return false;
+        CurrentGCAction = task;
+        return true;
     }
 };
 
diff --git a/ydb/core/tx/columnshard/blobs_action/abstract/storages_manager.h b/ydb/core/tx/columnshard/blobs_action/abstract/storages_manager.h
index 7c52f4c7987..d6bbe5de35a 100644
--- a/ydb/core/tx/columnshard/blobs_action/abstract/storages_manager.h
+++ b/ydb/core/tx/columnshard/blobs_action/abstract/storages_manager.h
@@ -24,6 +24,12 @@ public:
 
     IStoragesManager() = default;
 
+    void Stop() {
+        for (auto&& i : Constructed) {
+            i.second->Stop();
+        }
+    }
+
     std::shared_ptr<IBlobsStorageOperator> GetDefaultOperator() {
         return GetOperator(DefaultStorageId);
     }
diff --git a/ydb/core/tx/columnshard/blobs_action/bs/gc.cpp b/ydb/core/tx/columnshard/blobs_action/bs/gc.cpp
index 629dbcdef48..1cc35b4e4b1 100644
--- a/ydb/core/tx/columnshard/blobs_action/bs/gc.cpp
+++ b/ydb/core/tx/columnshard/blobs_action/bs/gc.cpp
@@ -3,6 +3,7 @@
 #include <ydb/core/tx/columnshard/columnshard_private_events.h>
 #include <ydb/core/tx/columnshard/columnshard_impl.h>
 #include <ydb/core/tx/columnshard/blob_manager.h>
+#include <library/cpp/actors/core/log.h>
 
 namespace NKikimr::NOlap::NBlobOperations::NBlobStorage {
 
@@ -23,9 +24,12 @@ void TGCTask::DoOnExecuteTxAfterCleaning(NColumnShard::TColumnShard& /*self*/, N
     }
 }
 
-void TGCTask::DoOnCompleteTxAfterCleaning(NColumnShard::TColumnShard& self, const std::shared_ptr<IBlobsGCAction>& taskAction) {
+bool TGCTask::DoOnCompleteTxAfterCleaning(NColumnShard::TColumnShard& self, const std::shared_ptr<IBlobsGCAction>& taskAction) {
     if (KeepsToErase.size() || DeletesToErase.size()) {
         TActorContext::AsActorContext().Send(self.SelfId(), std::make_unique<NColumnShard::TEvPrivate::TEvGarbageCollectionFinished>(taskAction));
+        return false;
+    } else {
+        return true;
     }
 }
 
@@ -41,7 +45,7 @@ TGCTask::TGCTask(const TString& storageId, TGCListsByGroup&& listsByGroupId, con
 }
 
 void TGCTask::OnGCResult(TEvBlobStorage::TEvCollectGarbageResult::TPtr ev) {
-    Y_VERIFY(ev->Get()->Status == NKikimrProto::OK, "The caller must handle unsuccessful status");
+    AFL_VERIFY(ev->Get()->Status == NKikimrProto::OK)("status", ev->Get()->Status)("details", ev->Get()->ToString())("action_id", GetActionGuid());
 
     // Find the group for this result
     ui64 counterFromRequest = ev->Get()->PerGenerationCounter;
diff --git a/ydb/core/tx/columnshard/blobs_action/bs/gc.h b/ydb/core/tx/columnshard/blobs_action/bs/gc.h
index 054528db24f..013f1a1029a 100644
--- a/ydb/core/tx/columnshard/blobs_action/bs/gc.h
+++ b/ydb/core/tx/columnshard/blobs_action/bs/gc.h
@@ -25,7 +25,7 @@ private:
     std::shared_ptr<NColumnShard::TBlobManager> Manager;
 protected:
     virtual void DoOnExecuteTxAfterCleaning(NColumnShard::TColumnShard& self, NColumnShard::TBlobManagerDb& dbBlobs) override;
-    virtual void DoOnCompleteTxAfterCleaning(NColumnShard::TColumnShard& self, const std::shared_ptr<IBlobsGCAction>& taskAction) override;
+    virtual bool DoOnCompleteTxAfterCleaning(NColumnShard::TColumnShard& self, const std::shared_ptr<IBlobsGCAction>& taskAction) override;
 public:
     bool IsEmpty() const {
         return ListsByGroupId.empty();
diff --git a/ydb/core/tx/columnshard/blobs_action/bs/gc_actor.cpp b/ydb/core/tx/columnshard/blobs_action/bs/gc_actor.cpp
index 40f8f4936a3..e0fd4d29f27 100644
--- a/ydb/core/tx/columnshard/blobs_action/bs/gc_actor.cpp
+++ b/ydb/core/tx/columnshard/blobs_action/bs/gc_actor.cpp
@@ -4,10 +4,16 @@
 namespace NKikimr::NOlap::NBlobOperations::NBlobStorage {
 
 void TGarbageCollectionActor::Handle(TEvBlobStorage::TEvCollectGarbageResult::TPtr& ev) {
+    ACFL_DEBUG("actor", "TEvCollectGarbageResult");
+    if (ev->Get()->Status == NKikimrProto::BLOCKED) {
+        auto g = PassAwayGuard();
+        ACFL_WARN("event", "blocked_gc_event");
+        return;
+    }
     GCTask->OnGCResult(ev);
     if (GCTask->IsFinished()) {
         auto g = PassAwayGuard();
-        AFL_DEBUG(NKikimrServices::TX_COLUMNSHARD)("actor", "TGarbageCollectionActor")("event", "finished");
+        ACFL_DEBUG("actor", "TGarbageCollectionActor")("event", "finished");
         TActorContext::AsActorContext().Send(TabletActorId, std::make_unique<NColumnShard::TEvPrivate::TEvGarbageCollectionFinished>(GCTask));
     }
 }
diff --git a/ydb/core/tx/columnshard/blobs_action/bs/gc_actor.h b/ydb/core/tx/columnshard/blobs_action/bs/gc_actor.h
index 7aad02a6293..bcd5dfdbe06 100644
--- a/ydb/core/tx/columnshard/blobs_action/bs/gc_actor.h
+++ b/ydb/core/tx/columnshard/blobs_action/bs/gc_actor.h
@@ -23,13 +23,14 @@ public:
     }
 
     STFUNC(StateWork) {
+        NActors::TLogContextGuard logGuard = NActors::TLogContextBuilder::Build(NKikimrServices::TX_COLUMNSHARD)("action_id", GCTask->GetActionGuid());
         switch (ev->GetTypeRewrite()) {
             hFunc(TEvBlobStorage::TEvCollectGarbageResult, Handle);
         }
     }
 
     void Bootstrap(const TActorContext& ctx) {
-        AFL_DEBUG(NKikimrServices::TX_COLUMNSHARD)("actor", "TGarbageCollectionActor")("event", "starting");
+        AFL_DEBUG(NKikimrServices::TX_COLUMNSHARD)("actor", "TGarbageCollectionActor")("event", "starting")("action_id", GCTask->GetActionGuid());
         for (auto&& i : Requests) {
             SendToBSProxy(ctx, i.first, i.second.release());
         }
diff --git a/ydb/core/tx/columnshard/blobs_action/bs/storage.cpp b/ydb/core/tx/columnshard/blobs_action/bs/storage.cpp
index b2ee8efcbf9..5293284fb78 100644
--- a/ydb/core/tx/columnshard/blobs_action/bs/storage.cpp
+++ b/ydb/core/tx/columnshard/blobs_action/bs/storage.cpp
@@ -20,17 +20,17 @@ std::shared_ptr<NKikimr::NOlap::IBlobsReadingAction> TOperator::DoStartReadingAc
     return std::make_shared<TReadingAction>(GetStorageId(), BlobCacheActorId);
 }
 
-bool TOperator::DoStartGC() {
+std::shared_ptr<IBlobsGCAction> TOperator::DoStartGCAction() const {
     auto gcTask = Manager->BuildGCTask(GetStorageId(), Manager);
     if (!gcTask || gcTask->IsEmpty()) {
         AFL_DEBUG(NKikimrServices::TX_COLUMNSHARD)("event", "StartGCSkipped");
-        return false;
+        return nullptr;
     }
     auto requests = gcTask->BuildRequests(PerGenerationCounter, Manager->GetTabletId(), Manager->GetCurrentGen());
     AFL_VERIFY(requests.size());
     AFL_DEBUG(NKikimrServices::TX_COLUMNSHARD)("event", "StartGC")("requests_count", requests.size());
     TActorContext::AsActorContext().Register(new TGarbageCollectionActor(gcTask, std::move(requests), TabletActorId));
-    return true;
+    return gcTask;
 }
 
 TOperator::TOperator(const TString& storageId, const NActors::TActorId& tabletActorId, const TIntrusivePtr<TTabletStorageInfo>& tabletInfo, const ui64 generation)
diff --git a/ydb/core/tx/columnshard/blobs_action/bs/storage.h b/ydb/core/tx/columnshard/blobs_action/bs/storage.h
index df8b08f3640..49e97a61d9a 100644
--- a/ydb/core/tx/columnshard/blobs_action/bs/storage.h
+++ b/ydb/core/tx/columnshard/blobs_action/bs/storage.h
@@ -1,6 +1,7 @@
 #pragma once
 
 #include <ydb/core/tx/columnshard/blobs_action/abstract/storage.h>
+#include <ydb/core/tx/columnshard/blobs_action/abstract/gc.h>
 #include <ydb/core/tx/columnshard/blob_manager.h>
 #include <ydb/core/tx/columnshard/blob_cache.h>
 
@@ -11,13 +12,13 @@ private:
     using TBase = IBlobsStorageOperator;
     std::shared_ptr<NColumnShard::TBlobManager> Manager;
     const TActorId BlobCacheActorId;
-    ui64 PerGenerationCounter = 1;
+    mutable ui64 PerGenerationCounter = 1;
     const TActorId TabletActorId;
 protected:
     virtual std::shared_ptr<IBlobsDeclareRemovingAction> DoStartDeclareRemovingAction() override;
     virtual std::shared_ptr<IBlobsWritingAction> DoStartWritingAction() override;
     virtual std::shared_ptr<IBlobsReadingAction> DoStartReadingAction() override;
-    virtual bool DoStartGC() override;
+    virtual std::shared_ptr<IBlobsGCAction> DoStartGCAction() const override;
     virtual bool DoLoad(NColumnShard::IBlobManagerDb& dbBlobs) override {
         return Manager->LoadState(dbBlobs);
     }
diff --git a/ydb/core/tx/columnshard/blobs_action/tier/gc.cpp b/ydb/core/tx/columnshard/blobs_action/tier/gc.cpp
index 3c92504a3a4..6d311f306c3 100644
--- a/ydb/core/tx/columnshard/blobs_action/tier/gc.cpp
+++ b/ydb/core/tx/columnshard/blobs_action/tier/gc.cpp
@@ -1,14 +1,30 @@
 #include "gc.h"
 #include <ydb/core/tx/columnshard/blobs_action/blob_manager_db.h>
+#include <ydb/core/tx/columnshard/columnshard_private_events.h>
+#include <ydb/core/tx/columnshard/columnshard_impl.h>
 
 namespace NKikimr::NOlap::NBlobOperations::NTier {
 
 void TGCTask::DoOnExecuteTxAfterCleaning(NColumnShard::TColumnShard& /*self*/, NColumnShard::TBlobManagerDb& dbBlobs) {
-    for (auto&& i : DraftBlobIds) {
-        dbBlobs.RemoveTierDraftBlobId(GetStorageId(), i);
+    size_t numBlobs = 0;
+
+    for (; DraftBlobIds.size() && numBlobs < NColumnShard::TLimits::MAX_BLOBS_TO_DELETE; ++numBlobs) {
+        dbBlobs.EraseBlobToKeep(DraftBlobIds.front());
+        DraftBlobIds.pop_front();
+    }
+
+    for (; DeleteBlobIds.size() && numBlobs < NColumnShard::TLimits::MAX_BLOBS_TO_DELETE; ++numBlobs) {
+        dbBlobs.EraseBlobToDelete(DeleteBlobIds.front());
+        DeleteBlobIds.pop_front();
     }
-    for (auto&& i : DeleteBlobIds) {
-        dbBlobs.RemoveTierBlobToDelete(GetStorageId(), i);
+}
+
+bool TGCTask::DoOnCompleteTxAfterCleaning(NColumnShard::TColumnShard& self, const std::shared_ptr<IBlobsGCAction>& taskAction) {
+    if (DraftBlobIds.size() || DeleteBlobIds.size()) {
+        TActorContext::AsActorContext().Send(self.SelfId(), std::make_unique<NColumnShard::TEvPrivate::TEvGarbageCollectionFinished>(taskAction));
+        return false;
+    } else {
+        return true;
     }
 }
 
diff --git a/ydb/core/tx/columnshard/blobs_action/tier/gc.h b/ydb/core/tx/columnshard/blobs_action/tier/gc.h
index 7bc5f8ef5fb..5917ca0c354 100644
--- a/ydb/core/tx/columnshard/blobs_action/tier/gc.h
+++ b/ydb/core/tx/columnshard/blobs_action/tier/gc.h
@@ -10,16 +10,14 @@ class TGCTask: public IBlobsGCAction {
 private:
     using TBase = IBlobsGCAction;
 private:
-    YDB_READONLY_DEF(std::vector<TUnifiedBlobId>, DraftBlobIds);
-    YDB_READONLY_DEF(std::vector<TUnifiedBlobId>, DeleteBlobIds);
+    YDB_READONLY_DEF(std::deque<TUnifiedBlobId>, DraftBlobIds);
+    YDB_READONLY_DEF(std::deque<TUnifiedBlobId>, DeleteBlobIds);
     YDB_READONLY_DEF(NWrappers::NExternalStorage::IExternalStorageOperator::TPtr, ExternalStorageOperator);
 protected:
     virtual void DoOnExecuteTxAfterCleaning(NColumnShard::TColumnShard& self, NColumnShard::TBlobManagerDb& dbBlobs) override;
-    virtual void DoOnCompleteTxAfterCleaning(NColumnShard::TColumnShard& /*self*/, const std::shared_ptr<IBlobsGCAction>& /*taskAction*/) override {
-
-    }
+    virtual bool DoOnCompleteTxAfterCleaning(NColumnShard::TColumnShard& self, const std::shared_ptr<IBlobsGCAction>& taskAction) override;
 public:
-    TGCTask(const TString& storageId, std::vector<TUnifiedBlobId>&& draftBlobIds, std::vector<TUnifiedBlobId>&& deleteBlobIds,
+    TGCTask(const TString& storageId, std::deque<TUnifiedBlobId>&& draftBlobIds, std::deque<TUnifiedBlobId>&& deleteBlobIds,
         const NWrappers::NExternalStorage::IExternalStorageOperator::TPtr& externalStorageOperator)
         : TBase(storageId)
         , DraftBlobIds(std::move(draftBlobIds))
diff --git a/ydb/core/tx/columnshard/blobs_action/tier/gc_info.h b/ydb/core/tx/columnshard/blobs_action/tier/gc_info.h
index 2d42b850a51..8814ccabe2a 100644
--- a/ydb/core/tx/columnshard/blobs_action/tier/gc_info.h
+++ b/ydb/core/tx/columnshard/blobs_action/tier/gc_info.h
@@ -17,7 +17,7 @@ public:
         }
     }
 
-    bool ExtractForGC(std::vector<TUnifiedBlobId>& deleteDraftBlobIds, std::vector<TUnifiedBlobId>& deleteBlobIds, const ui32 blobsCountLimit) {
+    bool ExtractForGC(std::deque<TUnifiedBlobId>& deleteDraftBlobIds, std::deque<TUnifiedBlobId>& deleteBlobIds, const ui32 blobsCountLimit) {
         if (DraftBlobIdsToRemove.empty() && BlobsToDelete.empty()) {
             return false;
         }
diff --git a/ydb/core/tx/columnshard/blobs_action/tier/storage.cpp b/ydb/core/tx/columnshard/blobs_action/tier/storage.cpp
index d8c22aa4b9e..a16358a6548 100644
--- a/ydb/core/tx/columnshard/blobs_action/tier/storage.cpp
+++ b/ydb/core/tx/columnshard/blobs_action/tier/storage.cpp
@@ -30,15 +30,15 @@ std::shared_ptr<IBlobsReadingAction> TOperator::DoStartReadingAction() {
     return std::make_shared<TReadingAction>(GetStorageId(), GetCurrentOperator());
 }
 
-bool TOperator::DoStartGC() {
-    std::vector<TUnifiedBlobId> draftBlobIds;
-    std::vector<TUnifiedBlobId> deleteBlobIds;
+std::shared_ptr<IBlobsGCAction> TOperator::DoStartGCAction() const {
+    std::deque<TUnifiedBlobId> draftBlobIds;
+    std::deque<TUnifiedBlobId> deleteBlobIds;
     if (!GCInfo->ExtractForGC(draftBlobIds, deleteBlobIds, 100000)) {
-        return false;
+        return nullptr;
     }
     auto gcTask = std::make_shared<TGCTask>(GetStorageId(), std::move(draftBlobIds), std::move(deleteBlobIds), GetCurrentOperator());
     TActorContext::AsActorContext().Register(new TGarbageCollectionActor(gcTask, TabletActorId));
-    return true;
+    return gcTask;
 }
 
 void TOperator::InitNewExternalOperator(const NColumnShard::NTiers::TManager& tierManager) {
diff --git a/ydb/core/tx/columnshard/blobs_action/tier/storage.h b/ydb/core/tx/columnshard/blobs_action/tier/storage.h
index dcd3a77050e..8f138d50415 100644
--- a/ydb/core/tx/columnshard/blobs_action/tier/storage.h
+++ b/ydb/core/tx/columnshard/blobs_action/tier/storage.h
@@ -30,7 +30,7 @@ protected:
     virtual std::shared_ptr<IBlobsDeclareRemovingAction> DoStartDeclareRemovingAction() override;
     virtual std::shared_ptr<IBlobsWritingAction> DoStartWritingAction() override;
     virtual std::shared_ptr<IBlobsReadingAction> DoStartReadingAction() override;
-    virtual bool DoStartGC() override;
+    virtual std::shared_ptr<IBlobsGCAction> DoStartGCAction() const override;
     virtual bool DoLoad(NColumnShard::IBlobManagerDb& dbBlobs) override {
         dbBlobs.LoadTierLists(GetStorageId(), GCInfo->MutableBlobsToDelete(), GCInfo->MutableDraftBlobIdsToRemove());
         return true;
diff --git a/ydb/core/tx/columnshard/columnshard.cpp b/ydb/core/tx/columnshard/columnshard.cpp
index cd30c5469c3..519117ce888 100644
--- a/ydb/core/tx/columnshard/columnshard.cpp
+++ b/ydb/core/tx/columnshard/columnshard.cpp
@@ -17,6 +17,7 @@ void TColumnShard::CleanupActors(const TActorContext& ctx)
 {
     ctx.Send(BlobsReadActor, new TEvents::TEvPoisonPill);
     ctx.Send(ResourceSubscribeActor, new TEvents::TEvPoisonPill);
+    StoragesManager->Stop();
     if (Tiers) {
         Tiers->Stop();
     }