[backup] Add draft backup controller tablet

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)
 {
 }

ydb/core/cms/console/console_tenants_manager.h

@@ -529,6 +529,7 @@ class TTenantsManager : public TActorBootstrapped<TTenantsManager> {
         bool IsExternalHive;
         bool IsExternalSysViewProcessor;
         bool IsExternalStatisticsAggregator;
+        bool IsExternalBackupController;
         bool AreResourcesShared;
         THashSet<TTenant::TPtr> HostedTenants;
 

ydb/core/driver_lib/run/kikimr_services_initializers.cpp

@@ -180,6 +180,8 @@
 #include <ydb/core/tx/conveyor/service/service.h>
 #include <ydb/core/tx/conveyor/usage/service.h>
 
+#include <ydb/core/backup/controller/tablet.h>
+
 #include <ydb/services/bg_tasks/ds_table/executor.h>
 #include <ydb/services/bg_tasks/service.h>
 #include <ydb/services/ext_index/common/config.h>
@@ -1104,6 +1106,7 @@ void TLocalServiceInitializer::InitializeServices(
     addToLocalConfig(TTabletTypes::BlobDepot, &NBlobDepot::CreateBlobDepot, TMailboxType::ReadAsFilled, appData->UserPoolId);
     addToLocalConfig(TTabletTypes::StatisticsAggregator, &NStat::CreateStatisticsAggregator, TMailboxType::ReadAsFilled, appData->UserPoolId);
     addToLocalConfig(TTabletTypes::GraphShard, &NGraph::CreateGraphShard, TMailboxType::ReadAsFilled, appData->UserPoolId);
+    addToLocalConfig(TTabletTypes::BackupController, &NBackup::CreateBackupController, TMailboxType::ReadAsFilled, appData->UserPoolId);
 
     TTenantPoolConfig::TPtr tenantPoolConfig = new TTenantPoolConfig(Config.GetTenantPoolConfig(), localConfig);
     if (!tenantPoolConfig->IsEnabled && !tenantPoolConfig->StaticSlots.empty())

ydb/core/driver_lib/run/ya.make

@@ -45,6 +45,7 @@ PEERDIR(
     ydb/core/actorlib_impl
     ydb/core/audit
     ydb/core/base
+    ydb/core/backup/controller
     ydb/core/blob_depot
     ydb/core/blobstorage
     ydb/core/blobstorage/backpressure

ydb/core/mind/configured_tablet_bootstrapper.cpp

@@ -6,6 +6,7 @@
 
 // for 'create' funcs
 #include <ydb/core/mind/bscontroller/bsc.h>
+#include <ydb/core/backup/controller/tablet.h>
 #include <ydb/core/base/hive.h>
 #include <ydb/core/tx/coordinator/coordinator.h>
 #include <ydb/core/tx/mediator/mediator.h>
@@ -231,6 +232,9 @@ TIntrusivePtr<TTabletSetupInfo> MakeTabletSetupInfo(
     case TTabletTypes::StatisticsAggregator:
         createFunc = &NStat::CreateStatisticsAggregator;
         break;
+    case TTabletTypes::BackupController:
+        createFunc = &NBackup::CreateBackupController;
+        break;
     default:
         return nullptr;
     }

ydb/core/mind/hive/hive.cpp

@@ -132,6 +132,7 @@ const std::unordered_map<TTabletTypes::EType, TString> TABLET_TYPE_SHORT_NAMES =
                                                                                   {TTabletTypes::GraphShard, "GS"},
                                                                                   {TTabletTypes::NodeBroker, "NB"},
                                                                                   {TTabletTypes::BlockStoreDiskRegistry, "BDR"},
+                                                                                  {TTabletTypes::BackupController, "BCT"},
                                                                                  };
 
 const std::unordered_map<TString, TTabletTypes::EType> TABLET_TYPE_BY_SHORT_NAME = MakeReverseMap(TABLET_TYPE_SHORT_NAMES);

ydb/core/protos/counters_backup.proto

@@ -0,0 +1,12 @@
+import "ydb/core/protos/counters.proto";
+
+package NKikimr.NBackup;
+
+option java_package = "ru.yandex.kikimr.proto";
+
+option (TabletTypeName) = "BackupController";
+
+enum ETxTypes {
+    TXTYPE_INIT_SCHEMA = 0                                [(TxTypeOpts) = {Name: "TxInitSchema"}];
+    TXTYPE_INIT = 1                                       [(TxTypeOpts) = {Name: "TxInit"}];
+}

ydb/core/protos/counters_schemeshard.proto

@@ -197,6 +197,8 @@ enum ESimpleCounters {
     COUNTER_GRAPHSHARD_COUNT = 158 [(CounterOpts) = {Name: "GraphShards"}];
 
     COUNTER_IN_FLIGHT_OPS_TxCopySequence = 159            [(CounterOpts) = {Name: "InFlightOps/CopySequence"}];
+
+    COUNTER_BACKUP_CONTROLLER_TABLET_COUNT = 160 [(CounterOpts) = {Name: "BackupControllers"}];
 }
 
 enum ECumulativeCounters {