Feature/network api (#492)

* network_api structure

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

* Net api separation

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

* net api disconnect

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

* netApi disconnect fixes

* logger upper level translation

* lambd capture fixes

* pr fixes

* includes fixes

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

* fix blocksync

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

Author: Elestrias

core/api/common_api.hpp

@@ -35,31 +35,13 @@ namespace fc::api {
                std::vector<Permission>,
                const std::string &)
 
-    /**
-     * Returns listen addresses.
-     */
-    API_METHOD(NetAddrsListen, jwt::kReadPermission, PeerInfo)
-
-    /**
-     * Initiates the connection to the peer.
-     */
-    API_METHOD(NetConnect, jwt::kWritePermission, void, const PeerInfo &)
-
-    /**
-     * Returns all peers connected to the this host.
-     */
-    API_METHOD(NetPeers, jwt::kReadPermission, std::vector<PeerInfo>)
-
     API_METHOD(Version, jwt::kReadPermission, VersionResult)
   };
 
   template <typename A, typename F>
   void visitCommon(A &&a, const F &f) {
     f(a.AuthNew);
     f(a.AuthVerify);
-    f(a.NetAddrsListen);
-    f(a.NetConnect);
-    f(a.NetPeers);
     f(a.Version);
   }
 }  // namespace fc::api

core/api/full_node/make.cpp

