From 34715ec1fa6cc18169f9be61a4e1da3419d0d016 Mon Sep 17 00:00:00 2001
From: Balachandar Namasivayam <bnamasivayam@apple.com>
Date: Wed, 28 Feb 2018 18:22:45 -0800
Subject: [PATCH 1/7] Improve fdbbackup status

Additional details added are
log bytes written
range bytes written
last snapshot version and its corresponding timestamp
last log version and its corresponding timestamp
If backup is supposed to stop at the next snapshot completion (stopWhenDone)
version/timestamp of snapshot start and expected end

Backup error reporting format changed to

Recent Errors (since latest restore point TIME ago)
	<TIME> ago:  <error description> on <task name>
Older Errors
	<TIME> ago:  <error description> on <task name>

TIME format:
<= 59 seconds ago
<= 59.99 minutes ago
<= 23.99 hours ago
N.NN days ago
---
 fdbclient/BackupAgent.h             |  3 +-
 fdbclient/FileBackupAgent.actor.cpp | 98 +++++++++++++++++++++++++----
 2 files changed, 87 insertions(+), 14 deletions(-)

diff --git a/fdbclient/BackupAgent.h b/fdbclient/BackupAgent.h
index 761a417c804..1b06315165c 100644
--- a/fdbclient/BackupAgent.h
+++ b/fdbclient/BackupAgent.h
@@ -735,9 +735,8 @@ class BackupConfig : public KeyBackedConfig {
 		// These should not happen
 		if(e.code() == error_code_key_not_found)
 			t.backtrace();
-		std::string msg = format("ERROR: %s %s", e.what(), details.c_str());
 
-		return updateErrorInfo(cx, e, msg);
+		return updateErrorInfo(cx, e, details);
 	}
 };
 #endif
diff --git a/fdbclient/FileBackupAgent.actor.cpp b/fdbclient/FileBackupAgent.actor.cpp
index c2f559c510a..9d202e32009 100644
--- a/fdbclient/FileBackupAgent.actor.cpp
+++ b/fdbclient/FileBackupAgent.actor.cpp
@@ -35,6 +35,49 @@
 #include <boost/algorithm/string/classification.hpp>
 #include <algorithm>
 
+static std::string boolToYesOrNo(bool val) { return val ? std::string("Yes") : std::string("No"); }
+
+static std::string versionToString(Optional<Version> version) {
+	if (version.present())
+		return std::to_string(version.get());
+	else
+		return "N/A";
+}
+
+static std::string timeStampToString(Optional<int64_t> ts) {
+	if (!ts.present())
+		return "N/A";
+	time_t curTs = ts.get();
+	char buffer[128];
+	struct tm* timeinfo;
+	timeinfo = localtime(&curTs);
+	strftime(buffer, 128, "%D %T", timeinfo);
+	return std::string(buffer);
+}
+
+static Future<Optional<int64_t>> getTimestampFromVersion(Optional<Version> ver, Reference<ReadYourWritesTransaction> tr) {
+	if (!ver.present())
+		return Optional<int64_t>();
+
+	return timeKeeperEpochsFromVersion(ver.get(), tr);
+}
+
+// Time format :
+// <= 59 seconds
+// <= 59.99 minutes
+// <= 23.99 hours
+// N.NN days
+std::string secondsToTimeFormat(int64_t seconds) {
+	if (seconds >= 86400)
+		return format("%.2f day(s)", seconds / 86400.0);
+	else if (seconds >= 3600)
+		return format("%.2f hour(s)", seconds / 3600.0);
+	else if (seconds >= 60)
+		return format("%.2f minute(s)", seconds / 60.0);
+	else
+		return format("%ld second(s)", seconds);
+}
+
 const Key FileBackupAgent::keyLastRestorable = LiteralStringRef("last_restorable");
 
 // For convenience
