Method _execute

fdbclient/FileBackupAgent.actor.cpp:1448–1487

	enum DispatchState { SKIP = 0, DONE = 1, NOT_DONE_MIN = 2 };

	ACTOR static Future<Void> _execute(Database cx,
	                                   Reference<TaskBucket> taskBucket,
	                                   Reference<FutureBucket> futureBucket,
	                                   Reference<Task> task) {
		state Reference<FlowLock> lock(new FlowLock(CLIENT_KNOBS->BACKUP_LOCK_BYTES));
		wait(checkTaskVersion(cx, task, name, version));

		state double startTime = timer();
		state Reference<ReadYourWritesTransaction> tr(new ReadYourWritesTransaction(cx));

		// The shard map will use 3 values classes.  Exactly SKIP, exactly DONE, then any number >= NOT_DONE_MIN which
		// will mean not done. This is to enable an efficient coalesce() call to squash adjacent ranges which are not
		// yet finished to enable efficiently finding random database shards which are not done.
		state int notDoneSequence = NOT_DONE_MIN;
		state KeyRangeMap<int> shardMap(notDoneSequence++, normalKeys.end);
		state Key beginKey = normalKeys.begin;

		// Read all shard boundaries and add them to the map
		loop {
			try {
				tr->setOption(FDBTransactionOptions::ACCESS_SYSTEM_KEYS);
				tr->setOption(FDBTransactionOptions::LOCK_AWARE);

				state Future<Standalone<VectorRef<KeyRef>>> shardBoundaries =
				    getBlockOfShards(tr, beginKey, normalKeys.end, CLIENT_KNOBS->TOO_MANY);
				wait(success(shardBoundaries) && taskBucket->keepRunning(tr, task));

				if (shardBoundaries.get().size() == 0)
					break;

				for (auto& boundary : shardBoundaries.get()) {
					shardMap.rawInsert(boundary, notDoneSequence++);
				}

				beginKey = keyAfter(shardBoundaries.get().back());
				tr->reset();
			} catch (Error& e) {
				wait(tr->onError(e));
			}
		}

		// Read required stuff from backup config
		state BackupConfig config(task);