Skip to content

Commit d2e2246

Browse files
VPolkaVPolka
authored
Merge 214733e into 3c2e65a 
2 parents 3c2e65a + 214733e commit d2e2246

29 files changed

+367
-88
lines changed

‎ydb/core/blobstorage/vdisk/common/blobstorage_status.cpp‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -37,7 +37,7 @@ namespace NKikimr {
3737
SetRacingGroupInfo(record, Result->Record, GroupInfo);
3838
LOG_DEBUG(ctx, BS_VDISK_OTHER, VDISKP(VCtx->VDiskLogPrefix, "TEvVStatusResult Request# {%s} Response# {%s}",
3939
SingleLineProto(record).data(), SingleLineProto(Result->Record).data()));
40-
SendVDiskResponse(ctx, Ev->Sender, Result.release(), Ev->Cookie, Ev->GetChannel(), VCtx);
40+
SendVDiskResponse(ctx, Ev->Sender, Result.release(), {}, Ev->Cookie, Ev->GetChannel(), VCtx);
4141
Die(ctx);
4242
return;
4343
}
@@ -73,7 +73,7 @@ namespace NKikimr {
7373
ctx.Send(NotifyId, new TEvents::TEvActorDied());
7474
LOG_DEBUG(ctx, BS_VDISK_GET,
7575
VDISKP(VCtx->VDiskLogPrefix, "TEvVStatusResult"));
76-
SendVDiskResponse(ctx, Ev->Sender, Result.release(), Ev->Cookie, Ev->GetChannel(), VCtx);
76+
SendVDiskResponse(ctx, Ev->Sender, Result.release(), {}, Ev->Cookie, Ev->GetChannel(), VCtx);
7777
Die(ctx);
7878
}
7979
}

