GetWork Refactor

Now totally async without the need of an own thread.
Also differentiates among socket errors and json errors (eg. "Still sincing").
Implements workTimeout (which was only for Stratum)
Totally built on boost without the need of json-rpc-cpp

Author: AndreaLanfranchi

ethminer/main.cpp

@@ -1181,7 +1181,7 @@ class MinerCLI
             client = new SimulateClient(20, m_benchmarkBlock);
             break;
         case MinerCLI::OperationMode::Farm:
-            client = new EthGetworkClient(m_farmPollInterval);
+            client = new EthGetworkClient(m_poolWorkTimeout, m_farmPollInterval);
             break;
         case MinerCLI::OperationMode::Stratum:
             client = new EthStratumClient(m_poolWorkTimeout, m_poolRespTimeout);

libpoolprotocols/CMakeLists.txt

@@ -4,12 +4,12 @@ set(SOURCES
 	PoolManager.h PoolManager.cpp
 	testing/SimulateClient.h testing/SimulateClient.cpp
 	stratum/EthStratumClient.h stratum/EthStratumClient.cpp
-	getwork/EthGetworkClient.h getwork/EthGetworkClient.cpp getwork/jsonrpc_getwork.h
+	getwork/EthGetworkClient.h getwork/EthGetworkClient.cpp
 )
 
 hunter_add_package(OpenSSL)
 find_package(OpenSSL REQUIRED)
 
 add_library(poolprotocols ${SOURCES})
-target_link_libraries(poolprotocols PRIVATE devcore ethminer-buildinfo ethash::ethash libjson-rpc-cpp::client Boost::system jsoncpp_lib_static OpenSSL::SSL OpenSSL::Crypto)
+target_link_libraries(poolprotocols PRIVATE devcore ethminer-buildinfo ethash::ethash Boost::system jsoncpp_lib_static OpenSSL::SSL OpenSSL::Crypto)
 target_include_directories(poolprotocols PRIVATE ..)

libpoolprotocols/PoolManager.cpp

