Class StartFullBackupTaskFunc

fdbclient/FileBackupAgent.actor.cpp:2707–2800

}

struct StartFullBackupTaskFunc : BackupTaskFuncBase {
	static StringRef name;
	static constexpr uint32_t version = 1;

	static struct {
		static TaskParam<Version> beginVersion() { return LiteralStringRef(__FUNCTION__); }
	} Params;

	ACTOR static Future<Void> _execute(Database cx,
	                                   Reference<TaskBucket> taskBucket,
	                                   Reference<FutureBucket> futureBucket,
	                                   Reference<Task> task) {
		wait(checkTaskVersion(cx, task, StartFullBackupTaskFunc::name, StartFullBackupTaskFunc::version));

		state Reference<ReadYourWritesTransaction> tr(new ReadYourWritesTransaction(cx));
		state BackupConfig config(task);
		state Future<Optional<bool>> partitionedLog;
		loop {
			try {
				tr->setOption(FDBTransactionOptions::ACCESS_SYSTEM_KEYS);
				tr->setOption(FDBTransactionOptions::LOCK_AWARE);
				partitionedLog = config.partitionedLogEnabled().get(tr);
				state Future<Version> startVersionFuture = tr->getReadVersion();
				wait(success(partitionedLog) && success(startVersionFuture));

				Params.beginVersion().set(task, startVersionFuture.get());
				break;
			} catch (Error& e) {
				wait(tr->onError(e));
			}
		}

		// Check if backup worker is enabled
		DatabaseConfiguration dbConfig = wait(getDatabaseConfiguration(cx));
		state bool backupWorkerEnabled = dbConfig.backupWorkerEnabled;
		if (!backupWorkerEnabled && partitionedLog.get().present() && partitionedLog.get().get()) {
			// Change configuration only when we set to use partitioned logs and
			// the flag was not set before.
			wait(success(ManagementAPI::changeConfig(cx.getReference(), "backup_worker_enabled:=1", true)));
			backupWorkerEnabled = true;
		}

		// Set the "backupStartedKey" and wait for all backup worker started
		tr->reset();
		loop {
			state Future<Void> watchFuture;
			try {
				tr->setOption(FDBTransactionOptions::ACCESS_SYSTEM_KEYS);
				tr->setOption(FDBTransactionOptions::LOCK_AWARE);
				state Future<Void> keepRunning = taskBucket->keepRunning(tr, task);

				state Future<Optional<Value>> started = tr->get(backupStartedKey);
				state Future<Optional<Value>> taskStarted = tr->get(config.allWorkerStarted().key);
				partitionedLog = config.partitionedLogEnabled().get(tr);
				wait(success(started) && success(taskStarted) && success(partitionedLog));

				if (!partitionedLog.get().present() || !partitionedLog.get().get()) {
					return Void(); // Skip if not using partitioned logs