butterflynet (#593)

Signed-off-by: turuslan <[email protected]>

Author: turuslan

core/api/storage_miner/storage_api.cpp

@@ -12,7 +12,6 @@
 #include "sector_storage/impl/remote_worker.hpp"
 
 namespace fc::api {
-  using common::HttpUri;
   using miner::kMinerVersion;
   using sector_storage::RemoteWorker;
 

core/blockchain/block_validator/validator.cpp

@@ -12,6 +12,8 @@
 #include "cbor_blake/memory.hpp"
 #include "common/error_text.hpp"
 #include "common/from_span.hpp"
+#include "common/prometheus/metrics.hpp"
+#include "common/prometheus/since.hpp"
 #include "crypto/bls/impl/bls_provider_impl.hpp"
 #include "primitives/block/rand.hpp"
 #include "primitives/tipset/chain.hpp"
@@ -48,6 +50,14 @@ namespace fc::blockchain::block_validator {
 
   outcome::result<void> BlockValidator::validate(const TsBranchPtr &branch,
                                                  const BlockHeader &block) {
+    static auto &metricTime{prometheus::BuildHistogram()
+                                .Name("lotus_block_validation_ms")
+                                .Help("Duration for Block Validation in ms")
+                                .Register(prometheusRegistry())
+                                .Add({}, kDefaultPrometheusMsBuckets)};
+    auto BOOST_OUTCOME_TRY_UNIQUE_NAME{
+        gsl::finally([since{Since{}}] { metricTime.Observe(since.ms()); })};
+
     OUTCOME_TRY(block_cbor, codec::cbor::encode(block));
     const auto block_cid{CbCid::hash(block_cbor)};
     storage::OneKey key{BytesIn{block_cid}, kv};

core/common/libp2p/soralog.hpp

@@ -34,7 +34,7 @@ namespace fc {
 groups:
   - name: main
     sink: file
-    level: debug
+    level: info
     children:
       - name: libp2p
           )",

core/common/uri_parser/percent_encoding.cpp

@@ -28,7 +28,8 @@
 #include <gsl/gsl_util>
 #include <iomanip>
 #include <sstream>
-#include <stdexcept>
+
+#include "common/error_text.hpp"
 
 // unreserved
 static const std::string unreserved(
@@ -53,16 +54,17 @@ inline static bool need_encode(const char c) {
   return true;
 }
 
-static int decodePercentEscapedByte(std::istringstream &iss) {
+static fc::outcome::result<int> decodePercentEscapedByte(
+    std::istringstream &iss) {
   auto c = iss.get();
   if (c != '%') {
-    throw std::runtime_error("Wrong token for start percent-encoded sequence");
+    return ERROR_TEXT("Wrong token for start percent-encoded sequence");
   }
 
   int result = 0;
 
   if (iss.eof()) {
-    throw std::runtime_error(
+    return ERROR_TEXT(
         "Unxpected end of data during try parse percent-encoded symbol");
   }
   c = iss.get();
@@ -73,14 +75,14 @@ static int decodePercentEscapedByte(std::istringstream &iss) {
   } else if (c >= 'A' && c <= 'F') {
     result = 10 + c - 'A';
   } else if (c == -1) {
-    throw std::runtime_error(
+    return ERROR_TEXT(
         "Unxpected end of data during try parse percent-encoded symbol");
   } else {
-    throw std::runtime_error("Wrong percent-encoded symbol");
+    return ERROR_TEXT("Wrong percent-encoded symbol");
   }
 
   if (iss.eof()) {
-    throw std::runtime_error(
+    return ERROR_TEXT(
         "Unxpected end of data during try parse percent-encoded symbol");
   }
   c = iss.get();
@@ -91,17 +93,18 @@ static int decodePercentEscapedByte(std::istringstream &iss) {
   } else if (c >= 'A' && c <= 'F') {
     result = (result << 4) | (10 + c - 'A');
   } else if (c == -1) {
-    throw std::runtime_error(
+    return ERROR_TEXT(
         "Unxpected end of data during try parse percent-encoded symbol");
   } else {
-    throw std::runtime_error("Wrong percent-encoded symbol");
+    return ERROR_TEXT("Wrong percent-encoded symbol");
   }
 
   return result;
 }
 
-static uint32_t decodePercentEscaped(std::istringstream &iss, bool &isUtf8) {
-  auto c = decodePercentEscapedByte(iss);
+static fc::outcome::result<uint32_t> decodePercentEscaped(
+    std::istringstream &iss, bool &isUtf8) {
+  OUTCOME_TRY(c, decodePercentEscapedByte(iss));
 
   if (!isUtf8) {
     return static_cast<uint32_t>(c);
@@ -140,7 +143,7 @@ static uint32_t decodePercentEscaped(std::istringstream &iss, bool &isUtf8) {
       return static_cast<uint32_t>(fc);
     }
     try {
-      c = decodePercentEscapedByte(iss);
+      OUTCOME_TRYA(c, decodePercentEscapedByte(iss));
     } catch (...) {
       iss.clear(std::istringstream::goodbit);
       iss.seekg(p);
@@ -157,15 +160,16 @@ static uint32_t decodePercentEscaped(std::istringstream &iss, bool &isUtf8) {
   return symbol;
 }
 
-std::string PercentEncoding::decode(const std::string &input) {
+fc::outcome::result<std::string> PercentEncoding::decode(
+    const std::string &input) {
   std::istringstream iss(input);
   std::ostringstream oss;
   bool isUtf8 = true;
 
   while (!iss.eof()) {
     int c = iss.peek();
     if (c == '%') {
-      auto symbol = decodePercentEscaped(iss, isUtf8);
+      OUTCOME_TRY(symbol, decodePercentEscaped(iss, isUtf8));
 
       if (symbol <= 0b0111'1111)  // 7bit -> 1byte
       {

core/common/uri_parser/percent_encoding.hpp

@@ -27,9 +27,11 @@
 
 #include <string>
 
+#include "common/outcome.hpp"
+
 class PercentEncoding final {
  public:
   static std::string encode(const std::string &input);
 
-  static std::string decode(std::string const &input);
+  static fc::outcome::result<std::string> decode(std::string const &input);
 };

core/common/uri_parser/uri_parser.cpp

@@ -30,18 +30,19 @@
 #include <cstring>
 #include <iomanip>
 #include <sstream>
-#include <stdexcept>
+
+#include "common/error_text.hpp"
 
 namespace fc::common {
-  HttpUri::HttpUri(const std::string &uri) {
-    try {
-      parse(uri);
-    } catch (const std::exception &exception) {
-      throw std::runtime_error(std::string("Bad URI ← ") + exception.what());
-    }
+  inline const auto kOutOfData{ERROR_TEXT("HttpUri: Out of data")};
+
+  outcome::result<HttpUri> HttpUri::parse(const std::string &string) {
+    HttpUri uri;
+    OUTCOME_TRY(uri.parseThis(string));
+    return uri;
   }
 
-  void HttpUri::parse(const std::string &string) {
+  outcome::result<void> HttpUri::parseThis(const std::string &string) {
     const char *s = string.c_str();
     const auto *end = string.c_str() + string.size();
 
@@ -51,7 +52,7 @@ namespace fc::common {
       s += 2;
     } else if (*s == '/') {
       scheme_ = Scheme::UNDEFINED;
-      parsePath(s, end);
+      OUTCOME_TRY(parsePath(s, end));
     } else if (string.length() >= 7 && strncasecmp(s, "http://", 7) == 0) {
       scheme_ = Scheme::HTTP;
       port_ = 80;
@@ -61,84 +62,86 @@ namespace fc::common {
       port_ = 443;
       s += 8;
     } else {
-      throw std::runtime_error("Wrong scheme");
+      return ERROR_TEXT("Wrong scheme");
     }
 
     // host:
     while (*s != 0 && *s != ':' && *s != '/' && *s != '?' && *s != '#'
            && isspace(*s) == 0) {
       if (isalnum(*s) == 0 && *s != '.' && *s != '-') {
-        throw std::runtime_error("Wrong hostname");
+        return ERROR_TEXT("Wrong hostname");
       }
       host_.push_back(static_cast<char>(tolower(*s)));
       if (++s > end) {
-        throw std::runtime_error("Out of data");
+        return kOutOfData;
       }
     }
 
     // port:
     if (*s == ':') {
       if (++s > end) {
-        throw std::runtime_error("Out of data");
+        return kOutOfData;
       }
       uint64_t port = 0;
       while (*s != 0 && *s != '/' && *s != '?' && *s != '#'
              && isspace(*s) == 0) {
         if (isdigit(*s) == 0) {
-          throw std::runtime_error("Wrong port");
+          return ERROR_TEXT("Wrong port");
         }
         port = port * 10 + *s - '0';
         if (port < 1 || port > 65535) {
-          throw std::runtime_error("Wrong port");
+          return ERROR_TEXT("Wrong port");
         }
         if (++s > end) {
-          throw std::runtime_error("Out of data");
+          return kOutOfData;
         }
       }
       port_ = static_cast<uint16_t>(port);
     }
 
     // path:
-    parsePath(s, end);
+    OUTCOME_TRY(parsePath(s, end));
+    return outcome::success();
   }
 
-  void HttpUri::parsePath(const char *s, const char *end) {
+  outcome::result<void> HttpUri::parsePath(const char *s, const char *end) {
     if (*s == '/') {
       while (*s != 0 && *s != '?' && *s != '#' && isspace(*s) == 0) {
         path_.push_back(*s);
         if (++s > end) {
-          throw std::runtime_error("Out of data");
+          return kOutOfData;
         }
       }
     }
 
     // query:
     if (*s == '?') {
       if (++s > end) {
-        throw std::runtime_error("Out of data");
+        return kOutOfData;
       }
       hasQuery_ = true;
       while (*s != 0 && *s != '#' && isspace(*s) == 0) {
         query_.push_back(*s);
         if (++s > end) {
-          throw std::runtime_error("Out of data");
+          return kOutOfData;
         }
       }
     }
 
     // fragment:
     if (*s == '#') {
       if (++s > end) {
-        throw std::runtime_error("Out of data");
+        return kOutOfData;
       }
       hasFragment_ = true;
       while (*s != 0 && isspace(*s) == 0) {
         fragment_.push_back(*s);
         if (++s > end) {
-          throw std::runtime_error("Out of data");
+          return kOutOfData;
         }
       }
     }
+    return outcome::success();
   }
 
   const std::string &HttpUri::str() const {
@@ -171,7 +174,7 @@ namespace fc::common {
     return thisAsString_;
   }
 
-  std::string HttpUri::urldecode(const std::string &input_) {
+  outcome::result<std::string> HttpUri::urldecode(const std::string &input_) {
     std::string input(input_);
     std::replace(input.begin(), input.end(), '+', ' ');
     return PercentEncoding::decode(input);

core/common/uri_parser/uri_parser.hpp

@@ -27,18 +27,17 @@
 
 #include <string>
 
+#include "common/outcome.hpp"
+
 namespace fc::common {
   class HttpUri final {
    public:
     enum class Scheme { UNDEFINED, HTTP, HTTPS };
 
     HttpUri() = default;
 
-    explicit HttpUri(const std::string &uri);
-
-    virtual ~HttpUri() = default;
-
-    void parse(const std::string &string);
+    static outcome::result<HttpUri> parse(const std::string &string);
+    outcome::result<void> parseThis(const std::string &string);
 
     const std::string &str() const;
 
@@ -111,12 +110,12 @@ namespace fc::common {
       }
     }
 
-    static std::string urldecode(const std::string &input);
+    static outcome::result<std::string> urldecode(const std::string &input);
 
     static std::string urlencode(const std::string &input);
 
    private:
-    void parsePath(const char *s, const char *end);
+    outcome::result<void> parsePath(const char *s, const char *end);
 
     Scheme scheme_ = Scheme::UNDEFINED;
     std::string host_;

core/config/profile_config.cpp

@@ -31,7 +31,7 @@ namespace fc::config {
     // one string, it's an error, and exception will be thrown.
     std::string const &value = get_single_string(values);
     if (value == "mainnet" || value == "2k" || value == "no-upgrades"
-        || value == "interopnet") {
+        || value == "interopnet" || value == "butterflynet") {
       v = boost::any(Profile{value});
     } else {
       throw validation_error(validation_error::invalid_option_value);
@@ -53,6 +53,8 @@ namespace fc::config {
                 setParamsNoUpgrades();
               } else if (profile == "interopnet") {
                 setParamsInteropnet();
+              } else if (profile == "butterflynet") {
+                setParamsButterfly();
               }
             }),
         "Network parameters profile configuration that defines network "