API fixes for Lotus remote worker (#578)

* Futon Miner Api sync with lotus-worker
Signed-off-by: elestrias <rus8-2002@mail.ru>

Author: Elestrias

core/api/common_api.hpp

@@ -36,12 +36,15 @@ namespace fc::api {
                const std::string &)
 
     API_METHOD(Version, jwt::kReadPermission, VersionResult)
+
+    API_METHOD(Session, jwt::kReadPermission, std::string)
   };
 
   template <typename A, typename F>
   void visitCommon(A &&a, const F &f) {
     f(a.AuthNew);
     f(a.AuthVerify);
+    f(a.Session);
     f(a.Version);
   }
 }  // namespace fc::api

core/api/full_node/make.cpp

@@ -1030,7 +1030,7 @@ namespace fc::api {
       }
       return result;
     };
-    // TODO(artyom-yurin): FIL-165 implement method
+
     api->StateSectorPartition =
         [=](const Address &address,
             SectorNumber sector,

core/api/rpc/json.hpp

@@ -78,6 +78,7 @@ namespace fc::api {
   using sector_storage::stores::AcquireMode;
   using sector_storage::stores::LocalPath;
   using sector_storage::stores::PathType;
+  using sector_storage::stores::SectorStorageInfo;
   using sector_storage::stores::StorageConfig;
   using sector_storage::stores::StorageInfo;
   using vm::actor::builtin::types::market::DealProposal;
@@ -91,6 +92,8 @@ namespace fc::api {
       ModularVerificationParameter;
   using vm::runtime::ExecutionResult;
   using base64 = cppcodec::base64_rfc4648;
+  using common::fromString;
+  using common::toString;
 
   struct Codec {
     rapidjson::MemoryPoolAllocator<> &allocator;
@@ -258,19 +261,23 @@ namespace fc::api {
     }
 
     ENCODE(PathType) {
-      return encode(common::to_int(v));
+      return encode(toString(v).value());
     }
 
     DECODE(PathType) {
-      decodeEnum(v, j);
+      std::string temp;
+      decode(temp, j);
+      v = fromString<PathType>(temp).value();
     }
 
     ENCODE(AcquireMode) {
-      return encode(common::to_int(v));
+      return encode(toString(v));
     }
 
     DECODE(AcquireMode) {
-      decodeEnum(v, j);
+      std::string temp;
+      decode(temp, j);
+      v = fromString<AcquireMode>(temp).value();
     }
 
     ENCODE(NetworkVersion) {
@@ -869,7 +876,7 @@ namespace fc::api {
       Get(j, "Locked", v.locked);
     }
 
-    ENCODE(StorageInfo) {
+    ENCODE(SectorStorageInfo) {
       Value j{rapidjson::kObjectType};
       Set(j, "ID", v.id);
       Set(j, "URLs", v.urls);
@@ -880,7 +887,7 @@ namespace fc::api {
       return j;
     }
 
-    DECODE(StorageInfo) {
+    DECODE(SectorStorageInfo) {
       Get(j, "ID", v.id);
       Get(j, "URLs", v.urls);
       Get(j, "Weight", v.weight);
@@ -889,6 +896,24 @@ namespace fc::api {
       Get(j, "Primary", v.is_primary);
     }
 
+    ENCODE(StorageInfo) {
+      Value j{rapidjson::kObjectType};
+      Set(j, "ID", v.id);
+      Set(j, "URLs", v.urls);
+      Set(j, "Weight", v.weight);
+      Set(j, "CanSeal", v.can_seal);
+      Set(j, "CanStore", v.can_store);
+      return j;
+    }
+
+    DECODE(StorageInfo) {
+      Get(j, "ID", v.id);
+      Get(j, "URLs", v.urls);
+      Get(j, "Weight", v.weight);
+      Get(j, "CanSeal", v.can_seal);
+      Get(j, "CanStore", v.can_store);
+    }
+
     ENCODE(StorageParticipantBalance) {
       Value j{rapidjson::kObjectType};
       Set(j, "Locked", v.locked);
@@ -1348,13 +1373,11 @@ namespace fc::api {
     ENCODE(HealthReport) {
       Value j{rapidjson::kObjectType};
       Set(j, "Stat", v.stat);
-      Set(j, "Error", v.error);
       return j;
     }
 
     DECODE(HealthReport) {
       decode(v.stat, Get(j, "Stat"));
-      decode(v.error, Get(j, "Error"));
     }
 
     ENCODE(libp2p::multi::Multiaddress) {
@@ -2058,13 +2081,15 @@ namespace fc::api {
       Value j{rapidjson::kObjectType};
       Set(j, "Capacity", v.capacity);
       Set(j, "Available", v.available);
+      Set(j, "FSAvailable", v.fs_available);
       Set(j, "Reserved", v.reserved);
       return j;
     }
 
     DECODE(FsStat) {
       decode(v.capacity, Get(j, "Capacity"));
       decode(v.available, Get(j, "Available"));
+      decode(v.fs_available, Get(j, "FSAvailable"));
       decode(v.reserved, Get(j, "Reserved"));
     }
 
@@ -2084,7 +2109,7 @@ namespace fc::api {
       Value j{rapidjson::kObjectType};
       Set(j, "MemPhysical", v.physical_memory);
       Set(j, "MemSwap", v.swap_memory);
-      Set(j, "MemReserved", v.reserved_memory);
+      Set(j, "MemUsed", v.reserved_memory);
       Set(j, "CPUs", v.cpus);
       Set(j, "GPUs", v.gpus);
       return j;
@@ -2093,7 +2118,7 @@ namespace fc::api {
     DECODE(WorkerResources) {
       Get(j, "MemPhysical", v.physical_memory);
       Get(j, "MemSwap", v.swap_memory);
-      Get(j, "MemReserved", v.reserved_memory);
+      Get(j, "MemUsed", v.reserved_memory);
       Get(j, "CPUs", v.cpus);
       Get(j, "GPUs", v.gpus);
     }
@@ -2189,6 +2214,21 @@ namespace fc::api {
       }
       return j;
     }
+    ENCODE(std::set<TaskType>) {
+      Value j{rapidjson::kObjectType};
+      j.MemberReserve(v.size(), allocator);
+      for (auto &pair : v) {
+        std::map<std::string, std::string> value;
+        Set(j, pair, value);
+      }
+      return j;
+    }
+
+    DECODE(std::set<TaskType>) {
+      for (auto it = j.MemberBegin(); it != j.MemberEnd(); ++it) {
+        v.emplace(TaskType(AsString(it->name)));
+      }
+    }
 
     template <typename T>
     DECODE(std::set<T>) {

core/api/setup_common.hpp

@@ -5,6 +5,9 @@
 
 #pragma once
 
+#include <boost/uuid/random_generator.hpp>
+#include <boost/uuid/uuid_io.hpp>
+
 #include "api/common_api.hpp"
 #include "api/utils.hpp"
 #include "api/version.hpp"
@@ -16,6 +19,7 @@ namespace fc::api {
   using ::fc::ApiAlgorithm;
   using primitives::jwt::kPermissionKey;
   using primitives::jwt::kTokenType;
+  namespace uuids = boost::uuids;
 
   void fillAuthApi(const std::shared_ptr<CommonApi> &api,
                    const std::shared_ptr<ApiAlgorithm> &secret_algorithm,
@@ -60,5 +64,10 @@ namespace fc::api {
 
       return std::move(perms);
     };
+
+    api->Session = []() {
+      const static std::string uuid = uuids::to_string(uuids::random_generator()());
+      return uuid;
+    };
   }
 }  // namespace fc::api

core/api/storage_miner/storage_api.cpp

@@ -6,10 +6,13 @@
 #include "api/storage_miner/storage_api.hpp"
 
 #include "api/storage_miner/return_api.hpp"
+#include "common/outcome.hpp"
+#include "common/uri_parser/uri_parser.hpp"
 #include "miner/miner_version.hpp"
 #include "sector_storage/impl/remote_worker.hpp"
 
 namespace fc::api {
+  using common::HttpUri;
   using miner::kMinerVersion;
   using sector_storage::RemoteWorker;
 
@@ -166,32 +169,35 @@ namespace fc::api {
       return sector_index->storageDropSector(storage_id, sector, file_type);
     };
 
-    api->StorageFindSector =
-        [=](const SectorId &sector,
-            const SectorFileType &file_type,
-            boost::optional<SectorSize> fetch_sector_size) {
-          return sector_index->storageFindSector(
-              sector, file_type, fetch_sector_size);
-        };
+    api->StorageFindSector = [=](const SectorId &sector,
+                                 const SectorFileType &file_type,
+                                 const SectorSize &fetch_sector_size,
+                                 bool allow_fetch) {
+      boost::optional<SectorSize> sector_size;
+      if (allow_fetch) {
+        sector_size = fetch_sector_size;
+      }
+      return sector_index->storageFindSector(sector, file_type, sector_size);
+    };
 
     api->StorageBestAlloc = [=](const SectorFileType &allocate,
                                 SectorSize sector_size,
-                                bool sealing_mode) {
+                                const std::string &sealing_mode) {
       return sector_index->storageBestAlloc(
-          allocate, sector_size, sealing_mode);
+          allocate, sector_size, (sealing_mode == "sealing"));
     };
 
     makeReturnApi(api, sector_scheduler);
 
-    api->WorkerConnect =
-        [=, self{api}](const std::string &address) -> outcome::result<void> {
-      OUTCOME_TRY(maddress, libp2p::multi::Multiaddress::create(address));
-      OUTCOME_TRY(worker,
-                  RemoteWorker::connectRemoteWorker(*io, self, maddress));
-
-      spdlog::info("Connected to a remote worker at {}", address);
+    api->WorkerConnect = [=, self{api}](auto &&cb,
+                                        const std::string &address) -> void {
+      io->post([=] {
+        OUTCOME_CB(auto worker,
+                   RemoteWorker::connectRemoteWorker(*io, api, address));
+        spdlog::info("Connected to a remote worker at {}", address);
 
-      return sector_manager->addWorker(std::move(worker));
+        OUTCOME_CB1(sector_manager->addWorker(std::move(worker)));
+      });
     };
 
     api->Version = [] {

core/api/storage_miner/storage_api.hpp

@@ -59,6 +59,7 @@ namespace fc::api {
   using sector_storage::stores::HealthReport;
   using sector_storage::stores::SectorIndex;
   using StorageInfo_ = sector_storage::stores::StorageInfo;
+  using sector_storage::stores::SectorStorageInfo;
 
   const static common::Logger kStorageApiLogger =
       common::createLogger("Storage API");
@@ -92,7 +93,7 @@ namespace fc::api {
     ChainEpoch early = {};
   };
 
-  constexpr ApiVersion kMinerApiVersion = makeApiVersion(1, 0, 0);
+  constexpr ApiVersion kMinerApiVersion = makeApiVersion(1, 3, 0);
 
   /**
    * Storage miner node low-level interface API.
@@ -172,16 +173,17 @@ namespace fc::api {
                const SectorFileType &)
     API_METHOD(StorageFindSector,
                jwt::kAdminPermission,
-               std::vector<StorageInfo_>,
+               std::vector<SectorStorageInfo>,
                const SectorId &,
                const SectorFileType &,
-               boost::optional<SectorSize>)
+               const SectorSize &,
+               bool)
     API_METHOD(StorageBestAlloc,
                jwt::kAdminPermission,
                std::vector<StorageInfo_>,
                const SectorFileType &,
                SectorSize,
-               bool)
+               const std::string &)
 
     API_METHOD(ReturnAddPiece,
                jwt::kAdminPermission,