Made arango_cluster_methods compile

arangodb · jsteemann · Feb 10, 2021 · Jan 21, 2021 · Jan 21, 2021 · Jan 21, 2021
commit 4c951663b9f2b99ccc62863b56b95315e5405562
diff --git a/arangod/Cluster/ClusterMethods.cpp b/arangod/Cluster/ClusterMethods.cpp
@@ -360,7 +360,7 @@ OperationResult handleCRUDShardResponsesFast(F&& func, CT const& opCtx,
           arr.get(StaticStrings::Error).isBoolean() &&
           arr.get(StaticStrings::Error).getBoolean()) {
         // an error occurred, now rethrow the error
-        int res = arr.get(StaticStrings::ErrorNum).getNumericValue<int>();
+        auto res = ::ErrorCode{arr.get(StaticStrings::ErrorNum).getNumericValue<int>()};
         VPackSlice msg = arr.get(StaticStrings::ErrorMessage);
         if (msg.isString()) {
           THROW_ARANGO_EXCEPTION_MESSAGE(res, msg.copyString());
@@ -385,7 +385,7 @@ OperationResult handleCRUDShardResponsesSlow(F&& func, size_t expectedLen, Opera
     std::shared_ptr<VPackBuffer<uint8_t>> buffer;
 
     int nrok = 0;
-    int commError = TRI_ERROR_NO_ERROR;
+    auto commError = TRI_ERROR_NO_ERROR;
     fuerte::StatusCode code;
     for (size_t i = 0; i < responses.size(); i++) {
       network::Response const& res = responses[i].get();
@@ -450,9 +450,8 @@ struct CrudOperationCtx {
 ///        it returns sth. else this document is NOT contained in the shardMap
 ////////////////////////////////////////////////////////////////////////////////
 
-int distributeBabyOnShards(CrudOperationCtx& opCtx,
-                           LogicalCollection& collinfo,
-                           VPackSlice const value) {
+::ErrorCode distributeBabyOnShards(CrudOperationCtx& opCtx, LogicalCollection& collinfo,
+                                   VPackSlice const value) {
   TRI_ASSERT(!collinfo.isSmart() || collinfo.type() == TRI_COL_TYPE_DOCUMENT);
 
   ShardID shardID;
@@ -465,7 +464,7 @@ int distributeBabyOnShards(CrudOperationCtx& opCtx,
   } else {
     // Now find the responsible shard:
     bool usesDefaultShardingAttributes;
-    int res = collinfo.getResponsibleShard(value, /*docComplete*/false, shardID,
+    auto res = collinfo.getResponsibleShard(value, /*docComplete*/false, shardID,
                                            usesDefaultShardingAttributes);
 
     if (res == TRI_ERROR_ARANGO_DATA_SOURCE_NOT_FOUND) {
@@ -2832,8 +2831,8 @@ arangodb::Result hotBackupList(network::ConnectionPool* pool,
     }
 
     if (resSlice.get(StaticStrings::Error).getBoolean()) {
-      return arangodb::Result(static_cast<int>(resSlice.get(StaticStrings::ErrorNum).getNumber<uint64_t>()),
-                              resSlice.get(StaticStrings::ErrorMessage).copyString());
+      auto res = ::ErrorCode{resSlice.get(StaticStrings::ErrorNum).getNumber<int>()};
+      return arangodb::Result(res, resSlice.get(StaticStrings::ErrorMessage).copyString());
     }
 
     if (!resSlice.hasKey("result") || !resSlice.get("result").isObject()) {
@@ -3391,7 +3390,7 @@ arangodb::Result lockDBServerTransactions(network::ConnectionPool* pool,
 
   // Now listen to the results and report the aggregated final result:
   arangodb::Result finalRes(TRI_ERROR_NO_ERROR);
-  auto reportError = [&](int c, std::string const& m) {
+  auto reportError = [&](::ErrorCode c, std::string const& m) {
     if (finalRes.ok()) {
       finalRes = arangodb::Result(c, m);
     } else {
@@ -3427,8 +3426,9 @@ arangodb::Result lockDBServerTransactions(network::ConnectionPool* pool,
       LOG_TOPIC("f4b8f", DEBUG, Logger::BACKUP)
           << "failed to acquire lock from " << r.destination << ": " << slc.toJson();
       auto errorNum = slc.get(StaticStrings::ErrorNum).getNumber<int>();
-      if (errorNum == TRI_ERROR_LOCK_TIMEOUT) {
-        reportError(errorNum, slc.get(StaticStrings::ErrorMessage).copyString());
+      auto err = ::ErrorCode{errorNum};
+      if (err == TRI_ERROR_LOCK_TIMEOUT) {
+        reportError(err, slc.get(StaticStrings::ErrorMessage).copyString());
         continue;
       }
       reportError(TRI_ERROR_LOCAL_LOCK_FAILED,
@@ -3676,9 +3676,10 @@ arangodb::Result removeLocalBackups(network::ConnectionPool* pool,
 
     if (!resSlice.hasKey(StaticStrings::Error) || !resSlice.get(StaticStrings::Error).isBoolean() ||
         resSlice.get(StaticStrings::Error).getBoolean()) {
-      int64_t errorNum = resSlice.get(StaticStrings::ErrorNum).getNumber<int64_t>();
+      auto errorNum = resSlice.get(StaticStrings::ErrorNum).getNumber<int>();
+      auto res = ::ErrorCode{errorNum};
 
-      if (errorNum == TRI_ERROR_FILE_NOT_FOUND) {
+      if (res == TRI_ERROR_FILE_NOT_FOUND) {
         notFoundCount += 1;
         continue;
       }
@@ -3689,7 +3690,7 @@ arangodb::Result removeLocalBackups(network::ConnectionPool* pool,
                              std::to_string(errorNum) + ")";
 
       LOG_TOPIC("9b94f", ERR, Logger::BACKUP) << errorMsg;
-      return arangodb::Result(static_cast<int>(errorNum), errorMsg);
+      return arangodb::Result(res, errorMsg);
     }
   }
 
@@ -3824,7 +3825,7 @@ arangodb::Result hotbackupWaitForLockDBServersTransactions(
     if (slc.get(StaticStrings::Error).getBoolean()) {
       LOG_TOPIC("d7a8a", DEBUG, Logger::BACKUP)
           << "failed to acquire lock from " << r.destination << ": " << slc.toJson();
-      auto errorNum = slc.get(StaticStrings::ErrorNum).getNumber<int>();
+      auto errorNum = ::ErrorCode{slc.get(StaticStrings::ErrorNum).getNumber<int>()};
       if (errorNum == TRI_ERROR_LOCK_TIMEOUT) {
         return arangodb::Result(errorNum, slc.get(StaticStrings::ErrorMessage).copyString());
       }

diff --git a/arangod/Cluster/ClusterTtlMethods.cpp b/arangod/Cluster/ClusterTtlMethods.cpp
@@ -73,7 +73,7 @@ Result getTtlStatisticsFromAllDBServers(ClusterFeature& feature, TtlStatistics&
     if (r.statusCode() == fuerte::StatusOK) {
       out += r.slice().get("result");
     } else {
-      int code = network::errorCodeFromBody(r.slice());
+      auto code = network::errorCodeFromBody(r.slice());
       if (code != TRI_ERROR_NO_ERROR) {
         return code;
       }
@@ -108,7 +108,7 @@ Result getTtlPropertiesFromAllDBServers(ClusterFeature& feature, VPackBuilder& o
       out.add(r.slice().get("result"));
       break;
     } else {
-      int code = network::errorCodeFromBody(r.slice());
+      auto code = network::errorCodeFromBody(r.slice());
       if (code != TRI_ERROR_NO_ERROR) {
         return code;
       }
@@ -148,7 +148,7 @@ Result setTtlPropertiesOnAllDBServers(ClusterFeature& feature,
       out.add(r.slice().get("result"));
       break;
     } else {
-      int code = network::errorCodeFromBody(r.slice());
+      auto code = network::errorCodeFromBody(r.slice());
       if (code != TRI_ERROR_NO_ERROR) {
         return code;
       }

diff --git a/arangod/Sharding/ShardingInfo.cpp b/arangod/Sharding/ShardingInfo.cpp
@@ -478,9 +478,10 @@ void ShardingInfo::setShardMap(std::shared_ptr<ShardMap> const& map) {
   _shardIds = map;
 }
 
-int ShardingInfo::getResponsibleShard(arangodb::velocypack::Slice slice, bool docComplete,
-                                      ShardID& shardID, bool& usesDefaultShardKeys,
-                                      VPackStringRef const& key) {
+ErrorCode ShardingInfo::getResponsibleShard(arangodb::velocypack::Slice slice,
+                                            bool docComplete, ShardID& shardID,
+                                            bool& usesDefaultShardKeys,
+                                            VPackStringRef const& key) {
   return _shardingStrategy->getResponsibleShard(slice, docComplete, shardID,
                                                 usesDefaultShardKeys, key);
 }

diff --git a/arangod/Sharding/ShardingInfo.h b/arangod/Sharding/ShardingInfo.h
@@ -100,9 +100,9 @@ class ShardingInfo {
   std::shared_ptr<ShardMap> shardIds(std::unordered_set<std::string> const& includedShards) const;
   void setShardMap(std::shared_ptr<ShardMap> const& map);
 
-  int getResponsibleShard(arangodb::velocypack::Slice, bool docComplete,
-                          ShardID& shardID, bool& usesDefaultShardKeys,
-                          arangodb::velocypack::StringRef const&);
+  ErrorCode getResponsibleShard(arangodb::velocypack::Slice slice, bool docComplete,
+                                ShardID& shardID, bool& usesDefaultShardKeys,
+                                arangodb::velocypack::StringRef const& key);
 
   static void sortShardNamesNumerically(std::vector<ShardID>& list);
 

diff --git a/arangod/Sharding/ShardingStrategy.h b/arangod/Sharding/ShardingStrategy.h
@@ -71,9 +71,9 @@ class ShardingStrategy {
   /// `_key` is the one and only sharding attribute.
   ////////////////////////////////////////////////////////////////////////////////
 
-  virtual int getResponsibleShard(arangodb::velocypack::Slice, bool docComplete,
-                                  ShardID& shardID, bool& usesDefaultShardKeys,
-                                  arangodb::velocypack::StringRef const& key) = 0;
+  virtual ErrorCode getResponsibleShard(arangodb::velocypack::Slice slice, bool docComplete,
+                                        ShardID& shardID, bool& usesDefaultShardKeys,
+                                        arangodb::velocypack::StringRef const& key) = 0;
 };
 
 }  // namespace arangodb

diff --git a/arangod/Sharding/ShardingStrategyDefault.cpp b/arangod/Sharding/ShardingStrategyDefault.cpp
@@ -219,10 +219,9 @@ ShardingStrategyNone::ShardingStrategyNone() : ShardingStrategy() {
 }
 
 /// calling getResponsibleShard on this class will always throw an exception
-int ShardingStrategyNone::getResponsibleShard(arangodb::velocypack::Slice slice,
-                                              bool docComplete, ShardID& shardID,
-                                              bool& usesDefaultShardKeys,
-                                              VPackStringRef const& key) {
+ErrorCode ShardingStrategyNone::getResponsibleShard(
+    arangodb::velocypack::Slice slice, bool docComplete, ShardID& shardID,
+    bool& usesDefaultShardKeys, arangodb::velocypack::StringRef const& key) {
   THROW_ARANGO_EXCEPTION_MESSAGE(
       TRI_ERROR_INTERNAL, "unexpected invocation of ShardingStrategyNone");
 }
@@ -236,10 +235,9 @@ ShardingStrategyOnlyInEnterprise::ShardingStrategyOnlyInEnterprise(std::string c
 
 /// @brief will always throw an exception telling the user the selected sharding
 /// is only available in the Enterprise Edition
-int ShardingStrategyOnlyInEnterprise::getResponsibleShard(arangodb::velocypack::Slice slice,
-                                                          bool docComplete, ShardID& shardID,
-                                                          bool& usesDefaultShardKeys,
-                                                          VPackStringRef const& key) {
+ErrorCode ShardingStrategyOnlyInEnterprise::getResponsibleShard(
+    arangodb::velocypack::Slice slice, bool docComplete, ShardID& shardID,
+    bool& usesDefaultShardKeys, arangodb::velocypack::StringRef const& key) {
   THROW_ARANGO_EXCEPTION_MESSAGE(
       TRI_ERROR_ONLY_ENTERPRISE,
       std::string("sharding strategy '") + _name +
@@ -268,10 +266,9 @@ ShardingStrategyHashBase::ShardingStrategyHashBase(ShardingInfo* sharding)
   }
 }
 
-int ShardingStrategyHashBase::getResponsibleShard(arangodb::velocypack::Slice slice,
-                                                  bool docComplete, ShardID& shardID,
-                                                  bool& usesDefaultShardKeys,
-                                                  VPackStringRef const& key) {
+ErrorCode ShardingStrategyHashBase::getResponsibleShard(
+    arangodb::velocypack::Slice slice, bool docComplete, ShardID& shardID,
+    bool& usesDefaultShardKeys, arangodb::velocypack::StringRef const& key) {
   static constexpr char const* magicPhrase =
       "Foxx you have stolen the goose, give she back again!";
   static constexpr size_t magicLength = 52;

diff --git a/arangod/Sharding/ShardingStrategyDefault.h b/arangod/Sharding/ShardingStrategyDefault.h
@@ -46,9 +46,9 @@ class ShardingStrategyNone final : public ShardingStrategy {
   /// @brief does not really matter here
   bool usesDefaultShardKeys() override { return true; }
 
-  int getResponsibleShard(arangodb::velocypack::Slice, bool docComplete,
-                          ShardID& shardID, bool& usesDefaultShardKeys,
-                          arangodb::velocypack::StringRef const& key) override;
+  ErrorCode getResponsibleShard(arangodb::velocypack::Slice slice, bool docComplete,
+                                ShardID& shardID, bool& usesDefaultShardKeys,
+                                arangodb::velocypack::StringRef const& key) override;
 };
 
 /// @brief a sharding class used to indicate that the selected sharding strategy
@@ -66,9 +66,9 @@ class ShardingStrategyOnlyInEnterprise final : public ShardingStrategy {
 
   /// @brief will always throw an exception telling the user the selected
   /// sharding is only available in the Enterprise Edition
-  int getResponsibleShard(arangodb::velocypack::Slice, bool docComplete,
-                          ShardID& shardID, bool& usesDefaultShardKeys,
-                          arangodb::velocypack::StringRef const& key) override;
+  ErrorCode getResponsibleShard(arangodb::velocypack::Slice slice, bool docComplete,
+                                ShardID& shardID, bool& usesDefaultShardKeys,
+                                arangodb::velocypack::StringRef const& key) override;
 
  private:
   /// @brief name of the sharding strategy we are replacing
@@ -80,9 +80,9 @@ class ShardingStrategyHashBase : public ShardingStrategy {
  public:
   explicit ShardingStrategyHashBase(ShardingInfo* sharding);
 
-  virtual int getResponsibleShard(arangodb::velocypack::Slice, bool docComplete,
-                                  ShardID& shardID, bool& usesDefaultShardKeys,
-                                  arangodb::velocypack::StringRef const& key) override;
+  virtual ErrorCode getResponsibleShard(arangodb::velocypack::Slice slice, bool docComplete,
+                                        ShardID& shardID, bool& usesDefaultShardKeys,
+                                        arangodb::velocypack::StringRef const& key) override;
 
   /// @brief does not really matter here
   bool usesDefaultShardKeys() override { return _usesDefaultShardKeys; }

diff --git a/arangod/Transaction/Methods.h b/arangod/Transaction/Methods.h
@@ -390,7 +390,7 @@ class Methods {
   bool isInaccessibleCollection(std::string const& /*cname*/) const;
 #endif
 
-  static int validateSmartJoinAttribute(LogicalCollection const& collinfo,
+  static ErrorCode validateSmartJoinAttribute(LogicalCollection const& collinfo,
                                         arangodb::velocypack::Slice value);
 
  private:

diff --git a/arangod/VocBase/KeyGenerator.cpp b/arangod/VocBase/KeyGenerator.cpp
@@ -237,7 +237,7 @@ class TraditionalKeyGenerator : public KeyGenerator {
   }
 
   /// @brief validate a key
-  int validate(char const* p, size_t length, bool isRestore) override {
+  ErrorCode validate(char const* p, size_t length, bool isRestore) override {
     int res = KeyGenerator::validate(p, length, isRestore);
 
     if (res == TRI_ERROR_NO_ERROR) {
@@ -397,7 +397,7 @@ class PaddedKeyGenerator : public KeyGenerator {
   }
 
   /// @brief validate a key
-  int validate(char const* p, size_t length, bool isRestore) override {
+  ErrorCode validate(char const* p, size_t length, bool isRestore) override {
     int res = KeyGenerator::validate(p, length, isRestore);
 
     if (res == TRI_ERROR_NO_ERROR) {
@@ -513,7 +513,7 @@ class AutoIncrementKeyGenerator final : public KeyGenerator {
   }
 
   /// @brief validate a key
-  int validate(char const* p, size_t length, bool isRestore) override {
+  ErrorCode validate(char const* p, size_t length, bool isRestore) override {
     int res = KeyGenerator::validate(p, length, isRestore);
 
     if (res == TRI_ERROR_NO_ERROR) {
@@ -795,12 +795,12 @@ KeyGenerator* KeyGenerator::factory(application_features::ApplicationServer& ser
 }
 
 /// @brief validate a key
-int KeyGenerator::validate(char const* p, size_t length, bool isRestore) {
+ErrorCode KeyGenerator::validate(char const* p, size_t length, bool isRestore) {
   return globalCheck(p, length, isRestore);
 }
 
 /// @brief check global key attributes
-int KeyGenerator::globalCheck(char const* p, size_t length, bool isRestore) {
+ErrorCode KeyGenerator::globalCheck(char const* p, size_t length, bool isRestore) {
   // user has specified a key
   if (length > 0 && !_allowUserKeys && !isRestore && !_isDBServer) {
     // we do not allow user-generated keys

diff --git a/arangod/VocBase/KeyGenerator.h b/arangod/VocBase/KeyGenerator.h
@@ -79,7 +79,7 @@ class KeyGenerator {
   virtual std::string generate() = 0;
 
   /// @brief validate a key
-  virtual int validate(char const* p, size_t length, bool isRestore);
+  virtual ErrorCode validate(char const* p, size_t length, bool isRestore);
 
   /// @brief track usage of a key
   virtual void track(char const* p, size_t length) = 0;
@@ -98,7 +98,7 @@ class KeyGenerator {
 
  protected:
   /// @brief check global key attributes
-  int globalCheck(char const* p, size_t length, bool isRestore);
+  ErrorCode globalCheck(char const* p, size_t length, bool isRestore);
 
  protected:
   /// @brief whether or not the users can specify their own keys

diff --git a/arangod/VocBase/LogicalCollection.cpp b/arangod/VocBase/LogicalCollection.cpp
@@ -392,7 +392,7 @@ int LogicalCollection::getResponsibleShard(std::string_view key, std::string& sh
                              VPackStringRef(key.data(), key.size()));
 }
 
-int LogicalCollection::getResponsibleShard(arangodb::velocypack::Slice slice,
+ErrorCode LogicalCollection::getResponsibleShard(arangodb::velocypack::Slice slice,
                                            bool docComplete, std::string& shardID,
                                            bool& usesDefaultShardKeys,
                                            VPackStringRef const& key) {

diff --git a/arangod/VocBase/LogicalCollection.h b/arangod/VocBase/LogicalCollection.h
@@ -183,10 +183,10 @@ class LogicalCollection : public LogicalDataSource {
   int getResponsibleShard(arangodb::velocypack::Slice, bool docComplete, std::string& shardID);
   int getResponsibleShard(std::string_view key, std::string& shardID);
 
-  int getResponsibleShard(arangodb::velocypack::Slice, bool docComplete,
-                          std::string& shardID, bool& usesDefaultShardKeys,
-                          arangodb::velocypack::StringRef const& key =
-                          arangodb::velocypack::StringRef());
+  ErrorCode getResponsibleShard(arangodb::velocypack::Slice slice, bool docComplete,
+                                std::string& shardID, bool& usesDefaultShardKeys,
+                                arangodb::velocypack::StringRef const& key =
+                                    arangodb::velocypack::StringRef());
 
   /// @briefs creates a new document key, the input slice is ignored here
   /// this method is overriden in derived classes

diff --git a/js/common/bootstrap/errors.js b/js/common/bootstrap/errors.js
@@ -42,6 +42,7 @@
     "ERROR_CANNOT_READ_FILE"       : { "code" : 34, "message" : "cannot read file" },
     "ERROR_INCOMPATIBLE_VERSION"   : { "code" : 35, "message" : "incompatible server version" },
     "ERROR_DISABLED"               : { "code" : 36, "message" : "disabled" },
+    "ERROR_MALFORMED_JSON"         : { "code" : 37, "message" : "malformed json" },
     "ERROR_HTTP_BAD_PARAMETER"     : { "code" : 400, "message" : "bad parameter" },
     "ERROR_HTTP_UNAUTHORIZED"      : { "code" : 401, "message" : "unauthorized" },
     "ERROR_HTTP_FORBIDDEN"         : { "code" : 403, "message" : "forbidden" },

diff --git a/lib/Basics/ResultT.h b/lib/Basics/ResultT.h
@@ -222,7 +222,7 @@ class ResultT {
   bool ok() const { return _result.ok(); }
   bool fail() const { return _result.fail(); }
   bool is(ErrorCode code) { return _result.is(code); }
-  int errorNumber() const { return _result.errorNumber(); }
+  ErrorCode errorNumber() const { return _result.errorNumber(); }
   [[nodiscard]] std::string_view errorMessage() const& { return _result.errorMessage(); }
   [[nodiscard]] std::string errorMessage() && { return std::move(_result).errorMessage(); }
 

diff --git a/lib/Basics/errors.dat b/lib/Basics/errors.dat
@@ -36,6 +36,7 @@ ERROR_ARANGO_ICU_ERROR,33,"icu error: %s","will be raised if icu operations fail
 ERROR_CANNOT_READ_FILE,34,"cannot read file","Will be raised when a file cannot be read."
 ERROR_INCOMPATIBLE_VERSION,35,"incompatible server version","Will be raised when a server is running an incompatible version of ArangoDB."
 ERROR_DISABLED,36,"disabled","Will be raised when a requested resource is not enabled."
+ERROR_MALFORMED_JSON,37,"malformed json","Will be raised when a JSON string could not be parsed."
 
 ################################################################################
 ## HTTP error status codes

diff --git a/lib/Basics/voc-errors.cpp b/lib/Basics/voc-errors.cpp
@@ -42,6 +42,7 @@ void TRI_InitializeErrorMessages() {
   REG_ERROR(ERROR_CANNOT_READ_FILE, "cannot read file");
   REG_ERROR(ERROR_INCOMPATIBLE_VERSION, "incompatible server version");
   REG_ERROR(ERROR_DISABLED, "disabled");
+  REG_ERROR(ERROR_MALFORMED_JSON, "malformed json");
   REG_ERROR(ERROR_HTTP_BAD_PARAMETER, "bad parameter");
   REG_ERROR(ERROR_HTTP_UNAUTHORIZED, "unauthorized");
   REG_ERROR(ERROR_HTTP_FORBIDDEN, "forbidden");