[backup] Add draft backup controller tablet (#4103)

Author: Enjection

ydb/core/backup/controller/tablet.cpp

@@ -0,0 +1,52 @@
+#include "tablet.h"
+#include "tablet_impl.h"
+
+namespace NKikimr::NBackup {
+
+TBackupController::TBackupController(const TActorId& tablet, TTabletStorageInfo* info)
+    : TActor(&TThis::StateInit)
+    , TTabletExecutedFlat(info, tablet, new NMiniKQL::TMiniKQLFactory)
+{
+    Y_UNUSED(tablet, info);
+}
+
+STFUNC(TBackupController::StateInit) {
+    StateInitImpl(ev, SelfId());
+}
+
+STFUNC(TBackupController::StateWork) {
+    HandleDefaultEvents(ev, SelfId());
+}
+
+void TBackupController::OnDetach(const TActorContext& ctx) {
+    Die(ctx);
+}
+
+void TBackupController::OnTabletDead(TEvTablet::TEvTabletDead::TPtr& ev, const TActorContext& ctx) {
+    Y_UNUSED(ev);
+    Die(ctx);
+}
+
+void TBackupController::OnActivateExecutor(const TActorContext& ctx) {
+    RunTxInitSchema(ctx);
+}
+
+void TBackupController::DefaultSignalTabletActive(const TActorContext& ctx) {
+    Y_UNUSED(ctx);
+}
+
+
+void TBackupController::SwitchToWork(const TActorContext& ctx) {
+    SignalTabletActive(ctx);
+    Become(&TThis::StateWork);
+}
+
+void TBackupController::Reset() {
+
+}
+
+IActor* CreateBackupController(const TActorId& tablet, TTabletStorageInfo* info) {
+    return new TBackupController(tablet, info);
+}
+
+} // namespace NKikimr::NBackup

ydb/core/backup/controller/tablet.h

@@ -0,0 +1,12 @@
+#pragma once
+
+#include <ydb/core/base/blobstorage.h>
+#include <ydb/library/actors/core/actor.h>
+
+namespace NKikimr::NBackup {
+
+using namespace NActors;
+
+IActor* CreateBackupController(const TActorId& tablet, TTabletStorageInfo* info);
+
+} // namespace NKikimr::NBackup

ydb/core/backup/controller/tablet_impl.h

@@ -0,0 +1,79 @@
+#pragma once
+
+#include <ydb/core/base/blobstorage.h>
+#include <ydb/core/base/defs.h>
+#include <ydb/core/engine/minikql/flat_local_tx_factory.h>
+#include <ydb/core/protos/counters_backup.pb.h>
+#include <ydb/core/tablet_flat/flat_cxx_database.h>
+#include <ydb/core/tablet_flat/tablet_flat_executed.h>
+#include <ydb/core/tx/replication/service/service.h>
+
+#include <ydb/library/actors/core/interconnect.h>
+#include <ydb/library/yverify_stream/yverify_stream.h>
+
+namespace NKikimr::NBackup {
+
+struct TBackupControllerSchema : NIceDb::Schema {
+    struct BackupCollections : Table<1> {
+        struct ID : Column<1, NScheme::NTypeIds::Uint32> {};
+
+        using TKey = TableKey<ID>;
+        using TColumns = TableColumns<ID>;
+    };
+
+    using TTables = SchemaTables<BackupCollections>;
+    using TSettings = SchemaSettings<ExecutorLogBatching<true>, ExecutorLogFlushPeriod<TDuration::MicroSeconds(512).GetValue()>>;
+};
+
+class TBackupController
+    : public TActor<TBackupController>
+    , public NTabletFlatExecutor::TTabletExecutedFlat
+{
+public:
+    class TTxBase
+        : public NTabletFlatExecutor::TTransactionBase<TBackupController>
+    {
+    public:
+        TTxBase(const TString& name, TBackupController* self)
+            : TTransactionBase(self)
+            , LogPrefix(name)
+        {
+        }
+
+    protected:
+        const TString LogPrefix;
+    };
+    using Schema = TBackupControllerSchema;
+
+    // local transactions
+    class TTxInitSchema;
+    class TTxInit;
+
+    // tx runners
+    void RunTxInitSchema(const TActorContext& ctx);
+    void RunTxInit(const TActorContext& ctx);
+
+    static constexpr NKikimrServices::TActivity::EType ActorActivityType() {
+        return NKikimrServices::TActivity::BACKUP_CONTROLLER_TABLET;
+    }
+
+    explicit TBackupController(const TActorId& tablet, TTabletStorageInfo* info);
+
+    STFUNC(StateInit);
+
+    STFUNC(StateWork);
+
+    void OnDetach(const TActorContext& ctx) override;
+
+    void OnTabletDead(TEvTablet::TEvTabletDead::TPtr& ev, const TActorContext& ctx) override;
+
+    void OnActivateExecutor(const TActorContext& ctx) override;
+
+    void DefaultSignalTabletActive(const TActorContext& ctx) override;
+
+    void SwitchToWork(const TActorContext& ctx);
+
+    void Reset();
+};
+
+} // namespace NKikimr::NBackup

ydb/core/backup/controller/tx_init.cpp

@@ -0,0 +1,43 @@
+#include "tablet_impl.h"
+
+namespace NKikimr::NBackup {
+
+class TBackupController::TTxInit
+    : public TTxBase
+{
+    inline bool Load(NIceDb::TNiceDb& db) {
+        Y_UNUSED(db);
+        Self->Reset();
+        return true;
+    }
+
+    inline bool Load(NTable::TDatabase& toughDb) {
+        NIceDb::TNiceDb db(toughDb);
+        return Load(db);
+    }
+
+public:
+    explicit TTxInit(TSelf* self)
+        : TTxBase("TxInit", self)
+    {
+    }
+
+    TTxType GetTxType() const override {
+        return TXTYPE_INIT;
+    }
+
+    bool Execute(TTransactionContext& txc, const TActorContext& ctx) override {
+        Y_UNUSED(ctx);
+        return Load(txc.DB);
+    }
+
+    void Complete(const TActorContext& ctx) override {
+        Self->SwitchToWork(ctx);
+    }
+}; // TTxInit
+
+void TBackupController::RunTxInit(const TActorContext& ctx) {
+    Execute(new TTxInit(this), ctx);
+}
+
+}

ydb/core/backup/controller/tx_init_schema.cpp

@@ -0,0 +1,37 @@
+#include "tablet_impl.h"
+
+namespace NKikimr::NBackup {
+
+class TBackupController::TTxInitSchema
+    : public TTxBase
+{
+public:
+    explicit TTxInitSchema(TBackupController* self)
+        : TTxBase("TxInitSchema", self)
+    {
+    }
+
+    TTxType GetTxType() const override {
+        return TXTYPE_INIT_SCHEMA;
+    }
+
+    bool Execute(TTransactionContext& txc, const TActorContext& ctx) override {
+        Y_UNUSED(ctx);
+
+        NIceDb::TNiceDb db(txc.DB);
+        db.Materialize<Schema>();
+
+        return true;
+    }
+
+    void Complete(const TActorContext& ctx) override {
+        Self->RunTxInit(ctx);
+    }
+
+}; // TTxInitSchema
+
+void TBackupController::RunTxInitSchema(const TActorContext& ctx) {
+    Execute(new TTxInitSchema(this), ctx);
+}
+
+}

ydb/core/backup/controller/ya.make

@@ -0,0 +1,16 @@
+LIBRARY()
+
+SRCS(
+    tablet.cpp
+    tx_init.cpp
+    tx_init_schema.cpp
+)
+
+PEERDIR(
+	library/cpp/lwtrace/protos
+	ydb/core/tablet_flat
+	ydb/core/protos
+	ydb/core/scheme/protos
+)
+
+END()

ydb/core/backup/ya.make

@@ -0,0 +1,3 @@
+RECURSE(
+    controller
+)

ydb/core/cms/console/console__create_tenant.cpp

@@ -127,6 +127,7 @@ class TTenantsManager::TTxCreateTenant : public TTransactionBase<TTenantsManager
         Tenant->IsExternalHive = Self->FeatureFlags.GetEnableExternalHive();
         Tenant->IsExternalSysViewProcessor = Self->FeatureFlags.GetEnableSystemViews();
         Tenant->IsExternalStatisticsAggregator = Self->FeatureFlags.GetEnableStatistics();
+        Tenant->IsExternalBackupController = Self->FeatureFlags.GetEnableBackupService();
 
         if (rec.options().disable_external_subdomain()) {
             Tenant->IsExternalSubdomain = false;
@@ -145,11 +146,13 @@ class TTenantsManager::TTxCreateTenant : public TTransactionBase<TTenantsManager
             Tenant->IsExternalHive = false;
             Tenant->IsExternalSysViewProcessor = false;
             Tenant->IsExternalStatisticsAggregator = false;
+            Tenant->IsExternalBackupController = false;
         }
 
         Tenant->IsExternalHive &= Tenant->IsExternalSubdomain; // external hive without external sub domain is pointless
         Tenant->IsExternalSysViewProcessor &= Tenant->IsExternalSubdomain;
         Tenant->IsExternalStatisticsAggregator &= Tenant->IsExternalSubdomain;
+        Tenant->IsExternalBackupController &= Tenant->IsExternalSubdomain;
 
         Tenant->StorageUnitsQuota = Self->Config.DefaultStorageUnitsQuota;
         Tenant->ComputationalUnitsQuota = Self->Config.DefaultComputationalUnitsQuota;

ydb/core/cms/console/console__scheme.h

@@ -48,13 +48,15 @@ struct Schema : NIceDb::Schema {
         struct AlterIdempotencyKey : Column<26, NScheme::NTypeIds::Utf8> {};
         struct DatabaseQuotas : Column<27, NScheme::NTypeIds::String> {};
         struct IsExternalStatisticsAggregator : Column<28, NScheme::NTypeIds::Bool> {};
+        struct IsExternalBackupController : Column<29, NScheme::NTypeIds::Bool> {};
 
         using TKey = TableKey<Path>;
         using TColumns = TableColumns<Path, State, Coordinators, Mediators, PlanResolution,
             Issue, TxId, UserToken, SubdomainVersion, ConfirmedSubdomain, TimeCastBucketsPerMediator,
             Attributes, Generation, SchemeShardId, PathId, ErrorCode, IsExternalSubDomain, IsExternalHive,
             AreResourcesShared, SharedDomainSchemeShardId, SharedDomainPathId, IsExternalSysViewProcessor,
-            SchemaOperationQuotas, CreateIdempotencyKey, AlterIdempotencyKey, DatabaseQuotas, IsExternalStatisticsAggregator>;
+            SchemaOperationQuotas, CreateIdempotencyKey, AlterIdempotencyKey, DatabaseQuotas, IsExternalStatisticsAggregator,
+            IsExternalBackupController>;
     };
 
     struct TenantPools : Table<3> {

ydb/core/cms/console/console_tenants_manager.cpp

@@ -461,6 +461,9 @@ class TSubDomainManip : public TActorBootstrapped<TSubDomainManip> {
             if (Tenant->IsExternalStatisticsAggregator) {
                 subdomain.SetExternalStatisticsAggregator(true);
             }
+            if (Tenant->IsExternalBackupController) {
+                subdomain.SetExternalBackupController(true);
+            }
         }
 
         if (SharedTenant) {
@@ -486,6 +489,9 @@ class TSubDomainManip : public TActorBootstrapped<TSubDomainManip> {
             if (Tenant->IsExternalStatisticsAggregator) {
                 subdomain.SetExternalStatisticsAggregator(true);
             }
+            if (Tenant->IsExternalBackupController) {
+                subdomain.SetExternalBackupController(true);
+            }
         }
         if (tablets) {
             subdomain.SetCoordinators(Tenant->Coordinators);
@@ -1196,6 +1202,7 @@ TTenantsManager::TTenant::TTenant(const TString &path,
     , IsExternalHive(false)
     , IsExternalSysViewProcessor(false)
     , IsExternalStatisticsAggregator(false)
+    , IsExternalBackupController(false)
     , AreResourcesShared(false)
 {
 }