‎ydb/core/blobstorage/vdisk/common/vdisk_context.cpp‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -61,6 +61,7 @@ namespace NKikimr {
6161
, ReplNodeResponseQuoter(std::move(replNodeResponseQuoter))
6262
, CostTracker()
6363
, OOSMonGroup(std::make_shared<NMonGroup::TOutOfSpaceGroup>(VDiskCounters, "subsystem", "oos"))
64+
, ResponseStatusMonGroup(std::make_shared<NMonGroup::TResponseStatusGroup>(VDiskCounters))
6465
, OutOfSpaceState(Top->GetTotalVDisksNum(), Top->GetOrderNumber(ShortSelfVDisk))
6566
, CostMonGroup(vdiskCounters, "subsystem", "cost")
6667
, Logger(as ? ActorSystemLogger(as) : DevNullLogger())

‎ydb/core/blobstorage/vdisk/common/vdisk_context.h‎

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -77,6 +77,9 @@ namespace NKikimr {
7777
std::atomic<ui32> CurrentOOSStatusFlag = NKikimrBlobStorage::StatusIsValid;
7878
std::shared_ptr<NMonGroup::TOutOfSpaceGroup> OOSMonGroup;
7979

80+
// response status
81+
std::shared_ptr<NMonGroup::TResponseStatusGroup> ResponseStatusMonGroup;
82+
8083
private:
8184
// Managing disk space
8285
TOutOfSpaceState OutOfSpaceState;

‎ydb/core/blobstorage/vdisk/common/vdisk_mongroups.h‎

Lines changed: 126 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -3,12 +3,13 @@
33
#include "defs.h"
44

55
#include <ydb/core/base/appdata_fwd.h>
6+
#include <ydb/core/protos/base.pb.h>
7+
#include <ydb/core/protos/blobstorage_base.pb.h>
68
#include <ydb/core/protos/node_whiteboard.pb.h>
79
#include <ydb/core/protos/whiteboard_disk_states.pb.h>
810

911
namespace NKikimr {
1012
namespace NMonGroup {
11-
1213
class TBase {
1314
public:
1415
TBase(const TIntrusivePtr<::NMonitoring::TDynamicCounters>& counters,
@@ -676,6 +677,130 @@ public:
676677
COUNTER_DEF(ResponsesWithDiskSpaceLightYellowMove);
677678
};
678679

680+
///////////////////////////////////////////////////////////////////////////////////
681+
// THandleClassGroup
682+
///////////////////////////////////////////////////////////////////////////////////
683+
class THandleClassGroup : public TBase {
684+
public:
685+
GROUP_CONSTRUCTOR(THandleClassGroup)
686+
{
687+
COUNTER_INIT(Undefined, true);
688+
COUNTER_INIT(GetDiscover, true);
689+
COUNTER_INIT(GetFast, true);
690+
COUNTER_INIT(GetAsync, true);
691+
COUNTER_INIT(GetLow, true);
692+
COUNTER_INIT(PutTabletLog, true);
693+
COUNTER_INIT(PutUserData, true);
694+
COUNTER_INIT(PutAsyncBlob, true);
695+
}
696+
697+
COUNTER_DEF(Undefined);
698+
COUNTER_DEF(GetDiscover);
699+
COUNTER_DEF(GetFast);
700+
COUNTER_DEF(GetAsync);
701+
COUNTER_DEF(GetLow);
702+
COUNTER_DEF(PutTabletLog);
703+
COUNTER_DEF(PutUserData);
704+
COUNTER_DEF(PutAsyncBlob);
705+
706+
::NMonitoring::TDeprecatedCounter &GetCounter(const NKikimrBlobStorage::EGetHandleClass& handleClass) {
707+
switch (handleClass) {
708+
case NKikimrBlobStorage::AsyncRead:
709+
return GetAsync();
710+
case NKikimrBlobStorage::FastRead:
711+
return GetFast();
712+
case NKikimrBlobStorage::Discover:
713+
return GetDiscover();
714+
case NKikimrBlobStorage::LowRead:
715+
return GetLow();
716+
}
717+
}
718+
::NMonitoring::TDeprecatedCounter &GetCounter(const NKikimrBlobStorage::EPutHandleClass& handleClass) {
719+
switch (handleClass) {
720+
case NKikimrBlobStorage::TabletLog:
721+
return PutTabletLog();
722+
case NKikimrBlobStorage::AsyncBlob:
723+
return PutAsyncBlob();
724+
case NKikimrBlobStorage::UserData:
725+
return PutUserData();
726+
}
727+
}
728+
729+
::NMonitoring::TDeprecatedCounter &GetCounter() {
730+
return Undefined();
731+
}
732+
};
733+
734+
///////////////////////////////////////////////////////////////////////////////////
735+
// TResponseStatusGroup
736+
///////////////////////////////////////////////////////////////////////////////////
737+
class TResponseStatusGroup {
738+
public:
739+
TIntrusivePtr<::NMonitoring::TDynamicCounters> Group;
740+
741+
THandleClassGroup Undefined;
742+
THandleClassGroup ResponsesWithStatusError;
743+
THandleClassGroup ResponsesWithStatusRace;
744+
THandleClassGroup ResponsesWithStatusBlocked;
745+
THandleClassGroup ResponsesWithStatusOutOfSpace;
746+
THandleClassGroup ResponsesWithStatusDeadline;
747+
THandleClassGroup ResponsesWithStatusNotReady;
748+
THandleClassGroup ResponsesWithStatusVdiskErrorState;
749+
750+
TResponseStatusGroup(const TIntrusivePtr<::NMonitoring::TDynamicCounters>& counters)
751+
: Group(counters->GetSubgroup("subsystem", "statuses"))
752+
, Undefined(Group, "status", "UNDEFINED")
753+
, ResponsesWithStatusError(Group, "status", "ERROR")
754+
, ResponsesWithStatusRace(Group, "status", "RACE")
755+
, ResponsesWithStatusBlocked(Group, "status", "BLOCKED")
756+
, ResponsesWithStatusOutOfSpace(Group, "status", "OUT_OF_SPACE")
757+
, ResponsesWithStatusDeadline(Group, "status", "DEADLINE")
758+
, ResponsesWithStatusNotReady(Group, "status", "NOT_READY")
759+
, ResponsesWithStatusVdiskErrorState(Group, "status", "VDISK_STATUS_ERROR")
760+
{}
761+
762+
template <typename THandleClassType>
763+
::NMonitoring::TDeprecatedCounter &GetCounter(NKikimrProto::EReplyStatus status, const THandleClassType& handleClass) {
764+
switch (status) {
765+
case NKikimrProto::ERROR:
766+
return ResponsesWithStatusError.GetCounter(handleClass);
767+
case NKikimrProto::RACE:
768+
return ResponsesWithStatusRace.GetCounter(handleClass);
769+
case NKikimrProto::BLOCKED:
770+
return ResponsesWithStatusBlocked.GetCounter(handleClass);
771+
case NKikimrProto::OUT_OF_SPACE:
772+
return ResponsesWithStatusOutOfSpace.GetCounter(handleClass);
773+
case NKikimrProto::DEADLINE:
774+
return ResponsesWithStatusDeadline.GetCounter(handleClass);
775+
case NKikimrProto::NOTREADY:
776+
return ResponsesWithStatusNotReady.GetCounter(handleClass);
777+
case NKikimrProto::VDISK_ERROR_STATE:
778+
return ResponsesWithStatusVdiskErrorState.GetCounter(handleClass);
779+
default: return Undefined.GetCounter(handleClass);
780+
}
781+
}
782+
783+
::NMonitoring::TDeprecatedCounter &GetCounter(NKikimrProto::EReplyStatus status) {
784+
switch (status) {
785+
case NKikimrProto::ERROR:
786+
return ResponsesWithStatusError.GetCounter();
787+
case NKikimrProto::RACE:
788+
return ResponsesWithStatusRace.GetCounter();
789+
case NKikimrProto::BLOCKED:
790+
return ResponsesWithStatusBlocked.GetCounter();
791+
case NKikimrProto::OUT_OF_SPACE:
792+
return ResponsesWithStatusOutOfSpace.GetCounter();
793+
case NKikimrProto::DEADLINE:
794+
return ResponsesWithStatusDeadline.GetCounter();
795+
case NKikimrProto::NOTREADY:
796+
return ResponsesWithStatusNotReady.GetCounter();
797+
case NKikimrProto::VDISK_ERROR_STATE:
798+
return ResponsesWithStatusVdiskErrorState.GetCounter();
799+
default: return Undefined.GetCounter();
800+
}
801+
}
802+
};
803+
679804
///////////////////////////////////////////////////////////////////////////////////
680805
// TCostTrackerGroup
681806
///////////////////////////////////////////////////////////////////////////////////

‎ydb/core/blobstorage/vdisk/common/vdisk_response.cpp‎

Lines changed: 105 additions & 19 deletions
Original file line numberDiff line numberDiff line change
@@ -6,35 +6,36 @@
66

77
namespace NKikimr {
88

9+
template <class TRecord>
10+
void ReportResponse(const TRecord& record, const TCommonHandleClass& handleClass, const TIntrusivePtr<TVDiskContext>& vCtx);
911
void LogOOSStatus(ui32 flags, const TLogoBlobID& blobId, const TString& vDiskLogPrefix, std::atomic<ui32>& curFlags);
1012
void UpdateMonOOSStatus(ui32 flags, const std::shared_ptr<NMonGroup::TOutOfSpaceGroup>& monGroup);
13+
void UpdateMonResponseStatus(NKikimrProto::EReplyStatus status, const TCommonHandleClass& handleClass, const std::shared_ptr<NMonGroup::TResponseStatusGroup>& monGroup);
1114

12-
void SendVDiskResponse(const TActorContext &ctx, const TActorId &recipient, IEventBase *ev, ui64 cookie, const TIntrusivePtr<TVDiskContext>& vCtx) {
15+
void SendVDiskResponse(const TActorContext &ctx, const TActorId &recipient, IEventBase *ev, const TCommonHandleClass& handleClass, ui64 cookie, const TIntrusivePtr<TVDiskContext>& vCtx) {
1316
ui32 channel = TInterconnectChannels::IC_BLOBSTORAGE;
1417
if (TEvVResultBase *base = dynamic_cast<TEvVResultBase *>(ev)) {
1518
channel = base->GetChannelToSend();
1619
}
17-
SendVDiskResponse(ctx, recipient, ev, cookie, channel, vCtx);
20+
SendVDiskResponse(ctx, recipient, ev, handleClass, cookie, channel, vCtx);
1821
}
1922

20-
void SendVDiskResponse(const TActorContext &ctx, const TActorId &recipient, IEventBase *ev, ui64 cookie, ui32 channel, const TIntrusivePtr<TVDiskContext>& vCtx) {
23+
void SendVDiskResponse(const TActorContext &ctx, const TActorId &recipient, IEventBase *ev, const TCommonHandleClass& handleClass, ui64 cookie, ui32 channel, const TIntrusivePtr<TVDiskContext>& vCtx) {
2124
if (vCtx) {
22-
switch(ev->Type()) {
23-
case TEvBlobStorage::TEvVPutResult::EventType: {
24-
TEvBlobStorage::TEvVPutResult* event = static_cast<TEvBlobStorage::TEvVPutResult *>(ev);
25-
LogOOSStatus(event->Record.GetStatusFlags(), LogoBlobIDFromLogoBlobID(event->Record.GetBlobID()), vCtx->VDiskLogPrefix, vCtx->CurrentOOSStatusFlag);
26-
UpdateMonOOSStatus(event->Record.GetStatusFlags(), vCtx->OOSMonGroup);
27-
break;
28-
}
29-
case TEvBlobStorage::TEvVMultiPutResult::EventType: {
30-
TEvBlobStorage::TEvVMultiPutResult *event = static_cast<TEvBlobStorage::TEvVMultiPutResult *>(ev);
31-
if (event->Record.ItemsSize() > 0) {
32-
const auto& item = event->Record.GetItems(0);
33-
LogOOSStatus(event->Record.GetStatusFlags(), LogoBlobIDFromLogoBlobID(item.GetBlobID()), vCtx->VDiskLogPrefix, vCtx->CurrentOOSStatusFlag);
34-
UpdateMonOOSStatus(event->Record.GetStatusFlags(), vCtx->OOSMonGroup);
35-
}
36-
break;
25+
switch (ev->Type()) {
26+
#define HANDLE_EVENT(T) \
27+
case T::EventType: { \
28+
T *event = static_cast<T *>(ev); \
29+
ReportResponse(event->Record, handleClass, vCtx); \
30+
break; \
3731
}
32+
33+
HANDLE_EVENT(TEvBlobStorage::TEvVPutResult)
34+
HANDLE_EVENT(TEvBlobStorage::TEvVMultiPutResult)
35+
HANDLE_EVENT(TEvBlobStorage::TEvVGetResult)
36+
HANDLE_EVENT(TEvBlobStorage::TEvVGetBlockResult)
37+
HANDLE_EVENT(TEvBlobStorage::TEvVCollectGarbageResult)
38+
#undef HANDLE_EVENT
3839
}
3940
}
4041

@@ -69,6 +70,77 @@ void SendVDiskResponse(const TActorContext &ctx, const TActorId &recipient, IEve
6970
}
7071
}
7172

73+
template <typename T, typename Tuple>
74+
struct IsInTypes;
75+
76+
template <typename T, typename... Types>
77+
struct IsInTypes<T, std::tuple<Types...>> {
78+
static constexpr bool value = (std::is_same_v<T, Types> || ...);
79+
};
80+
81+
struct TReportingOSStatus {
82+
using EnableFor = std::tuple<
83+
NKikimrBlobStorage::TEvVPutResult,
84+
NKikimrBlobStorage::TEvVMultiPutResult>;
85+
86+
template <typename TRecord>
87+
static void Report(const TRecord& record, const TCommonHandleClass&, const TIntrusivePtr<TVDiskContext>& vCtx) {
88+
LogOOSStatus(record.GetStatusFlags(), LogoBlobIDFromLogoBlobID(record.GetBlobID()), vCtx->VDiskLogPrefix, vCtx->CurrentOOSStatusFlag);
89+
UpdateMonOOSStatus(record.GetStatusFlags(), vCtx->OOSMonGroup);
90+
}
91+
92+
template<>
93+
void Report(const NKikimrBlobStorage::TEvVMultiPutResult& record, const TCommonHandleClass&, const TIntrusivePtr<TVDiskContext>& vCtx) {
94+
if (record.ItemsSize() > 0) {
95+
const auto& item = record.GetItems(0);
96+
LogOOSStatus(record.GetStatusFlags(), LogoBlobIDFromLogoBlobID(item.GetBlobID()), vCtx->VDiskLogPrefix, vCtx->CurrentOOSStatusFlag);
97+
UpdateMonOOSStatus(record.GetStatusFlags(), vCtx->OOSMonGroup);
98+
}
99+
}
100+
};
101+
102+
struct TReportingResponseStatus {
103+
using EnableFor = std::tuple<
104+
NKikimrBlobStorage::TEvVPutResult,
105+
NKikimrBlobStorage::TEvVMultiPutResult,
106+
NKikimrBlobStorage::TEvVGetResult,
107+
NKikimrBlobStorage::TEvVGetBlockResult,
108+
NKikimrBlobStorage::TEvVCollectGarbageResult>;
109+
110+
template <typename TRecord>
111+
static void Report(const TRecord& record, const TCommonHandleClass& handleClass, const TIntrusivePtr<TVDiskContext>& vCtx) {
112+
UpdateMonResponseStatus(record.GetStatus(), handleClass, vCtx->ResponseStatusMonGroup);
113+
}
114+
115+
template<>
116+
void Report(const NKikimrBlobStorage::TEvVMultiPutResult& record, const TCommonHandleClass& handleClass, const TIntrusivePtr<TVDiskContext>& vCtx) {
117+
for (const auto& item : record.GetItems()) {
118+
UpdateMonResponseStatus(item.GetStatus(), handleClass, vCtx->ResponseStatusMonGroup);
119+
}
120+
}
121+
};
122+
123+
#define DEFUNE_REPORT(NAME) \
124+
template <typename TRecord> \
125+
typename std::enable_if<IsInTypes<TRecord, TReporting##NAME::EnableFor>::value>::type Report##NAME( \
126+
const TRecord& record, const TCommonHandleClass& handleClass, const TIntrusivePtr<TVDiskContext>& vCtx) { \
127+
TReporting##NAME::Report(record, handleClass, vCtx); \
128+
} \
129+
\
130+
template <typename TRecord> \
131+
typename std::enable_if<!IsInTypes<TRecord, TReporting##NAME::EnableFor>::value>::type Report##NAME( \
132+
const TRecord& record, const TCommonHandleClass& handleClass, const TIntrusivePtr<TVDiskContext>& vCtx) {}
133+
134+
DEFUNE_REPORT(OSStatus)
135+
DEFUNE_REPORT(ResponseStatus)
136+
#undef DEFUNE_REPORT
137+
138+
template <class TRecord>
139+
void ReportResponse(const TRecord& record, const TCommonHandleClass& handleClass, const TIntrusivePtr<TVDiskContext>& vCtx) {
140+
ReportOSStatus(record, handleClass, vCtx);
141+
ReportResponseStatus(record, handleClass, vCtx);
142+
}
143+
72144
void LogOOSStatus(ui32 flags, const TLogoBlobID& blobId, const TString& vDiskLogPrefix, std::atomic<ui32>& curFlags) {
73145
if (!TlsActivationContext) {
74146
return;
@@ -111,4 +183,18 @@ void UpdateMonOOSStatus(ui32 flags, const std::shared_ptr<NMonGroup::TOutOfSpace
111183
}
112184
}
113185

114-
}//NKikimr
186+
void UpdateMonResponseStatus(NKikimrProto::EReplyStatus status, const TCommonHandleClass& handleClass, const std::shared_ptr<NMonGroup::TResponseStatusGroup>& monGroup) {
187+
if (!monGroup) {
188+
return;
189+
}
190+
191+
if (handleClass.PutHandleClass) {
192+
monGroup->GetCounter(status, *handleClass.PutHandleClass).Inc();
193+
} else if (handleClass.GetHandleClass) {
194+
monGroup->GetCounter(status, *handleClass.GetHandleClass).Inc();
195+
} else {
196+
monGroup->GetCounter(status).Inc();
197+
}
198+
}
199+
200+
} //NKikimr

‎ydb/core/blobstorage/vdisk/common/vdisk_response.h‎

Lines changed: 55 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -5,8 +5,61 @@
55

66
namespace NKikimr {
77

8-
void SendVDiskResponse(const TActorContext &ctx, const TActorId &recipient, IEventBase *ev, ui64 cookie, const TIntrusivePtr<TVDiskContext>& vCtx);
8+
template <typename TEv, typename = void>
9+
struct THasGetHandleClass : std::false_type {};
10+
template <typename TEv>
11+
struct THasGetHandleClass<TEv, std::void_t<decltype(std::declval<TEv>().GetHandleClass())>> : std::true_type {};
912

10-
void SendVDiskResponse(const TActorContext &ctx, const TActorId &recipient, IEventBase *ev, ui64 cookie, ui32 channel, const TIntrusivePtr<TVDiskContext>& vCtx);
13+
template <typename TEv>
14+
void A(const TEv& ev) {
15+
int a = ev;
16+
std::cerr << "YES\n" << a;
17+
}
18+
19+
template <>
20+
void A(const NKikimrBlobStorage::TEvVMultiPut&) {
21+
std::cerr << "YES\n";
22+
}
23+
24+
template <typename TEv>
25+
void B(const TEv& ev) {
26+
int a = ev;
27+
std::cerr << "NO\n" << a;
28+
}
29+
30+
struct TCommonHandleClass {
31+
TCommonHandleClass() = default;
32+
template <typename TEv>
33+
TCommonHandleClass(const TEv& ev) {
34+
if constexpr (THasGetHandleClass<TEv>::value) {
35+
SetHandleClass(ev.GetHandleClass());
36+
A(ev);
37+
} else {
38+
TCommonHandleClass(ev.GetHandleClass());
39+
B(ev);
40+
}
41+
}
42+
template <>
43+
TCommonHandleClass(const std::optional<NKikimrBlobStorage::EPutHandleClass>& putHandleClass) {
44+
SetHandleClass(putHandleClass);
45+
}
46+
template <>
47+
TCommonHandleClass(const std::optional<NKikimrBlobStorage::EGetHandleClass>& getHandleClass) {
48+
SetHandleClass(getHandleClass);
49+
}
50+
void SetHandleClass(const std::optional<NKikimrBlobStorage::EPutHandleClass>& putHandleClass) {
51+
PutHandleClass = putHandleClass;
52+
}
53+
void SetHandleClass(const std::optional<NKikimrBlobStorage::EGetHandleClass>& getHandleClass) {
54+
GetHandleClass = getHandleClass;
55+
}
56+
57+
std::optional<NKikimrBlobStorage::EPutHandleClass> PutHandleClass;
58+
std::optional<NKikimrBlobStorage::EGetHandleClass> GetHandleClass;
59+
};
60+
61+
void SendVDiskResponse(const TActorContext &ctx, const TActorId &recipient, IEventBase *ev, const TCommonHandleClass& handleClass, ui64 cookie, const TIntrusivePtr<TVDiskContext>& vCtx);
62+
63+
void SendVDiskResponse(const TActorContext &ctx, const TActorId &recipient, IEventBase *ev, const TCommonHandleClass& handleClass, ui64 cookie, ui32 channel, const TIntrusivePtr<TVDiskContext>& vCtx);
1164

1265
}//NKikimr

0 commit comments

Comments
 (0)