YQ-3597 disable metadata objects on serverless (#8806)

Author: GrigoriyPA

ydb/core/kqp/workload_service/ut/common/kqp_workload_service_ut_common.cpp

@@ -230,6 +230,7 @@ class TWorkloadServiceYdbSetup : public IYdbSetup {
     TAppConfig GetAppConfig() const {
         TAppConfig appConfig;
         appConfig.MutableFeatureFlags()->SetEnableResourcePools(Settings_.EnableResourcePools_);
+        appConfig.MutableFeatureFlags()->SetEnableMetadataObjectsOnServerless(Settings_.EnableMetadataObjectsOnServerless_);
 
         return appConfig;
     }

ydb/core/kqp/workload_service/ut/common/kqp_workload_service_ut_common.h

@@ -69,6 +69,7 @@ struct TYdbSetupSettings {
     FLUENT_SETTING_DEFAULT(TString, DomainName, "Root");
     FLUENT_SETTING_DEFAULT(bool, CreateSampleTenants, false);
     FLUENT_SETTING_DEFAULT(bool, EnableResourcePools, true);
+    FLUENT_SETTING_DEFAULT(bool, EnableMetadataObjectsOnServerless, true);
 
     // Default pool settings
     FLUENT_SETTING_DEFAULT(TString, PoolId, "sample_pool_id");

ydb/core/protos/feature_flags.proto

@@ -149,4 +149,5 @@ message TFeatureFlags {
     optional bool EnableResourcePoolsCounters = 135 [default = false];
     optional bool EnableOptionalColumnsInColumnShard = 136 [default = false];
     optional bool EnablePgSyntax = 139 [default = false];
+    optional bool EnableMetadataObjectsOnServerless = 141 [default = true];
 }

ydb/core/testlib/basics/feature_flags.h

@@ -63,6 +63,7 @@ class TTestFeatureFlagsHolder {
     FEATURE_FLAG_SETTER(EnableResourcePools)
     FEATURE_FLAG_SETTER(EnableChangefeedsOnIndexTables)
     FEATURE_FLAG_SETTER(EnablePgSyntax)
+    FEATURE_FLAG_SETTER(EnableMetadataObjectsOnServerless)
 
     #undef FEATURE_FLAG_SETTER
 };

ydb/services/metadata/manager/alter_impl.h

@@ -1,5 +1,6 @@
 #pragma once
 #include "abstract.h"
+#include "fetch_database.h"
 #include "modification_controller.h"
 #include "preparation_controller.h"
 #include "restore.h"
@@ -111,6 +112,7 @@ class TModificationActorImpl: public NActors::TActorBootstrapped<TModificationAc
             hFunc(NRequest::TEvRequestFailed, Handle);
             hFunc(TEvRestoreProblem, Handle);
             hFunc(TEvAlterPreparationProblem, Handle);
+            hFunc(TEvFetchDatabaseResponse, Handle);
             default:
                 break;
         }
@@ -126,6 +128,30 @@ class TModificationActorImpl: public NActors::TActorBootstrapped<TModificationAc
             return TBase::PassAway();
         }
 
+        if (!AppData()->FeatureFlags.GetEnableMetadataObjectsOnServerless() && Context.GetActivityType() != IOperationsManager::EActivityType::Drop) {
+            TBase::Register(CreateDatabaseFetcherActor(Context.GetExternalData().GetDatabase()));
+        } else {
+            CreateSession();
+        }
+    }
+
+    void Handle(TEvFetchDatabaseResponse::TPtr& ev) {
+        TString errorMessage;
+        if (const auto& errorString = ev->Get()->GetErrorString()) {
+            errorMessage = TStringBuilder() << "Cannot fetch database '" << Context.GetExternalData().GetDatabase() << "': " << *errorString;
+        } else if (ev->Get()->GetServerless()) {
+            errorMessage = TStringBuilder() << "Objects " << TObject::GetTypeId() << " are disabled for serverless domains. Please contact your system administrator to enable it";
+        }
+
+        if (errorMessage) {
+            auto g = TBase::PassAwayGuard();
+            ExternalController->OnAlteringProblem(errorMessage);
+        } else {
+            CreateSession();
+        }
+    }
+
+    void CreateSession() const {
         TBase::Register(new NRequest::TYDBCallbackRequest<NRequest::TDialogCreateSession>(
             NRequest::TDialogCreateSession::TRequest(), UserToken, TBase::SelfId()));
     }

ydb/services/metadata/manager/common.h

@@ -35,6 +35,7 @@ enum EEvents {
     EvAlterProblem,
     EvAlterPreparationFinished,
     EvAlterPreparationProblem,
+    EvFetchDatabaseResponse,
     EvEnd
 };
 static_assert(EEvents::EvEnd < EventSpaceEnd(TKikimrEvents::ES_METADATA_MANAGER), "expect EvEnd < EventSpaceEnd(TKikimrEvents::ES_METADATA_MANAGER)");

ydb/services/metadata/manager/fetch_database.cpp

