someut

.github/workflows/library.yml

@@ -123,7 +123,7 @@ jobs:
           conan profile path default
           grep -n . `conan profile path default`
           echo "compiler=apple-clang" >> `conan profile path default`
-          echo "compiler.cppstd=17" >> `conan profile path default`
+          echo "compiler.cppstd=20" >> `conan profile path default`
           echo "compiler.libcxx=libc++" >> `conan profile path default`
           echo "compiler.version=14.0" >> `conan profile path default`
           conan profile show

component/block_http_request.cc

@@ -65,7 +65,7 @@ void Self::OnResponse(std::shared_ptr<Self>,
   ContextApi::HeaderAccess header_accessor = [](auto) { return std::string{}; };
   auto sz = body ? body->size() : 0UL;
   if (loader_->NetError()) {
-    LOG(WARNING) << "NetErr " << loader_->NetError() << " for " << inf_.url;
+    LOG(INFO) << "NetErr " << loader_->NetError() << " for " << inf_.url;
   }
   VLOG(1) << "Handling HTTP response body of size " << sz << " with NetErr "
           << loader_->NetError() << " for " << inf_.url;
@@ -86,7 +86,7 @@ void Self::OnResponse(std::shared_ptr<Self>,
       return val;
     };
   } else {
-    LOG(WARNING) << "No response header info?";
+    LOG(INFO) << "No response header info?";
   }
   if (body) {
     callback_(status, *body, header_accessor);

component/ipns_cbor.cc

@@ -30,7 +30,7 @@ void Assign(cbor::Value::MapValue const& m, char const* n, V& out) {
     return;
   }
   if (Assign(i->second, out)) {
-    LOG(INFO) << "Assigned successfully '" << n << "'='" << out << "'.";
+    VLOG(1) << "Assigned successfully '" << n << "'='" << out << "'.";
   } else {
     LOG(ERROR) << "Type mismatch on " << n
                << " type received: " << static_cast<int>(i->second.type());

library/CMakeLists.txt

@@ -146,6 +146,7 @@ if(GTest_FOUND)
       PRIVATE
       include/
       src/
+      ../test_data/include
       )
     target_link_libraries(unit_test_runner
       PUBLIC

library/include/ipfs_client/ipld/dag_node.h

@@ -33,10 +33,12 @@ struct MoreDataNeeded {
   std::vector<std::string> ipfs_abs_paths_;
 };
 enum class ProvenAbsent {};
-using NewPath = std::string;
+struct PathChange {
+  std::string new_path;
+};
 
 using ResolveResult =
-    std::variant<MoreDataNeeded, Response, ProvenAbsent, NewPath>;
+    std::variant<MoreDataNeeded, Response, ProvenAbsent, PathChange>;
 /**
  * @brief A block, an IPNS record, etc.
  */
@@ -64,4 +66,6 @@ class DagNode : public std::enable_shared_from_this<DagNode> {
 };
 }  // namespace ipfs::ipld
 
+std::ostream& operator<<(std::ostream&, ipfs::ipld::PathChange const&);
+
 #endif  // IPFS_DAG_NODE_H_

library/include/libp2p/multi/content_identifier_codec.hpp

@@ -78,7 +78,7 @@ class ContentIdentifierCodec {
    * @return CID
    */
   static ipfs::expected<ContentIdentifier, DecodeError> fromString(
-      const std::string& str);
+      std::string_view str);
 };
 
 std::string_view Stringify(libp2p::multi::ContentIdentifierCodec::DecodeError);

library/include/vocab/span.h

@@ -1,20 +1,20 @@
 #ifndef IPFS_SPAN_H_
 #define IPFS_SPAN_H_
 
-#if __has_include("base/containers/span.h")
+#if __cpp_lib_span
+#include <span>
 
-#include "base/containers/span.h"
 namespace ipfs {
 template <class Value>
-using span = base::span<Value>;
+using span = std::span<Value>;
 }  // namespace ipfs
 
-#elif __has_cpp_attribute(__cpp_lib_span)
+#elif __has_include("base/containers/span.h")
 
