Merge pull request #3073 from tclinken/fix-open-for-ide-build

Fix non-boost-related OPEN_FOR_IDE build errors

fdbclient/FileBackupAgent.actor.cpp

@@ -4614,11 +4614,10 @@ public:
 	// Similar to atomicRestore, only used in simulation test.
 	// locks the database before discontinuing the backup and that same lock is then used while doing the restore.
 	// the tagname of the backup must be the same as the restore.
-	ACTOR static Future<Void> atomicParallelRestore(FileBackupAgent* backupAgent, Database cx, Key tagName,
+	static Future<Void> atomicParallelRestore(FileBackupAgent* backupAgent, Database cx, Key tagName,
 	                                                Standalone<VectorRef<KeyRangeRef>> ranges, Key addPrefix,
 	                                                Key removePrefix) {
-		Version ver = wait(atomicRestore(backupAgent, cx, tagName, ranges, addPrefix, removePrefix, true));
+		return success(atomicRestore(backupAgent, cx, tagName, ranges, addPrefix, removePrefix, true));
-		return Void();
 	}
 };
 

fdbrpc/FlowTransport.actor.cpp

@@ -437,12 +437,13 @@ ACTOR Future<Void> connectionKeeper( Reference<Peer> self,
 		.detail("ConnSet", (bool)conn);
 	ASSERT_WE_THINK(FlowTransport::transport().getLocalAddress() != self->destination);
 
+	state Future<Void> delayedHealthUpdateF;
 	state Optional<double> firstConnFailedTime = Optional<double>();
 	state int retryConnect = false;
 
 	loop {
 		try {
-			state Future<Void> delayedHealthUpdateF = Future<Void>();
+			delayedHealthUpdateF = Future<Void>();
 
 			if (!conn) {  // Always, except for the first loop with an incoming connection
 				self->outgoingConnectionIdle = true;

fdbserver/CMakeLists.txt

@@ -77,6 +77,7 @@ set(FDBSERVER_SRCS
   RestoreWorker.actor.cpp
   Resolver.actor.cpp
   ResolverInterface.h
+  ServerDBInfo.actor.h
   ServerDBInfo.h
   SimulatedCluster.actor.cpp
   SimulatedCluster.h

fdbserver/RestoreMaster.actor.cpp

@@ -193,7 +193,6 @@ ACTOR Future<Void> distributeRestoreSysInfo(Reference<RestoreMasterData> masterD
 ACTOR Future<Void> startProcessRestoreRequests(Reference<RestoreMasterData> self, Database cx) {
 	state UID randomUID = deterministicRandom()->randomUniqueID();
 	state Standalone<VectorRef<RestoreRequest>> restoreRequests = wait(collectRestoreRequests(cx));
-	state int numTries = 0;
 	state int restoreIndex = 0;
 
 	TraceEvent("FastRestoreMasterWaitOnRestoreRequests", self->id()).detail("RestoreRequests", restoreRequests.size());

fdbserver/ServerDBInfo.actor.h

@@ -0,0 +1,101 @@
+/*
+ * ServerDBInfo.actor.h
+ *
+ * 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.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#if defined(NO_INTELLISENSE) && !defined(FDBSERVER_SERVERDBINFO_ACTOR_G_H)
+#define FDBSERVER_SERVERDBINFO_ACTOR_G_H
+#include "fdbserver/ServerDBInfo.actor.g.h"
+#elif !defined(FDBSERVER_SERVERDBINFO_ACTOR_H)
+#define FDBSERVER_SERVERDBINFO_ACTOR_H
+#define FDBSERVER_SERVERDBINFO_H
+#pragma once
+
+#include "fdbserver/DataDistributorInterface.h"
+#include "fdbserver/MasterInterface.h"
+#include "fdbserver/LogSystemConfig.h"
+#include "fdbserver/RatekeeperInterface.h"
+#include "fdbserver/RecoveryState.h"
+#include "fdbserver/LatencyBandConfig.h"
+#include "fdbserver/WorkerInterface.actor.h"
+#include "flow/actorcompiler.h" // This must be the last #include.
+
+struct ServerDBInfo {
+	constexpr static FileIdentifier file_identifier = 13838807;
+	// This structure contains transient information which is broadcast to all workers for a database,
+	// permitting them to communicate with each other.  It is not available to the client.  This mechanism
+	// (see GetServerDBInfoRequest) is closely parallel to OpenDatabaseRequest for the client.
+
+	UID id;  // Changes each time any other member changes
+	ClusterControllerFullInterface clusterInterface;
+	ClientDBInfo client;           // After a successful recovery, eventually proxies that communicate with it
+	Optional<DataDistributorInterface> distributor;  // The best guess of current data distributor.
+	MasterInterface master;        // The best guess as to the most recent master, which might still be recovering
+	Optional<RatekeeperInterface> ratekeeper;
+	std::vector<ResolverInterface> resolvers;
+	DBRecoveryCount recoveryCount; // A recovery count from DBCoreState.  A successful master recovery increments it twice; unsuccessful recoveries may increment it once. Depending on where the current master is in its recovery process, this might not have been written by the current master.
+	RecoveryState recoveryState;
+	LifetimeToken masterLifetime;  // Used by masterserver to detect not being the currently chosen master
+	LocalityData myLocality;       // (Not serialized) Locality information, if available, for the *local* process
+	LogSystemConfig logSystemConfig;
+	std::vector<UID> priorCommittedLogServers;   // If !fullyRecovered and logSystemConfig refers to a new log system which may not have been committed to the coordinated state yet, then priorCommittedLogServers are the previous, fully committed generation which need to stay alive in case this recovery fails
+	Optional<LatencyBandConfig> latencyBandConfig;
+	std::vector<std::pair<uint16_t,StorageServerInterface>> storageCaches;
+	int64_t infoGeneration;
+
+	ServerDBInfo() : recoveryCount(0), recoveryState(RecoveryState::UNINITIALIZED), logSystemConfig(0), infoGeneration(0) {}
+
+	bool operator == (ServerDBInfo const& r) const { return id == r.id; }
+	bool operator != (ServerDBInfo const& r) const { return id != r.id; }
+
+	template <class Ar>
+	void serialize( Ar& ar ) {
+		serializer(ar, id, clusterInterface, client, distributor, master, ratekeeper, resolvers, recoveryCount, recoveryState, masterLifetime, logSystemConfig, priorCommittedLogServers, latencyBandConfig, storageCaches, infoGeneration);
+	}
+};
+
+struct UpdateServerDBInfoRequest {
+	constexpr static FileIdentifier file_identifier = 9467438;
+	Standalone<StringRef> serializedDbInfo;
+	std::vector<Endpoint> broadcastInfo;
+	ReplyPromise<std::vector<Endpoint>> reply;
+
+	template <class Ar>
+	void serialize(Ar& ar) {
+		serializer(ar, serializedDbInfo, broadcastInfo, reply);
+	}
+};
+
+struct GetServerDBInfoRequest {
+	constexpr static FileIdentifier file_identifier = 9467439;
+	UID knownServerInfoID;
+	ReplyPromise<struct ServerDBInfo> reply;
+
+	template <class Ar>
+	void serialize(Ar& ar) {
+		serializer(ar, knownServerInfoID, reply);
+	}
+};
+
+
+ACTOR Future<Void> broadcastTxnRequest(TxnStateRequest req, int sendAmount, bool sendReply);
+
+ACTOR Future<std::vector<Endpoint>> broadcastDBInfoRequest(UpdateServerDBInfoRequest req, int sendAmount, Optional<Endpoint> sender, bool sendReply);
+
+#include "flow/unactorcompiler.h"
+#endif

fdbserver/ServerDBInfo.h

@@ -22,74 +22,6 @@
 #define FDBSERVER_SERVERDBINFO_H
 #pragma once
 
-#include "fdbserver/DataDistributorInterface.h"
+#include "fdbserver/ServerDBInfo.actor.h"
-#include "fdbserver/MasterInterface.h"
-#include "fdbserver/LogSystemConfig.h"
-#include "fdbserver/RatekeeperInterface.h"
-#include "fdbserver/RecoveryState.h"
-#include "fdbserver/LatencyBandConfig.h"
-#include "fdbserver/WorkerInterface.actor.h"
-
-struct ServerDBInfo {
-	constexpr static FileIdentifier file_identifier = 13838807;
-	// This structure contains transient information which is broadcast to all workers for a database,
-	// permitting them to communicate with each other.  It is not available to the client.  This mechanism
-	// (see GetServerDBInfoRequest) is closely parallel to OpenDatabaseRequest for the client.
-
-	UID id;  // Changes each time any other member changes
-	ClusterControllerFullInterface clusterInterface;
-	ClientDBInfo client;           // After a successful recovery, eventually proxies that communicate with it
-	Optional<DataDistributorInterface> distributor;  // The best guess of current data distributor.
-	MasterInterface master;        // The best guess as to the most recent master, which might still be recovering
-	Optional<RatekeeperInterface> ratekeeper;
-	std::vector<ResolverInterface> resolvers;
-	DBRecoveryCount recoveryCount; // A recovery count from DBCoreState.  A successful master recovery increments it twice; unsuccessful recoveries may increment it once. Depending on where the current master is in its recovery process, this might not have been written by the current master.
-	RecoveryState recoveryState;
-	LifetimeToken masterLifetime;  // Used by masterserver to detect not being the currently chosen master
-	LocalityData myLocality;       // (Not serialized) Locality information, if available, for the *local* process
-	LogSystemConfig logSystemConfig;
-	std::vector<UID> priorCommittedLogServers;   // If !fullyRecovered and logSystemConfig refers to a new log system which may not have been committed to the coordinated state yet, then priorCommittedLogServers are the previous, fully committed generation which need to stay alive in case this recovery fails
-	Optional<LatencyBandConfig> latencyBandConfig;
-	std::vector<std::pair<uint16_t,StorageServerInterface>> storageCaches;
-	int64_t infoGeneration;
-
-	ServerDBInfo() : recoveryCount(0), recoveryState(RecoveryState::UNINITIALIZED), logSystemConfig(0), infoGeneration(0) {}
-
-	bool operator == (ServerDBInfo const& r) const { return id == r.id; }
-	bool operator != (ServerDBInfo const& r) const { return id != r.id; }
-
-	template <class Ar>
-	void serialize( Ar& ar ) {
-		serializer(ar, id, clusterInterface, client, distributor, master, ratekeeper, resolvers, recoveryCount, recoveryState, masterLifetime, logSystemConfig, priorCommittedLogServers, latencyBandConfig, storageCaches, infoGeneration);
-	}
-};
-
-struct UpdateServerDBInfoRequest {
-	constexpr static FileIdentifier file_identifier = 9467438;
-	Standalone<StringRef> serializedDbInfo;
-	std::vector<Endpoint> broadcastInfo;
-	ReplyPromise<std::vector<Endpoint>> reply;
-
-	template <class Ar>
-	void serialize(Ar& ar) {
-		serializer(ar, serializedDbInfo, broadcastInfo, reply);
-	}
-};
-
-struct GetServerDBInfoRequest {
-	constexpr static FileIdentifier file_identifier = 9467439;
-	UID knownServerInfoID;
-	ReplyPromise<struct ServerDBInfo> reply;
-
-	template <class Ar>
-	void serialize(Ar& ar) {
-		serializer(ar, knownServerInfoID, reply);
-	}
-};
-
-
-Future<Void> broadcastTxnRequest(TxnStateRequest const& req, int const& sendAmount, bool const& sendReply);
-
-Future<std::vector<Endpoint>> broadcastDBInfoRequest(UpdateServerDBInfoRequest const& req, int const& sendAmount, Optional<Endpoint> const& sender, bool const& sendReply);
 
 #endif

fdbserver/Status.actor.cpp

@@ -974,9 +974,9 @@ ACTOR static Future<JsonBuilderObject> recoveryStateStatusFetcher(WorkerDetails
 		// TODO:  time_in_recovery: 0.5
 		//        time_in_state: 0.1
 
-		TraceEventFields md = wait(activeGens);
+		TraceEventFields mdActiveGens = wait(activeGens);
-		if(md.size()) {
+		if(mdActiveGens.size()) {
-			int activeGenerations = md.getInt("ActiveGenerations");
+			int activeGenerations = mdActiveGens.getInt("ActiveGenerations");
 			message["active_generations"] = activeGenerations;
 		}
 

fdbserver/workloads/BackupAndParallelRestoreCorrectness.actor.cpp

@@ -335,7 +335,6 @@ struct BackupAndParallelRestoreCorrectnessWorkload : TestWorkload {
 		state bool extraTasks = false;
 		state UID randomID = nondeterministicRandom()->randomUniqueID();
 		state int restoreIndex = 0;
-		state bool restoreDone = false;
 		state ReadYourWritesTransaction tr2(cx);
 
 		TraceEvent("BARW_Arguments")