@@ -33,7 +33,13 @@ PoolManager::PoolManager(PoolClient* client, MinerType const& minerType, unsigne
     p_client->onConnected([&]() {
         {
             Guard l(m_activeConnectionMutex);
-            m_selectedHost.append(p_client->ActiveEndPoint());
+
+            // If HostName is already an IP address no need to append the
+            // effective ip address.
+            if (p_client->getConnection()->HostNameType() == dev::UriHostNameType::Dns ||
+                p_client->getConnection()->HostNameType() == dev::UriHostNameType::Basic)
+                m_selectedHost.append(p_client->ActiveEndPoint());
+
             cnote << "Established connection to " << m_selectedHost;
 
             // Reset current WorkPackage

libpoolprotocols/getwork/EthGetworkClient.cpp

@@ -1,22 +1,24 @@
 #pragma once
 
 #include <iostream>
+#include <string>
 
-#include "jsonrpc_getwork.h"
-#include <jsonrpccpp/client/connectors/httpclient.h>
+#include <boost/algorithm/string/predicate.hpp>
+#include <boost/lexical_cast.hpp>
+#include <boost/lockfree/queue.hpp>
 
-#include <libdevcore/Worker.h>
+#include <json/json.h>
 
 #include "../PoolClient.h"
 
 using namespace std;
 using namespace dev;
 using namespace eth;
 
-class EthGetworkClient : public PoolClient, Worker
+class EthGetworkClient : public PoolClient
 {
 public:
-    EthGetworkClient(unsigned farmRecheckPeriod);
+    EthGetworkClient(int worktimeout, unsigned farmRecheckPeriod);
     ~EthGetworkClient();
 
     void connect() override;
@@ -25,18 +27,52 @@ class EthGetworkClient : public PoolClient, Worker
     bool isConnected() override { return m_connected; }
     bool isPendingState() override { return false; }
 
-    string ActiveEndPoint() override { return ""; };
+    string ActiveEndPoint() override { return " [" + toString(m_endpoint) + "]"; };
 
     void submitHashrate(string const& rate, string const& id) override;
     void submitSolution(const Solution& solution) override;
 
 private:
-    void workLoop() override;
-    unsigned m_farmRecheckPeriod = 500;
 
-    string m_HashrateHex;  // Hashrate value already as hex string
-    string m_HashrateId;   // Hashrate unique identifier
+    unsigned m_farmRecheckPeriod = 500; // In milliseconds
 
-    JsonrpcGetwork* p_client = nullptr;
-    WorkPackage m_prevWorkPackage;
+    void begin_connect();
+    void handle_resolve(
+        const boost::system::error_code& ec, boost::asio::ip::tcp::resolver::iterator i);
+    void handle_connect(const boost::system::error_code& ec);
+    void handle_write(const boost::system::error_code& ec);
+    void handle_read(const boost::system::error_code& ec, std::size_t bytes_transferred);
+    std::string processError(Json::Value& JRes);
+    void processResponse(Json::Value& JRes);
+    void send(Json::Value const& jReq);
+    void send(std::string const& sReq);
+    void getwork_timer_elapsed(const boost::system::error_code& ec);
+
+    WorkPackage m_current;
+
+    std::atomic<bool> m_connecting = {false}; // Whether or not socket is on first try connect
+    std::atomic<bool> m_txPending = {false}; // Whether or not an async socket operation is pending
+    boost::lockfree::queue<std::string*> m_txQueue;
+
+    boost::asio::io_service& m_io_service;  // The IO service reference passed in the constructor
+    boost::asio::io_service::strand m_io_strand;
+
+    boost::asio::ip::tcp::socket m_socket;
+    boost::asio::ip::tcp::resolver m_resolver;
+    std::queue<boost::asio::ip::basic_endpoint<boost::asio::ip::tcp>> m_endpoints;
+
+    boost::asio::streambuf m_request;
+    boost::asio::streambuf m_response;
+    Json::StreamWriterBuilder m_jSwBuilder;
+    std::string m_jsonGetWork;
+    Json::Value m_pendingJReq;
+    std::chrono::time_point<std::chrono::steady_clock> m_pending_tstamp;
+
+    boost::asio::deadline_timer m_getwork_timer; // The timer which triggers getWork requests
+
+    // seconds to trigger a work_timeout (overwritten in constructor)
+    int m_worktimeout;
+    std::chrono::time_point<std::chrono::steady_clock> m_current_tstamp;
+    
+    unsigned m_solution_submitted_max_id;  // maximum json id we used to send a solution
 };

libpoolprotocols/getwork/EthGetworkClient.h

@@ -206,7 +206,6 @@ void EthStratumClient::connect()
     m_workloop_timer.async_wait(m_io_strand.wrap(boost::bind(
         &EthStratumClient::workloop_timer_elapsed, this, boost::asio::placeholders::error)));
 
-
     // Reset status flags
     m_canconnect.store(false, std::memory_order_relaxed);
     m_connected.store(false, std::memory_order_relaxed);
@@ -230,7 +229,6 @@ void EthStratumClient::connect()
     if (!m_socket)
         init_socket();
 
-
     // Initialize a new queue of end points
     m_endpoints = std::queue<boost::asio::ip::basic_endpoint<boost::asio::ip::tcp>>();
     m_endpoint = boost::asio::ip::basic_endpoint<boost::asio::ip::tcp>();
@@ -381,9 +379,7 @@ void EthStratumClient::disconnect_finalize()
 
     // Trigger handlers
     if (m_onDisconnected)
-    {
         m_onDisconnected();
-    }
 }
 
 void EthStratumClient::resolve_handler(

libpoolprotocols/getwork/getwork.json

@@ -130,7 +130,7 @@ class EthStratumClient : public PoolClient
     boost::asio::io_service& m_io_service;  // The IO service reference passed in the constructor
     boost::asio::io_service::strand m_io_strand;
     boost::asio::ip::tcp::socket* m_socket;
-    std::string m_message; // The internal message string buffer
+    std::string m_message;  // The internal message string buffer
     bool m_newjobprocessed = false;
 
     // Use shared ptrs to avoid crashes due to async_writes
@@ -155,8 +155,6 @@ class EthStratumClient : public PoolClient
     boost::asio::ip::tcp::resolver m_resolver;
     std::queue<boost::asio::ip::basic_endpoint<boost::asio::ip::tcp>> m_endpoints;
 
-    string m_rate;
-
     h256 m_nextWorkBoundary = h256("0x00000000ffff0000000000000000000000000000000000000000000000000000");
 
     uint64_t m_extraNonce = 0;