pr fixes

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

Author: Elestrias

core/api/rpc/wsc.cpp

@@ -37,14 +37,14 @@ namespace fc::api::rpc {
     return connect(ip, port, target, token);
   }
 
-    outcome::result<void> Client::connect(const std::string &host,
-                                          const std::string &port,
-                                          const std::string &target,
-                                          const std::string &token) {
+  outcome::result<void> Client::connect(const std::string &host,
+                                        const std::string &port,
+                                        const std::string &target,
+                                        const std::string &token) {
     boost::system::error_code ec;
     socket->next_layer().connect({boost::asio::ip::make_address(host),
-                                 boost::lexical_cast<uint16_t>(port)},
-                                ec);
+                                  boost::lexical_cast<uint16_t>(port)},
+                                 ec);
     if (ec) {
       return ec;
     }
@@ -92,19 +92,19 @@ namespace fc::api::rpc {
   }
 
   void Client::_flush() {
-    if (!writing && !write_queue.empty() && not reconnecting){
+    if (!writing && !write_queue.empty() && not reconnecting) {
       auto &[id, buffer] = write_queue.front();
       writing = true;
       socket->async_write(boost::asio::buffer(buffer.data(), buffer.size()),
-                         [=](auto &&ec, auto) {
-                           std::lock_guard lock{mutex};
-                           if (ec) {
-                             return _error(ec);
-                           }
-                           writing = false;
-                           write_queue.pop();
-                           _flush();
-                         });
+                          [=](auto &&ec, auto) {
+                            std::lock_guard lock{mutex};
+                            if (ec) {
+                              return _error(ec);
+                            }
+                            writing = false;
+                            write_queue.pop();
+                            _flush();
+                          });
     }
   }
 
@@ -189,23 +189,34 @@ namespace fc::api::rpc {
   }
 
   void Client::reconnect(int counter, std::chrono::milliseconds wait) {
-    if(reconnecting) return;
+    if (reconnecting) return;
     reconnecting = true;
-    logger_->info("Starting reconnect to {}:{}", client_data.host, client_data.port);
-    for(int i = 0; i < counter; i++){
+    bool rec_status{false};
+    logger_->info(
+        "Starting reconnect to {}:{}", client_data.host, client_data.port);
+    for (int i = 0; i < counter; i++) {
       std::this_thread::sleep_for(wait);
       socket.reset();
       socket.emplace(io);
       auto res = connect(client_data.host,
                          client_data.port,
                          client_data.target,
                          client_data.token);
-      if(!res.has_error()) {
+      if (not res.has_error()) {
+        rec_status = true;
         break;
       }
     }
     reconnecting = false;
-    logger_->info("Reconnect to {}:{} was successful", client_data.host, client_data.port);
-    _flush();
+    if (rec_status) {
+      logger_->info("Reconnect to {}:{} was successful",
+                    client_data.host,
+                    client_data.port);
+      _flush();
+    } else {
+      logger_->error("Reconnect to {}:{} have been failed",
+                     client_data.host,
+                     client_data.port);
+    }
   }
 }  // namespace fc::api::rpc

core/sector_storage/impl/local_worker.cpp

@@ -904,7 +904,7 @@ namespace fc::sector_storage {
 
     return call_id;
   }
-  void LocalWorker::ping(std::function<void(const bool &resp)> cb) {
+  void LocalWorker::ping(std::function<void(bool resp)> cb) {
     cb(true);
   }
 }  // namespace fc::sector_storage

core/sector_storage/impl/local_worker.hpp

@@ -99,7 +99,7 @@ namespace fc::sector_storage {
     outcome::result<std::vector<primitives::StoragePath>> getAccessiblePaths()
         override;
 
-    void ping(std::function<void(const bool &resp)> cb) override;
+    void ping(std::function<void(bool resp)> cb) override;
 
    private:
     template <typename W, typename R>

core/sector_storage/impl/remote_worker.cpp

@@ -255,9 +255,7 @@ namespace fc::sector_storage {
     return api_.Fetch(sector, file_type, path_type, mode);
   }
 
-  void RemoteWorker::ping(std::function<void(const bool &resp)> cb) {
-    api_.Version([=](auto res){
-      cb(!res.has_error());
-    });
+  void RemoteWorker::ping(std::function<void(bool resp)> cb) {
+    api_.Version([=](auto res) { cb(!res.has_error()); });
   }
 }  // namespace fc::sector_storage

core/sector_storage/impl/remote_worker.hpp

@@ -39,7 +39,7 @@ namespace fc::sector_storage {
         const SectorRef &sector,
         const PreCommit1Output &pre_commit_1_output) override;
 
-    void ping(std::function<void(const bool &resp)> cb) override;
+    void ping(std::function<void(bool resp)> cb) override;
 
     outcome::result<CallId> sealCommit1(const SectorRef &sector,
                                         const SealRandomness &ticket,

core/sector_storage/impl/scheduler_impl.cpp

@@ -200,14 +200,14 @@ namespace fc::sector_storage {
       std::future<WorkerID> wid_future = wid_promise.get_future();
       auto done = std::make_shared<std::atomic_bool>();
       for (const auto &cur : acceptable) {
-        workers_[cur]->worker->ping([&wid_promise, done, cur](const bool &resp) {
+        workers_[cur]->worker->ping([&wid_promise, done, cur](bool resp) {
           if (resp && !done->exchange(true)) {
             wid_promise.set_value(cur);
           }
         });
       }
       auto status = wid_future.wait_for(std::chrono::seconds(5));
-      if(status == std::future_status::timeout){
+      if (status == std::future_status::timeout) {
         return false;
       }
       WorkerID wid = wid_future.get();

core/sector_storage/worker.hpp

@@ -143,7 +143,7 @@ namespace fc::sector_storage {
     virtual outcome::result<std::vector<primitives::StoragePath>>
     getAccessiblePaths() = 0;
 
-    virtual void ping(std::function<void(const bool &resp)> cb) = 0;
+    virtual void ping(std::function<void(bool resp)> cb) = 0;
   };
 
   enum class CallErrorCode : uint64_t {