1 /* 2 * ClusterRecruitmentInterface.h 3 * 4 * This source file is part of the FoundationDB open source project 5 * 6 * Copyright 2013-2018 Apple Inc. and the FoundationDB project authors 7 * 8 * Licensed under the Apache License, Version 2.0 (the "License"); 9 * you may not use this file except in compliance with the License. 10 * You may obtain a copy of the License at 11 * 12 * http://www.apache.org/licenses/LICENSE-2.0 13 * 14 * Unless required by applicable law or agreed to in writing, software 15 * distributed under the License is distributed on an "AS IS" BASIS, 16 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 17 * See the License for the specific language governing permissions and 18 * limitations under the License. 19 */ 20 21 #ifndef FDBSERVER_CLUSTERRECRUITMENTINTERFACE_H 22 #define FDBSERVER_CLUSTERRECRUITMENTINTERFACE_H 23 #pragma once 24 25 #include "fdbclient/ClusterInterface.h" 26 #include "fdbclient/StorageServerInterface.h" 27 #include "fdbclient/MasterProxyInterface.h" 28 #include "fdbclient/DatabaseConfiguration.h" 29 #include "fdbserver/DataDistributorInterface.h" 30 #include "fdbserver/MasterInterface.h" 31 #include "fdbserver/RecoveryState.h" 32 #include "fdbserver/TLogInterface.h" 33 #include "fdbserver/WorkerInterface.actor.h" 34 #include "fdbserver/Knobs.h" 35 36 // This interface and its serialization depend on slicing, since the client will deserialize only the first part of this structure 37 struct ClusterControllerFullInterface { 38 ClusterInterface clientInterface; 39 RequestStream< struct RecruitFromConfigurationRequest > recruitFromConfiguration; 40 RequestStream< struct RecruitRemoteFromConfigurationRequest > recruitRemoteFromConfiguration; 41 RequestStream< struct RecruitStorageRequest > recruitStorage; 42 RequestStream< struct RegisterWorkerRequest > registerWorker; 43 RequestStream< struct GetWorkersRequest > getWorkers; 44 RequestStream< struct RegisterMasterRequest > registerMaster; 45 RequestStream< struct GetServerDBInfoRequest > getServerDBInfo; 46 idClusterControllerFullInterface47 UID id() const { return clientInterface.id(); } 48 bool operator == (ClusterControllerFullInterface const& r) const { return id() == r.id(); } 49 bool operator != (ClusterControllerFullInterface const& r) const { return id() != r.id(); } 50 initEndpointsClusterControllerFullInterface51 void initEndpoints() { 52 clientInterface.initEndpoints(); 53 recruitFromConfiguration.getEndpoint( TaskClusterController ); 54 recruitRemoteFromConfiguration.getEndpoint( TaskClusterController ); 55 recruitStorage.getEndpoint( TaskClusterController ); 56 registerWorker.getEndpoint( TaskClusterController ); 57 getWorkers.getEndpoint( TaskClusterController ); 58 registerMaster.getEndpoint( TaskClusterController ); 59 getServerDBInfo.getEndpoint( TaskClusterController ); 60 } 61 62 template <class Ar> serializeClusterControllerFullInterface63 void serialize( Ar& ar ) { 64 ASSERT( ar.protocolVersion() >= 0x0FDB00A200040001LL ); 65 serializer(ar, clientInterface, recruitFromConfiguration, recruitRemoteFromConfiguration, recruitStorage, registerWorker, getWorkers, registerMaster, getServerDBInfo); 66 } 67 }; 68 69 struct RecruitFromConfigurationRequest { 70 DatabaseConfiguration configuration; 71 bool recruitSeedServers; 72 int maxOldLogRouters; 73 ReplyPromise< struct RecruitFromConfigurationReply > reply; 74 RecruitFromConfigurationRequestRecruitFromConfigurationRequest75 RecruitFromConfigurationRequest() {} RecruitFromConfigurationRequestRecruitFromConfigurationRequest76 explicit RecruitFromConfigurationRequest(DatabaseConfiguration const& configuration, bool recruitSeedServers, int maxOldLogRouters) 77 : configuration(configuration), recruitSeedServers(recruitSeedServers), maxOldLogRouters(maxOldLogRouters) {} 78 79 template <class Ar> serializeRecruitFromConfigurationRequest80 void serialize( Ar& ar ) { 81 serializer(ar, configuration, recruitSeedServers, maxOldLogRouters, reply); 82 } 83 }; 84 85 struct RecruitFromConfigurationReply { 86 vector<WorkerInterface> tLogs; 87 vector<WorkerInterface> satelliteTLogs; 88 vector<WorkerInterface> proxies; 89 vector<WorkerInterface> resolvers; 90 vector<WorkerInterface> storageServers; 91 vector<WorkerInterface> oldLogRouters; 92 Optional<Key> dcId; 93 bool satelliteFallback; 94 RecruitFromConfigurationReplyRecruitFromConfigurationReply95 RecruitFromConfigurationReply() : satelliteFallback(false) {} 96 97 template <class Ar> serializeRecruitFromConfigurationReply98 void serialize( Ar& ar ) { 99 serializer(ar, tLogs, satelliteTLogs, proxies, resolvers, storageServers, oldLogRouters, dcId, satelliteFallback); 100 } 101 }; 102 103 struct RecruitRemoteFromConfigurationRequest { 104 DatabaseConfiguration configuration; 105 Optional<Key> dcId; 106 int logRouterCount; 107 std::vector<UID> exclusionWorkerIds; 108 ReplyPromise< struct RecruitRemoteFromConfigurationReply > reply; 109 RecruitRemoteFromConfigurationRequestRecruitRemoteFromConfigurationRequest110 RecruitRemoteFromConfigurationRequest() {} RecruitRemoteFromConfigurationRequestRecruitRemoteFromConfigurationRequest111 RecruitRemoteFromConfigurationRequest(DatabaseConfiguration const& configuration, Optional<Key> const& dcId, int logRouterCount, const std::vector<UID> &exclusionWorkerIds) : configuration(configuration), dcId(dcId), logRouterCount(logRouterCount), exclusionWorkerIds(exclusionWorkerIds){} 112 113 template <class Ar> serializeRecruitRemoteFromConfigurationRequest114 void serialize( Ar& ar ) { 115 serializer(ar, configuration, dcId, logRouterCount, exclusionWorkerIds, reply); 116 } 117 }; 118 119 struct RecruitRemoteFromConfigurationReply { 120 vector<WorkerInterface> remoteTLogs; 121 vector<WorkerInterface> logRouters; 122 123 template <class Ar> serializeRecruitRemoteFromConfigurationReply124 void serialize( Ar& ar ) { 125 serializer(ar, remoteTLogs, logRouters); 126 } 127 }; 128 129 struct RecruitStorageReply { 130 WorkerInterface worker; 131 ProcessClass processClass; 132 133 template <class Ar> serializeRecruitStorageReply134 void serialize( Ar& ar ) { 135 serializer(ar, worker, processClass); 136 } 137 }; 138 139 struct RecruitStorageRequest { 140 std::vector<Optional<Standalone<StringRef>>> excludeMachines; //< Don't recruit any of these machines 141 std::vector<AddressExclusion> excludeAddresses; //< Don't recruit any of these addresses 142 std::vector<Optional<Standalone<StringRef>>> includeDCs; 143 bool criticalRecruitment; //< True if machine classes are to be ignored 144 ReplyPromise< RecruitStorageReply > reply; 145 146 template <class Ar> serializeRecruitStorageRequest147 void serialize( Ar& ar ) { 148 serializer(ar, excludeMachines, excludeAddresses, includeDCs, criticalRecruitment, reply); 149 } 150 }; 151 152 struct RegisterWorkerReply { 153 ProcessClass processClass; 154 ClusterControllerPriorityInfo priorityInfo; 155 RegisterWorkerReplyRegisterWorkerReply156 RegisterWorkerReply() : priorityInfo(ProcessClass::UnsetFit, false, ClusterControllerPriorityInfo::FitnessUnknown) {} RegisterWorkerReplyRegisterWorkerReply157 RegisterWorkerReply(ProcessClass processClass, ClusterControllerPriorityInfo priorityInfo) : processClass(processClass), priorityInfo(priorityInfo) {} 158 159 template <class Ar> serializeRegisterWorkerReply160 void serialize( Ar& ar ) { 161 serializer(ar, processClass, priorityInfo); 162 } 163 }; 164 165 struct RegisterWorkerRequest { 166 WorkerInterface wi; 167 ProcessClass initialClass; 168 ProcessClass processClass; 169 ClusterControllerPriorityInfo priorityInfo; 170 Generation generation; 171 Optional<DataDistributorInterface> distributorInterf; 172 Optional<RatekeeperInterface> ratekeeperInterf; 173 ReplyPromise<RegisterWorkerReply> reply; 174 bool degraded; 175 RegisterWorkerRequestRegisterWorkerRequest176 RegisterWorkerRequest() : priorityInfo(ProcessClass::UnsetFit, false, ClusterControllerPriorityInfo::FitnessUnknown), degraded(false) {} RegisterWorkerRequestRegisterWorkerRequest177 RegisterWorkerRequest(WorkerInterface wi, ProcessClass initialClass, ProcessClass processClass, ClusterControllerPriorityInfo priorityInfo, Generation generation, Optional<DataDistributorInterface> ddInterf, Optional<RatekeeperInterface> rkInterf, bool degraded) : 178 wi(wi), initialClass(initialClass), processClass(processClass), priorityInfo(priorityInfo), generation(generation), distributorInterf(ddInterf), ratekeeperInterf(rkInterf), degraded(degraded) {} 179 180 template <class Ar> serializeRegisterWorkerRequest181 void serialize( Ar& ar ) { 182 serializer(ar, wi, initialClass, processClass, priorityInfo, generation, distributorInterf, ratekeeperInterf, reply, degraded); 183 } 184 }; 185 186 struct GetWorkersRequest { 187 enum { TESTER_CLASS_ONLY = 0x1, NON_EXCLUDED_PROCESSES_ONLY = 0x2 }; 188 189 int flags; 190 ReplyPromise<vector<WorkerDetails>> reply; 191 GetWorkersRequestGetWorkersRequest192 GetWorkersRequest() : flags(0) {} GetWorkersRequestGetWorkersRequest193 explicit GetWorkersRequest(int fl) : flags(fl) {} 194 195 template <class Ar> serializeGetWorkersRequest196 void serialize(Ar& ar) { 197 serializer(ar, flags, reply); 198 } 199 }; 200 201 struct RegisterMasterRequest { 202 UID id; 203 LocalityData mi; 204 LogSystemConfig logSystemConfig; 205 vector<MasterProxyInterface> proxies; 206 vector<ResolverInterface> resolvers; 207 DBRecoveryCount recoveryCount; 208 int64_t registrationCount; 209 Optional<DatabaseConfiguration> configuration; 210 vector<UID> priorCommittedLogServers; 211 RecoveryState recoveryState; 212 bool recoveryStalled; 213 214 ReplyPromise<Void> reply; 215 RegisterMasterRequestRegisterMasterRequest216 RegisterMasterRequest() {} 217 218 template <class Ar> serializeRegisterMasterRequest219 void serialize( Ar& ar ) { 220 ASSERT( ar.protocolVersion() >= 0x0FDB00A200040001LL ); 221 serializer(ar, id, mi, logSystemConfig, proxies, resolvers, recoveryCount, registrationCount, configuration, priorCommittedLogServers, recoveryState, recoveryStalled, reply); 222 } 223 }; 224 225 struct GetServerDBInfoRequest { 226 UID knownServerInfoID; 227 Standalone<VectorRef<StringRef>> issues; 228 std::vector<NetworkAddress> incompatiblePeers; 229 ReplyPromise< struct ServerDBInfo > reply; 230 231 template <class Ar> serializeGetServerDBInfoRequest232 void serialize(Ar& ar) { 233 serializer(ar, knownServerInfoID, issues, incompatiblePeers, reply); 234 } 235 }; 236 237 #include "fdbserver/ServerDBInfo.h" // include order hack 238 239 #endif 240