Hawkin
/
arangodb
mirror of https://gitee.com/bigwinds/arangodb
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
arangodb/arangod/Cluster/ClusterInfo.h

1057 lines
44 KiB
C++
Raw Blame History

////////////////////////////////////////////////////////////////////////////////
/// @brief Class to get and cache information about the cluster state
///
/// @file ClusterInfo.h
///
/// DISCLAIMER
///
/// Copyright 2014 ArangoDB GmbH, Cologne, Germany
/// Copyright 2004-2014 triAGENS GmbH, Cologne, Germany
///
/// 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.
///
/// Copyright holder is ArangoDB GmbH, Cologne, Germany
///
/// @author Max Neunhoeffer
/// @author Jan Steemann
/// @author Copyright 2014, ArangoDB GmbH, Cologne, Germany
/// @author Copyright 2013, triagens GmbH, Cologne, Germany
////////////////////////////////////////////////////////////////////////////////
#ifndef ARANGODB_CLUSTER_CLUSTER_INFO_H
#define ARANGODB_CLUSTER_CLUSTER_INFO_H 1
#include "Basics/Common.h"
#include "Basics/JsonHelper.h"
#include "Basics/Mutex.h"
#include "Basics/ReadWriteLock.h"
#include "Cluster/AgencyComm.h"
#include "VocBase/collection.h"
#include "VocBase/voc-types.h"
#include "VocBase/vocbase.h"
#include "velocypack/Slice.h"
struct TRI_json_t;
struct TRI_memory_zone_s;
namespace triagens {
namespace arango {
class ClusterInfo;
// -----------------------------------------------------------------------------
// --SECTION-- some types for ClusterInfo
// -----------------------------------------------------------------------------
typedef std::string ServerID; // ID of a server
typedef std::string DatabaseID; // ID/name of a database
typedef std::string CollectionID; // ID of a collection
typedef std::string ShardID; // ID of a shard
// -----------------------------------------------------------------------------
// --SECTION-- class CollectionInfo
// -----------------------------------------------------------------------------
class CollectionInfo {
friend class ClusterInfo;
// -----------------------------------------------------------------------------
// --SECTION-- constructors / destructors
// -----------------------------------------------------------------------------
public:
CollectionInfo ();
explicit CollectionInfo (struct TRI_json_t*);
CollectionInfo (CollectionInfo const&);
CollectionInfo (CollectionInfo&&);
CollectionInfo& operator= (CollectionInfo const&);
CollectionInfo& operator= (CollectionInfo&&);
~CollectionInfo ();
// -----------------------------------------------------------------------------
// --SECTION-- public methods
// -----------------------------------------------------------------------------
public:
////////////////////////////////////////////////////////////////////////////////
/// @brief checks whether there is no info contained
////////////////////////////////////////////////////////////////////////////////
bool empty () const {
return (nullptr == _json); //|| (id() == 0);
}
////////////////////////////////////////////////////////////////////////////////
/// @brief returns the collection id
////////////////////////////////////////////////////////////////////////////////
TRI_voc_cid_t id () const {
return triagens::basics::JsonHelper::stringUInt64(_json, "id");
}
////////////////////////////////////////////////////////////////////////////////
/// @brief returns the collection id as a string
////////////////////////////////////////////////////////////////////////////////
std::string id_as_string () const {
return triagens::basics::JsonHelper::getStringValue(_json, "id", "");
}
////////////////////////////////////////////////////////////////////////////////
/// @brief returns the collection name
////////////////////////////////////////////////////////////////////////////////
std::string name () const {
return triagens::basics::JsonHelper::getStringValue(_json, "name", "");
}
////////////////////////////////////////////////////////////////////////////////
/// @brief returns the collection type
////////////////////////////////////////////////////////////////////////////////
TRI_col_type_e type () const {
return (TRI_col_type_e) triagens::basics::JsonHelper::getNumericValue<int>(_json, "type", (int) TRI_COL_TYPE_UNKNOWN);
}
////////////////////////////////////////////////////////////////////////////////
/// @brief returns the collection status
////////////////////////////////////////////////////////////////////////////////
TRI_vocbase_col_status_e status () const {
return (TRI_vocbase_col_status_e) triagens::basics::JsonHelper::getNumericValue<int>(_json, "status", (int) TRI_VOC_COL_STATUS_CORRUPTED);
}
////////////////////////////////////////////////////////////////////////////////
/// @brief returns the collection status as a string
////////////////////////////////////////////////////////////////////////////////
std::string statusString () const {
return TRI_GetStatusStringCollectionVocBase(status());
}
////////////////////////////////////////////////////////////////////////////////
/// @brief returns the deleted flag
////////////////////////////////////////////////////////////////////////////////
bool deleted () const {
return triagens::basics::JsonHelper::getBooleanValue(_json, "deleted", false);
}
////////////////////////////////////////////////////////////////////////////////
/// @brief returns the docompact flag
////////////////////////////////////////////////////////////////////////////////
bool doCompact () const {
return triagens::basics::JsonHelper::getBooleanValue(_json, "doCompact", false);
}
////////////////////////////////////////////////////////////////////////////////
/// @brief returns the issystem flag
////////////////////////////////////////////////////////////////////////////////
bool isSystem () const {
return triagens::basics::JsonHelper::getBooleanValue(_json, "isSystem", false);
}
////////////////////////////////////////////////////////////////////////////////
/// @brief returns the isvolatile flag
////////////////////////////////////////////////////////////////////////////////
bool isVolatile () const {
return triagens::basics::JsonHelper::getBooleanValue(_json, "isVolatile", false);
}
////////////////////////////////////////////////////////////////////////////////
/// @brief returns the indexes
////////////////////////////////////////////////////////////////////////////////
TRI_json_t const* getIndexes () const {
return triagens::basics::JsonHelper::getObjectElement(_json, "indexes");
}
////////////////////////////////////////////////////////////////////////////////
/// @brief returns a copy of the key options
/// the caller is responsible for freeing it
////////////////////////////////////////////////////////////////////////////////
TRI_json_t* keyOptions () const {
TRI_json_t const* keyOptions = triagens::basics::JsonHelper::getObjectElement(_json, "keyOptions");
if (keyOptions != nullptr) {
return TRI_CopyJson(TRI_UNKNOWN_MEM_ZONE, keyOptions);
}
return nullptr;
}
////////////////////////////////////////////////////////////////////////////////
/// @brief whether or not a collection allows user-defined keys
////////////////////////////////////////////////////////////////////////////////
bool allowUserKeys () const {
TRI_json_t const* keyOptions = triagens::basics::JsonHelper::getObjectElement(_json, "keyOptions");
if (keyOptions != nullptr) {
return triagens::basics::JsonHelper::getBooleanValue(keyOptions, "allowUserKeys", true);
}
return true; // the default value
}
////////////////////////////////////////////////////////////////////////////////
/// @brief returns the waitforsync flag
////////////////////////////////////////////////////////////////////////////////
bool waitForSync () const {
return triagens::basics::JsonHelper::getBooleanValue(_json, "waitForSync", false);
}
////////////////////////////////////////////////////////////////////////////////
/// @brief returns the maximal journal size
////////////////////////////////////////////////////////////////////////////////
TRI_voc_size_t journalSize () const {
return triagens::basics::JsonHelper::getNumericValue<TRI_voc_size_t>(_json, "journalSize", 0);
}
////////////////////////////////////////////////////////////////////////////////
/// @brief returns the number of buckets for indexes
////////////////////////////////////////////////////////////////////////////////
uint32_t indexBuckets () const {
return triagens::basics::JsonHelper::getNumericValue<uint32_t>(_json, "indexBuckets", 1);
}
////////////////////////////////////////////////////////////////////////////////
/// @brief returns the shard keys
////////////////////////////////////////////////////////////////////////////////
std::vector<std::string> shardKeys () const {
TRI_json_t* const node = triagens::basics::JsonHelper::getObjectElement(_json, "shardKeys");
return triagens::basics::JsonHelper::stringArray(node);
}
////////////////////////////////////////////////////////////////////////////////
/// @brief returns true if the default shard key is used
////////////////////////////////////////////////////////////////////////////////
bool usesDefaultShardKeys () const {
TRI_json_t* const node = triagens::basics::JsonHelper::getObjectElement(_json, "shardKeys");
if (TRI_LengthArrayJson(node) != 1) {
return false;
}
TRI_json_t* firstKey = TRI_LookupArrayJson(node, 0);
TRI_ASSERT(TRI_IsStringJson(firstKey));
std::string shardKey = triagens::basics::JsonHelper::getStringValue(firstKey, "");
return shardKey == TRI_VOC_ATTRIBUTE_KEY;
}
////////////////////////////////////////////////////////////////////////////////
/// @brief returns the shard ids
////////////////////////////////////////////////////////////////////////////////
typedef std::unordered_map<ShardID, std::vector<ServerID>> ShardMap;
std::shared_ptr<ShardMap> shardIds () const {
std::shared_ptr<ShardMap> res;
{
std::lock_guard<std::mutex> locker(_mutex);
res = _shardMapCache;
}
if (res.get() != nullptr) {
return res;
}
res.reset(new ShardMap());
TRI_json_t* const node
= triagens::basics::JsonHelper::getObjectElement(_json, "shards");
if (node != nullptr && TRI_IsObjectJson(node)) {
size_t len = TRI_LengthVector(&node->_value._objects);
for (size_t i = 0; i < len; i += 2) {
auto key = static_cast<TRI_json_t*>(
TRI_AtVector(&node->_value._objects, i));
auto value = static_cast<TRI_json_t*>(
TRI_AtVector(&node->_value._objects, i + 1));
if (TRI_IsStringJson(key) && TRI_IsArrayJson(value)) {
ShardID shard
= triagens::basics::JsonHelper::getStringValue(key, "");
std::vector<ServerID> servers
= triagens::basics::JsonHelper::stringArray(value);
if (shard != "") {
(*res).insert(make_pair(shard, servers));
}
}
}
}
{
std::lock_guard<std::mutex> locker(_mutex);
_shardMapCache = res;
}
return res;
}
////////////////////////////////////////////////////////////////////////////////
/// @brief returns the number of shards
////////////////////////////////////////////////////////////////////////////////
int numberOfShards () const {
TRI_json_t* const node = triagens::basics::JsonHelper::getObjectElement(_json, "shards");
if (TRI_IsObjectJson(node)) {
return (int) (TRI_LengthVector(&node->_value._objects) / 2);
}
return 0;
}
////////////////////////////////////////////////////////////////////////////////
/// @brief returns the json
////////////////////////////////////////////////////////////////////////////////
TRI_json_t const* getJson () const {
return _json;
}
// -----------------------------------------------------------------------------
// --SECTION-- private methods
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
// --SECTION-- private variables
// -----------------------------------------------------------------------------
private:
TRI_json_t* _json;
// Only to protect the cache:
mutable std::mutex _mutex;
// Just a cache
mutable std::shared_ptr<ShardMap> _shardMapCache;
};
// -----------------------------------------------------------------------------
// --SECTION-- class CollectionInfoCurrent
// -----------------------------------------------------------------------------
class CollectionInfoCurrent {
friend class ClusterInfo;
// -----------------------------------------------------------------------------
// --SECTION-- constructors / destructors
// -----------------------------------------------------------------------------
public:
CollectionInfoCurrent ();
CollectionInfoCurrent (ShardID const&, struct TRI_json_t*);
CollectionInfoCurrent (CollectionInfoCurrent const&);
CollectionInfoCurrent (CollectionInfoCurrent&&);
CollectionInfoCurrent& operator= (CollectionInfoCurrent const&);
CollectionInfoCurrent& operator= (CollectionInfoCurrent&&);
~CollectionInfoCurrent ();
private:
void freeAllJsons ();
void copyAllJsons ();
// -----------------------------------------------------------------------------
// --SECTION-- public methods
// -----------------------------------------------------------------------------
////////////////////////////////////////////////////////////////////////////////
/// @brief add a new shardID and JSON pair, returns true if OK and false
/// if the shardID already exists. In the latter case nothing happens.
/// The CollectionInfoCurrent object takes ownership of the TRI_json_t*.
////////////////////////////////////////////////////////////////////////////////
public:
bool add (ShardID const& shardID, TRI_json_t* json) {
auto it = _jsons.find(shardID);
if (it == _jsons.end()) {
_jsons.insert(std::make_pair(shardID, json));
return true;
}
return false;
}
////////////////////////////////////////////////////////////////////////////////
/// @brief returns the indexes
////////////////////////////////////////////////////////////////////////////////
TRI_json_t const* getIndexes (ShardID const& shardID) const {
auto it = _jsons.find(shardID);
if (it != _jsons.end()) {
TRI_json_t* json = it->second;
return triagens::basics::JsonHelper::getObjectElement(
json, "indexes");
}
return nullptr;
}
////////////////////////////////////////////////////////////////////////////////
/// @brief returns the error flag for a shardID
////////////////////////////////////////////////////////////////////////////////
bool error (ShardID const& shardID) const {
return getFlag("error", shardID);
}
////////////////////////////////////////////////////////////////////////////////
/// @brief returns the error flag for all shardIDs
////////////////////////////////////////////////////////////////////////////////
std::unordered_map<ShardID, bool> error () const {
return getFlag("error");
}
////////////////////////////////////////////////////////////////////////////////
/// @brief returns the errorNum for one shardID
////////////////////////////////////////////////////////////////////////////////
int errorNum (ShardID const& shardID) const {
auto it = _jsons.find(shardID);
if (it != _jsons.end()) {
TRI_json_t* json = it->second;
return triagens::basics::JsonHelper::getNumericValue<int>
(json, "errorNum", 0);
}
return 0;
}
////////////////////////////////////////////////////////////////////////////////
/// @brief returns the errorNum for all shardIDs
////////////////////////////////////////////////////////////////////////////////
std::unordered_map<ShardID, int> errorNum () const {
std::unordered_map<ShardID, int> m;
TRI_voc_size_t s;
for (auto it = _jsons.begin(); it != _jsons.end(); ++it) {
TRI_json_t* json = it->second;
s = triagens::basics::JsonHelper::getNumericValue<int>
(json, "errorNum", 0);
m.insert(std::make_pair(it->first, s));
}
return m;
}
////////////////////////////////////////////////////////////////////////////////
/// @brief returns the current leader and followers for a shard
////////////////////////////////////////////////////////////////////////////////
std::vector<ServerID> servers (ShardID const& shardID) const {
std::vector<ServerID> v;
auto it = _jsons.find(shardID);
if (it != _jsons.end()) {
TRI_json_t const* json
= triagens::basics::JsonHelper::getObjectElement(it->second,
"servers");
if (json != nullptr) {
v = triagens::basics::JsonHelper::stringArray(json);
}
}
return v;
}
////////////////////////////////////////////////////////////////////////////////
/// @brief returns the errorMessage entry for one shardID
////////////////////////////////////////////////////////////////////////////////
std::string errorMessage (ShardID const& shardID) const {
auto it = _jsons.find(shardID);
if (it != _jsons.end()) {
TRI_json_t* json = it->second;
return triagens::basics::JsonHelper::getStringValue
(json, "errorMessage", "");
}
return std::string();
}
// -----------------------------------------------------------------------------
// --SECTION-- private methods
// -----------------------------------------------------------------------------
////////////////////////////////////////////////////////////////////////////////
/// @brief local helper to return boolean flags
////////////////////////////////////////////////////////////////////////////////
private:
bool getFlag (char const* name, ShardID const& shardID) const {
auto it = _jsons.find(shardID);
if (it != _jsons.end()) {
TRI_json_t* json = it->second;
return triagens::basics::JsonHelper::getBooleanValue(json,
name, false);
}
return false;
}
////////////////////////////////////////////////////////////////////////////////
/// @brief local helper to return a map to boolean
////////////////////////////////////////////////////////////////////////////////
std::unordered_map<ShardID, bool> getFlag (char const* name ) const {
std::unordered_map<ShardID, bool> m;
bool b;
for (auto it = _jsons.begin(); it != _jsons.end(); ++it) {
TRI_json_t* json = it->second;
b = triagens::basics::JsonHelper::getBooleanValue(json,
name, false);
m.insert(std::make_pair(it->first, b));
}
return m;
}
// -----------------------------------------------------------------------------
// --SECTION-- private variables
// -----------------------------------------------------------------------------
private:
std::unordered_map<ShardID, TRI_json_t*> _jsons;
};
// -----------------------------------------------------------------------------
// --SECTION-- class ClusterInfo
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
// --SECTION-- typedefs
// -----------------------------------------------------------------------------
class ClusterInfo {
private:
typedef std::unordered_map<CollectionID,
std::shared_ptr<CollectionInfo>>
DatabaseCollections;
typedef std::unordered_map<DatabaseID, DatabaseCollections>
AllCollections;
typedef std::unordered_map<CollectionID,
std::shared_ptr<CollectionInfoCurrent>>
DatabaseCollectionsCurrent;
typedef std::unordered_map<DatabaseID, DatabaseCollectionsCurrent>
AllCollectionsCurrent;
// -----------------------------------------------------------------------------
// --SECTION-- constructors and destructors
// -----------------------------------------------------------------------------
private:
////////////////////////////////////////////////////////////////////////////////
/// @brief initializes library
/// We are a singleton class, therefore nobody is allowed to create
/// new instances or copy them, except we ourselves.
////////////////////////////////////////////////////////////////////////////////
ClusterInfo (ClusterInfo const&) = delete; // not implemented
ClusterInfo& operator= (ClusterInfo const&) = delete; // not implemented
public:
////////////////////////////////////////////////////////////////////////////////
/// @brief creates library
////////////////////////////////////////////////////////////////////////////////
ClusterInfo ();
////////////////////////////////////////////////////////////////////////////////
/// @brief shuts down library
////////////////////////////////////////////////////////////////////////////////
~ClusterInfo ();
// -----------------------------------------------------------------------------
// --SECTION-- public static methods
// -----------------------------------------------------------------------------
public:
////////////////////////////////////////////////////////////////////////////////
/// @brief get the unique instance
////////////////////////////////////////////////////////////////////////////////
static ClusterInfo* instance ();
// -----------------------------------------------------------------------------
// --SECTION-- public methods
// -----------------------------------------------------------------------------
public:
////////////////////////////////////////////////////////////////////////////////
/// @brief get a number of cluster-wide unique IDs, returns the first
/// one and guarantees that <number> are reserved for the caller.
////////////////////////////////////////////////////////////////////////////////
uint64_t uniqid (uint64_t = 1);
////////////////////////////////////////////////////////////////////////////////
/// @brief flush the caches (used for testing only)
////////////////////////////////////////////////////////////////////////////////
void flush ();
////////////////////////////////////////////////////////////////////////////////
/// @brief ask whether a cluster database exists
////////////////////////////////////////////////////////////////////////////////
bool doesDatabaseExist (DatabaseID const&,
bool = false);
////////////////////////////////////////////////////////////////////////////////
/// @brief get list of databases in the cluster
////////////////////////////////////////////////////////////////////////////////
std::vector<DatabaseID> listDatabases (bool = false);
////////////////////////////////////////////////////////////////////////////////
/// @brief (re-)load the information about planned collections from the agency
/// Usually one does not have to call this directly.
////////////////////////////////////////////////////////////////////////////////
void loadPlannedCollections ();
////////////////////////////////////////////////////////////////////////////////
/// @brief (re-)load the information about planned databases
/// Usually one does not have to call this directly.
////////////////////////////////////////////////////////////////////////////////
void loadPlannedDatabases ();
////////////////////////////////////////////////////////////////////////////////
/// @brief (re-)load the information about current databases
/// Usually one does not have to call this directly.
////////////////////////////////////////////////////////////////////////////////
void loadCurrentDatabases ();
////////////////////////////////////////////////////////////////////////////////
/// @brief ask about a collection
/// If it is not found in the cache, the cache is reloaded once. The second
/// argument can be a collection ID or a collection name (both cluster-wide).
////////////////////////////////////////////////////////////////////////////////
std::shared_ptr<CollectionInfo> getCollection (DatabaseID const&,
CollectionID const&);
////////////////////////////////////////////////////////////////////////////////
/// @brief get properties of a collection
////////////////////////////////////////////////////////////////////////////////
TRI_col_info_t getCollectionProperties (CollectionInfo const&);
////////////////////////////////////////////////////////////////////////////////
/// @brief get properties of a collection
////////////////////////////////////////////////////////////////////////////////
TRI_col_info_t getCollectionProperties (DatabaseID const&,
CollectionID const&);
////////////////////////////////////////////////////////////////////////////////
/// @brief ask about all collections
////////////////////////////////////////////////////////////////////////////////
std::vector<std::shared_ptr<CollectionInfo>> const getCollections
(DatabaseID const&);
////////////////////////////////////////////////////////////////////////////////
/// @brief (re-)load the information about current collections from the agency
/// Usually one does not have to call this directly. Note that this is
/// necessarily complicated, since here we have to consider information
/// about all shards of a collection.
////////////////////////////////////////////////////////////////////////////////
void loadCurrentCollections ();
////////////////////////////////////////////////////////////////////////////////
/// @brief ask about a collection in current. This returns information about
/// all shards in the collection.
/// If it is not found in the cache, the cache is reloaded once.
////////////////////////////////////////////////////////////////////////////////
std::shared_ptr<CollectionInfoCurrent> getCollectionCurrent (
DatabaseID const&,
CollectionID const&);
////////////////////////////////////////////////////////////////////////////////
/// @brief create database in coordinator
////////////////////////////////////////////////////////////////////////////////
int createDatabaseCoordinator (std::string const& name,
TRI_json_t const* json,
std::string& errorMsg, double timeout);
////////////////////////////////////////////////////////////////////////////////
/// @brief drop database in coordinator
////////////////////////////////////////////////////////////////////////////////
int dropDatabaseCoordinator (std::string const& name,
std::string& errorMsg,
double timeout);
////////////////////////////////////////////////////////////////////////////////
/// @brief create collection in coordinator
////////////////////////////////////////////////////////////////////////////////
int createCollectionCoordinator (std::string const& databaseName,
std::string const& collectionID,
uint64_t numberOfShards,
arangodb::velocypack::Slice const json,
std::string& errorMsg,
double timeout);
////////////////////////////////////////////////////////////////////////////////
/// @brief drop collection in coordinator
////////////////////////////////////////////////////////////////////////////////
int dropCollectionCoordinator (std::string const& databaseName,
std::string const& collectionID,
std::string& errorMsg,
double timeout);
////////////////////////////////////////////////////////////////////////////////
/// @brief set collection properties in coordinator
////////////////////////////////////////////////////////////////////////////////
int setCollectionPropertiesCoordinator (std::string const& databaseName,
std::string const& collectionID,
TRI_col_info_t const*);
////////////////////////////////////////////////////////////////////////////////
/// @brief set collection status in coordinator
////////////////////////////////////////////////////////////////////////////////
int setCollectionStatusCoordinator (std::string const& databaseName,
std::string const& collectionID,
TRI_vocbase_col_status_e status);
////////////////////////////////////////////////////////////////////////////////
/// @brief ensure an index in coordinator.
////////////////////////////////////////////////////////////////////////////////
int ensureIndexCoordinator (std::string const& databaseName,
std::string const& collectionID,
TRI_json_t const* json,
bool create,
bool (*compare)(TRI_json_t const*, TRI_json_t const*),
TRI_json_t*& resultJson,
std::string& errorMsg,
double timeout);
////////////////////////////////////////////////////////////////////////////////
/// @brief drop an index in coordinator.
////////////////////////////////////////////////////////////////////////////////
int dropIndexCoordinator (std::string const& databaseName,
std::string const& collectionID,
TRI_idx_iid_t iid,
std::string& errorMsg,
double timeout);
////////////////////////////////////////////////////////////////////////////////
/// @brief (re-)load the information about servers from the agency
/// Usually one does not have to call this directly.
////////////////////////////////////////////////////////////////////////////////
void loadServers ();
////////////////////////////////////////////////////////////////////////////////
/// @brief find the endpoint of a server from its ID.
/// If it is not found in the cache, the cache is reloaded once, if
/// it is still not there an empty string is returned as an error.
////////////////////////////////////////////////////////////////////////////////
std::string getServerEndpoint (ServerID const&);
////////////////////////////////////////////////////////////////////////////////
/// @brief find the server ID for an endpoint.
/// If it is not found in the cache, the cache is reloaded once, if
/// it is still not there an empty string is returned as an error.
////////////////////////////////////////////////////////////////////////////////
std::string getServerName (std::string const& endpoint);
////////////////////////////////////////////////////////////////////////////////
/// @brief (re-)load the information about all coordinators from the agency
/// Usually one does not have to call this directly.
////////////////////////////////////////////////////////////////////////////////
void loadCurrentCoordinators ();
////////////////////////////////////////////////////////////////////////////////
/// @brief (re-)load the information about all DBservers from the agency
/// Usually one does not have to call this directly.
////////////////////////////////////////////////////////////////////////////////
void loadCurrentDBServers ();
////////////////////////////////////////////////////////////////////////////////
/// @brief return a list of all DBServers in the cluster that have
/// currently registered
////////////////////////////////////////////////////////////////////////////////
std::vector<ServerID> getCurrentDBServers ();
////////////////////////////////////////////////////////////////////////////////
/// @brief lookup the server's endpoint by scanning Target/MapIDToEnpdoint for
/// our id
////////////////////////////////////////////////////////////////////////////////
std::string getTargetServerEndpoint (ServerID const&);
////////////////////////////////////////////////////////////////////////////////
/// @brief find the servers who are responsible for a shard (one leader
/// and possibly multiple followers).
/// If it is not found in the cache, the cache is reloaded once, if
/// it is still not there a pointer to an empty vector is returned as
/// an error.
////////////////////////////////////////////////////////////////////////////////
std::shared_ptr<std::vector<ServerID>> getResponsibleServer (
ShardID const&);
////////////////////////////////////////////////////////////////////////////////
/// @brief find the shard list of a collection, sorted numerically
////////////////////////////////////////////////////////////////////////////////
std::shared_ptr<std::vector<ShardID>> getShardList (
CollectionID const&);
////////////////////////////////////////////////////////////////////////////////
/// @brief find the shard that is responsible for a document
////////////////////////////////////////////////////////////////////////////////
int getResponsibleShard (CollectionID const&,
TRI_json_t const*,
bool docComplete,
ShardID& shardID,
bool& usesDefaultShardingAttributes);
////////////////////////////////////////////////////////////////////////////////
/// @brief return the list of coordinator server names
////////////////////////////////////////////////////////////////////////////////
std::vector<ServerID> getCurrentCoordinators ();
private:
////////////////////////////////////////////////////////////////////////////////
/// @brief actually clears a list of planned databases
////////////////////////////////////////////////////////////////////////////////
void clearPlannedDatabases (
std::unordered_map<DatabaseID, TRI_json_t*>& databases);
////////////////////////////////////////////////////////////////////////////////
/// @brief actually clears a list of current databases
////////////////////////////////////////////////////////////////////////////////
void clearCurrentDatabases (
std::unordered_map<DatabaseID,
std::unordered_map<ServerID, TRI_json_t*>>&
databases);
////////////////////////////////////////////////////////////////////////////////
/// @brief get an operation timeout
////////////////////////////////////////////////////////////////////////////////
double getTimeout (double timeout) const {
if (timeout == 0.0) {
return 24.0 * 3600.0;
}
return timeout;
}
////////////////////////////////////////////////////////////////////////////////
/// @brief get the poll interval
////////////////////////////////////////////////////////////////////////////////
double getPollInterval () const {
return 5.0;
}
////////////////////////////////////////////////////////////////////////////////
/// @brief get the timeout for reloading the server list
////////////////////////////////////////////////////////////////////////////////
double getReloadServerListTimeout () const {
return 60.0;
}
// -----------------------------------------------------------------------------
// --SECTION-- private variables
// -----------------------------------------------------------------------------
private:
AgencyComm _agency;
// Cached data from the agency, we reload whenever necessary:
// We group the data, each group has an atomic "valid-flag"
// which is used for lazy loading in the beginning. It starts
// as false, is set to true at each reload and is never reset
// to false in the lifetime of the server. The variable is
// atomic to be able to check it without acquiring
// the read lock (see below). Flush is just an explicit reload
// for all data and is only used in tests.
// Furthermore, each group has a mutex that protects against
// simultaneously contacting the agency for an update.
// In addition, each group has an atomic version number, this is used
// to prevent a stampede if multiple threads notice concurrently
// that an update from the agency is necessary. Finally, there is
// a read/write lock which protects the actual data structure.
// We encapsulate this protection in the struct ProtectionData:
struct ProtectionData {
std::atomic<bool> isValid;
triagens::basics::Mutex mutex;
std::atomic<uint64_t> version;
triagens::basics::ReadWriteLock lock;
ProtectionData () : isValid(false), version(0) {
}
};
// The servers, first all, we only need Current here:
std::unordered_map<ServerID, std::string>
_servers; // from Current/ServersRegistered
ProtectionData _serversProt;
// The DBServers, also from Current:
std::unordered_map<ServerID, ServerID>
_DBServers; // from Current/DBServers
ProtectionData _DBServersProt;
// The Coordinators, also from Current:
std::unordered_map<ServerID, ServerID>
_coordinators; // from Current/Coordinators
ProtectionData _coordinatorsProt;
// First the databases, there is Plan and Current information:
std::unordered_map<DatabaseID, struct TRI_json_t*>
_plannedDatabases; // from Plan/Databases
ProtectionData _plannedDatabasesProt;
std::unordered_map<DatabaseID,
std::unordered_map<ServerID, struct TRI_json_t*>>
_currentDatabases; // from Current/Databases
ProtectionData _currentDatabasesProt;
// Finally, we need information about collections, again we have
// data from Plan and from Current.
// The information for _shards and _shardKeys are filled from the
// Plan (since they are fixed for the lifetime of the collection).
// _shardIds is filled from Current, since we have to be able to
// move shards between servers, and Plan contains who ought to be
// responsible and Current contains the actual current responsibility.
// The Plan state:
AllCollections
_plannedCollections; // from Plan/Collections/
ProtectionData _plannedCollectionsProt;
std::unordered_map<CollectionID,
std::shared_ptr<std::vector<std::string>>>
_shards; // from Plan/Collections/
// (may later come from Current/Collections/ )
std::unordered_map<CollectionID,
std::shared_ptr<std::vector<std::string>>>
_shardKeys; // from Plan/Collections/
// The Current state:
AllCollectionsCurrent
_currentCollections; // from Current/Collections/
ProtectionData _currentCollectionsProt;
std::unordered_map<ShardID, std::shared_ptr<std::vector<ServerID>>>
_shardIds; // from Current/Collections/
////////////////////////////////////////////////////////////////////////////////
/// @brief uniqid sequence
////////////////////////////////////////////////////////////////////////////////
struct {
uint64_t _currentValue;
uint64_t _upperValue;
}
_uniqid;
////////////////////////////////////////////////////////////////////////////////
/// @brief lock for uniqid sequence
////////////////////////////////////////////////////////////////////////////////
triagens::basics::Mutex _idLock;
// -----------------------------------------------------------------------------
// --SECTION-- private static variables
// -----------------------------------------------------------------------------
////////////////////////////////////////////////////////////////////////////////
/// @brief the sole instance
////////////////////////////////////////////////////////////////////////////////
static ClusterInfo* _theinstance;
////////////////////////////////////////////////////////////////////////////////
/// @brief how big a batch is for unique ids
////////////////////////////////////////////////////////////////////////////////
static const uint64_t MinIdsPerBatch = 1000000;
////////////////////////////////////////////////////////////////////////////////
/// @brief default wait timeout
////////////////////////////////////////////////////////////////////////////////
static const double operationTimeout;
////////////////////////////////////////////////////////////////////////////////
/// @brief reload timeout
////////////////////////////////////////////////////////////////////////////////
static const double reloadServerListTimeout;
};
} // end namespace arango
} // end namespace triagens
#endif
// -----------------------------------------------------------------------------
// --SECTION-- END-OF-FILE
// -----------------------------------------------------------------------------
// Local Variables:
// mode: outline-minor
// outline-regexp: "/// @brief\\|/// {@inheritDoc}\\|/// @page\\|// --SECTION--\\|/// @\\}"
// End:
Reference in New Issue View Git Blame Copy Permalink