Skip to content

Commit cf465d4

Browse files
alexvrualexvru
committed
Fix shred interface in PDisk
1 parent 52b2390 commit cf465d4

File tree

23 files changed

+922
-75
lines changed

23 files changed

+922
-75
lines changed

‎ydb/core/blobstorage/nodewarden/node_warden_impl.cpp

Lines changed: 96 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -100,6 +100,8 @@ STATEFN(TNodeWarden::StateOnline) {
100100
hFunc(TEvTabletPipe::TEvClientDestroyed, Handle);
101101

102102
hFunc(NPDisk::TEvSlayResult, Handle);
103+
hFunc(NPDisk::TEvShredPDiskResult, Handle);
104+
hFunc(NPDisk::TEvShredPDisk, Handle);
103105

104106
hFunc(TEvRegisterPDiskLoadActor, Handle);
105107

@@ -575,6 +577,50 @@ void TNodeWarden::Handle(NPDisk::TEvSlayResult::TPtr ev) {
575577
};
576578
}
577579

580+
void TNodeWarden::Handle(NPDisk::TEvShredPDiskResult::TPtr ev) {
581+
ProcessShredStatus(ev->Cookie, ev->Get()->ShredGeneration, ev->Get()->Status == NKikimrProto::OK ? std::nullopt :
582+
std::make_optional(TStringBuilder() << "failed to shred PDisk Status# " << NKikimrProto::EReplyStatus_Name(
583+
ev->Get()->Status)));
584+
}
585+
586+
void TNodeWarden::Handle(NPDisk::TEvShredPDisk::TPtr ev) {
587+
// the message has returned to sender -- PDisk was terminated before processing it; normally it must never happen,
588+
// because NodeWarden issues PoisonPill synchronously with removing PDisk from the LocalPDisks set
589+
ProcessShredStatus(ev->Cookie, ev->Get()->ShredGeneration, "PDisk has been terminated before it got shredded");
590+
Y_DEBUG_ABORT("unexpected case");
591+
}
592+
593+
void TNodeWarden::ProcessShredStatus(ui64 cookie, ui64 generation, std::optional<TString> error) {
594+
const auto it = ShredInFlight.find(cookie);
595+
const std::optional<TPDiskKey> key = it != ShredInFlight.end() ? std::make_optional(it->second) : std::nullopt;
596+
if (it != ShredInFlight.end()) {
597+
ShredInFlight.erase(it);
598+
}
599+
600+
const auto pdiskIt = key ? LocalPDisks.find(*key) : LocalPDisks.end();
601+
TPDiskRecord *pdisk = pdiskIt != LocalPDisks.end() ? &pdiskIt->second : nullptr;
602+
if (pdisk) {
603+
const size_t numErased = pdisk->ShredCookies.erase(cookie);
604+
Y_ABORT_UNLESS(numErased);
605+
}
606+
607+
STLOG(PRI_DEBUG, BS_SHRED, BSSN00, "processing shred result from PDisk",
608+
(Cookie, cookie),
609+
(PDiskId, key),
610+
(ShredGeneration, generation),
611+
(ErrorReason, error),
612+
(ShredGenerationIssued, pdisk ? pdisk->ShredGenerationIssued : std::nullopt));
613+
614+
if (pdisk && generation == pdisk->ShredGenerationIssued) {
615+
if (error) {
616+
pdisk->ShredState.emplace<TString>(std::move(*error));
617+
} else {
618+
pdisk->ShredState.emplace<ui64>(generation);
619+
}
620+
SendPDiskReport(key->PDiskId, NKikimrBlobStorage::TEvControllerNodeReport::PD_SHRED, pdisk->ShredState);
621+
}
622+
}
623+
578624
void TNodeWarden::Handle(TEvRegisterPDiskLoadActor::TPtr ev) {
579625
Send(ev.Get()->Sender, new TEvRegisterPDiskLoadActorResult(NextLocalPDiskInitOwnerRound()));
580626
}
@@ -609,6 +655,56 @@ void TNodeWarden::Handle(TEvBlobStorage::TEvControllerNodeServiceSetUpdate::TPtr
609655
ApplyGroupInfo(groupId, generation, nullptr, false, false);
610656
}
611657
}
658+
659+
if (record.HasShredRequest()) {
660+
const auto& request = record.GetShredRequest();
661+
const ui64 generation = request.GetShredGeneration();
662+
for (ui32 pdiskId : request.GetPDiskIds()) {
663+
const TPDiskKey key(LocalNodeId, pdiskId);
664+
if (const auto it = LocalPDisks.find(key); it != LocalPDisks.end()) {
665+
TPDiskRecord& pdisk = it->second;
666+
667+
auto issueShredRequestToPDisk = [&] {
668+
const ui64 cookie = ++LastShredCookie;
669+
ShredInFlight.emplace(cookie, key);
670+
pdisk.ShredCookies.insert(cookie);
671+
672+
const TActorId actorId = SelfId();
673+
auto ev = std::make_unique<NPDisk::TEvShredPDisk>(generation);
674+
TActivationContext::Send(new IEventHandle(MakeBlobStoragePDiskID(LocalNodeId, pdiskId), SelfId(),
675+
ev.release(), IEventHandle::FlagForwardOnNondelivery, cookie, &actorId));
676+
pdisk.ShredGenerationIssued.emplace(generation);
677+
678+
STLOG(PRI_DEBUG, BS_SHRED, BSSN01, "sending shred query to PDisk",
679+
(Cookie, cookie),
680+
(PDiskId, key),
681+
(ShredGeneration, generation));
682+
};
683+
684+
if (pdisk.ShredGenerationIssued == generation) {
685+
std::visit(TOverloaded{
686+
[&](std::monostate&) {
687+
// shredding is in progress, do nothing
688+
},
689+
[&](ui64& generation) {
690+
// shredding has already completed for this generation, report it
691+
SendPDiskReport(pdiskId, NKikimrBlobStorage::TEvControllerNodeReport::PD_SHRED, generation);
692+
},
693+
[&](TString& /*aborted*/) {
694+
// shredding finished with error last time, restart
695+
issueShredRequestToPDisk();
696+
}
697+
}, pdisk.ShredState);
698+
} else if (pdisk.ShredGenerationIssued < generation) {
699+
issueShredRequestToPDisk();
700+
} else {
701+
SendPDiskReport(pdiskId, NKikimrBlobStorage::TEvControllerNodeReport::PD_SHRED, "obsolete generation");
702+
}
703+
} else {
704+
SendPDiskReport(pdiskId, NKikimrBlobStorage::TEvControllerNodeReport::PD_SHRED, "PDisk not found");
705+
}
706+
}
707+
}
612708
}
613709

