Skip to content

Commit c131499

Browse files
aavdonkinblinkov
aavdonkin
authored and
blinkov
committed
Stop writing to column tables if quota is exceeded (#11580)
1 parent 27e31a4 commit c131499

25 files changed

+606
-24
lines changed

Diff for: ‎ydb/core/protos/counters_columnshard.proto

+2
Original file line numberDiff line numberDiff line change
@@ -205,4 +205,6 @@ enum ETxTypes {
205205
TXTYPE_ASK_PORTION_METADATA = 38 [(TxTypeOpts) = {Name: "TxAskPortionMetadata"}];
206206
TXTYPE_WRITE_PORTIONS_FINISHED = 39 [(TxTypeOpts) = {Name: "TxWritePortionsFinished"}];
207207
TXTYPE_WRITE_PORTIONS_FAILED = 40 [(TxTypeOpts) = {Name: "TxWritePortionsFailed"}];
208+
TXTYPE_PERSIST_SUBDOMAIN_OUT_OF_SPACE = 41 [(TxTypeOpts) = {Name: "TxPersistSubDomainOutOfSpace"}];
209+
TXTYPE_PERSIST_SUBDOMAIN_PATH_ID = 42 [(TxTypeOpts) = {Name: "TxPersistSubDomainPathId"}];
208210
}

Diff for: ‎ydb/core/protos/tx_columnshard.proto

+1
Original file line numberDiff line numberDiff line change
@@ -162,6 +162,7 @@ message TEvProposeTransaction {
162162
optional NKikimrSubDomains.TProcessingParams ProcessingParams = 6;
163163
optional uint64 Flags = 7;
164164
optional NKikimrTx.TMessageSeqNo SeqNo = 8;
165+
optional uint64 SubDomainPathId = 9;
165166
}
166167

167168
message TEvCheckPlannedTransaction {

Diff for: ‎ydb/core/tx/columnshard/columnshard.h

+6-3
Original file line numberDiff line numberDiff line change
@@ -140,16 +140,19 @@ namespace TEvColumnShard {
140140
}
141141

142142
TEvProposeTransaction(NKikimrTxColumnShard::ETransactionKind txKind, ui64 ssId, const TActorId& source,
143-
ui64 txId, TString txBody, const ui32 flags = 0)
143+
ui64 txId, TString txBody, const ui32 flags, ui64 subDomainPathId)
144144
: TEvProposeTransaction(txKind, source, txId, std::move(txBody), flags)
145145
{
146146
// Y_ABORT_UNLESS(txKind == NKikimrTxColumnShard::TX_KIND_SCHEMA);
147147
Record.SetSchemeShardId(ssId);
148+
if (subDomainPathId != 0) {
149+
Record.SetSubDomainPathId(subDomainPathId);
150+
}
148151
}
149152

150153
TEvProposeTransaction(NKikimrTxColumnShard::ETransactionKind txKind, ui64 ssId, const TActorId& source,
151-
ui64 txId, TString txBody, const TMessageSeqNo& seqNo, const NKikimrSubDomains::TProcessingParams& processingParams, const ui32 flags = 0)
152-
: TEvProposeTransaction(txKind, ssId, source, txId, std::move(txBody), flags)
154+
ui64 txId, TString txBody, const TMessageSeqNo& seqNo, const NKikimrSubDomains::TProcessingParams& processingParams, const ui32 flags, ui64 subDomainPathId)
155+
: TEvProposeTransaction(txKind, ssId, source, txId, std::move(txBody), flags, subDomainPathId)
153156
{
154157
Record.MutableProcessingParams()->CopyFrom(processingParams);
155158
*Record.MutableSeqNo() = seqNo.SerializeToProto();

Diff for: ‎ydb/core/tx/columnshard/columnshard__init.cpp

+5
Original file line numberDiff line numberDiff line change
@@ -108,6 +108,11 @@ void TTxInit::Complete(const TActorContext& ctx) {
108108
AFL_VERIFY(!Self->IsTxInitFinished);
109109
Self->IsTxInitFinished = true;
110110
Self->TrySwitchToWork(ctx);
111+
if (Self->SpaceWatcher->SubDomainPathId) {
112+
Self->SpaceWatcher->StartWatchingSubDomainPathId();
113+
} else {
114+
Self->SpaceWatcher->StartFindSubDomainPathId();
115+
}
111116
}
112117

113118
class TTxUpdateSchema: public TTransactionBase<TColumnShard> {

Diff for: ‎ydb/core/tx/columnshard/columnshard__propose_transaction.cpp

+10
Original file line numberDiff line numberDiff line change
@@ -54,6 +54,16 @@ class TTxProposeTransaction: public NTabletFlatExecutor::TTransactionBase<TColum
5454
} else {
5555
AFL_VERIFY(Self->CurrentSchemeShardId == record.GetSchemeShardId());
5656
}
57+
if (txKind == NKikimrTxColumnShard::TX_KIND_SCHEMA) {
58+
if (record.HasSubDomainPathId()) {
59+
ui64 subDomainPathId = record.GetSubDomainPathId();
60+
AFL_DEBUG(NKikimrServices::TX_COLUMNSHARD)("event", "propose")("subdomain_id", subDomainPathId);
61+
Self->SpaceWatcher->PersistSubDomainPathId(subDomainPathId, txc);
62+
Self->SpaceWatcher->StartWatchingSubDomainPathId();
63+
} else {
64+
Self->SpaceWatcher->StartFindSubDomainPathId();
65+
}
66+
}
5767
}
5868
std::optional<TMessageSeqNo> msgSeqNo;
5969
if (Ev->Get()->Record.HasSeqNo()) {

Diff for: ‎ydb/core/tx/columnshard/columnshard__write.cpp

+17-7
Original file line numberDiff line numberDiff line change
@@ -203,24 +203,30 @@ void TColumnShard::Handle(TEvColumnShard::TEvWrite::TPtr& ev, const TActorContex
203203
writeMeta.SetLongTxId(NLongTxService::TLongTxId::FromProto(record.GetLongTxId()));
204204
writeMeta.SetWritePartId(record.GetWritePartId());
205205

206-
const auto returnFail = [&](const NColumnShard::ECumulativeCounters signalIndex, const EWriteFailReason reason) {
206+
const auto returnFail = [&](const NColumnShard::ECumulativeCounters signalIndex, const EWriteFailReason reason, NKikimrTxColumnShard::EResultStatus resultStatus) {
207207
Counters.GetTabletCounters()->IncCounter(signalIndex);
208208

209-
ctx.Send(source, std::make_unique<TEvColumnShard::TEvWriteResult>(TabletID(), writeMeta, NKikimrTxColumnShard::EResultStatus::ERROR));
209+
ctx.Send(source, std::make_unique<TEvColumnShard::TEvWriteResult>(TabletID(), writeMeta, resultStatus));
210210
Counters.GetCSCounters().OnFailedWriteResponse(reason);
211211
return;
212212
};
213213

214+
if (SpaceWatcher->SubDomainOutOfSpace && (!record.HasModificationType() || (record.GetModificationType() != NKikimrTxColumnShard::TEvWrite::OPERATION_DELETE))) {
215+
AFL_WARN(NKikimrServices::TX_COLUMNSHARD)("event", "skip_writing")("reason", "quota_exceeded");
216+
Counters.GetTabletCounters()->IncCounter(COUNTER_OUT_OF_SPACE);
217+
return returnFail(COUNTER_WRITE_FAIL, EWriteFailReason::Overload, NKikimrTxColumnShard::EResultStatus::OVERLOADED);
218+
}
219+
214220
if (!AppDataVerified().ColumnShardConfig.GetWritingEnabled()) {
215221
AFL_WARN(NKikimrServices::TX_COLUMNSHARD_WRITE)("event", "skip_writing")("reason", "disabled");
216-
return returnFail(COUNTER_WRITE_FAIL, EWriteFailReason::Disabled);
222+
return returnFail(COUNTER_WRITE_FAIL, EWriteFailReason::Disabled, NKikimrTxColumnShard::EResultStatus::ERROR);
217223
}
218224

219225
if (!TablesManager.IsReadyForStartWrite(pathId, false)) {
220226
LOG_S_NOTICE("Write (fail) into pathId:" << writeMeta.GetTableId() << (TablesManager.HasPrimaryIndex() ? "" : " no index")
221227
<< " at tablet " << TabletID());
222228

223-
return returnFail(COUNTER_WRITE_FAIL, EWriteFailReason::NoTable);
229+
return returnFail(COUNTER_WRITE_FAIL, EWriteFailReason::NoTable, NKikimrTxColumnShard::EResultStatus::ERROR);
224230
}
225231

226232
{
@@ -230,7 +236,7 @@ void TColumnShard::Handle(TEvColumnShard::TEvWrite::TPtr& ev, const TActorContex
230236
.CheckWriteData();
231237
if (status.IsFail()) {
232238
AFL_WARN(NKikimrServices::TX_COLUMNSHARD_WRITE)("event", "writing_fail_through_compaction")("reason", status.GetErrorMessage());
233-
return returnFail(COUNTER_WRITE_FAIL, EWriteFailReason::CompactionCriteria);
239+
return returnFail(COUNTER_WRITE_FAIL, EWriteFailReason::CompactionCriteria, NKikimrTxColumnShard::EResultStatus::ERROR);
234240
}
235241
}
236242

@@ -239,7 +245,7 @@ void TColumnShard::Handle(TEvColumnShard::TEvWrite::TPtr& ev, const TActorContex
239245
if (!arrowData->ParseFromProto(record)) {
240246
LOG_S_ERROR(
241247
"Write (fail) " << record.GetData().size() << " bytes into pathId " << writeMeta.GetTableId() << " at tablet " << TabletID());
242-
return returnFail(COUNTER_WRITE_FAIL, EWriteFailReason::IncorrectSchema);
248+
return returnFail(COUNTER_WRITE_FAIL, EWriteFailReason::IncorrectSchema, NKikimrTxColumnShard::EResultStatus::ERROR);
243249
}
244250

245251
NEvWrite::TWriteData writeData(writeMetaPtr, arrowData, snapshotSchema->GetIndexInfo().GetReplaceKey(),
@@ -564,7 +570,11 @@ void TColumnShard::Handle(NEvents::TDataEvents::TEvWrite::TPtr& ev, const TActor
564570
return;
565571
}
566572

567-
auto overloadStatus = CheckOverloadedImmediate(pathId);
573+
const bool outOfSpace = SpaceWatcher->SubDomainOutOfSpace && (*mType != NEvWrite::EModificationType::Delete);
574+
if (outOfSpace) {
575+
AFL_WARN(NKikimrServices::TX_COLUMNSHARD)("event", "skip_writing")("reason", "quota_exceeded")("source", "dataevent");
576+
}
577+
auto overloadStatus = outOfSpace ? EOverloadStatus::Disk : CheckOverloadedImmediate(pathId);
568578
if (overloadStatus != EOverloadStatus::None) {
569579
std::unique_ptr<NActors::IEventBase> result = NEvents::TDataEvents::TEvWriteResult::BuildError(
570580
TabletID(), 0, NKikimrDataEvents::TEvWriteResult::STATUS_OVERLOADED, "overload data error");

Diff for: ‎ydb/core/tx/columnshard/columnshard_impl.cpp

+4
Original file line numberDiff line numberDiff line change
@@ -97,6 +97,8 @@ TColumnShard::TColumnShard(TTabletStorageInfo* info, const TActorId& tablet)
9797
, NormalizerController(StoragesManager, Counters.GetSubscribeCounters())
9898
, SysLocks(this) {
9999
AFL_VERIFY(TabletActivityImpl->Inc() == 1);
100+
SpaceWatcher = new TSpaceWatcher(this);
101+
SpaceWatcherId = TActorContext::AsActorContext().Register(SpaceWatcher);
100102
}
101103

102104
void TColumnShard::OnDetach(const TActorContext& ctx) {
@@ -1158,6 +1160,7 @@ void TColumnShard::Die(const TActorContext& ctx) {
11581160
NTabletPipe::CloseAndForgetClient(SelfId(), StatsReportPipe);
11591161
UnregisterMediatorTimeCast();
11601162
NYDBTest::TControllers::GetColumnShardController()->OnTabletStopped(*this);
1163+
Send(SpaceWatcherId, new NActors::TEvents::TEvPoison);
11611164
IActor::Die(ctx);
11621165
}
11631166

@@ -1606,6 +1609,7 @@ void TColumnShard::Enqueue(STFUNC_SIG) {
16061609
HFunc(TEvPrivate::TEvTieringModified, HandleInit);
16071610
HFunc(TEvPrivate::TEvNormalizerResult, Handle);
16081611
HFunc(NOlap::NDataAccessorControl::TEvAskTabletDataAccessors, Handle);
1612+
HFunc(TEvTxProxySchemeCache::TEvWatchNotifyUpdated, Handle);
16091613
default:
16101614
AFL_WARN(NKikimrServices::TX_COLUMNSHARD)("event", "unexpected event in enqueue");
16111615
return NTabletFlatExecutor::TTabletExecutedFlat::Enqueue(ev);

Diff for: ‎ydb/core/tx/columnshard/columnshard_impl.h

+9-1
Original file line numberDiff line numberDiff line change
@@ -2,6 +2,7 @@
22
#include "background_controller.h"
33
#include "columnshard.h"
44
#include "columnshard_private_events.h"
5+
#include "columnshard_subdomain_path_id.h"
56
#include "counters.h"
67
#include "defs.h"
78
#include "inflight_request_tracker.h"
@@ -39,6 +40,7 @@
3940
#include <ydb/core/tx/tiering/common.h>
4041
#include <ydb/core/tx/time_cast/time_cast.h>
4142
#include <ydb/core/tx/tx_processing.h>
43+
#include <ydb/core/tx/scheme_cache/scheme_cache.h>
4244

4345
#include <ydb/services/metadata/abstract/common.h>
4446
#include <ydb/services/metadata/service.h>
@@ -182,6 +184,9 @@ class TColumnShard: public TActor<TColumnShard>, public NTabletFlatExecutor::TTa
182184
friend class TTxRemoveSharedBlobs;
183185
friend class TTxFinishAsyncTransaction;
184186
friend class TWaitEraseTablesTxSubscriber;
187+
friend class TTxPersistSubDomainOutOfSpace;
188+
friend class TTxPersistSubDomainPathId;
189+
friend class TSpaceWatcher;
185190

186191
friend class NOlap::TCleanupPortionsColumnEngineChanges;
187192
friend class NOlap::TCleanupTablesColumnEngineChanges;
@@ -295,8 +300,8 @@ class TColumnShard: public TActor<TColumnShard>, public NTabletFlatExecutor::TTa
295300
void Handle(NOlap::NDataSharing::NEvents::TEvFinishedFromSource::TPtr& ev, const TActorContext& ctx);
296301
void Handle(NOlap::NDataSharing::NEvents::TEvAckFinishToSource::TPtr& ev, const TActorContext& ctx);
297302
void Handle(NOlap::NDataSharing::NEvents::TEvAckFinishFromInitiator::TPtr& ev, const TActorContext& ctx);
298-
299303
void Handle(NOlap::NDataAccessorControl::TEvAskTabletDataAccessors::TPtr& ev, const TActorContext& ctx);
304+
void Handle(TEvTxProxySchemeCache::TEvWatchNotifyUpdated::TPtr& ev, const TActorContext& ctx);
300305

301306
void HandleInit(TEvPrivate::TEvTieringModified::TPtr& ev, const TActorContext&);
302307

@@ -463,6 +468,7 @@ class TColumnShard: public TActor<TColumnShard>, public NTabletFlatExecutor::TTa
463468
HFunc(NOlap::NDataSharing::NEvents::TEvAckFinishToSource, Handle);
464469
HFunc(NOlap::NDataSharing::NEvents::TEvAckFinishFromInitiator, Handle);
465470
HFunc(NOlap::NDataAccessorControl::TEvAskTabletDataAccessors, Handle);
471+
HFunc(TEvTxProxySchemeCache::TEvWatchNotifyUpdated, Handle);
466472

467473
default:
468474
if (!HandleDefaultEvents(ev, SelfId())) {
@@ -552,6 +558,8 @@ class TColumnShard: public TActor<TColumnShard>, public NTabletFlatExecutor::TTa
552558
TLimits Limits;
553559
NOlap::TNormalizationController NormalizerController;
554560
NDataShard::TSysLocks SysLocks;
561+
TSpaceWatcher* SpaceWatcher;
562+
TActorId SpaceWatcherId;
555563

556564
void TryRegisterMediatorTimeCast();
557565
void UnregisterMediatorTimeCast();

Diff for: ‎ydb/core/tx/columnshard/columnshard_schema.h

+3-1
Original file line numberDiff line numberDiff line change
@@ -83,7 +83,9 @@ struct Schema : NIceDb::Schema {
8383
LastCompletedTxId = 14,
8484
LastNormalizerSequentialId = 15,
8585
GCBarrierPreparationGen = 16,
86-
GCBarrierPreparationStep = 17
86+
GCBarrierPreparationStep = 17,
87+
SubDomainLocalPathId = 18,
88+
SubDomainOutOfSpace = 19
8789
};
8890

8991
enum class EInsertTableIds : ui8 {

Diff for: ‎ydb/core/tx/columnshard/columnshard_subdomain_path_id.cpp

+120
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,120 @@
1+
#include "columnshard_impl.h"
2+
3+
namespace NKikimr::NColumnShard {
4+
5+
class TTxPersistSubDomainOutOfSpace : public NTabletFlatExecutor::TTransactionBase<TColumnShard> {
6+
public:
7+
TTxPersistSubDomainOutOfSpace(TColumnShard* self, bool outOfSpace)
8+
: TTransactionBase(self)
9+
, OutOfSpace(outOfSpace)
10+
{ }
11+
12+
TTxType GetTxType() const override { return TXTYPE_PERSIST_SUBDOMAIN_OUT_OF_SPACE; }
13+
14+
bool Execute(TTransactionContext& txc, const TActorContext&) override {
15+
NIceDb::TNiceDb db(txc.DB);
16+
17+
if (Self->SpaceWatcher->SubDomainOutOfSpace != OutOfSpace) {
18+
Schema::SaveSpecialValue(db, Schema::EValueIds::SubDomainOutOfSpace, ui64(OutOfSpace ? 1 : 0));
19+
Self->SpaceWatcher->SubDomainOutOfSpace = OutOfSpace;
20+
}
21+
22+
return true;
23+
}
24+
25+
void Complete(const TActorContext&) override {
26+
// nothing
27+
}
28+
29+
private:
30+
const bool OutOfSpace;
31+
};
32+
33+
class TTxPersistSubDomainPathId : public NTabletFlatExecutor::TTransactionBase<TColumnShard> {
34+
public:
35+
TTxPersistSubDomainPathId(TColumnShard* self, ui64 localPathId)
36+
: TTransactionBase(self)
37+
, LocalPathId(localPathId)
38+
{ }
39+
40+
TTxType GetTxType() const override { return TXTYPE_PERSIST_SUBDOMAIN_PATH_ID; }
41+
42+
bool Execute(TTransactionContext& txc, const TActorContext&) override {
43+
if (!Self->SpaceWatcher->SubDomainPathId) {
44+
Self->SpaceWatcher->PersistSubDomainPathId(LocalPathId, txc);
45+
Self->SpaceWatcher->StartWatchingSubDomainPathId();
46+
}
47+
return true;
48+
}
49+
50+
void Complete(const TActorContext&) override {
51+
// nothing
52+
}
53+
54+
private:
55+
const ui64 LocalPathId;
56+
};
57+
58+
void TSpaceWatcher::PersistSubDomainPathId(ui64 localPathId,
59+
NTabletFlatExecutor::TTransactionContext &txc) {
60+
SubDomainPathId = localPathId;
61+
NIceDb::TNiceDb db(txc.DB);
62+
Schema::SaveSpecialValue(db, Schema::EValueIds::SubDomainLocalPathId, localPathId);
63+
}
64+
65+
void TSpaceWatcher::StopWatchingSubDomainPathId() {
66+
if (WatchingSubDomainPathId) {
67+
Send(MakeSchemeCacheID(), new TEvTxProxySchemeCache::TEvWatchRemove());
68+
WatchingSubDomainPathId.reset();
69+
}
70+
}
71+
72+
void TSpaceWatcher::StartWatchingSubDomainPathId() {
73+
if (!SubDomainPathId) {
74+
return;
75+
}
76+
77+
if (!WatchingSubDomainPathId) {
78+
AFL_DEBUG(NKikimrServices::TX_COLUMNSHARD)("started_watching_subdomain", *SubDomainPathId);
79+
Self->Send(MakeSchemeCacheID(), new TEvTxProxySchemeCache::TEvWatchPathId(TPathId(Self->CurrentSchemeShardId, *SubDomainPathId)));
80+
WatchingSubDomainPathId = *SubDomainPathId;
81+
}
82+
}
83+
84+
void TSpaceWatcher::Handle(NActors::TEvents::TEvPoison::TPtr& , const TActorContext& ctx) {
85+
Die(ctx);
86+
}
87+
88+
void TColumnShard::Handle(TEvTxProxySchemeCache::TEvWatchNotifyUpdated::TPtr& ev, const TActorContext& ctx) {
89+
const auto* msg = ev->Get();
90+
AFL_DEBUG(NKikimrServices::TX_COLUMNSHARD)("notify_subdomain", msg->PathId);
91+
const bool outOfSpace = msg->Result->GetPathDescription()
92+
.GetDomainDescription()
93+
.GetDomainState()
94+
.GetDiskQuotaExceeded();
95+
96+
Execute(new TTxPersistSubDomainOutOfSpace(this, outOfSpace), ctx);
97+
}
98+
99+
static constexpr TDuration MaxFindSubDomainPathIdDelay = TDuration::Minutes(10);
100+
101+
void TSpaceWatcher::StartFindSubDomainPathId(bool delayFirstRequest) {
102+
if (!FindSubDomainPathIdActor &&
103+
Self->CurrentSchemeShardId != 0 &&
104+
(!SubDomainPathId))
105+
{
106+
FindSubDomainPathIdActor = Register(CreateFindSubDomainPathIdActor(SelfId(), Self->TabletID(), Self->CurrentSchemeShardId, delayFirstRequest, MaxFindSubDomainPathIdDelay));
107+
}
108+
}
109+
110+
111+
void TSpaceWatcher::Handle(NSchemeShard::TEvSchemeShard::TEvSubDomainPathIdFound::TPtr& ev, const TActorContext& ctx) {
112+
const auto* msg = ev->Get();
113+
if (FindSubDomainPathIdActor == ev->Sender) {
114+
FindSubDomainPathIdActor = { };
115+
}
116+
AFL_INFO(NKikimrServices::TX_COLUMNSHARD)("event", "subdomain_found")("scheme_shard_id", msg->SchemeShardId)("local_path_id", msg->LocalPathId);
117+
Self->Execute(new TTxPersistSubDomainPathId(Self, msg->LocalPathId), ctx);
118+
}
119+
120+
}

Diff for: ‎ydb/core/tx/columnshard/columnshard_subdomain_path_id.h

+56
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,56 @@
1+
#pragma once
2+
3+
#include <ydb/library/actors/core/actorid.h>
4+
#include <ydb/core/tx/scheme_cache/scheme_cache.h>
5+
6+
namespace NKikimr::NColumnShard::NLoading {
7+
class TSpecialValuesInitializer;
8+
};
9+
10+
namespace NKikimr::NColumnShard {
11+
12+
class TSpaceWatcher : public TActorBootstrapped<TSpaceWatcher> {
13+
TColumnShard* Self;
14+
NActors::TActorId FindSubDomainPathIdActor;
15+
std::optional<NKikimr::TLocalPathId> SubDomainPathId;
16+
std::optional<NKikimr::TLocalPathId> WatchingSubDomainPathId;
17+
bool SubDomainOutOfSpace = false;
18+
19+
public:
20+
friend class TColumnShard;
21+
friend class TTxInit;
22+
friend class TTxPersistSubDomainOutOfSpace;
23+
friend class TTxPersistSubDomainPathId;
24+
friend class NKikimr::NColumnShard::NLoading::TSpecialValuesInitializer;
25+
26+
public:
27+
TSpaceWatcher(TColumnShard* self)
28+
: Self(self) {
29+
}
30+
31+
void PersistSubDomainPathId(ui64 localPathId, NTabletFlatExecutor::TTransactionContext &txc);
32+
void StopWatchingSubDomainPathId();
33+
void StartWatchingSubDomainPathId();
34+
void StartFindSubDomainPathId(bool delayFirstRequest = true);
35+
36+
void Bootstrap(const TActorContext& /*ctx*/) {
37+
Become(&TThis::StateWork);
38+
}
39+
40+
void Handle(TEvTxProxySchemeCache::TEvWatchNotifyUpdated::TPtr& ev, const TActorContext& ctx);
41+
void Handle(NSchemeShard::TEvSchemeShard::TEvSubDomainPathIdFound::TPtr& ev, const TActorContext&);
42+
void Handle(NActors::TEvents::TEvPoison::TPtr& ev, const TActorContext&);
43+
44+
STFUNC(StateWork) {
45+
switch (ev->GetTypeRewrite()) {
46+
HFunc(NSchemeShard::TEvSchemeShard::TEvSubDomainPathIdFound, Handle);
47+
HFunc(NActors::TEvents::TEvPoison, Handle);
48+
default:
49+
LOG_S_WARN("TSpaceWatcher.StateWork at " << " unhandled event type: " << ev->GetTypeName()
50+
<< " event: " << ev->ToString());
51+
break;
52+
}
53+
}
54+
};
55+
56+
}

0 commit comments

Comments
 (0)