@@ -0,0 +1,112 @@
+#include "fetch_database.h"
+
+#include <library/cpp/retry/retry_policy.h>
+
+#include <ydb/core/base/appdata_fwd.h>
+
+#include <ydb/library/table_creator/table_creator.h>
+
+
+namespace NKikimr::NMetadata::NModifications {
+
+namespace {
+
+class TDatabaseFetcherActor : public TActorBootstrapped<TDatabaseFetcherActor> {
+    using TBase = TActorBootstrapped<TDatabaseFetcherActor>;
+    using TRetryPolicy = IRetryPolicy<>;
+
+public:
+    explicit TDatabaseFetcherActor(const TString& database)
+        : Database(database)
+    {}
+
+    void Registered(TActorSystem* sys, const TActorId& owner) override {
+        TBase::Registered(sys, owner);
+        Owner = owner;
+    }
+
+    void Bootstrap() {
+        StartRequest();
+        Become(&TDatabaseFetcherActor::StateFunc);
+    }
+
+    void Handle(TEvents::TEvUndelivered::TPtr& ev) {
+        if (ev->Get()->Reason == NActors::TEvents::TEvUndelivered::ReasonActorUnknown && ScheduleRetry()) {
+            return;
+        }
+
+        Reply("Scheme cache is unavailable");
+    }
+
+    void Handle(TEvTxProxySchemeCache::TEvNavigateKeySetResult::TPtr& ev) {
+        const auto& results = ev->Get()->Request->ResultSet;
+        Y_ABORT_UNLESS(results.size() == 1);
+
+        const auto& result = results[0];
+        if (result.DomainInfo) {
+            Serverless = result.DomainInfo->IsServerless();
+            Reply();
+            return;
+        }
+
+        if (result.Status == NSchemeCache::TSchemeCacheNavigate::EStatus::LookupError && ScheduleRetry()) {
+            return;
+        }
+
+        Reply(TStringBuilder() << "Failed to fetch database info: " << result.Status);
+    }
+
+    STRICT_STFUNC(StateFunc,
+        sFunc(TEvents::TEvWakeup, StartRequest);
+        hFunc(TEvents::TEvUndelivered, Handle);
+        hFunc(TEvTxProxySchemeCache::TEvNavigateKeySetResult, Handle);
+    )
+
+private:
+    void StartRequest() {
+        auto event = NTableCreator::BuildSchemeCacheNavigateRequest(
+            {{}},
+            Database ? Database : AppData()->TenantName,
+            MakeIntrusive<NACLib::TUserToken>(BUILTIN_ACL_METADATA, TVector<NACLib::TSID>{})
+        );
+        event->ResultSet[0].Operation = NSchemeCache::TSchemeCacheNavigate::OpPath;
+        Send(MakeSchemeCacheID(), new TEvTxProxySchemeCache::TEvNavigateKeySet(event.Release()), IEventHandle::FlagTrackDelivery);
+    }
+
+    bool ScheduleRetry() {
+        if (!RetryState) {
+            RetryState = TRetryPolicy::GetFixedIntervalPolicy(
+                  [](){return ERetryErrorClass::ShortRetry;}
+                , TDuration::MilliSeconds(100)
+                , TDuration::MilliSeconds(500)
+                , 100
+            )->CreateRetryState();;
+        }
+
+        if (const auto delay = RetryState->GetNextRetryDelay()) {
+            this->Schedule(*delay, new TEvents::TEvWakeup());
+            return true;
+        }
+
+        return false;
+    }
+
+    void Reply(const std::optional<TString>& errorMessage = std::nullopt) {
+        Send(Owner, new TEvFetchDatabaseResponse(Serverless, errorMessage));
+        PassAway();
+    }
+
+private:
+    const TString Database;
+    TActorId Owner;
+    TRetryPolicy::IRetryState::TPtr RetryState;
+    bool Serverless = false;
+};
+
+}  // anonymous namespace
+
+IActor* CreateDatabaseFetcherActor(const TString& database) {
+    return new TDatabaseFetcherActor(database);
+}
+
+}  // NKikimr::NMetadata::NModifications

ydb/services/metadata/manager/fetch_database.h

@@ -0,0 +1,24 @@
+#pragma once
+
+#include "common.h"
+
+#include <ydb/library/accessor/accessor.h>
+
+
+namespace NKikimr::NMetadata::NModifications {
+
+class TEvFetchDatabaseResponse : public TEventLocal<TEvFetchDatabaseResponse, EvFetchDatabaseResponse> {
+private:
+    YDB_READONLY_DEF(bool, Serverless);
+    YDB_READONLY_DEF(std::optional<TString>, ErrorString);
+
+public:
+    TEvFetchDatabaseResponse(bool serverless, const std::optional<TString>& errorString)
+        : Serverless(serverless)
+        , ErrorString(errorString)
+    {}
+};
+
+IActor* CreateDatabaseFetcherActor(const TString& database);
+
+}  // NKikimr::NMetadata::NModifications

ydb/services/metadata/manager/ya.make

@@ -14,11 +14,13 @@ SRCS(
     ydb_value_operator.cpp
     modification_controller.cpp
     object.cpp
+    fetch_database.cpp
 )
 
 PEERDIR(
     ydb/library/accessor
     ydb/library/actors/core
+    ydb/library/table_creator
     ydb/public/api/protos
     ydb/core/protos
     ydb/services/bg_tasks/abstract