-#include <span>
+#include "base/containers/span.h"
 namespace ipfs {
 template <class Value>
-using span = std::span<Value>;
+using span = base::span<Value>;
 }  // namespace ipfs
 
 #elif __has_include(<absl/types/span.h>)

library/src/ipfs_client/dag_block_unittest.cc

@@ -51,7 +51,7 @@ TEST(BlockTest, AdHoc) {
   std::for_each(directory_iterator("."), directory_iterator(), [](auto e) {
     if (is_regular_file(e) && e.path().extension() == ".block") {
       LOG(INFO) << e.path();
-      auto cid = Codec ::fromString(e.path().stem()).value();
+      auto cid = Codec::fromString(e.path().stem().string()).value();
       std::ifstream f{e.path()};
       std::stringstream buffer;
       buffer << f.rdbuf();

library/src/ipfs_client/generated_directory_listing.cc

@@ -25,14 +25,13 @@ ipfs::GeneratedDirectoryListing::GeneratedDirectoryListing(
 }
 
 void ipfs::GeneratedDirectoryListing::AddEntry(std::string_view name) {
-  //  auto path = base_path_;
-  //  path.append(name);
-  //  AddLink(name, path);
-  AddLink(name, name);
+  auto path = base_path_;
+  path.append(name);
+  AddLink(name, path);
 }
 void ipfs::GeneratedDirectoryListing::AddLink(std::string_view name,
                                               std::string_view path) {
-  LOG(INFO) << "Adding link to generated index.html " << name << '=' << path;
+  VLOG(1) << "Adding link to generated index.html " << name << '=' << path;
   html_.append("      <li>\n")
       .append("        <a href='")
       .append(path)

library/src/ipfs_client/gw/gateway_http_requestor.cc

@@ -87,10 +87,9 @@ auto Self::handle(ipfs::gw::RequestPtr r) -> HandleOutcome {
                   << " forwarding request " << r->debug_string()
                   << " to next requestor.";
       }
-    }
-  } else {
-      LOG(INFO) << r->debug_string() << " got a failure of status " << status
-                << " from " << prefix_;
+    } else {
+      VLOG(1) << r->debug_string() << " got a failure of status " << status
+              << " from " << prefix_;
     }
   LOG(INFO) << "Demote(" << prefix_ << ')';
   aff_bad_.insert(r->affinity);
@@ -100,7 +99,7 @@ auto Self::handle(ipfs::gw::RequestPtr r) -> HandleOutcome {
   DCHECK(api_);
   api_->SendHttpRequest(desc.value(), cb);
   seen_.insert(req_key);
-  pending++;
+  pending_++;
   return HandleOutcome::PENDING;
 }
 

library/src/ipfs_client/gw/gateway_http_requestor_unittest.cc

@@ -1,6 +1,6 @@
 #include <ipfs_client/gw/gateway_http_requestor.h>
 
-#include <gtest/gtest.h>
+#include <mock_api.h>
 
 #include <ipfs_client/ipfs_request.h>
 #include <ipfs_client/orchestrator.h>
@@ -12,40 +12,7 @@ using P = ipfs::gw::RequestPtr;
 using namespace std::literals;
 
 namespace {
-struct FakeApi final : public ipfs::ContextApi {
-  std::vector<HttpRequestDescription> mutable http_requests_sent;
-  std::vector<HttpCompleteCallback> mutable cbs;
-  void SendHttpRequest(HttpRequestDescription d,
-                       HttpCompleteCallback cb) const {
-    http_requests_sent.push_back(d);
-    cbs.push_back(cb);
-  }
 
-  void SendDnsTextRequest(std::string hostname,
-                          DnsTextResultsCallback,
-                          DnsTextCompleteCallback) {}
-  std::string MimeType(std::string extension,
-                       std::string_view content,
-                       std::string const& url) const {
-    return "";
-  }
-  std::string UnescapeUrlComponent(std::string_view url_comp) const {
-    return "";
-  }
-  IpnsCborEntry deserialize_cbor(ByteView) const { return {}; }
-  bool verify_key_signature(SigningKeyType,
-                            ByteView signature,
-                            ByteView data,
-                            ByteView key_bytes) const {
-    return true;
-  }
-
-  void Discover(std::function<void(std::vector<std::string>)> cb) {}
-  std::shared_ptr<ipfs::GatewayRequest> InitiateGatewayRequest(
-      ipfs::BusyGateway) {
-    return {};
-  }
-};
 struct FakeRtor : public ipfs::gw::Requestor {
   std::string_view name() const { return "fake requestor"; }
   std::vector<P> requests_forwarded;
@@ -55,7 +22,7 @@ struct FakeRtor : public ipfs::gw::Requestor {
   }
 };
 struct GatewayHttpRequestorTest : public ::testing::Test {
-  std::shared_ptr<FakeApi> api = std::make_shared<FakeApi>();
+  std::shared_ptr<MockApi> api = std::make_shared<MockApi>();
   std::shared_ptr<T> t = std::make_shared<T>("scheme://host", api);
   std::shared_ptr<FakeRtor> chain = std::make_shared<FakeRtor>();
   std::shared_ptr<ipfs::Orchestrator> orc;

library/src/ipfs_client/gw/requestor_pool_unittest.cc

@@ -0,0 +1,46 @@
+#include <ipfs_client/gw/requestor_pool.h>
+
+#include <ipfs_client/gw/gateway_request.h>
+
+#include <mock_api.h>
+#include <mock_requestor.h>
+
+namespace {
+struct RequestorPoolTest : public ::testing::Test {
+  std::vector<std::shared_ptr<MockRequestor>> members;
+  std::shared_ptr<MockApi> api = std::make_shared<MockApi>();
+  std::shared_ptr<ig::RequestorPool> tested =
+      std::make_shared<ig::RequestorPool>();
+  std::shared_ptr<ig::GatewayRequest> req =
+      ig::GatewayRequest::fromIpfsPath("/ipns/ipfs.io"sv);
+  void add() {
+    auto p = std::make_shared<MockRequestor>();
+    members.push_back(p);
+    tested->add(p);
+  }
+  void set_api() {
+    auto p = std::make_shared<MockRequestor>();
+    p->api(api);
+    p->or_else(tested);
+  }
+};
+}  // namespace
+
+TEST_F(RequestorPoolTest, add_with_api_sets_member_api) {
+  add();
+  EXPECT_EQ(members.size(), 1U);
+  set_api();
+  add();
+  EXPECT_EQ(members.size(), 2U);
+  EXPECT_TRUE(members.at(0));
+  EXPECT_TRUE(members.at(1));
+  EXPECT_FALSE(members.at(0)->api());
+  EXPECT_TRUE(members.at(1)->api());
+}
+TEST_F(RequestorPoolTest, pending_doesnt_stop_parallel_requests) {
+  add();
+  add();
+  members.at(0)->outcomes.push_back(MockRequestor::O::PENDING);
+  members.at(1)->outcomes.push_back(MockRequestor::O::PENDING);
+  tested->request(req);
+}

library/src/ipfs_client/ipld/dag_node.cc

@@ -66,4 +66,8 @@ auto Node::as_hamt() -> DirShard* {
 }
 void Node::set_api(std::shared_ptr<ContextApi> api) {
   api_ = api;
-}
+}
+
+std::ostream& operator<<(std::ostream& s, ipfs::ipld::PathChange const& c) {
+  return s << "PathChange{" << c.new_path << '}';
+}

library/src/ipfs_client/ipld/small_directory.cc

@@ -24,10 +24,12 @@ auto Self::resolve(SlashDelimited path, BlockLookup blu, std::string& to_here)
     -> ResolveResult {
   if (!path) {
     LOG(INFO) << "Directory listing requested.";
-    GeneratedDirectoryListing index_html{to_here};
+    SlashDelimited dir_path{to_here};
+    dir_path.pop_n(2);
+    GeneratedDirectoryListing index_html{dir_path.to_string()};
     for (auto& [name, link] : links_) {
-      LOG(INFO) << "Listing " << to_here << " encountered " << name << '='
-                << link.cid;
+      VLOG(1) << "Listing " << dir_path.to_string() << " encountered " << name
+              << '=' << link.cid;
       if (name == "index.html") {
         auto& n = node(link, blu);
         if (n) {
@@ -52,7 +54,7 @@ auto Self::resolve(SlashDelimited path, BlockLookup blu, std::string& to_here)
   auto match = [&name](auto& l) { return l.first == name; };
   auto it = std::find_if(links_.begin(), links_.end(), match);
   if (links_.end() == it) {
-    LOG(INFO) << name << " does not exist in directory.";
+    LOG(INFO) << name << " does not exist in directory " << to_here;
     return ProvenAbsent{};
   }
   auto& link = it->second;

library/src/ipfs_client/ipld/symlink.cc

@@ -1,29 +1,67 @@
 #include "symlink.h"
 
+#include <libp2p/multi/content_identifier_codec.hpp>
+
+#include "log_macros.h"
+
 using Self = ipfs::ipld::Symlink;
 
-Self::Symlink(std::string target) : target_{target} {}
+Self::Symlink(std::string target)
+    : style_{from_target(target)}, target_{target} {}
+
 Self::~Symlink() {}
 
-auto Self::resolve(SlashDelimited path, BlockLookup, std::string& buf)
+auto Self::resolve(SlashDelimited path, BlockLookup, std::string& to_here)
     -> ResolveResult {
-  if (target_.at(0) == '/') {
-    buf.assign(target_);
-  } else {
-    if (std::count(buf.begin(), buf.end(), '/') > 1 && buf.back() == '/') {
-      buf.resize(buf.size() - 1);
-    }
-    auto popped = buf.find_last_of('/');
-    if (popped < buf.size()) {
-      buf.resize(popped + 1);  // include the slash at the end
-    }
-    buf.append(target_);
+  std::string result;
+  switch (style_) {
+    case Style::Absolute:
+      result.assign(target_);
+      break;
+    case Style::Relative: {
+      auto c = to_here.find_last_not_of('/');
+      c = to_here.find_last_of('/', c);
+      DCHECK(c != to_here.size()) << to_here;
+      result.assign(to_here, 0, c + 1).append(target_);
+    } break;
+    case Style::FromRoot:
+      result.assign(SlashDelimited{to_here}.pop_n(2))
+          .append("/")
+          .append(target_);
   }
   if (path) {
-    if (buf.back() != '/') {
-      buf.push_back('/');
-    }
-    buf.append(path.pop_all());
+    result.append("/").append(path.pop_all());
+  }
+  std::size_t i;
+  while ((i = result.find("//")) != std::string::npos) {
+    result.erase(i, 1);
+  }
+  DCHECK_GT(result.size(), 0U);
+  if (result.back() == '/') {
+    result.resize(result.size() - 1);
+  }
+  return PathChange{result};
+}
+
+auto Self::from_target(std::string const& target) -> Style {
+  DCHECK_GT(target.size(), 0U);
+  if (target.at(0) != '/') {
+    return Style::Relative;
+  }
+  SlashDelimited t{target};
+  auto ns = t.pop();
+  if (ns != "ipfs" && ns != "ipns") {
+    return Style::FromRoot;
+  }
+  auto root = t.pop();
+  using namespace libp2p::multi;
+  auto cid = ContentIdentifierCodec::fromString(root);
+  if (!cid.has_value()) {
+    return Style::FromRoot;
+  }
+  if (cid.value().content_type == MulticodecType::Code::LIBP2P_KEY) {
+    return ns == "ipns" ? Style::Absolute : Style::FromRoot;
+  } else {
+    return ns == "ipfs" ? Style::Absolute : Style::FromRoot;
   }
-  return buf;
 }

library/src/ipfs_client/ipld/symlink.h

@@ -5,8 +5,15 @@
 
 namespace ipfs::ipld {
 class Symlink : public DagNode {
+  enum class Style {
+    Relative,
+    Absolute,
+    FromRoot,
+  };
+  Style const style_;
   std::string const target_;
 
+  Style from_target(std::string const&);
   ResolveResult resolve(SlashDelimited path,
                         BlockLookup,
                         std::string& up_to_here) override;