@@ -92,8 +92,6 @@ namespace fc::api {
   using vm::toolchain::Toolchain;
   using vm::version::getNetworkVersion;
 
-  const static Logger logger = common::createLogger("Full node API");
-
   // TODO (turuslan): reuse for block validation
   inline bool minerHasMinPower(const StoragePower &claim_qa,
                                size_t min_power_miners) {
@@ -440,7 +438,7 @@ namespace fc::api {
             std::vector<QueryOffer> result;
             for (const auto &[peer, maybe_response] : all_calls) {
               if (maybe_response.has_error()) {
-                logger->error("Error when query peer {}",
+                kNodeApiLogger->error("Error when query peer {}",
                               maybe_response.error().message());
               } else {
                 result.emplace_back(maybe_response.value());
@@ -490,11 +488,11 @@ namespace fc::api {
           order.miner,
           [=](outcome::result<void> res) {
             if (res.has_error()) {
-              logger->error("Error in ClientRetrieve {}",
+              kNodeApiLogger->error("Error in ClientRetrieve {}",
                             res.error().message());
               return cb(res.error());
             }
-            logger->info("retrieval deal done");
+            kNodeApiLogger->info("retrieval deal done");
             if (file_ref.is_car) {
               OUTCOME_CB1(storage::car::makeSelectiveCar(
                   *markets_ipld, {{order.root, {}}}, file_ref.path));

core/api/full_node/make.hpp

@@ -7,6 +7,7 @@
 
 #include "api/full_node/node_api.hpp"
 #include "blockchain/weight_calculator.hpp"
+#include "common/logger.hpp"
 #include "fwd.hpp"
 #include "markets/discovery/discovery.hpp"
 #include "markets/retrieval/client/retrieval_client.hpp"
@@ -32,6 +33,8 @@ namespace fc::api {
   using sync::PubSubGate;
   using vm::runtime::EnvironmentContext;
 
+  const static common::Logger kNodeApiLogger = common::createLogger("Full Node API");
+
   outcome::result<IpldObject> getNode(const std::shared_ptr<Ipld> &ipld,
                                       const CID &root,
                                       gsl::span<const std::string> parts);

core/api/full_node/node_api.hpp

@@ -6,6 +6,7 @@
 #pragma once
 
 #include "api/common_api.hpp"
+#include "api/network/network_api.hpp"
 #include "common/libp2p/peer/cbor_peer_id.hpp"
 #include "const.hpp"
 #include "data_transfer/types.hpp"
@@ -294,7 +295,7 @@ namespace fc::api {
    * FullNode API is a low-level interface to the Filecoin network full node.
    * Provides the latest node API v2.0.0
    */
-  struct FullNodeApi : public CommonApi {
+  struct FullNodeApi : public CommonApi, public NetworkApi {
     /**
      * @note long operation
      */
@@ -805,6 +806,7 @@ namespace fc::api {
   template <typename A, typename F>
   void visit(const FullNodeApi &, A &&a, const F &f) {
     visitCommon(a, f);
+    visitNet(a, f);
     f(a.BeaconGetEntry);
     f(a.ChainGetBlock);
     f(a.ChainGetBlockMessages);

core/api/network/network_api.hpp

@@ -0,0 +1,42 @@
+/**
+ * Copyright Soramitsu Co., Ltd. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#pragma once
+
+#include "api/common_api.hpp"
+
+namespace fc::api {
+  class NetworkApi{
+   public:
+    /**
+     * Returns listen addresses.
+     */
+    API_METHOD(NetAddrsListen, jwt::kReadPermission, PeerInfo)
+
+    /**
+     * Initiates the connection to the peer.
+     */
+    API_METHOD(NetConnect, jwt::kWritePermission, void, const PeerInfo &)
+
+    /**
+     * Returns all peers connected to the this host.
+     */
+    API_METHOD(NetPeers, jwt::kReadPermission, std::vector<PeerInfo>)
+
+    /**
+     * Removes provided peer from list of connected.
+     */
+    API_METHOD(NetDisconnect, jwt::kWritePermission, void, const PeerInfo &)
+  };
+
+  template <typename A, typename F>
+  void visitNet(A &&a, const F &f) {
+    f(a.NetAddrsListen);
+    f(a.NetConnect);
+    f(a.NetPeers);
+    f(a.NetDisconnect);
+  }
+
+};  // namespace fc::api

core/api/network/setup_net.hpp

@@ -0,0 +1,49 @@
+/**
+ * Copyright Soramitsu Co., Ltd. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#pragma once
+
+#include <libp2p/host/host.hpp>
+#include "api/network/network_api.hpp"
+
+namespace fc::api {
+  using libp2p::Host;
+
+  inline void fillNetApi(const std::shared_ptr<NetworkApi> &api,
+                         const PeerInfo &api_peer_info,
+                         const std::shared_ptr<Host> &host,
+                         const common::Logger &logger) {
+    api->NetAddrsListen = [api_peer_info]() -> outcome::result<PeerInfo> {
+      return api_peer_info;
+    };
+
+    api->NetConnect = [=](auto &peer) {
+      host->connect(peer);
+      return outcome::success();
+    };
+
+    api->NetPeers = [=]() -> outcome::result<std::vector<PeerInfo>> {
+      const auto &peer_repository = host->getPeerRepository();
+      const auto connections =
+          host->getNetwork().getConnectionManager().getConnections();
+      std::vector<PeerInfo> result;
+      for (const auto &conncection : connections) {
+        const auto remote = conncection->remotePeer();
+        if (remote.has_error()) {
+          logger->error("get remote peer error", remote.error().message());
+          continue;
+        }
+        result.push_back(peer_repository.getPeerInfo(remote.value()));
+      }
+      return result;
+    };
+
+    api->NetDisconnect = [=](const auto &peer) {
+      host->disconnect(peer.id);
+      return outcome::success();
+    };
+  }
+
+}  // namespace fc::api

core/api/storage_miner/storage_api.hpp

@@ -7,7 +7,9 @@
 
 #include "api/common_api.hpp"
 #include "api/full_node/node_api.hpp"
+#include "api/network/network_api.hpp"
 #include "api/version.hpp"
+#include "common/logger.hpp"
 #include "markets/retrieval/provider/retrieval_provider.hpp"
 #include "markets/retrieval/types.hpp"
 #include "markets/storage/ask_protocol.hpp"
@@ -53,6 +55,8 @@ namespace fc::api {
   using sector_storage::stores::SectorIndex;
   using StorageInfo_ = sector_storage::stores::StorageInfo;
 
+  const static common::Logger kStorageApiLogger = common::createLogger("Storage API");
+
   struct PieceLocation {
     SectorNumber sector_number;
     PaddedPieceSize offset;
@@ -75,7 +79,7 @@ namespace fc::api {
   /**
    * Storage miner node low-level interface API.
    */
-  struct StorageMinerApi : public CommonApi {
+  struct StorageMinerApi : public CommonApi, public NetworkApi {
     API_METHOD(ActorAddress, jwt::kReadPermission, Address)
 
     API_METHOD(ActorSectorSize,
@@ -236,6 +240,7 @@ namespace fc::api {
   template <typename A, typename F>
   void visit(const StorageMinerApi &, A &&a, const F &f) {
     visitCommon(a, f);
+    visitNet(a, f);
     f(a.ActorAddress);
     f(a.ActorSectorSize);
     f(a.PledgeSector);

core/miner/main/main.cpp

@@ -497,7 +497,8 @@ namespace fc {
                                     storage_provider,
                                     retrieval_provider);
 
-    api::fillAuthApi(mapi, api_secret, log());
+    api::fillAuthApi(mapi, api_secret, api::kStorageApiLogger);
+    //TODO(@elestrias): [FIL-427] make net api configuration
 
     std::map<std::string, std::shared_ptr<api::Rpc>> mrpc;
     mrpc.emplace(

core/node/main/builder.cpp

@@ -22,6 +22,7 @@
 #include <libp2p/protocol/kademlia/impl/validator_default.hpp>
 
 #include "api/full_node/make.hpp"
+#include "api/network/setup_net.hpp"
 #include "api/impl/paych_get.hpp"
 #include "api/setup_common.hpp"
 #include "blockchain/block_validator/impl/block_validator_impl.hpp"
@@ -33,6 +34,7 @@
 #include "codec/json/json.hpp"
 #include "common/api_secret.hpp"
 #include "common/error_text.hpp"
+#include "common/libp2p/peer/peer_info_helper.hpp"
 #include "common/peer_key.hpp"
 #include "crypto/bls/impl/bls_provider_impl.hpp"
 #include "crypto/secp256k1/impl/secp256k1_provider_impl.hpp"
@@ -75,6 +77,7 @@
 #include "vm/state/impl/state_tree_impl.hpp"
 
 namespace fc::node {
+  using api::PeerInfo;
   using markets::discovery::DiscoveryImpl;
   using markets::pieceio::PieceIOImpl;
   using markets::retrieval::client::RetrievalClientImpl;
@@ -638,7 +641,13 @@ namespace fc::node {
             o.api,
             std::make_shared<storage::MapPrefix>("paych_maker/", o.kv_store)));
 
-    api::fillAuthApi(o.api, api_secret, log());
+    api::fillAuthApi(o.api, api_secret, api::kNodeApiLogger);
+
+    const PeerInfo api_peer_info{
+        o.host->getPeerInfo().id,
+        nonZeroAddrs(o.host->getAddresses(), &config.localIp())};
+
+    api::fillNetApi(o.api, api_peer_info, o.host, api::kNodeApiLogger);
 
     auto paych{
         std::make_shared<payment_channel_manager::PaymentChannelManagerImpl>(

core/node/main/main.cpp

@@ -85,34 +85,6 @@ namespace fc {
   void startApi(const node::Config &config,
                 NodeObjects &node_objects,
                 const Metrics &metrics) {
-    // Network API
-    PeerInfo api_peer_info{
-        node_objects.host->getPeerInfo().id,
-        nonZeroAddrs(node_objects.host->getAddresses(), &config.localIp())};
-    node_objects.api->NetAddrsListen =
-        [api_peer_info]() -> outcome::result<PeerInfo> {
-      return api_peer_info;
-    };
-    node_objects.api->NetConnect = [&](auto &peer) {
-      node_objects.host->connect(peer);
-      return outcome::success();
-    };
-    node_objects.api->NetPeers =
-        [&]() -> outcome::result<std::vector<PeerInfo>> {
-      const auto &peer_repository = node_objects.host->getPeerRepository();
-      auto connections = node_objects.host->getNetwork()
-                             .getConnectionManager()
-                             .getConnections();
-      std::vector<PeerInfo> result;
-      for (const auto &conncection : connections) {
-        const auto remote = conncection->remotePeer();
-        if (remote.has_error())
-          log()->error("get remote peer error", remote.error().message());
-        result.push_back(peer_repository.getPeerInfo(remote.value()));
-      }
-      return result;
-    };
-
     // Market Client API
     node_objects.api->ClientImport =
         [&](auto &file_ref) -> outcome::result<ImportRes> {
@@ -123,7 +95,7 @@ namespace fc {
       return ImportRes{root, 0};
     };
 
-    node_objects.api->ClientListDeals = [api_peer_info, &node_objects]()
+    node_objects.api->ClientListDeals = [&node_objects]()
         -> outcome::result<std::vector<StorageMarketDealInfo>> {
       std::vector<StorageMarketDealInfo> result;
       OUTCOME_TRY(local_deals,
@@ -145,7 +117,7 @@ namespace fc {
             {},
             deal.client_deal_proposal.proposal.verified,
             // TODO (a.chernyshov) actual ChannelId
-            {api_peer_info.id, deal.miner.id, 0},
+            {node_objects.host->getId(), deal.miner.id, 0},
             // TODO (a.chernyshov) actual data transfer
             {0, 0, deal.proposal_cid, true, true, "", "", deal.miner.id, 0}});
       }