Skip to content

Commit 6e37da6

Browse files
alexvrualexvru
authored
Merge 5abf5a8 into 14c83d5 
2 parents 14c83d5 + 5abf5a8 commit 6e37da6

File tree

13 files changed

+87
-66
lines changed

13 files changed

+87
-66
lines changed

‎ydb/core/blobstorage/dsproxy/dsproxy.h

Lines changed: 1 addition & 19 deletions
Original file line numberDiff line numberDiff line change
@@ -91,24 +91,6 @@ struct TEvLatencyReport : public TEventLocal<TEvLatencyReport, TEvBlobStorage::E
9191
{}
9292
};
9393

94-
struct TNodeLayoutInfo : TThrRefBase {
95-
// indexed by NodeId
96-
TNodeLocation SelfLocation;
97-
TVector<TNodeLocation> LocationPerOrderNumber;
98-
99-
TNodeLayoutInfo(const TNodeLocation& selfLocation, const TIntrusivePtr<TBlobStorageGroupInfo>& info,
100-
std::unordered_map<ui32, TNodeLocation>& map)
101-
: SelfLocation(selfLocation)
102-
, LocationPerOrderNumber(info->GetTotalVDisksNum())
103-
{
104-
for (ui32 i = 0; i < LocationPerOrderNumber.size(); ++i) {
105-
LocationPerOrderNumber[i] = map[info->GetActorId(i).NodeId()];
106-
}
107-
}
108-
};
109-
110-
using TNodeLayoutInfoPtr = TIntrusivePtr<TNodeLayoutInfo>;
111-
11294
inline TStoragePoolCounters::EHandleClass HandleClassToHandleClass(NKikimrBlobStorage::EGetHandleClass handleClass) {
11395
switch (handleClass) {
11496
case NKikimrBlobStorage::FastRead:
@@ -545,7 +527,7 @@ struct TBlobStorageProxyParameters {
545527
TBlobStorageProxyControlWrappers Controls;
546528
};
547529

548-
IActor* CreateBlobStorageGroupProxyConfigured(TIntrusivePtr<TBlobStorageGroupInfo>&& info,
530+
IActor* CreateBlobStorageGroupProxyConfigured(TIntrusivePtr<TBlobStorageGroupInfo>&& info, TNodeLayoutInfoPtr nodeLayoutInfo,
549531
bool forceWaitAllDrives, TIntrusivePtr<TDsProxyNodeMon> &nodeMon,
550532
TIntrusivePtr<TStoragePoolCounters>&& storagePoolCounters, const TBlobStorageProxyParameters& params);
551533

‎ydb/core/blobstorage/dsproxy/dsproxy_impl.cpp

Lines changed: 8 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -4,9 +4,9 @@ namespace NKikimr {
44

55
std::atomic<TMonotonic> TBlobStorageGroupProxy::ThrottlingTimestamp;
66

7-
TBlobStorageGroupProxy::TBlobStorageGroupProxy(TIntrusivePtr<TBlobStorageGroupInfo>&& info, bool forceWaitAllDrives,
8-
TIntrusivePtr<TDsProxyNodeMon> &nodeMon, TIntrusivePtr<TStoragePoolCounters>&& storagePoolCounters,
9-
const TBlobStorageProxyParameters& params)
7+
TBlobStorageGroupProxy::TBlobStorageGroupProxy(TIntrusivePtr<TBlobStorageGroupInfo>&& info,
8+
TNodeLayoutInfoPtr nodeLayoutInfo, bool forceWaitAllDrives, TIntrusivePtr<TDsProxyNodeMon> &nodeMon,
9+
TIntrusivePtr<TStoragePoolCounters>&& storagePoolCounters, const TBlobStorageProxyParameters& params)
1010
: GroupId(info->GroupID)
1111
, Info(std::move(info))
1212
, Topology(Info->PickTopology())
@@ -15,10 +15,11 @@ namespace NKikimr {
1515
, IsEjected(false)
1616
, ForceWaitAllDrives(forceWaitAllDrives)
1717
, UseActorSystemTimeInBSQueue(params.UseActorSystemTimeInBSQueue)
18+
, NodeLayoutInfo(std::move(nodeLayoutInfo))
1819
, Controls(std::move(params.Controls))
1920
{}
2021

21-
TBlobStorageGroupProxy::TBlobStorageGroupProxy(ui32 groupId, bool isEjected,TIntrusivePtr<TDsProxyNodeMon> &nodeMon,
22+
TBlobStorageGroupProxy::TBlobStorageGroupProxy(ui32 groupId, bool isEjected, TIntrusivePtr<TDsProxyNodeMon> &nodeMon,
2223
const TBlobStorageProxyParameters& params)
2324
: GroupId(TGroupId::FromValue(groupId))
2425
, NodeMon(nodeMon)
@@ -39,11 +40,12 @@ namespace NKikimr {
3940
);
4041
}
4142

42-
IActor* CreateBlobStorageGroupProxyConfigured(TIntrusivePtr<TBlobStorageGroupInfo>&& info, bool forceWaitAllDrives,
43+
IActor* CreateBlobStorageGroupProxyConfigured(TIntrusivePtr<TBlobStorageGroupInfo>&& info,
44+
TNodeLayoutInfoPtr nodeLayoutInfo, bool forceWaitAllDrives,
4345
TIntrusivePtr<TDsProxyNodeMon> &nodeMon, TIntrusivePtr<TStoragePoolCounters>&& storagePoolCounters,
4446
const TBlobStorageProxyParameters& params) {
4547
Y_ABORT_UNLESS(info);
46-
return new TBlobStorageGroupProxy(std::move(info), forceWaitAllDrives, nodeMon,
48+
return new TBlobStorageGroupProxy(std::move(info), std::move(nodeLayoutInfo), forceWaitAllDrives, nodeMon,
4749
std::move(storagePoolCounters), params);
4850
}
4951

‎ydb/core/blobstorage/dsproxy/dsproxy_impl.h

Lines changed: 6 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -180,7 +180,8 @@ class TBlobStorageGroupProxy : public TActorBootstrapped<TBlobStorageGroupProxy>
180180
std::optional<TCypherKey> CypherKey;
181181

182182
void Handle(TEvBlobStorage::TEvConfigureProxy::TPtr ev);
183-
void ApplyGroupInfo(TIntrusivePtr<TBlobStorageGroupInfo>&& info, TIntrusivePtr<TStoragePoolCounters>&& counters);
183+
void ApplyGroupInfo(TIntrusivePtr<TBlobStorageGroupInfo>&& info, TNodeLayoutInfoPtr nodeLayoutInfo,
184+
TIntrusivePtr<TStoragePoolCounters>&& counters);
184185

185186
void WakeupUnconfigured(TEvConfigureQueryTimeout::TPtr ev);
186187

@@ -319,17 +320,15 @@ class TBlobStorageGroupProxy : public TActorBootstrapped<TBlobStorageGroupProxy>
319320
return NKikimrServices::TActivity::BS_PROXY_ACTOR;
320321
}
321322

322-
TBlobStorageGroupProxy(TIntrusivePtr<TBlobStorageGroupInfo>&& info, bool forceWaitAllDrives,
323-
TIntrusivePtr<TDsProxyNodeMon> &nodeMon, TIntrusivePtr<TStoragePoolCounters>&& storagePoolCounters,
324-
const TBlobStorageProxyParameters& params);
323+
TBlobStorageGroupProxy(TIntrusivePtr<TBlobStorageGroupInfo>&& info, TNodeLayoutInfoPtr nodeLayoutInfo,
324+
bool forceWaitAllDrives, TIntrusivePtr<TDsProxyNodeMon> &nodeMon,
325+
TIntrusivePtr<TStoragePoolCounters>&& storagePoolCounters, const TBlobStorageProxyParameters& params);
325326

326327
TBlobStorageGroupProxy(ui32 groupId, bool isEjected, TIntrusivePtr<TDsProxyNodeMon> &nodeMon,
327-
const TBlobStorageProxyParameters& params);
328+
const TBlobStorageProxyParameters& params);
328329

329330
void Bootstrap();
330331

331-
void Handle(TEvInterconnect::TEvNodesInfo::TPtr& ev);
332-
333332
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
334333
// Configuration process
335334

@@ -358,7 +357,6 @@ class TBlobStorageGroupProxy : public TActorBootstrapped<TBlobStorageGroupProxy>
358357
hFunc(TEvBlobStorage::TEvBunchOfEvents, Handle);
359358
hFunc(TEvTimeStats, Handle);
360359
cFunc(TEvents::TSystem::Poison, PassAway);
361-
hFunc(TEvInterconnect::TEvNodesInfo, Handle);
362360
hFunc(TEvBlobStorage::TEvConfigureProxy, Handle);
363361
hFunc(TEvProxyQueueState, Handle);
364362
cFunc(EvUpdateResponsiveness, HandleUpdateResponsiveness);

‎ydb/core/blobstorage/dsproxy/dsproxy_state.cpp

Lines changed: 14 additions & 21 deletions
Original file line numberDiff line numberDiff line change
@@ -85,21 +85,29 @@ namespace NKikimr {
8585

8686
void TBlobStorageGroupProxy::Handle(TEvBlobStorage::TEvConfigureProxy::TPtr ev) {
8787
auto *msg = ev->Get();
88-
ApplyGroupInfo(std::move(msg->Info), std::move(msg->StoragePoolCounters));
88+
ApplyGroupInfo(std::move(msg->Info), std::move(msg->NodeLayoutInfo), std::move(msg->StoragePoolCounters));
8989
}
9090

9191
void TBlobStorageGroupProxy::ApplyGroupInfo(TIntrusivePtr<TBlobStorageGroupInfo>&& info,
92-
TIntrusivePtr<TStoragePoolCounters>&& counters) {
93-
Info = std::move(info);
92+
TNodeLayoutInfoPtr nodeLayoutInfo, TIntrusivePtr<TStoragePoolCounters>&& counters) {
93+
auto prevInfo = std::exchange(Info, std::move(info));
9494
if (Info) {
9595
if (Topology) {
9696
Y_DEBUG_ABORT_UNLESS(Topology->EqualityCheck(Info->GetTopology()));
9797
} else {
9898
Topology = Info->PickTopology();
9999
}
100100
}
101-
NodeLayoutInfo = nullptr;
102-
Send(MonActor, new TEvBlobStorage::TEvConfigureProxy(Info));
101+
NodeLayoutInfo = std::move(nodeLayoutInfo);
102+
if (counters) {
103+
StoragePoolCounters = std::move(counters);
104+
}
105+
106+
if (prevInfo && Info && prevInfo->GroupGeneration == Info->GroupGeneration) {
107+
return; // group did not actually change
108+
}
109+
110+
Send(MonActor, new TEvBlobStorage::TEvConfigureProxy(Info, nullptr));
103111
if (Info) {
104112
Y_ABORT_UNLESS(!EncryptionMode || *EncryptionMode == Info->GetEncryptionMode());
105113
Y_ABORT_UNLESS(!LifeCyclePhase || *LifeCyclePhase == Info->GetLifeCyclePhase());
@@ -109,10 +117,6 @@ namespace NKikimr {
109117
LifeCyclePhase = Info->GetLifeCyclePhase();
110118
GroupKeyNonce = Info->GetGroupKeyNonce();
111119
CypherKey = *Info->GetCypherKey();
112-
Send(GetNameserviceActorId(), new TEvInterconnect::TEvListNodes(true));
113-
}
114-
if (counters) {
115-
StoragePoolCounters = std::move(counters);
116120
}
117121
IsLimitedKeyless = false;
118122
if (Info && Info->GetEncryptionMode() != TBlobStorageGroupInfo::EEM_NONE) {
@@ -240,22 +244,11 @@ namespace NKikimr {
240244
new IEventHandle(SelfId(), SelfId(), new TEvStopBatchingPutRequests));
241245
StopGetBatchingEvent = static_cast<TEventHandle<TEvStopBatchingGetRequests>*>(
242246
new IEventHandle(SelfId(), SelfId(), new TEvStopBatchingGetRequests));
243-
ApplyGroupInfo(std::exchange(Info, {}), std::exchange(StoragePoolCounters, {}));
247+
ApplyGroupInfo(std::exchange(Info, {}), std::exchange(NodeLayoutInfo, {}), std::exchange(StoragePoolCounters, {}));
244248
CheckDeadlines();
245249
}
246250
}
247251

248-
void TBlobStorageGroupProxy::Handle(TEvInterconnect::TEvNodesInfo::TPtr& ev) {
249-
if (Info) {
250-
std::unordered_map<ui32, TNodeLocation> map;
251-
for (auto& info : ev->Get()->Nodes) {
252-
map[info.NodeId] = std::move(info.Location);
253-
}
254-
NodeLayoutInfo = MakeIntrusive<TNodeLayoutInfo>(map[TlsActivationContext->ExecutorThread.ActorSystem->NodeId],
255-
Info, map);
256-
}
257-
}
258-
259252
void TBlobStorageGroupProxy::PassAway() {
260253
for (const auto& [actorId, _] : ActiveRequests) {
261254
TActivationContext::Send(new IEventHandle(TEvents::TSystem::Poison, 0, actorId, {}, nullptr, 0));

‎ydb/core/blobstorage/dsproxy/ut/dsproxy_env_mock_ut.h

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -81,7 +81,7 @@ struct TDSProxyEnv {
8181
TIntrusivePtr<TStoragePoolCounters> storagePoolCounters = perPoolCounters.GetPoolCounters("pool_name");
8282
TControlWrapper enablePutBatching(DefaultEnablePutBatching, false, true);
8383
TControlWrapper enableVPatch(DefaultEnableVPatch, false, true);
84-
IActor *dsproxy = CreateBlobStorageGroupProxyConfigured(TIntrusivePtr(Info), true, nodeMon,
84+
IActor *dsproxy = CreateBlobStorageGroupProxyConfigured(TIntrusivePtr(Info), nullptr, true, nodeMon,
8585
std::move(storagePoolCounters), TBlobStorageProxyParameters{
8686
.Controls = TBlobStorageProxyControlWrappers{
8787
.EnablePutBatching = enablePutBatching,

‎ydb/core/blobstorage/dsproxy/ut_fat/dsproxy_ut.cpp

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -4230,7 +4230,7 @@ class TBlobStorageProxyTest: public TTestBase {
42304230
TIntrusivePtr<TStoragePoolCounters> storagePoolCounters = perPoolCounters.GetPoolCounters("pool_name");
42314231
TControlWrapper enablePutBatching(args.EnablePutBatching, false, true);
42324232
TControlWrapper enableVPatch(DefaultEnableVPatch, false, true);
4233-
std::unique_ptr<IActor> proxyActor{CreateBlobStorageGroupProxyConfigured(TIntrusivePtr(bsInfo), false,
4233+
std::unique_ptr<IActor> proxyActor{CreateBlobStorageGroupProxyConfigured(TIntrusivePtr(bsInfo), nullptr, false,
42344234
dsProxyNodeMon, TIntrusivePtr(storagePoolCounters),
42354235
TBlobStorageProxyParameters{
42364236
.Controls = TBlobStorageProxyControlWrappers{

‎ydb/core/blobstorage/dsproxy/ut_ftol/dsproxy_fault_tolerance_ut_runtime.h

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -87,7 +87,7 @@ class TFaultToleranceTestRuntime {
8787
TIntrusivePtr<TStoragePoolCounters> storagePoolCounters = perPoolCounters.GetPoolCounters("pool_name");
8888
TControlWrapper enablePutBatching(DefaultEnablePutBatching, false, true);
8989
TControlWrapper enableVPatch(DefaultEnableVPatch, false, true);
90-
IActor *dsproxy = CreateBlobStorageGroupProxyConfigured(TIntrusivePtr(GroupInfo), false, nodeMon,
90+
IActor *dsproxy = CreateBlobStorageGroupProxyConfigured(TIntrusivePtr(GroupInfo), nullptr, false, nodeMon,
9191
std::move(storagePoolCounters), TBlobStorageProxyParameters{
9292
.Controls = TBlobStorageProxyControlWrappers{
9393
.EnablePutBatching = enablePutBatching,

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

Lines changed: 7 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -193,15 +193,19 @@ namespace NKikimr::NStorage {
193193
// we do not have relevant group configuration, but we know that there is one, so reset the configuration
194194
// for group/proxy and ask BSC for group info
195195
group.Info.Reset();
196+
group.NodeLayoutInfo.Reset();
196197
RequestGroupConfig(groupId, group);
197198
if (group.ProxyId) {
198-
Send(group.ProxyId, new TEvBlobStorage::TEvConfigureProxy(nullptr));
199+
Send(group.ProxyId, new TEvBlobStorage::TEvConfigureProxy(nullptr, nullptr));
199200
}
200201
} else if (groupChanged) {
201202
// group has changed; obtain main encryption key for this group and try to parse group info from the protobuf
202203
auto& mainKey = GetGroupMainKey(groupId);
203204
TStringStream err;
204205
group.Info = TBlobStorageGroupInfo::Parse(*currentGroup, &mainKey, &err);
206+
if (group.Info->Type.GetErasure() == TBlobStorageGroupType::ErasureMirror3dc) {
207+
group.NodeLayoutInfo = MakeIntrusive<TNodeLayoutInfo>(NodeLocationMap[LocalNodeId], group.Info, NodeLocationMap);
208+
}
205209
Y_ABORT_UNLESS(group.EncryptionParams.HasEncryptionMode());
206210
if (const TString& s = err.Str()) {
207211
STLOG(PRI_ERROR, BS_NODE, NW19, "error while parsing group", (GroupId, groupId), (Err, s));
@@ -224,7 +228,8 @@ namespace NKikimr::NStorage {
224228

225229
// forward ConfigureProxy anyway, because when we switch to BlobDepot agent, we still need to update
226230
// ds proxy configuration
227-
Send(group.ProxyId, new TEvBlobStorage::TEvConfigureProxy(std::move(info), std::move(counters)));
231+
Send(group.ProxyId, new TEvBlobStorage::TEvConfigureProxy(std::move(info), group.NodeLayoutInfo,
232+
std::move(counters)));
228233
}
229234

230235
if (const auto& info = group.Info) {

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

Lines changed: 17 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -82,6 +82,7 @@ STATEFN(TNodeWarden::StateOnline) {
8282
hFunc(NIncrHuge::TEvIncrHugeInit, HandleIncrHugeInit);
8383

8484
hFunc(TEvInterconnect::TEvNodeInfo, Handle);
85+
hFunc(TEvInterconnect::TEvNodesInfo, Handle);
8586

8687
hFunc(TEvTabletPipe::TEvClientConnected, Handle);
8788
hFunc(TEvTabletPipe::TEvClientDestroyed, Handle);
@@ -417,6 +418,7 @@ void TNodeWarden::Bootstrap() {
417418
EstablishPipe();
418419

419420
Send(GetNameserviceActorId(), new TEvInterconnect::TEvGetNode(LocalNodeId));
421+
Send(GetNameserviceActorId(), new TEvInterconnect::TEvListNodes(true));
420422

421423
if (Cfg->IsCacheEnabled()) {
422424
TActivationContext::Schedule(TDuration::Seconds(5), new IEventHandle(TEvPrivate::EvReadCache, 0, SelfId(), {}, nullptr, 0));
@@ -484,6 +486,21 @@ void TNodeWarden::Handle(TEvInterconnect::TEvNodeInfo::TPtr ev) {
484486
}
485487
}
486488

489+
void TNodeWarden::Handle(TEvInterconnect::TEvNodesInfo::TPtr ev) {
490+
NodeLocationMap.clear();
491+
for (const auto& info : ev->Get()->Nodes) {
492+
NodeLocationMap.emplace(info.NodeId, std::move(info.Location));
493+
}
494+
for (auto& [groupId, group] : Groups) {
495+
if (group.Info && group.Info->Type.GetErasure() == TBlobStorageGroupType::ErasureMirror3dc) {
496+
group.NodeLayoutInfo = MakeIntrusive<TNodeLayoutInfo>(NodeLocationMap[LocalNodeId], group.Info, NodeLocationMap);
497+
if (group.ProxyId) {
498+
Send(group.ProxyId, new TEvBlobStorage::TEvConfigureProxy(group.Info, group.NodeLayoutInfo));
499+
}
500+
}
501+
}
502+
}
503+
487504
void TNodeWarden::Handle(NPDisk::TEvSlayResult::TPtr ev) {
488505
const NPDisk::TEvSlayResult &msg = *ev->Get();
489506
const TVSlotId vslotId(LocalNodeId, msg.PDiskId, msg.VSlotId);

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

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -471,13 +471,15 @@ namespace NKikimr::NStorage {
471471
bool ProposeRequestPending = false; // if true, then we have sent ProposeKey request and waiting for the group
472472
TActorId GroupResolver; // resolver actor id
473473
TIntrusiveList<TVDiskRecord, TGroupRelationTag> VDisksOfGroup;
474+
TNodeLayoutInfoPtr NodeLayoutInfo;
474475
};
475476

476477
std::unordered_map<ui32, TGroupRecord> Groups;
477478
std::unordered_set<ui32> EjectedGroups;
478479
using TGroupPendingQueue = THashMap<ui32, std::deque<std::tuple<TMonotonic, std::unique_ptr<IEventHandle>>>>;
479480
TGroupPendingQueue GroupPendingQueue;
480481
std::set<std::tuple<TMonotonic, TGroupPendingQueue::value_type*>> TimeoutToQueue;
482+
THashMap<ui32, TNodeLocation> NodeLocationMap;
481483

482484
// this function returns group info if possible, or otherwise starts requesting group info and/or proposing key
483485
// if needed
@@ -517,6 +519,7 @@ namespace NKikimr::NStorage {
517519
void Bootstrap();
518520
void HandleReadCache();
519521
void Handle(TEvInterconnect::TEvNodeInfo::TPtr ev);
522+
void Handle(TEvInterconnect::TEvNodesInfo::TPtr ev);
520523
void Handle(NPDisk::TEvSlayResult::TPtr ev);
521524
void Handle(TEvRegisterPDiskLoadActor::TPtr ev);
522525
void Handle(TEvBlobStorage::TEvControllerNodeServiceSetUpdate::TPtr ev);

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

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -45,8 +45,8 @@ void TNodeWarden::StartLocalProxy(ui32 groupId) {
4545
case NKikimrBlobStorage::TGroupDecommitStatus::IN_PROGRESS:
4646
// create proxy that will be used by blob depot agent to fetch underlying data
4747
proxyActorId = as->Register(CreateBlobStorageGroupProxyConfigured(
48-
TIntrusivePtr<TBlobStorageGroupInfo>(info), false, DsProxyNodeMon, getCounters(info),
49-
TBlobStorageProxyParameters{
48+
TIntrusivePtr<TBlobStorageGroupInfo>(info), group.NodeLayoutInfo, false, DsProxyNodeMon,
49+
getCounters(info), TBlobStorageProxyParameters{
5050
.UseActorSystemTimeInBSQueue = Cfg->UseActorSystemTimeInBSQueue,
5151
.Controls = TBlobStorageProxyControlWrappers{
5252
.EnablePutBatching = EnablePutBatching,
@@ -68,8 +68,8 @@ void TNodeWarden::StartLocalProxy(ui32 groupId) {
6868
}
6969
} else {
7070
// create proxy with configuration
71-
proxy.reset(CreateBlobStorageGroupProxyConfigured(TIntrusivePtr<TBlobStorageGroupInfo>(info), false,
72-
DsProxyNodeMon, getCounters(info), TBlobStorageProxyParameters{
71+
proxy.reset(CreateBlobStorageGroupProxyConfigured(TIntrusivePtr<TBlobStorageGroupInfo>(info),
72+
group.NodeLayoutInfo, false, DsProxyNodeMon, getCounters(info), TBlobStorageProxyParameters{
7373
.UseActorSystemTimeInBSQueue = Cfg->UseActorSystemTimeInBSQueue,
7474
.Controls = TBlobStorageProxyControlWrappers{
7575
.EnablePutBatching = EnablePutBatching,

‎ydb/core/blobstorage/ut_group/main.cpp

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -331,7 +331,7 @@ class TTestEnv {
331331

332332
// update group info for proxy
333333
runtime.Send(new IEventHandle(MakeBlobStorageProxyID(Info->GroupID), TActorId(),
334-
new TEvBlobStorage::TEvConfigureProxy(Info, StoragePoolCounters)), 1);
334+
new TEvBlobStorage::TEvConfigureProxy(Info, nullptr, StoragePoolCounters)), 1);
335335
}
336336

337337
void Slay(TTestActorSystem& runtime, TDiskRecord& disk) {
@@ -409,7 +409,7 @@ class TTestEnv {
409409
StoragePoolCounters = MakeIntrusive<TStoragePoolCounters>(proxy, TString(), NPDisk::DEVICE_TYPE_SSD);
410410
TControlWrapper enablePutBatching(DefaultEnablePutBatching, false, true);
411411
TControlWrapper enableVPatch(DefaultEnableVPatch, false, true);
412-
std::unique_ptr<IActor> proxyActor{CreateBlobStorageGroupProxyConfigured(TIntrusivePtr(Info), false, mon,
412+
std::unique_ptr<IActor> proxyActor{CreateBlobStorageGroupProxyConfigured(TIntrusivePtr(Info), nullptr, false, mon,
413413
TIntrusivePtr(StoragePoolCounters), TBlobStorageProxyParameters{
414414
.Controls = TBlobStorageProxyControlWrappers{
415415
.EnablePutBatching = enablePutBatching,

0 commit comments

Comments
 (0)