Merge branch 'devel' of https://github.com/arangodb/arangodb into devel

arangod/Agency/Node.cpp

@@ -139,6 +139,8 @@ std::string Node::uri() const {
 /// Move constructor
 Node::Node(Node&& other)
     : _node_name(std::move(other._node_name)),
+      _parent(nullptr),
+      _store(nullptr),
       _children(std::move(other._children)),
       _value(std::move(other._value)),
       _vecBuf(std::move(other._vecBuf)),

arangod/Cluster/ClusterInfo.cpp

@@ -2360,35 +2360,19 @@ void ClusterInfo::loadCurrentDBServers() {
 
 std::vector<ServerID> ClusterInfo::getCurrentDBServers() {
   std::vector<ServerID> result;
-  int tries = 0;
 
   if (!_DBServersProt.isValid) {
     loadCurrentDBServers();
-    tries++;
   }
-  while (true) {
-    {
-      // return a consistent state of servers
-      READ_LOCKER(readLocker, _DBServersProt.lock);
+  // return a consistent state of servers
+  READ_LOCKER(readLocker, _DBServersProt.lock);
 
-      result.reserve(_DBServers.size());
+  result.reserve(_DBServers.size());
 
-      for (auto& it : _DBServers) {
-        result.emplace_back(it.first);
-      }
-
-      return result;
-    }
-
-    if (++tries >= 2) {
-      break;
-    }
-
-    // loadCurrentDBServers needs the write lock
-    loadCurrentDBServers();
+  for (auto& it : _DBServers) {
+    result.emplace_back(it.first);
   }
 
-  // note that the result will be empty if we get here
   return result;
 }
 
@@ -2560,35 +2544,20 @@ int ClusterInfo::getResponsibleShard(LogicalCollection* collInfo,
 
 std::vector<ServerID> ClusterInfo::getCurrentCoordinators() {
   std::vector<ServerID> result;
-  int tries = 0;
 
   if (!_coordinatorsProt.isValid) {
     loadCurrentCoordinators();
-    tries++;
-  }
-  while (true) {
-    {
-      // return a consistent state of servers
-      READ_LOCKER(readLocker, _coordinatorsProt.lock);
-
-      result.reserve(_coordinators.size());
-
-      for (auto& it : _coordinators) {
-        result.emplace_back(it.first);
-      }
-
-      return result;
-    }
-
-    if (++tries >= 2) {
-      break;
-    }
-
-    // loadCurrentCoordinators needs the write lock
-    loadCurrentCoordinators();
   }
 
-  // note that the result will be empty if we get here
+  // return a consistent state of servers
+  READ_LOCKER(readLocker, _coordinatorsProt.lock);
+
+  result.reserve(_coordinators.size());
+
+  for (auto& it : _coordinators) {
+    result.emplace_back(it.first);
+  }
+
   return result;
 }
 

arangod/Cluster/ClusterInfo.h

@@ -186,8 +186,7 @@ class CollectionInfoCurrent {
   bool getFlag(char const* name, ShardID const& shardID) const {
     auto it = _vpacks.find(shardID);
     if (it != _vpacks.end()) {
-      return arangodb::basics::VelocyPackHelper::getBooleanValue(it->second->slice(), "errorMessage",
-                                                          "");
+      return arangodb::basics::VelocyPackHelper::getBooleanValue(it->second->slice(), name, false);
     }
     return false;
   }

arangod/StorageEngine/MMFilesWalSlots.cpp

@@ -488,11 +488,12 @@ void MMFilesWalSlots::getActiveTickRange(wal::Logfile* logfile, TRI_voc_tick_t&
 
 /// @brief close a logfile
 int MMFilesWalSlots::closeLogfile(MMFilesWalSlot::TickType& lastCommittedTick, bool& worked) {
-  int iterations = 0;
   bool hasWaited = false;
   worked = false;
 
-  while (++iterations < 1000) {
+  double const maxWait = 30.0;
+  double const end = TRI_microtime() + maxWait;
+  while (true) {
     {
       MUTEX_LOCKER(mutexLocker, _lock);
 
@@ -593,6 +594,11 @@ int MMFilesWalSlots::closeLogfile(MMFilesWalSlot::TickType& lastCommittedTick, b
     if (mustWait) {
       guard.wait(10 * 1000);
     }
+    
+    if (TRI_microtime() >= end) {
+      // time's up!
+      break;
+    }
   }
 
   return TRI_ERROR_ARANGO_NO_JOURNAL;

arangod/Wal/LogfileManager.cpp

@@ -174,6 +174,9 @@ void LogfileManager::collectOptions(std::shared_ptr<ProgramOptions> options) {
       "--wal.ignore-recovery-errors",
       "continue recovery even if re-applying operations fails",
       new BooleanParameter(&_ignoreRecoveryErrors));
+  
+  options->addHiddenOption("--wal.flush-timeout", "flush timeout (in milliseconds)",
+                     new UInt64Parameter(&_flushTimeout));
 
   options->addOption("--wal.logfile-size", "size of each logfile (in bytes)",
                      new UInt32Parameter(&_filesize));
@@ -1319,7 +1322,7 @@ int LogfileManager::getWriteableLogfile(uint32_t size,
   }
   
   size_t iterations = 0;
-  double const end = TRI_microtime() + 15.0;
+  double const end = TRI_microtime() + (_flushTimeout / 1000.0);
 
   while (true) {
     {
@@ -1383,7 +1386,7 @@ int LogfileManager::getWriteableLogfile(uint32_t size,
   }
 
   TRI_ASSERT(result == nullptr);
-  LOG(ERR) << "unable to acquire writeable WAL logfile after 15 s";
+  LOG(ERR) << "unable to acquire writeable WAL logfile after " << _flushTimeout << " ms";
 
   return TRI_ERROR_LOCK_TIMEOUT;
 }

arangod/Wal/LogfileManager.h

@@ -465,6 +465,7 @@ class LogfileManager final : public application_features::ApplicationFeature {
   uint32_t _historicLogfiles = 10;
   bool _ignoreLogfileErrors = false;
   bool _ignoreRecoveryErrors = false;
+  uint64_t _flushTimeout = 15000;
   uint32_t _filesize = 32 * 1024 * 1024;
   uint32_t _maxOpenLogfiles = 0;
   uint32_t _reserveLogfiles = 3;

lib/Basics/VelocyPackHelper.h

@@ -444,7 +444,7 @@ struct hash<arangodb::basics::VPackHashedSlice> {
 template <>
 struct equal_to<arangodb::basics::VPackHashedSlice> {
   bool operator()(arangodb::basics::VPackHashedSlice const& lhs,
-                  arangodb::basics::VPackHashedSlice const& rhs) const noexcept {
+                  arangodb::basics::VPackHashedSlice const& rhs) const {
     return lhs.slice.equals(rhs.slice);
   }
 };

lib/ProgramOptions/Parameters.h

@@ -42,8 +42,8 @@ namespace options {
 template <typename T>
 inline typename std::enable_if<std::is_signed<T>::value, T>::type toNumber(
     std::string const& value) {
-  auto v = static_cast<T>(std::stoll(value));
-  if (v < (std::numeric_limits<T>::min)() || v > (std::numeric_limits<T>::max)()) {
+  auto v = static_cast<int64_t>(std::stoll(value));
+  if (v < static_cast<int64_t>((std::numeric_limits<T>::min)()) || v > static_cast<int64_t>((std::numeric_limits<T>::max)())) {
     throw std::out_of_range(value);
   }
   return static_cast<T>(v);
@@ -53,8 +53,8 @@ inline typename std::enable_if<std::is_signed<T>::value, T>::type toNumber(
 template <typename T>
 inline typename std::enable_if<std::is_unsigned<T>::value, T>::type toNumber(
     std::string const& value) {
-  auto v = static_cast<T>(std::stoull(value));
-  if (v < (std::numeric_limits<T>::min)() || v > (std::numeric_limits<T>::max)()) {
+  auto v = static_cast<uint64_t>(std::stoull(value));
+  if (v < static_cast<uint64_t>((std::numeric_limits<T>::min)()) || v > static_cast<uint64_t>((std::numeric_limits<T>::max)())) {
     throw std::out_of_range(value);
   }
   return static_cast<T>(v);
@@ -210,15 +210,11 @@ struct NumericParameter : public Parameter {
   std::string set(std::string const& value) override {
     try {
       ValueType v = toNumber<ValueType>(value);
-      if (v >= (std::numeric_limits<T>::min)() &&
-          v <= (std::numeric_limits<T>::max)()) {
-        *ptr = v;
-        return "";
-      }
+      *ptr = v;
+      return "";
     } catch (...) {
       return "invalid numeric value";
     }
-    return "number out of range";
   }
 
   void toVPack(VPackBuilder& builder) const override {
@@ -291,9 +287,7 @@ struct BoundedParameter : public T {
   std::string set(std::string const& value) override {
     try {
       typename T::ValueType v = toNumber<typename T::ValueType>(value);
-      if (v >= (std::numeric_limits<typename T::ValueType>::min)() &&
-          v <= (std::numeric_limits<typename T::ValueType>::max)() && v >= minValue &&
-          v <= maxValue) {
+      if (v >= minValue && v <= maxValue) {
         *this->ptr = v;
         return "";
       }