614710
void TNodeWarden::SendDropDonorQuery(ui32 nodeId, ui32 pdiskId, ui32 vslotId, const TVDiskID& vdiskId, TDuration backoff) {

‎ydb/core/blobstorage/nodewarden/node_warden_impl.h

Lines changed: 15 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -61,6 +61,10 @@ namespace NKikimr::NStorage {
6161
friend bool operator ==(const TPDiskKey& x, const TPDiskKey& y) {
6262
return x.NodeId == y.NodeId && x.PDiskId == y.PDiskId;
6363
}
64+
65+
TString ToString() const {
66+
return TStringBuilder() << '[' << NodeId << ':' << PDiskId << ']';
67+
}
6468
};
6569

6670
struct TUnreportedMetricTag {};
@@ -78,6 +82,10 @@ namespace NKikimr::NStorage {
7882
ui32 RefCount = 0;
7983
bool Temporary = false;
8084

85+
std::optional<ui64> ShredGenerationIssued;
86+
std::variant<std::monostate, ui64, TString> ShredState; // not issued, finished with generation, aborted
87+
THashSet<ui64> ShredCookies;
88+
8189
TPDiskRecord(NKikimrBlobStorage::TNodeWardenServiceSet::TPDisk record)
8290
: Record(std::move(record))
8391
{}
@@ -113,6 +121,8 @@ namespace NKikimr::NStorage {
113121
std::map<TPDiskKey, TPDiskRecord> LocalPDisks;
114122
TIntrusiveList<TPDiskRecord, TUnreportedMetricTag> PDisksWithUnreportedMetrics;
115123
std::map<ui64, ui32> PDiskRestartRequests;
124+
ui64 LastShredCookie = 0;
125+
THashMap<ui64, TPDiskKey> ShredInFlight;
116126

117127
struct TPDiskByPathInfo {
118128
TPDiskKey RunningPDiskId; // currently running PDiskId
@@ -535,6 +545,9 @@ namespace NKikimr::NStorage {
535545
void Handle(TEvInterconnect::TEvNodeInfo::TPtr ev);
536546
void Handle(TEvInterconnect::TEvNodesInfo::TPtr ev);
537547
void Handle(NPDisk::TEvSlayResult::TPtr ev);
548+
void Handle(NPDisk::TEvShredPDiskResult::TPtr ev);
549+
void Handle(NPDisk::TEvShredPDisk::TPtr ev);
550+
void ProcessShredStatus(ui64 cookie, ui64 generation, std::optional<TString> error);
538551
void Handle(TEvRegisterPDiskLoadActor::TPtr ev);
539552
void Handle(TEvBlobStorage::TEvControllerNodeServiceSetUpdate::TPtr ev);
540553

@@ -543,7 +556,8 @@ namespace NKikimr::NStorage {
543556
void SendVDiskReport(TVSlotId vslotId, const TVDiskID& vdiskId,
544557
NKikimrBlobStorage::TEvControllerNodeReport::EVDiskPhase phase, TDuration backoff = {});
545558

546-
void SendPDiskReport(ui32 pdiskId, NKikimrBlobStorage::TEvControllerNodeReport::EPDiskPhase phase);
559+
void SendPDiskReport(ui32 pdiskId, NKikimrBlobStorage::TEvControllerNodeReport::EPDiskPhase phase,
560+
std::variant<std::monostate, ui64, TString> shredState = {});
547561

548562
void Handle(TEvBlobStorage::TEvControllerUpdateDiskStatus::TPtr ev);
549563
void Handle(TEvBlobStorage::TEvControllerGroupMetricsExchange::TPtr ev);

‎ydb/core/blobstorage/nodewarden/node_warden_pdisk.cpp

Lines changed: 16 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -224,6 +224,9 @@ namespace NKikimr::NStorage {
224224
Y_ABORT_UNLESS(jt != PDiskByPath.end() && jt->second.RunningPDiskId == it->first);
225225
pending = std::move(jt->second.Pending);
226226
PDiskByPath.erase(jt);
227+
for (ui64 cookie : it->second.ShredCookies) {
228+
ShredInFlight.erase(cookie);
229+
}
227230
LocalPDisks.erase(it);
228231
PDiskRestartInFlight.erase(pdiskId);
229232

@@ -250,14 +253,26 @@ namespace NKikimr::NStorage {
250253
}
251254
}
252255

253-
void TNodeWarden::SendPDiskReport(ui32 pdiskId, NKikimrBlobStorage::TEvControllerNodeReport::EPDiskPhase phase) {
256+
void TNodeWarden::SendPDiskReport(ui32 pdiskId, NKikimrBlobStorage::TEvControllerNodeReport::EPDiskPhase phase,
257+
std::variant<std::monostate, ui64, TString> shredState) {
254258
STLOG(PRI_DEBUG, BS_NODE, NW41, "SendPDiskReport", (PDiskId, pdiskId), (Phase, phase));
255259

256260
auto report = std::make_unique<TEvBlobStorage::TEvControllerNodeReport>(LocalNodeId);
257261
auto *pReport = report->Record.AddPDiskReports();
258262
pReport->SetPDiskId(pdiskId);
259263
pReport->SetPhase(phase);
260264

265+
const TPDiskKey key(LocalNodeId, pdiskId);
266+
if (const auto it = LocalPDisks.find(key); it != LocalPDisks.end() && it->second.Record.HasPDiskGuid()) {
267+
pReport->SetPDiskGuid(it->second.Record.GetPDiskGuid());
268+
}
269+
270+
std::visit(TOverloaded{
271+
[](std::monostate&) {},
272+
[pReport](ui64& generation) { pReport->SetShredGenerationFinished(generation); },
273+
[pReport](TString& aborted) { pReport->SetShredAborted(aborted); }
274+
}, shredState);
275+
261276
SendToController(std::move(report));
262277
}
263278

‎ydb/core/blobstorage/nodewarden/node_warden_pipe.cpp

Lines changed: 15 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -83,6 +83,21 @@ void TNodeWarden::SendRegisterNode() {
8383
FillInVDiskStatus(ev->Record.MutableVDiskStatus(), true);
8484
ev->Record.SetDeclarativePDiskManagement(true);
8585

86+
for (const auto& [key, pdisk] : LocalPDisks) {
87+
if (pdisk.ShredGenerationIssued) {
88+
auto *item = ev->Record.AddShredStatus();
89+
item->SetPDiskId(key.PDiskId);
90+
if (pdisk.Record.HasPDiskGuid()) {
91+
item->SetPDiskGuid(pdisk.Record.GetPDiskGuid());
92+
}
93+
std::visit(TOverloaded{
94+
[item](const std::monostate&) { item->SetShredInProgress(true); },
95+
[item](const ui64& generation) { item->SetShredGenerationFinished(generation); },
96+
[item](const TString& aborted) { item->SetShredAborted(aborted); }
97+
}, pdisk.ShredState);
98+
}
99+
}
100+
86101
SendToController(std::move(ev));
87102
}
88103

‎ydb/core/blobstorage/pdisk/blobstorage_pdisk_actor.cpp

Lines changed: 8 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -65,11 +65,13 @@ class TPDiskActor : public TActorBootstrapped<TPDiskActor> {
6565
ui32 SlotId = 0;
6666
bool IsShred = false;
6767
ui64 ShredGeneration = 0;
68+
ui64 Cookie;
6869

69-
TInitQueueItem(const TActorId sender, const ui64 shredGeneration)
70+
TInitQueueItem(const TActorId sender, const ui64 shredGeneration, ui64 cookie)
7071
: Sender(sender)
7172
, IsShred(true)
7273
, ShredGeneration(shredGeneration)
74+
, Cookie(cookie)
7375
{}
7476

7577
TInitQueueItem(TOwnerRound ownerRound, TVDiskID vDisk, ui64 pDiskGuid, TActorId sender, TActorId cutLogId,
@@ -299,7 +301,7 @@ class TPDiskActor : public TActorBootstrapped<TPDiskActor> {
299301
Become(&TThis::StateError);
300302
for (TList<TInitQueueItem>::iterator it = InitQueue.begin(); it != InitQueue.end(); ++it) {
301303
if (it->IsShred) {
302-
Send(it->Sender, new NPDisk::TEvShredPDiskResult(NKikimrProto::CORRUPTED, it->ShredGeneration, errorReason));
304+
Send(it->Sender, new NPDisk::TEvShredPDiskResult(NKikimrProto::CORRUPTED, it->ShredGeneration, errorReason), 0, it->Cookie);
303305
if (PDisk) {
304306
PDisk->Mon.ShredPDisk.CountResponse();
305307
}
@@ -617,6 +619,7 @@ class TPDiskActor : public TActorBootstrapped<TPDiskActor> {
617619
if (it->IsShred) {
618620
NPDisk::TEvShredPDisk evShredPDisk(it->ShredGeneration);
619621
auto* request = PDisk->ReqCreator.CreateFromEv<NPDisk::TShredPDisk>(evShredPDisk, it->Sender);
622+
request->Cookie = it->Cookie;
620623
PDisk->InputRequest(request);
621624
} else {
622625
NPDisk::TEvYardInit evInit(it->OwnerRound, it->VDisk, it->PDiskGuid, it->CutLogId, it->WhiteboardProxyId,
@@ -667,7 +670,7 @@ class TPDiskActor : public TActorBootstrapped<TPDiskActor> {
667670

668671
void InitHandle(NPDisk::TEvShredPDisk::TPtr &ev) {
669672
const NPDisk::TEvShredPDisk &evShredPDisk = *ev->Get();
670-
InitQueue.emplace_back(ev->Sender, evShredPDisk.ShredGeneration);
673+
InitQueue.emplace_back(ev->Sender, evShredPDisk.ShredGeneration, ev->Cookie);
671674
}
672675

673676
void InitHandle(NPDisk::TEvPreShredCompactVDiskResult::TPtr &ev) {
@@ -843,7 +846,7 @@ class TPDiskActor : public TActorBootstrapped<TPDiskActor> {
843846

844847
void ErrorHandle(NPDisk::TEvShredPDisk::TPtr &ev) {
845848
// Respond with error, can't shred in this state.
846-
Send(ev->Sender, new NPDisk::TEvShredPDiskResult(NKikimrProto::CORRUPTED, 0, StateErrorReason));
849+
Send(ev->Sender, new NPDisk::TEvShredPDiskResult(NKikimrProto::CORRUPTED, 0, StateErrorReason), 0, ev->Cookie);
847850
}
848851

849852
void ErrorHandle(NPDisk::TEvPreShredCompactVDiskResult::TPtr &ev) {
@@ -1060,6 +1063,7 @@ class TPDiskActor : public TActorBootstrapped<TPDiskActor> {
10601063

10611064
void Handle(NPDisk::TEvShredPDisk::TPtr &ev) {
10621065
auto* request = PDisk->ReqCreator.CreateFromEv<TShredPDisk>(*ev->Get(), ev->Sender);
1066+
request->Cookie = ev->Cookie;
10631067
PDisk->InputRequest(request);
10641068
}
10651069

‎ydb/core/blobstorage/pdisk/blobstorage_pdisk_impl.cpp

Lines changed: 20 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -3935,7 +3935,7 @@ void TPDisk::ProgressShredState() {
39353935
<< " sends compact request to VDisk# " << data.VDiskId
39363936
<< " ownerId# " << ownerId
39373937
<< " request# " << compactRequest->ToString());
3938-
PCtx->ActorSystem->Send(data.CutLogId, compactRequest.Release());
3938+
PCtx->ActorSystem->Send(new IEventHandle(data.CutLogId, PCtx->PDiskActor, compactRequest.Release()));
39393939
data.LastShredGeneration = ShredGeneration;
39403940
data.ShredState = TOwnerData::VDISK_SHRED_STATE_COMPACT_REQUESTED;
39413941
}
@@ -3984,7 +3984,7 @@ void TPDisk::ProgressShredState() {
39843984
<< " sends shred request to VDisk# " << data.VDiskId
39853985
<< " ownerId# " << ownerId
39863986
<< " request# " << shredRequest->ToString());
3987-
PCtx->ActorSystem->Send(data.CutLogId, shredRequest.Release());
3987+
PCtx->ActorSystem->Send(new IEventHandle(data.CutLogId, PCtx->PDiskActor, shredRequest.Release()));
39883988
data.ShredState = TOwnerData::VDISK_SHRED_STATE_SHRED_REQUESTED;
39893989
data.LastShredGeneration = ShredGeneration;
39903990
}
@@ -4011,8 +4011,9 @@ void TPDisk::ProgressShredState() {
40114011
LOG_NOTICE_S(*PCtx->ActorSystem, NKikimrServices::BS_PDISK_SHRED,
40124012
"Shred request is finished at PDisk# " << PCtx->PDiskId
40134013
<< " ShredGeneration# " << ShredGeneration);
4014-
for (TActorId &requester : ShredRequesters) {
4015-
PCtx->ActorSystem->Send(requester, new TEvShredPDiskResult(NKikimrProto::OK, ShredGeneration, ""));
4014+
for (auto& [requester, cookie] : ShredRequesters) {
4015+
PCtx->ActorSystem->Send(new IEventHandle(requester, PCtx->PDiskActor, new TEvShredPDiskResult(
4016+
NKikimrProto::OK, ShredGeneration, ""), 0, cookie));
40164017
}
40174018
ShredRequesters.clear();
40184019
}
@@ -4029,27 +4030,28 @@ void TPDisk::ProcessShredPDisk(TShredPDisk& request) {
40294030
TGuard<TMutex> guard(StateMutex);
40304031
if (request.ShredGeneration < ShredGeneration) {
40314032
guard.Release();
4032-
PCtx->ActorSystem->Send(request.Sender,
4033-
new TEvShredPDiskResult(NKikimrProto::RACE, request.ShredGeneration,
4034-
"A shred request with a higher generation is already in progress"));
4033+
PCtx->ActorSystem->Send(new IEventHandle(request.Sender, PCtx->PDiskActor, new TEvShredPDiskResult(
4034+
NKikimrProto::RACE, request.ShredGeneration, "A shred request with a higher generation is already in progress"),
4035+
0, request.Cookie));
40354036
return;
40364037
}
40374038
if (request.ShredGeneration == ShredGeneration) {
40384039
// Do nothing, since we already have a shred request with the same generation.
40394040
// Just add the sender to the list of requesters.
4040-
ShredRequesters.push_back(request.Sender);
4041+
ShredRequesters.emplace_back(request.Sender, request.Cookie);
40414042
return;
40424043
}
40434044
// ShredGeneration > request.ShredGeneration
40444045
if (ShredRequesters.size() > 0) {
4045-
for (TActorId &requester : ShredRequesters) {
4046-
PCtx->ActorSystem->Send(requester, new TEvShredPDiskResult(NKikimrProto::RACE, request.ShredGeneration,
4047-
"A shred request with a higher generation is received"));
4046+
for (auto& [requester, cookie] : ShredRequesters) {
4047+
PCtx->ActorSystem->Send(new IEventHandle(requester, PCtx->PDiskActor, new TEvShredPDiskResult(
4048+
NKikimrProto::RACE, request.ShredGeneration, "A shred request with a higher generation is received"), 0,
4049+
cookie));
40484050
}
40494051
ShredRequesters.clear();
40504052
}
40514053
ShredGeneration = request.ShredGeneration;
4052-
ShredRequesters.push_back(request.Sender);
4054+
ShredRequesters.emplace_back(request.Sender, request.Cookie);
40534055
ShredState = EShredStateSendPreShredCompactVDisk;
40544056
ProgressShredState();
40554057
}
@@ -4094,7 +4096,7 @@ void TPDisk::ProcessPreShredCompactVDiskResult(TPreShredCompactVDiskResult& requ
40944096
}
40954097
if (request.Status != NKikimrProto::OK) {
40964098
ShredState = EShredStateFailed;
4097-
for (TActorId &requester : ShredRequesters) {
4099+
for (auto& [requester, cookie] : ShredRequesters) {
40984100
TStringStream str;
40994101
str << "Shred request failed at PDisk# " << PCtx->PDiskId
41004102
<< " for shredGeneration# " << request.ShredGeneration
@@ -4103,8 +4105,8 @@ void TPDisk::ProcessPreShredCompactVDiskResult(TPreShredCompactVDiskResult& requ
41034105
<< " replied with PreShredCompactVDiskResult status# " << request.Status
41044106
<< " and ErrorReason# " << request.ErrorReason;
41054107
LOG_ERROR_S(*PCtx->ActorSystem, NKikimrServices::BS_PDISK_SHRED, str.Str());
4106-
PCtx->ActorSystem->Send(requester, new TEvShredPDiskResult(NKikimrProto::ERROR, request.ShredGeneration,
4107-
str.Str()));
4108+
PCtx->ActorSystem->Send(new IEventHandle(requester, PCtx->PDiskActor, new TEvShredPDiskResult(
4109+
NKikimrProto::ERROR, request.ShredGeneration, str.Str()), 0, cookie));
41084110
}
41094111
ShredRequesters.clear();
41104112
return;
@@ -4153,7 +4155,7 @@ void TPDisk::ProcessShredVDiskResult(TShredVDiskResult& request) {
41534155
}
41544156
if (request.Status != NKikimrProto::OK) {
41554157
ShredState = EShredStateFailed;
4156-
for (TActorId &requester : ShredRequesters) {
4158+
for (auto& [requester, cookie] : ShredRequesters) {
41574159
TStringStream str;
41584160
str << "Shred request failed at PDisk# " << PCtx->PDiskId
41594161
<< " for shredGeneration# " << request.ShredGeneration
@@ -4162,8 +4164,8 @@ void TPDisk::ProcessShredVDiskResult(TShredVDiskResult& request) {
41624164
<< " replied with status# " << request.Status
41634165
<< " and ErrorReason# " << request.ErrorReason;
41644166
LOG_ERROR_S(*PCtx->ActorSystem, NKikimrServices::BS_PDISK_SHRED, str.Str());
4165-
PCtx->ActorSystem->Send(requester, new TEvShredPDiskResult(NKikimrProto::ERROR, request.ShredGeneration,
4166-
str.Str()));
4167+
PCtx->ActorSystem->Send(new IEventHandle(requester, PCtx->PDiskActor, new TEvShredPDiskResult(
4168+
NKikimrProto::ERROR, request.ShredGeneration, str.Str()), 0, cookie));
41674169
}
41684170
ShredRequesters.clear();
41694171
return;

0 commit comments

Comments
 (0)