From ae69608375484fed91b0a286130a5ed42328f5bf Mon Sep 17 00:00:00 2001
From: sfc-gh-tclinkenbeard <trevor.clinkenbeard@snowflake.com>
Date: Sun, 25 Apr 2021 19:01:17 -0700
Subject: [PATCH] Very simple partial implementation of
 LocalConfiguration::consume

---
 fdbserver/LocalConfiguration.actor.cpp | 46 ++++++++++++++++----------
 fdbserver/LocalConfiguration.h         |  7 ++--
 fdbserver/worker.actor.cpp             |  4 ++-
 3 files changed, 34 insertions(+), 23 deletions(-)

diff --git a/fdbserver/LocalConfiguration.actor.cpp b/fdbserver/LocalConfiguration.actor.cpp
index b91eae8c13..7422049880 100644
--- a/fdbserver/LocalConfiguration.actor.cpp
+++ b/fdbserver/LocalConfiguration.actor.cpp
@@ -35,7 +35,6 @@ class LocalConfigurationImpl {
 	ConfigClassSet configClasses;
 	Version lastSeenVersion { 0 };
 	Future<Void> initFuture;
-	Reference<AsyncVar<ServerDBInfo> const> serverDBInfo;
 	TestKnobs testKnobs;
 
 	ACTOR static Future<Void> saveConfigClasses(LocalConfigurationImpl* self) {
@@ -87,20 +86,33 @@ class LocalConfigurationImpl {
 		return Void();
 	}
 
-	ACTOR static Future<Void> consume(LocalConfigurationImpl* self) {
+	Future<ConfigFollowerGetChangesReply> getChanges(ServerDBInfo serverDBInfo) {
+		if (!serverDBInfo.configFollowerInterface.present()) {
+			return Never();
+		} else {
+			return serverDBInfo.configFollowerInterface.get().getChanges.getReply(
+			    ConfigFollowerGetChangesRequest{ lastSeenVersion, {} });
+		}
+	}
+
+	ACTOR static Future<Void> consume(LocalConfigurationImpl* self,
+	                                  Reference<AsyncVar<ServerDBInfo> const> serverDBInfo) {
 		wait(self->initFuture);
 		state Future<Void> timeout = Void();
-		state Future<ConfigFollowerGetChangesReply> getChangesReply;
+		state Future<ConfigFollowerGetChangesReply> getChangesReply = Never();
 		loop {
 			choose {
-				when(wait(self->serverDBInfo->onChange())) { timeout = Void(); }
+				when(wait(serverDBInfo->onChange())) {
+					getChangesReply = self->getChanges(serverDBInfo->get());
+					timeout = Never();
+				}
 				when(wait(timeout)) {
-					getChangesReply = self->serverDBInfo->get().configFollowerInterface.get().getChanges.getReply(
-					    ConfigFollowerGetChangesRequest{ self->lastSeenVersion, {} });
-					timeout = Future<Void>{};
+					getChangesReply = self->getChanges(serverDBInfo->get());
+					timeout = Never();
 				}
 				when(ConfigFollowerGetChangesReply reply = wait(getChangesReply)) {
 					// TODO: Handle reply
+					getChangesReply = Never();
 					timeout = delay(0.5); // TODO: Make knob?
 				}
 			}
@@ -108,10 +120,8 @@ class LocalConfigurationImpl {
 	}
 
 public:
-	LocalConfigurationImpl(ConfigClassSet const& configClasses,
-	                       std::string const& dataFolder,
-	                       Reference<AsyncVar<ServerDBInfo> const> const& serverDBInfo)
-	  : configClasses(configClasses), serverDBInfo(serverDBInfo) {
+	LocalConfigurationImpl(ConfigClassSet const& configClasses, std::string const& dataFolder)
+	  : configClasses(configClasses) {
 		platform::createDirectory(dataFolder);
 		kvStore = keyValueStoreMemory(joinPath(dataFolder, "localconf-"), UID{}, 500e6);
 	}
@@ -127,13 +137,13 @@ public:
 		return testKnobs;
 	}
 
-	Future<Void> consume() { return consume(this); }
+	Future<Void> consume(Reference<AsyncVar<ServerDBInfo> const> const& serverDBInfo) {
+		return consume(this, serverDBInfo);
+	}
 };
 
-LocalConfiguration::LocalConfiguration(ConfigClassSet const& configClasses,
-                                       std::string const& dataFolder,
-                                       Reference<AsyncVar<ServerDBInfo> const> const& serverDBInfo)
-  : impl(std::make_unique<LocalConfigurationImpl>(configClasses, dataFolder, serverDBInfo)) {}
+LocalConfiguration::LocalConfiguration(ConfigClassSet const& configClasses, std::string const& dataFolder)
+  : impl(std::make_unique<LocalConfigurationImpl>(configClasses, dataFolder)) {}
 
 LocalConfiguration::~LocalConfiguration() = default;
 
@@ -145,8 +155,8 @@ TestKnobs const &LocalConfiguration::getKnobs() const {
 	return impl->getKnobs();
 }
 
-Future<Void> LocalConfiguration::consume() {
-	return impl->consume();
+Future<Void> LocalConfiguration::consume(Reference<AsyncVar<ServerDBInfo> const> const& serverDBInfo) {
+	return impl->consume(serverDBInfo);
 }
 
 #define init(knob, value) initKnob(knob, value, #knob)
diff --git a/fdbserver/LocalConfiguration.h b/fdbserver/LocalConfiguration.h
index 33dbc3e600..aff21d2290 100644
--- a/fdbserver/LocalConfiguration.h
+++ b/fdbserver/LocalConfiguration.h
@@ -38,11 +38,10 @@ class LocalConfiguration {
 	std::unique_ptr<class LocalConfigurationImpl> impl;
 
 public:
-	LocalConfiguration(ConfigClassSet const& configClasses,
-	                   std::string const& dataFolder,
-	                   Reference<AsyncVar<ServerDBInfo> const> const&);
+	LocalConfiguration(ConfigClassSet const& configClasses, std::string const& dataFolder);
 	~LocalConfiguration();
 	Future<Void> init();
 	TestKnobs const &getKnobs() const;
-	Future<Void> consume();
+	// TODO: Only one field of serverDBInfo is required, so improve encapsulation
+	Future<Void> consume(Reference<AsyncVar<ServerDBInfo> const> const&);
 };
diff --git a/fdbserver/worker.actor.cpp b/fdbserver/worker.actor.cpp
index f105c33e6f..fce190e513 100644
--- a/fdbserver/worker.actor.cpp
+++ b/fdbserver/worker.actor.cpp
@@ -2022,6 +2022,8 @@ ACTOR Future<Void> fdbd(Reference<ClusterConnectionFile> connFile,
                         std::string whitelistBinPaths) {
 	state vector<Future<Void>> actors;
 	state Promise<Void> recoveredDiskFiles;
+	state LocalConfiguration localConfig(ConfigClassSet{}, dataFolder);
+	wait(localConfig.init());
 
 	actors.push_back(serveProtocolInfo());
 
@@ -2056,8 +2058,8 @@ ACTOR Future<Void> fdbd(Reference<ClusterConnectionFile> connFile,
 		auto asyncPriorityInfo =
 		    makeReference<AsyncVar<ClusterControllerPriorityInfo>>(getCCPriorityInfo(fitnessFilePath, processClass));
 		auto dbInfo = makeReference<AsyncVar<ServerDBInfo>>();
-		LocalConfiguration localConfig(ConfigClassSet{}, dataFolder, dbInfo);
 
+		actors.push_back(reportErrors(localConfig.consume(dbInfo), "LocalConfiguration"));
 		actors.push_back(reportErrors(monitorAndWriteCCPriorityInfo(fitnessFilePath, asyncPriorityInfo),
 		                              "MonitorAndWriteCCPriorityInfo"));
 		if (processClass.machineClassFitness(ProcessClass::ClusterController) == ProcessClass::NeverAssign) {