Filled DatabaseName in SchemeCache requests P.2

n00bcracker · n00bcracker · commit ca3bde3de698 · 2025-10-08T22:28:32.000Z
diff --git a/ydb/core/fq/libs/actors/run_actor.cpp b/ydb/core/fq/libs/actors/run_actor.cpp
@@ -930,6 +930,7 @@ class TRunActor : public NActors::TActorBootstrapped<TRunActor> {
         if (Params.Resources.rate_limiter_path()) {
             const TString rateLimiterResource = GetRateLimiterResourcePath(Params.CloudId, Params.Scope.ParseFolder(), Params.QueryId);
             for (auto& task : *ev->Get()->GraphParams.MutableTasks()) {
+                task.SetRateLimiterDatabase(Params.TenantName);
                 task.SetRateLimiter(Params.Resources.rate_limiter_path());
                 task.SetRateLimiterResource(rateLimiterResource);
             }
diff --git a/ydb/core/grpc_services/rpc_rate_limiter_api.cpp b/ydb/core/grpc_services/rpc_rate_limiter_api.cpp
@@ -621,17 +621,20 @@ class TAcquireRateLimiterResourceRPC : public TRateLimiterRequest<TAcquireRateLi
 
     void SendRequest() {
         UnsafeBecome(&TAcquireRateLimiterResourceRPC::StateFunc);
+        const TString database = CanonizePath(Request().GetDatabaseName().GetOrElse(""));
 
         if (GetProtoRequest()->units_case() == Ydb::RateLimiter::AcquireResourceRequest::UnitsCase::kRequired) {
             SendLeaf(
-                TEvQuota::TResourceLeaf(GetProtoRequest()->coordination_node_path(),
+                TEvQuota::TResourceLeaf(database,
+                                        GetProtoRequest()->coordination_node_path(),
                                         GetProtoRequest()->resource_path(),
                                         GetProtoRequest()->required()));
             return;
         }
 
         SendLeaf(
-            TEvQuota::TResourceLeaf(GetProtoRequest()->coordination_node_path(),
+            TEvQuota::TResourceLeaf(database,
+                                    GetProtoRequest()->coordination_node_path(),
                                     GetProtoRequest()->resource_path(),
                                     GetProtoRequest()->used(),
                                     true));
diff --git a/ydb/core/kesus/proxy/events.h b/ydb/core/kesus/proxy/events.h
@@ -28,10 +28,12 @@ struct TEvKesusProxy {
         "expected EvEnd <= EventSpaceEnd(TKikimrEvents::ES_KESUS_PROXY)");
 
     struct TEvResolveKesusProxy : public TEventLocal<TEvResolveKesusProxy, EvResolveKesusProxy> {
+        const TString Database;
         const TString KesusPath;
 
-        explicit TEvResolveKesusProxy(const TString& kesusPath)
-            : KesusPath(kesusPath)
+        TEvResolveKesusProxy(const TString& database, const TString& kesusPath)
+            : Database(database)
+            , KesusPath(kesusPath)
         {}
     };
 
diff --git a/ydb/core/kesus/proxy/proxy.cpp b/ydb/core/kesus/proxy/proxy.cpp
@@ -73,7 +73,7 @@ class TKesusProxyService : public TActor<TKesusProxyService> {
     }
 
 private:
-    IActor* CreateResolveActor(const TString& kesusPath);
+    IActor* CreateResolveActor(const TString& database, const TString& kesusPath);
 
     void Handle(TEvKesusProxy::TEvResolveKesusProxy::TPtr& ev) {
         const auto* msg = ev->Get();
@@ -103,7 +103,7 @@ class TKesusProxyService : public TActor<TKesusProxyService> {
                 // Recheck schemecache for changes
                 LOG_TRACE_S(ctx, NKikimrServices::KESUS_PROXY,
                     "Starting resolve for kesus " << msg->KesusPath.Quote());
-                RegisterWithSameMailbox(CreateResolveActor(msg->KesusPath));
+                RegisterWithSameMailbox(CreateResolveActor(msg->Database, msg->KesusPath));
                 entry.State = CACHE_STATE_RESOLVING;
                 [[fallthrough]];
 
@@ -220,21 +220,25 @@ class TKesusProxyService : public TActor<TKesusProxyService> {
 class TKesusProxyService::TResolveActor : public TActorBootstrapped<TResolveActor> {
 private:
     const TActorId Owner;
+    const TString Database;
     const TString KesusPath;
 
 public:
-    TResolveActor(const TActorId& owner, const TString& kesusPath)
+    TResolveActor(const TActorId& owner, const TString& database, const TString& kesusPath)
         : Owner(owner)
+        , Database(CanonizePath(database))
         , KesusPath(kesusPath)
     {}
 
     void Bootstrap(const TActorContext& ctx) {
         LOG_TRACE_S(ctx, NKikimrServices::KESUS_PROXY,
             "Sending resolve request to SchemeCache: " << KesusPath.Quote());
-        auto request = MakeHolder<NSchemeCache::TSchemeCacheNavigate>();
+        auto request = MakeHolder<TSchemeCacheNavigate>();
+        request->DatabaseName = Database;
+
         auto& entry = request->ResultSet.emplace_back();
         entry.Path = SplitPath(KesusPath);
-        entry.Operation = NSchemeCache::TSchemeCacheNavigate::OpPath;
+        entry.Operation = TSchemeCacheNavigate::OpPath;
         Send(MakeSchemeCacheID(), new TEvTxProxySchemeCache::TEvNavigateKeySet(request.Release()));
         Become(&TThis::StateWork);
     }
@@ -262,8 +266,8 @@ class TKesusProxyService::TResolveActor : public TActorBootstrapped<TResolveActo
     }
 };
 
-IActor* TKesusProxyService::CreateResolveActor(const TString& kesusPath) {
-    return new TResolveActor(SelfId(), kesusPath);
+IActor* TKesusProxyService::CreateResolveActor(const TString& database, const TString& kesusPath) {
+    return new TResolveActor(SelfId(), database, kesusPath);
 }
 
 TActorId MakeKesusProxyServiceId() {
diff --git a/ydb/core/persqueue/pqtablet/partition/account_read_quoter.cpp b/ydb/core/persqueue/pqtablet/partition/account_read_quoter.cpp
@@ -102,7 +102,7 @@ void TBasicAccountQuoter::HandleQuotaConsumed(NAccountQuoterEvents::TEvConsumed:
             TThis::Send(MakeQuoterServiceID(),
                 new TEvQuota::TEvRequest(
                     TEvQuota::EResourceOperator::And,
-                    { TEvQuota::TResourceLeaf(KesusPath, ResourcePath, ConsumedBytesInCredit) },
+                    { TEvQuota::TResourceLeaf(KesusPath, KesusPath, ResourcePath, ConsumedBytesInCredit) },
                     TDuration::Max()),
                 0,
                 ++CurrentQuotaRequestCookie
diff --git a/ydb/core/quoter/public/quoter.h b/ydb/core/quoter/public/quoter.h
@@ -41,6 +41,7 @@ struct TEvQuota {
 
         const ui64 QuoterId;
         const ui64 ResourceId;
+        const TString Database;
         const TString Quoter;
         const TString Resource;
 
@@ -56,9 +57,10 @@ struct TEvQuota {
             , IsUsedAmount(isUsedAmount)
         {}
 
-        TResourceLeaf(const TString &quoter, const TString &resource, ui64 amount, bool isUsedAmount = false)
+        TResourceLeaf(const TString& database, const TString &quoter, const TString &resource, ui64 amount, bool isUsedAmount = false)
             : QuoterId(0)
             , ResourceId(0)
+            , Database(database)
             , Quoter(quoter)
             , Resource(resource)
             , Amount(amount)
diff --git a/ydb/core/quoter/quoter_service.cpp b/ydb/core/quoter/quoter_service.cpp
@@ -568,6 +568,8 @@ TQuoterService::EInitLeafStatus TQuoterService::InitResourceLeaf(const TEvQuota:
             Counters.ActiveQuoterProxies->Inc();
 
             THolder<NSchemeCache::TSchemeCacheNavigate> req(new NSchemeCache::TSchemeCacheNavigate());
+            req->DatabaseName = leaf.Database;
+
             req->ResultSet.emplace_back();
             req->ResultSet.back().Path.swap(path);
             req->ResultSet.back().Operation = NSchemeCache::TSchemeCacheNavigate::OpPath;
@@ -1469,7 +1471,7 @@ TString TQuoterService::PrintEvent(const TEvQuota::TEvRequest::TPtr& ev) {
         }
         ret << " { " << leaf.Amount << ", ";
         if (leaf.Quoter) {
-            ret << "\"" << leaf.Quoter << "\":\"" << leaf.Resource << "\"";
+            ret << "\"" << leaf.Database << "\":\"" << leaf.Quoter << "\":\"" << leaf.Resource << "\"";
         } else {
             ret << leaf.QuoterId << ":" << leaf.ResourceId;
         }
diff --git a/ydb/core/quoter/quoter_service_bandwidth_test/quota_requester.cpp b/ydb/core/quoter/quoter_service_bandwidth_test/quota_requester.cpp
@@ -97,7 +97,7 @@ TKesusQuotaRequester::TKesusQuotaRequester(const NKikimr::TOptions& opts, NKikim
 
 THolder<TEvQuota::TEvRequest> TKesusQuotaRequester::MakeQuoterRequest() {
     TVector<TEvQuota::TResourceLeaf> reqs = {
-        TEvQuota::TResourceLeaf(KesusPath, ResourcePath, 1.0)
+        TEvQuota::TResourceLeaf(TTestServer::GetDomainPath(), KesusPath, ResourcePath, 1.0)
     };
     return MakeHolder<TEvQuota::TEvRequest>(TEvQuota::EResourceOperator::And, std::move(reqs), Opts.QuotaRequestDeadline);
 }
diff --git a/ydb/core/quoter/quoter_service_bandwidth_test/server.cpp b/ydb/core/quoter/quoter_service_bandwidth_test/server.cpp
@@ -19,6 +19,10 @@ TTestServer::TTestServer(const TOptions &opts)
     RunServer();
 }
 
+TString TTestServer::GetDomainPath() {
+    return TStringBuilder() << "/" << Tests::TestDomainName;
+}
+
 std::pair<TString, TString> TTestServer::GetKesusPathAndName(size_t i) {
     return {Tests::TestDomainName, TStringBuilder() << "Kesus_" << i};
 }
diff --git a/ydb/core/quoter/quoter_service_bandwidth_test/server.h b/ydb/core/quoter/quoter_service_bandwidth_test/server.h
@@ -23,6 +23,7 @@ class TTestServer {
 
     void RunQuotaRequesters(TRequestStats& stats);
 
+    static TString GetDomainPath();
     static std::pair<TString, TString> GetKesusPathAndName(size_t i);
     static TString GetKesusPath(size_t i);
     static TString GetKesusResource(size_t i);
diff --git a/ydb/core/quoter/quoter_service_ut.cpp b/ydb/core/quoter/quoter_service_ut.cpp
@@ -190,18 +190,20 @@ Y_UNIT_TEST_SUITE(TQuoterServiceTest) {
         constexpr double secondsForWait = static_cast<double>(waitDuration.MicroSeconds()) / 1000000.0;
         constexpr double doubleRate = static_cast<double>(rate);
 
+        TString database;
         TString quoter;
         TString resource;
         if (resType == ESpeedTestResourceType::KesusResource) {
             CreateKesus(server);
             CreateKesusResource(server, doubleRate);
+            database = TStringBuilder() << "/" << Tests::TestDomainName;
             quoter = TStringBuilder() << "/" << Tests::TestDomainName << "/KesusQuoter";
             resource = "Res";
         }
 
         const TEvQuota::TResourceLeaf resLeaf = resType == ESpeedTestResourceType::StaticTaggedRateResource ?
             TEvQuota::TResourceLeaf(TEvQuota::TResourceLeaf::QuoterSystem, TEvQuota::TResourceLeaf::MakeTaggedRateRes(42, rate), 1) :
-            TEvQuota::TResourceLeaf(quoter, resource, 1);
+            TEvQuota::TResourceLeaf(database, quoter, resource, 1);
 
         for (size_t iteration = 0; iteration < 2; ++iteration) {
             const TInstant start = TInstant::Now();
diff --git a/ydb/core/quoter/ut_helpers.cpp b/ydb/core/quoter/ut_helpers.cpp
@@ -134,7 +134,7 @@ void TKesusQuoterTestSetup::SendGetQuotaRequest(const std::vector<std::tuple<TSt
     TVector<TEvQuota::TResourceLeaf> res;
     res.reserve(resources.size());
     for (auto&& [kesusPath, resourcePath, amount] : resources) {
-        res.emplace_back(kesusPath, resourcePath, amount);
+        res.emplace_back("/" + DEFAULT_KESUS_PARENT_PATH, kesusPath, resourcePath, amount);
     }
     GetServer().GetRuntime()->Send(new IEventHandle(MakeQuoterServiceID(), GetEdgeActor(), new TEvQuota::TEvRequest(operation, std::move(res), deadline)));
 }
diff --git a/ydb/library/yql/dq/actors/compute/dq_async_compute_actor.cpp b/ydb/library/yql/dq/actors/compute/dq_async_compute_actor.cpp
@@ -660,7 +660,7 @@ class TDqAsyncComputeActor : public TDqComputeActorBase<TDqAsyncComputeActor, TC
             Send(QuoterServiceActorId,
                 new NKikimr::TEvQuota::TEvRequest(
                     NKikimr::TEvQuota::EResourceOperator::And,
-                    { NKikimr::TEvQuota::TResourceLeaf(Task.GetRateLimiter(), Task.GetRateLimiterResource(), CpuTimeSpent.MilliSeconds(), true) },
+                    { NKikimr::TEvQuota::TResourceLeaf(Task.GetRateLimiterDatabase(), Task.GetRateLimiter(), Task.GetRateLimiterResource(), CpuTimeSpent.MilliSeconds(), true) },
                     TDuration::Max()));
         }
         TBase::PassAway();
@@ -1109,7 +1109,7 @@ class TDqAsyncComputeActor : public TDqComputeActorBase<TDqAsyncComputeActor, TC
             Send(QuoterServiceActorId,
                 new NKikimr::TEvQuota::TEvRequest(
                     NKikimr::TEvQuota::EResourceOperator::And,
-                    { NKikimr::TEvQuota::TResourceLeaf(Task.GetRateLimiter(), Task.GetRateLimiterResource(), CpuTimeSpent.MilliSeconds(), true) },
+                    { NKikimr::TEvQuota::TResourceLeaf(Task.GetRateLimiterDatabase(), Task.GetRateLimiter(), Task.GetRateLimiterResource(), CpuTimeSpent.MilliSeconds(), true) },
                     TDuration::Max()));
             CpuTimeQuotaAsked = TInstant::Now();
             CpuTimeSpent = TDuration::Zero();
diff --git a/ydb/library/yql/dq/proto/dq_tasks.proto b/ydb/library/yql/dq/proto/dq_tasks.proto
@@ -233,4 +233,5 @@ message TDqTask {
     optional bool DisableMetering = 22;
     optional uint64 BufferPageAllocSize = 23;
     EValuePackerVersion ValuePackerVersion = 24;
+    string RateLimiterDatabase = 25;
 }
diff --git a/ydb/library/yql/dq/runtime/dq_tasks_runner.h b/ydb/library/yql/dq/runtime/dq_tasks_runner.h
@@ -284,7 +284,7 @@ class TDqTaskSettings {
         Y_ABORT_UNLESS(!ParamProvider, "GetSerialized isn't supported if external ParamProvider callback is specified!");
         return *Task_;
     }
-    
+
     NDqProto::TDqTask* GetTask() const {
         Y_ABORT_UNLESS(Arena);
         return Task_;
@@ -347,6 +347,10 @@ class TDqTaskSettings {
         return Task_->GetRateLimiterResource();
     }
 
+    const TProtoStringType& GetRateLimiterDatabase() const {
+        return Task_->GetRateLimiterDatabase();
+    }
+
     const TProtoStringType& GetRateLimiter() const {
         return Task_->GetRateLimiter();
     }
diff --git a/ydb/services/kesus/grpc_service.cpp b/ydb/services/kesus/grpc_service.cpp
@@ -150,9 +150,10 @@ class TGRpcSessionActor
             PingPeriod = MinPingPeriod;
         }
 
+        const TString database = RequestEvent->GetDatabaseName().GetOrElse("");
         KesusPath = StartRequest->Record.session_start().path();
 
-        auto resolve = MakeHolder<TEvKesusProxy::TEvResolveKesusProxy>(KesusPath);
+        auto resolve = MakeHolder<TEvKesusProxy::TEvResolveKesusProxy>(database, KesusPath);
         if (!Send(MakeKesusProxyServiceId(), resolve.Release())) {
             RequestEvent->Finish(Ydb::StatusIds::UNSUPPORTED, grpc::Status(grpc::StatusCode::UNIMPLEMENTED,
                 "Coordination service not implemented on this server"));

Original file line number	Diff line number	Diff line change
`@@ -930,6 +930,7 @@ class TRunActor : public NActors::TActorBootstrapped<TRunActor> {`
`930`	`930`	`if (Params.Resources.rate_limiter_path()) {`
`931`	`931`	`const TString rateLimiterResource = GetRateLimiterResourcePath(Params.CloudId, Params.Scope.ParseFolder(), Params.QueryId);`
`932`	`932`	`for (auto& task : *ev->Get()->GraphParams.MutableTasks()) {`
	`933`	`+ task.SetRateLimiterDatabase(Params.TenantName);`
`933`	`934`	`task.SetRateLimiter(Params.Resources.rate_limiter_path());`
`934`	`935`	`task.SetRateLimiterResource(rateLimiterResource);`
`935`	`936`	`}`
Original file line number	Diff line number	Diff line change
`@@ -97,7 +97,7 @@ TKesusQuotaRequester::TKesusQuotaRequester(const NKikimr::TOptions& opts, NKikim`
`97`	`97`
`98`	`98`	`THolder<TEvQuota::TEvRequest> TKesusQuotaRequester::MakeQuoterRequest() {`
`99`	`99`	`TVector<TEvQuota::TResourceLeaf> reqs = {`
`100`		`- TEvQuota::TResourceLeaf(KesusPath, ResourcePath, 1.0)`
	`100`	`+ TEvQuota::TResourceLeaf(TTestServer::GetDomainPath(), KesusPath, ResourcePath, 1.0)`
`101`	`101`	`};`
`102`	`102`	`return MakeHolder<TEvQuota::TEvRequest>(TEvQuota::EResourceOperator::And, std::move(reqs), Opts.QuotaRequestDeadline);`
`103`	`103`	`}`
Original file line number	Diff line number	Diff line change
`@@ -19,6 +19,10 @@ TTestServer::TTestServer(const TOptions &opts)`
`19`	`19`	`RunServer();`
`20`	`20`	`}`
`21`	`21`
	`22`	`+TString TTestServer::GetDomainPath() {`
	`23`	`+ return TStringBuilder() << "/" << Tests::TestDomainName;`
	`24`	`+}`
	`25`	`+`
`22`	`26`	`std::pair<TString, TString> TTestServer::GetKesusPathAndName(size_t i) {`
`23`	`27`	`return {Tests::TestDomainName, TStringBuilder() << "Kesus_" << i};`
`24`	`28`	`}`