@@ -177,9 +220,8 @@ class RestoreConfig : public KeyBackedConfig {
 		// These should not happen
 		if(e.code() == error_code_key_not_found)
 			t.backtrace();
-		std::string msg = format("ERROR: %s (%s)", details.c_str(), e.what());
 
-		return updateErrorInfo(cx, e, msg);
+		return updateErrorInfo(cx, e, details);
 	}
 
 	Key mutationLogPrefix() {
@@ -790,7 +832,7 @@ namespace fileBackup {
 	// servers to catch and log to the appropriate config any error that execute/finish didn't catch and log.
 	struct RestoreTaskFuncBase : TaskFuncBase {
 		virtual Future<Void> handleError(Database cx, Reference<Task> task, Error const &error) {
-			return RestoreConfig(task).logError(cx, error, format("Task '%s' UID '%s' %s failed", task->params[Task::reservedTaskParamKeyType].printable().c_str(), task->key.printable().c_str(), toString(task).c_str()));
+			return RestoreConfig(task).logError(cx, error, format("'%s' on '%s'", error.what(), task->params[Task::reservedTaskParamKeyType].printable().c_str()));
 		}
 		virtual std::string toString(Reference<Task> task)
 		{
@@ -800,7 +842,7 @@ namespace fileBackup {
 
 	struct BackupTaskFuncBase : TaskFuncBase {
 		virtual Future<Void> handleError(Database cx, Reference<Task> task, Error const &error) {
-			return BackupConfig(task).logError(cx, error, format("Task '%s' UID '%s' %s failed", task->params[Task::reservedTaskParamKeyType].printable().c_str(), task->key.printable().c_str(), toString(task).c_str()));
+			return BackupConfig(task).logError(cx, error, format("'%s' on '%s'", error.what(), task->params[Task::reservedTaskParamKeyType].printable().c_str()));
 		}
 		virtual std::string toString(Reference<Task> task)
 		{
@@ -3536,19 +3578,46 @@ class FileBackupAgentImpl {
 
 					if(snapshotProgress) {
 						state int64_t snapshotInterval;
-						state Version snapshotBeginVersion;
-						state Version snapshotTargetEndVersion;
+						state Version snapshotBeginVersion; state Version snapshotTargetEndVersion;
+						state Optional<Version> latestSnapshotEndVersion; state Optional<Version> latestLogEndVersion;
+						state Optional<int64_t> logBytesWritten; state Optional<int64_t> rangeBytesWritten; state Optional<int64_t> latestSnapshotEndVersionTimestamp;
+						state Optional<int64_t> latestLogEndVersionTimestamp; state Optional<int64_t> snapshotBeginVersionTimestamp; state Optional<int64_t> snapshotTargetEndVersionTimestamp;
+						state bool stopWhenDone;
 
 						Void _ = wait( store(config.snapshotBeginVersion().getOrThrow(tr), snapshotBeginVersion)
 									&& store(config.snapshotTargetEndVersion().getOrThrow(tr), snapshotTargetEndVersion)
 									&& store(config.snapshotIntervalSeconds().getOrThrow(tr), snapshotInterval)
-								);
+									&& store(config.logBytesWritten().get(tr), logBytesWritten)
+									&& store(config.rangeBytesWritten().get(tr), rangeBytesWritten)
+									&& store(config.latestLogEndVersion().get(tr), latestLogEndVersion)
+									&& store(config.latestSnapshotEndVersion().get(tr), latestSnapshotEndVersion)
+									&& store(config.stopWhenDone().getOrThrow(tr), stopWhenDone) 
+									);
+
+						Void _ = wait( store(getTimestampFromVersion(latestSnapshotEndVersion, tr), latestSnapshotEndVersionTimestamp)
+									&& store(getTimestampFromVersion(latestLogEndVersion, tr), latestLogEndVersionTimestamp)
+									&& store(timeKeeperEpochsFromVersion(snapshotBeginVersion, tr), snapshotBeginVersionTimestamp)
+									&& store(timeKeeperEpochsFromVersion(snapshotTargetEndVersion, tr), snapshotTargetEndVersionTimestamp)
+									);
 
 						statusText += format("Snapshot interval is %lld seconds.  ", snapshotInterval);
 						if(backupState == BackupAgentBase::STATE_DIFFERENTIAL)
 							statusText += format("Current snapshot progress target is %3.2f%% (>100%% means the snapshot is supposed to be done)\n", 100.0 * (recentReadVersion - snapshotBeginVersion) / (snapshotTargetEndVersion - snapshotBeginVersion)) ;
 						else
 							statusText += "The initial snapshot is still running.\n";
+						
+						statusText += format("\nDetails:\n LogBytes written - %ld\n RangeBytes written - %ld\n "
+											 "Last complete log version and timestamp        - %s, %s\n "
+											 "Last complete snapshot version and timestamp   - %s, %s\n "
+											 "Current Snapshot start version and timestamp   - %s, %s\n "
+											 "Expected snapshot end version and timestamp    - %s, %s\n "
+											 "Backup supposed to stop at next snapshot completion - %s\n",
+											 logBytesWritten.orDefault(0), rangeBytesWritten.orDefault(0),
+											 versionToString(latestLogEndVersion).c_str(), timeStampToString(latestLogEndVersionTimestamp).c_str(),
+											 versionToString(latestSnapshotEndVersion).c_str(), timeStampToString(latestSnapshotEndVersionTimestamp).c_str(),
+											 versionToString(snapshotBeginVersion).c_str(), timeStampToString(snapshotBeginVersionTimestamp).c_str(),
+											 versionToString(snapshotTargetEndVersion).c_str(), timeStampToString(snapshotTargetEndVersionTimestamp).c_str(),
+											 boolToYesOrNo(stopWhenDone).c_str());
 					}
 
 					// Append the errors, if requested
@@ -3559,8 +3628,7 @@ class FileBackupAgentImpl {
 
 						for(auto &e : errors) {
 							Version v = e.second.second;
-							std::string msg = format("%s (%lld seconds ago)\n", e.second.first.c_str(),
-														(recentReadVersion - v) / CLIENT_KNOBS->CORE_VERSIONSPERSECOND);
+							std::string msg = format("%s ago : %s\n", secondsToTimeFormat((recentReadVersion - v) / CLIENT_KNOBS->CORE_VERSIONSPERSECOND).c_str(), e.second.first.c_str());
 
 							// If error version is at or more recent than the latest restorable version then it could be inhibiting progress
 							if(v >= latestRestorableVersion.orDefault(0)) {
@@ -3571,10 +3639,16 @@ class FileBackupAgentImpl {
 							}
 						}
 
-						if(!recentErrors.empty())
-							statusText += "Errors possibly preventing progress:\n" + recentErrors;
+						if (!recentErrors.empty()) {
+							if (latestRestorableVersion.present())
+								statusText += format("Recent Errors (since latest restorable point %s ago)\n",
+														secondsToTimeFormat((recentReadVersion - latestRestorableVersion.get()) / CLIENT_KNOBS->CORE_VERSIONSPERSECOND).c_str())
+											  + recentErrors;
+							else
+								statusText += "Recent Errors (since initialization)\n" + recentErrors;
+						}
 						if(!pastErrors.empty())
-							statusText += "Older errors:\n" + pastErrors;
+							statusText += "Older Errors\n" + pastErrors;
 					}
 				}
 

From 3c3460f201032cd00c149ff51201982ac8600442 Mon Sep 17 00:00:00 2001
From: Alvin Moore <alvinm@apple.com>
Date: Thu, 1 Mar 2018 11:17:59 -0800
Subject: [PATCH 2/7] Fixed suffix for build dependency

---
 build/packages.mk | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/build/packages.mk b/build/packages.mk
index a93f2e74fa3..36f10dcc9d2 100644
--- a/build/packages.mk
+++ b/build/packages.mk
@@ -4,13 +4,13 @@
 # This source file is part of the FoundationDB open source project
 #
 # Copyright 2013-2018 Apple Inc. and the FoundationDB project authors
-# 
+#
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
-# 
+#
 #     http://www.apache.org/licenses/LICENSE-2.0
-# 
+#
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -26,7 +26,7 @@ PACKAGE_CONTENTS := $(addprefix bin/, $(PACKAGE_BINARIES)) $(addprefix bin/, $(a
 
 packages: TGZ FDBSERVERAPI
 
-TGZ: $(PACKAGE_CONTENTS) versions.target lib/libfdb_java.so
+TGZ: $(PACKAGE_CONTENTS) versions.target lib/libfdb_java.$(DLEXT)
 	@echo "Archiving      tgz"
 	@mkdir -p packages
 	@rm -f packages/FoundationDB-$(PLATFORM)-*.tar.gz

From 066a9b7e5587b6f6bc53c7c037ffbd0a9c349084 Mon Sep 17 00:00:00 2001
From: Balachandar Namasivayam <bnamasivayam@apple.com>
Date: Fri, 2 Mar 2018 16:30:13 -0800
Subject: [PATCH 3/7] Declare each state variable on its own line...

---
 fdbclient/FileBackupAgent.actor.cpp | 14 ++++++++++----
 1 file changed, 10 insertions(+), 4 deletions(-)

diff --git a/fdbclient/FileBackupAgent.actor.cpp b/fdbclient/FileBackupAgent.actor.cpp
index 9d202e32009..72dc9b1a164 100644
--- a/fdbclient/FileBackupAgent.actor.cpp
+++ b/fdbclient/FileBackupAgent.actor.cpp
@@ -3578,10 +3578,16 @@ class FileBackupAgentImpl {
 
 					if(snapshotProgress) {
 						state int64_t snapshotInterval;
-						state Version snapshotBeginVersion; state Version snapshotTargetEndVersion;
-						state Optional<Version> latestSnapshotEndVersion; state Optional<Version> latestLogEndVersion;
-						state Optional<int64_t> logBytesWritten; state Optional<int64_t> rangeBytesWritten; state Optional<int64_t> latestSnapshotEndVersionTimestamp;
-						state Optional<int64_t> latestLogEndVersionTimestamp; state Optional<int64_t> snapshotBeginVersionTimestamp; state Optional<int64_t> snapshotTargetEndVersionTimestamp;
+						state Version snapshotBeginVersion;
+						state Version snapshotTargetEndVersion;
+						state Optional<Version> latestSnapshotEndVersion;
+						state Optional<Version> latestLogEndVersion;
+						state Optional<int64_t> logBytesWritten;
+						state Optional<int64_t> rangeBytesWritten;
+						state Optional<int64_t> latestSnapshotEndVersionTimestamp;
+						state Optional<int64_t> latestLogEndVersionTimestamp;
+						state Optional<int64_t> snapshotBeginVersionTimestamp;
+						state Optional<int64_t> snapshotTargetEndVersionTimestamp;
 						state bool stopWhenDone;
 
 						Void _ = wait( store(config.snapshotBeginVersion().getOrThrow(tr), snapshotBeginVersion)

From 11df1aeabf2ea4c3efb5dbbd177984ff09ca11df Mon Sep 17 00:00:00 2001
From: Balachandar Namasivayam <bnamasivayam@apple.com>
Date: Fri, 2 Mar 2018 16:50:30 -0800
Subject: [PATCH 4/7] Add new api to get shared tlogs id and address

---
 fdbserver/LogSystemConfig.h       | 19 +++++++++++++++++++
 fdbserver/MasterInterface.h       |  2 ++
 fdbserver/OldTLogServer.actor.cpp |  3 +--
 fdbserver/TLogInterface.h         |  8 ++++++--
 fdbserver/TLogServer.actor.cpp    | 17 +++++++----------
 flow/Net2.actor.cpp               |  2 +-
 6 files changed, 36 insertions(+), 15 deletions(-)

diff --git a/fdbserver/LogSystemConfig.h b/fdbserver/LogSystemConfig.h
index 81295e9824b..b4ca5cfa5d5 100644
--- a/fdbserver/LogSystemConfig.h
+++ b/fdbserver/LogSystemConfig.h
@@ -126,6 +126,25 @@ struct LogSystemConfig {
 		return results;
 	}
 
+	std::vector<std::pair<UID, NetworkAddress>> allSharedLogs() const {
+		typedef std::pair<UID, NetworkAddress> IdAddrPair;
+		std::vector<IdAddrPair> results;
+		for (auto tLog : tLogs)
+			if (tLog.present())
+				results.push_back(IdAddrPair(tLog.interf().getSharedTLogID(), tLog.interf().address()));
+
+		for (auto &oldLog : oldTLogs) {
+			for (auto &tLog : oldLog.tLogs) {
+				if (tLog.present())
+					results.push_back(IdAddrPair(tLog.interf().getSharedTLogID(), tLog.interf().address()));
+			}
+		}
+		uniquify(results);
+		// This assert depends on the fact that uniquify will sort the elements based on <UID, NetworkAddr> order
+		ASSERT_WE_THINK(std::unique(results.begin(), results.end(), [](IdAddrPair &x, IdAddrPair &y) { return x.first == y.first; }) == results.end());
+		return results;
+	}
+
 	bool operator == ( const LogSystemConfig& rhs ) const { return isEqual(rhs); }
 
 	bool isEqual(LogSystemConfig const& r) const {
diff --git a/fdbserver/MasterInterface.h b/fdbserver/MasterInterface.h
index 5b012a36474..7e788a9de75 100644
--- a/fdbserver/MasterInterface.h
+++ b/fdbserver/MasterInterface.h
@@ -80,6 +80,8 @@ struct TLogRejoinRequest {
 	DBRecoveryCount recoveryCount;
 	ReplyPromise<bool> reply;   // false means someone else registered, so we should re-register.  true means this master is recovered, so don't send again to the same master.
 
+	TLogRejoinRequest() { }
+	explicit TLogRejoinRequest(const TLogInterface &interf) : myInterface(interf) { }
 	template <class Ar>
 	void serialize(Ar& ar) {
 		ar & myInterface & reply;
diff --git a/fdbserver/OldTLogServer.actor.cpp b/fdbserver/OldTLogServer.actor.cpp
index ee2cb182e22..a2623114b3f 100644
--- a/fdbserver/OldTLogServer.actor.cpp
+++ b/fdbserver/OldTLogServer.actor.cpp
@@ -1417,8 +1417,7 @@ namespace oldTLog {
 
 			if (self->dbInfo->get().master.id() != lastMasterID) {
 				// The TLogRejoinRequest is needed to establish communications with a new master, which doesn't have our TLogInterface
-				TLogRejoinRequest req;
-				req.myInterface = tli;
+				TLogRejoinRequest req(tli);
 				TraceEvent("TLogRejoining", self->dbgid).detail("Master", self->dbInfo->get().master.id());
 				choose {
 					when ( bool success = wait( brokenPromiseToNever( self->dbInfo->get().master.tlogRejoin.getReply( req ) ) ) ) {
diff --git a/fdbserver/TLogInterface.h b/fdbserver/TLogInterface.h
index b318217ee34..e2afa61d1b5 100644
--- a/fdbserver/TLogInterface.h
+++ b/fdbserver/TLogInterface.h
@@ -32,6 +32,7 @@ struct TLogInterface {
 	enum { LocationAwareLoadBalance = 1 };
 	LocalityData locality;
 	UID uniqueID;
+	UID sharedTLogID;
 	RequestStream< struct TLogPeekRequest > peekMessages;
 	RequestStream< struct TLogPopRequest > popMessages;
 
@@ -42,8 +43,11 @@ struct TLogInterface {
 	RequestStream<ReplyPromise<Void>> waitFailure;
 	RequestStream< struct TLogRecoveryFinishedRequest > recoveryFinished;
 	
-	TLogInterface() : uniqueID( g_random->randomUniqueID() ) {}
+	TLogInterface() { }
+	TLogInterface(UID _sharedTLogID, LocalityData _locality) : uniqueID( g_random->randomUniqueID() ), sharedTLogID(_sharedTLogID), locality(_locality) {}
+	TLogInterface(UID _uniqueID, UID _sharedTLogID, LocalityData _locality) : uniqueID(_uniqueID), sharedTLogID(_sharedTLogID), locality(_locality) {}
 	UID id() const { return uniqueID; }
+	UID getSharedTLogID() const { return sharedTLogID; }
 	std::string toString() const { return id().shortString(); }
 	bool operator == ( TLogInterface const& r ) const { return id() == r.id(); }
 	NetworkAddress address() const { return peekMessages.getEndpoint().address; }
@@ -57,7 +61,7 @@ struct TLogInterface {
 
 	template <class Ar> 
 	void serialize( Ar& ar ) {
-		ar & uniqueID & locality & peekMessages & popMessages 
+		ar & uniqueID & sharedTLogID & locality & peekMessages & popMessages
 		   & commit & lock & getQueuingMetrics & confirmRunning & waitFailure & recoveryFinished;
 	}
 };
diff --git a/fdbserver/TLogServer.actor.cpp b/fdbserver/TLogServer.actor.cpp
index 01937cc6e1e..32ed9e00538 100644
--- a/fdbserver/TLogServer.actor.cpp
+++ b/fdbserver/TLogServer.actor.cpp
@@ -1119,8 +1119,7 @@ ACTOR Future<Void> rejoinMasters( TLogData* self, TLogInterface tli, DBRecoveryC
 		if( registerWithMaster.isReady() ) {
 			if ( self->dbInfo->get().master.id() != lastMasterID) {
 				// The TLogRejoinRequest is needed to establish communications with a new master, which doesn't have our TLogInterface
-				TLogRejoinRequest req;
-				req.myInterface = tli;
+				TLogRejoinRequest req(tli);
 				TraceEvent("TLogRejoining", self->dbgid).detail("Master", self->dbInfo->get().master.id());
 				choose {
 					when ( bool success = wait( brokenPromiseToNever( self->dbInfo->get().master.tlogRejoin.getReply( req ) ) ) ) {
@@ -1341,9 +1340,7 @@ ACTOR Future<Void> restorePersistentState( TLogData* self, LocalityData locality
 	state std::vector<Future<ErrorOr<Void>>> removed;
 
 	if(fFormat.get().get() == LiteralStringRef("FoundationDB/LogServer/2/2")) {
-		TLogInterface recruited;
-		recruited.uniqueID = self->dbgid;
-		recruited.locality = locality;
+		TLogInterface recruited(self->dbgid, self->dbgid, locality);
 		recruited.initEndpoints();
 
 		DUMPTOKEN( recruited.peekMessages );
@@ -1374,9 +1371,7 @@ ACTOR Future<Void> restorePersistentState( TLogData* self, LocalityData locality
 		UID id2 = BinaryReader::fromStringRef<UID>( fRecoverCounts.get()[idx].key.removePrefix(persistRecoveryCountKeys.begin), Unversioned() );
 		ASSERT(id1 == id2);
 
-		TLogInterface recruited;
-		recruited.uniqueID = id1;
-		recruited.locality = locality;
+		TLogInterface recruited(id1, id1, locality);
 		recruited.initEndpoints();
 
 		DUMPTOKEN( recruited.peekMessages );
@@ -1679,7 +1674,7 @@ ACTOR Future<Void> recoverFromLogSystem( TLogData* self, Reference<LogData> logD
 }
 
 ACTOR Future<Void> tLogStart( TLogData* self, InitializeTLogRequest req, LocalityData locality ) {
-	state TLogInterface recruited;
+	state TLogInterface recruited(self->dbgid, locality);
 	recruited.locality = locality;
 	recruited.initEndpoints();
 
@@ -1758,7 +1753,8 @@ ACTOR Future<Void> tLog( IKeyValueStore* persistentData, IDiskQueue* persistentQ
 	state Future<Void> error = actorCollection( self.sharedActors.getFuture() );
 
 	TraceEvent("SharedTlog", tlogId);
-
+	// FIXME: Pass the worker id instead of stubbing it
+	startRole(tlogId, UID(), "SharedTLog");
 	try {
 		if(restoreFromDisk) {
 			Void _ = wait( restorePersistentState( &self, locality, oldLog, recovered, tlogRequests ) );
@@ -1787,6 +1783,7 @@ ACTOR Future<Void> tLog( IKeyValueStore* persistentData, IDiskQueue* persistentQ
 		}
 	} catch (Error& e) {
 		TraceEvent("TLogError", tlogId).error(e, true);
+		endRole(tlogId, "SharedTLog", "Error", true);
 		if(recovered.canBeSet()) recovered.send(Void());
 
 		while(!tlogRequests.isEmpty()) {
diff --git a/flow/Net2.actor.cpp b/flow/Net2.actor.cpp
index 602dfda5b8d..1817592b5d4 100644
--- a/flow/Net2.actor.cpp
+++ b/flow/Net2.actor.cpp
@@ -51,7 +51,7 @@ using namespace boost::asio::ip;
 // These impact both communications and the deserialization of certain database and IKeyValueStore keys
 //                                                 xyzdev
 //                                                 vvvv
-uint64_t currentProtocolVersion        = 0x0FDB00A551040001LL;
+uint64_t currentProtocolVersion        = 0x0FDB00A551060001LL;
 uint64_t compatibleProtocolVersionMask = 0xffffffffffff0000LL;
 uint64_t minValidProtocolVersion       = 0x0FDB00A200060001LL;
 

From 8ae640c06234c02f6a78cf2dda0f2d859a55ce18 Mon Sep 17 00:00:00 2001
From: Balachandar Namasivayam <bnamasivayam@apple.com>
Date: Fri, 2 Mar 2018 17:56:49 -0800
Subject: [PATCH 5/7] Addressed review comments.

---
 fdbserver/LogSystemConfig.h    | 3 ++-
 fdbserver/MasterInterface.h    | 1 -
 fdbserver/TLogInterface.h      | 4 ++--
 fdbserver/TLogServer.actor.cpp | 2 +-
 4 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/fdbserver/LogSystemConfig.h b/fdbserver/LogSystemConfig.h
index b4ca5cfa5d5..491b4559dfa 100644
--- a/fdbserver/LogSystemConfig.h
+++ b/fdbserver/LogSystemConfig.h
@@ -129,9 +129,10 @@ struct LogSystemConfig {
 	std::vector<std::pair<UID, NetworkAddress>> allSharedLogs() const {
 		typedef std::pair<UID, NetworkAddress> IdAddrPair;
 		std::vector<IdAddrPair> results;
-		for (auto tLog : tLogs)
+		for (auto &tLog : tLogs) {
 			if (tLog.present())
 				results.push_back(IdAddrPair(tLog.interf().getSharedTLogID(), tLog.interf().address()));
+		}
 
 		for (auto &oldLog : oldTLogs) {
 			for (auto &tLog : oldLog.tLogs) {
diff --git a/fdbserver/MasterInterface.h b/fdbserver/MasterInterface.h
index 7e788a9de75..7cfb9b6fece 100644
--- a/fdbserver/MasterInterface.h
+++ b/fdbserver/MasterInterface.h
@@ -77,7 +77,6 @@ struct GetRateInfoReply {
 
 struct TLogRejoinRequest {
 	TLogInterface myInterface;
-	DBRecoveryCount recoveryCount;
 	ReplyPromise<bool> reply;   // false means someone else registered, so we should re-register.  true means this master is recovered, so don't send again to the same master.
 
 	TLogRejoinRequest() { }
diff --git a/fdbserver/TLogInterface.h b/fdbserver/TLogInterface.h
index e2afa61d1b5..8836d51040f 100644
--- a/fdbserver/TLogInterface.h
+++ b/fdbserver/TLogInterface.h
@@ -44,8 +44,8 @@ struct TLogInterface {
 	RequestStream< struct TLogRecoveryFinishedRequest > recoveryFinished;
 	
 	TLogInterface() { }
-	TLogInterface(UID _sharedTLogID, LocalityData _locality) : uniqueID( g_random->randomUniqueID() ), sharedTLogID(_sharedTLogID), locality(_locality) {}
-	TLogInterface(UID _uniqueID, UID _sharedTLogID, LocalityData _locality) : uniqueID(_uniqueID), sharedTLogID(_sharedTLogID), locality(_locality) {}
+	TLogInterface(UID sharedTLogID, LocalityData locality) : uniqueID( g_random->randomUniqueID() ), sharedTLogID(sharedTLogID), locality(locality) {}
+	TLogInterface(UID uniqueID, UID sharedTLogID, LocalityData locality) : uniqueID(uniqueID), sharedTLogID(sharedTLogID), locality(locality) {}
 	UID id() const { return uniqueID; }
 	UID getSharedTLogID() const { return sharedTLogID; }
 	std::string toString() const { return id().shortString(); }
diff --git a/fdbserver/TLogServer.actor.cpp b/fdbserver/TLogServer.actor.cpp
index 32ed9e00538..305f1450335 100644
--- a/fdbserver/TLogServer.actor.cpp
+++ b/fdbserver/TLogServer.actor.cpp
@@ -1371,7 +1371,7 @@ ACTOR Future<Void> restorePersistentState( TLogData* self, LocalityData locality
 		UID id2 = BinaryReader::fromStringRef<UID>( fRecoverCounts.get()[idx].key.removePrefix(persistRecoveryCountKeys.begin), Unversioned() );
 		ASSERT(id1 == id2);
 
-		TLogInterface recruited(id1, id1, locality);
+		TLogInterface recruited(id1, self->dbgid, locality);
 		recruited.initEndpoints();
 
 		DUMPTOKEN( recruited.peekMessages );

From fd4c9d5b54756205d60fe14dc07e7afda9579efa Mon Sep 17 00:00:00 2001
From: "A.J. Beamon" <ajbeamon@apple.com>
Date: Mon, 5 Mar 2018 10:37:52 -0800
Subject: [PATCH 6/7] Fix line endings

---
 fdbclient/NativeAPI.actor.cpp | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/fdbclient/NativeAPI.actor.cpp b/fdbclient/NativeAPI.actor.cpp
index abf54d25ffa..008cd989bb8 100644
--- a/fdbclient/NativeAPI.actor.cpp
+++ b/fdbclient/NativeAPI.actor.cpp
@@ -890,12 +890,12 @@ Reference<ProxyInfo> DatabaseContext::getMasterProxies() {
 }
 
 //Actor which will wait until the ProxyInfo returned by the DatabaseContext cx is not NULL
-ACTOR Future<Reference<ProxyInfo>> getMasterProxiesFuture(DatabaseContext *cx) {
-	loop{
-		Reference<ProxyInfo> proxies = cx->getMasterProxies();
-		if (proxies)
-			return proxies;
-		Void _ = wait( cx->onMasterProxiesChanged() );
+ACTOR Future<Reference<ProxyInfo>> getMasterProxiesFuture(DatabaseContext *cx) {
+	loop{
+		Reference<ProxyInfo> proxies = cx->getMasterProxies();
+		if (proxies)
+			return proxies;
+		Void _ = wait( cx->onMasterProxiesChanged() );
 	}
 }
 

From 94e90454da81fcfeb37b92fc49371628544b0c7b Mon Sep 17 00:00:00 2001
From: "A.J. Beamon" <ajbeamon@apple.com>
Date: Mon, 5 Mar 2018 12:16:37 -0800
Subject: [PATCH 7/7] Fix line endings

---
 fdbclient/FileBackupAgent.actor.cpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/fdbclient/FileBackupAgent.actor.cpp b/fdbclient/FileBackupAgent.actor.cpp
index 72dc9b1a164..a79fe34d9f7 100644
--- a/fdbclient/FileBackupAgent.actor.cpp
+++ b/fdbclient/FileBackupAgent.actor.cpp
@@ -62,10 +62,10 @@ static Future<Optional<int64_t>> getTimestampFromVersion(Optional<Version> ver,
 	return timeKeeperEpochsFromVersion(ver.get(), tr);
 }
 
-// Time format :
-// <= 59 seconds
-// <= 59.99 minutes
-// <= 23.99 hours
+// Time format :
+// <= 59 seconds
+// <= 59.99 minutes
+// <= 23.99 hours
 // N.NN days
 std::string secondsToTimeFormat(int64_t seconds) {
 	if (seconds >= 86400)