Skip to content

Commit 2bfc45c

Browse files
Refactory send path request
1 parent a110d96 commit 2bfc45c

3 files changed

Lines changed: 43 additions & 74 deletions

File tree

‎src/cpp/common/py_monero_common.cpp‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -166,6 +166,7 @@ PyMoneroPathRequest::PyMoneroPathRequest(const std::string& method, const boost:
166166
PyMoneroPathRequest::PyMoneroPathRequest(const std::string& method, const std::shared_ptr<PyMoneroRequestParams>& params):
167167
m_params(params) {
168168
m_method = method;
169+
if (params == nullptr) m_params = boost::none;
169170
}
170171

171172
PyMoneroBinaryRequest::PyMoneroBinaryRequest(const std::string& method, const boost::optional<py::object>& params) {

‎src/cpp/common/py_monero_common.h‎

Lines changed: 8 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -298,6 +298,14 @@ class PyMoneroRpcConnection : public monero::monero_rpc_connection {
298298
return std::make_shared<PyMoneroJsonResponse>(response);
299299
}
300300

301+
inline const boost::property_tree::ptree send_path_request(const std::string& path, const std::shared_ptr<PyMoneroRequestParams>& params = nullptr) {
302+
PyMoneroPathRequest request(path, params);
303+
auto response = send_path_request(request);
304+
305+
if (response->m_response == boost::none) throw std::runtime_error("Invalid Monero path response");
306+
return response->m_response.get();
307+
}
308+
301309
inline const std::shared_ptr<PyMoneroPathResponse> send_path_request(const PyMoneroPathRequest &request, std::chrono::milliseconds timeout = std::chrono::seconds(15)) {
302310
PyMoneroPathResponse response;
303311

‎src/cpp/daemon/py_monero_daemon_rpc.cpp‎

Lines changed: 34 additions & 74 deletions
Original file line numberDiff line numberDiff line change
@@ -90,14 +90,10 @@ monero::monero_version PyMoneroDaemonRpc::get_version() {
9090
}
9191

9292
bool PyMoneroDaemonRpc::is_trusted() {
93-
PyMoneroPathRequest request("get_height");
94-
std::shared_ptr<PyMoneroPathResponse> response = m_rpc->send_path_request(request);
95-
96-
if (response->m_response == boost::none) throw std::runtime_error("Invalid Monero JSONRPC response");
97-
auto res = response->m_response.get();
98-
auto _res = std::make_shared<PyMoneroGetHeightResponse>();
99-
PyMoneroGetHeightResponse::from_property_tree(res, _res);
100-
return !_res->m_untrusted.get();
93+
auto res = m_rpc->send_path_request("get_height");
94+
auto get_height_response = std::make_shared<PyMoneroGetHeightResponse>();
95+
PyMoneroGetHeightResponse::from_property_tree(res, get_height_response);
96+
return !get_height_response->m_untrusted.get();
10197
}
10298

10399
uint64_t PyMoneroDaemonRpc::get_height() {
@@ -289,16 +285,14 @@ std::vector<std::string> PyMoneroDaemonRpc::get_block_hashes(const std::vector<s
289285
std::vector<std::shared_ptr<monero::monero_tx>> PyMoneroDaemonRpc::get_txs(const std::vector<std::string>& tx_hashes, bool prune) {
290286
if (tx_hashes.empty()) throw std::runtime_error("Must provide an array of transaction hashes");
291287
auto params = std::make_shared<PyMoneroGetTxsParams>(tx_hashes, prune);
292-
PyMoneroPathRequest request("get_transactions", params);
293-
std::shared_ptr<PyMoneroPathResponse> response = m_rpc->send_path_request(request);
294-
try { check_response_status(response); }
288+
auto res = m_rpc->send_path_request("get_transactions", params);
289+
try { check_response_status(res); }
295290
catch (const std::exception& ex) {
296291
if (std::string(ex.what()).find("Failed to parse hex representation of transaction hash") != std::string::npos) {
297292
throw std::runtime_error("Invalid transaction hash");
298293
}
299294
throw;
300295
}
301-
auto res = response->m_response.get();
302296
std::vector<std::shared_ptr<monero::monero_tx>> txs;
303297
PyMoneroTx::from_property_tree(res, txs);
304298
return txs;
@@ -336,16 +330,13 @@ std::shared_ptr<PyMoneroFeeEstimate> PyMoneroDaemonRpc::get_fee_estimate(uint64_
336330

337331
std::shared_ptr<PyMoneroSubmitTxResult> PyMoneroDaemonRpc::submit_tx_hex(const std::string& tx_hex, bool do_not_relay) {
338332
auto params = std::make_shared<PyMoneroSubmitTxParams>(tx_hex, do_not_relay);
339-
PyMoneroPathRequest request("send_raw_transaction", params);
340-
std::shared_ptr<PyMoneroPathResponse> response = m_rpc->send_path_request(request);
341-
if (response->m_response == boost::none) throw std::runtime_error("Invalid Monero JSONRPC response");
342-
auto res = response->m_response.get();
333+
auto res = m_rpc->send_path_request("send_raw_transaction", params);
343334
auto sum = std::make_shared<PyMoneroSubmitTxResult>();
344335
PyMoneroSubmitTxResult::from_property_tree(res, sum);
345336

346337
// set m_is_good based on status
347338
try {
348-
check_response_status(response);
339+
check_response_status(res);
349340
sum->m_is_good = true;
350341
} catch (...) {
351342
sum->m_is_good = false;
@@ -367,20 +358,14 @@ std::shared_ptr<PyMoneroTxPoolStats> PyMoneroDaemonRpc::get_tx_pool_stats() {
367358
}
368359

369360
std::vector<std::shared_ptr<monero::monero_tx>> PyMoneroDaemonRpc::get_tx_pool() {
370-
PyMoneroPathRequest request("get_transaction_pool");
371-
std::shared_ptr<PyMoneroPathResponse> response = m_rpc->send_path_request(request);
372-
if (response->m_response == boost::none) throw std::runtime_error("Invalid Monero JSONRPC response");
373-
auto res = response->m_response.get();
361+
auto res = m_rpc->send_path_request("get_transaction_pool");
374362
std::vector<std::shared_ptr<monero::monero_tx>> pool;
375363
PyMoneroTx::from_property_tree(res, pool);
376364
return pool;
377365
}
378366

379367
std::vector<std::string> PyMoneroDaemonRpc::get_tx_pool_hashes() {
380-
PyMoneroPathRequest request("get_transaction_pool_hashes");
381-
std::shared_ptr<PyMoneroPathResponse> response = m_rpc->send_path_request(request);
382-
if (response->m_response == boost::none) throw std::runtime_error("Invalid Monero RPC response");
383-
auto res = response->m_response.get();
368+
auto res = m_rpc->send_path_request("get_transaction_pool_hashes");
384369
return PyMoneroTxHashes::from_property_tree(res);
385370
}
386371

@@ -404,10 +389,8 @@ void PyMoneroDaemonRpc::flush_tx_pool(const std::string &hash) {
404389
std::vector<PyMoneroKeyImageSpentStatus> PyMoneroDaemonRpc::get_key_image_spent_statuses(const std::vector<std::string>& key_images) {
405390
if (key_images.empty()) throw std::runtime_error("Must provide key images to check the status of");
406391
auto params = std::make_shared<PyMoneroIsKeyImageSpentParams>(key_images);
407-
PyMoneroPathRequest request("is_key_image_spent", params);
408-
std::shared_ptr<PyMoneroPathResponse> response = m_rpc->send_path_request(request);
409-
check_response_status(response);
410-
auto res = response->m_response.get();
392+
auto res = m_rpc->send_path_request("is_key_image_spent", params);
393+
check_response_status(res);
411394
std::vector<PyMoneroKeyImageSpentStatus> statuses;
412395
for (auto it = res.begin(); it != res.end(); ++it) {
413396
std::string key = it->first;
@@ -484,10 +467,7 @@ std::vector<std::shared_ptr<PyMoneroAltChain>> PyMoneroDaemonRpc::get_alt_chains
484467
}
485468

486469
std::vector<std::string> PyMoneroDaemonRpc::get_alt_block_hashes() {
487-
PyMoneroPathRequest request("get_alt_blocks_hashes");
488-
std::shared_ptr<PyMoneroPathResponse> response = m_rpc->send_path_request(request);
489-
if (response->m_response == boost::none) throw std::runtime_error("Invalid Monero JSONRPC response");
490-
auto res = response->m_response.get();
470+
auto res = m_rpc->send_path_request("get_alt_blocks_hashes");
491471
std::vector<std::string> hashes;
492472
PyMoneroGetAltBlocksHashesResponse::from_property_tree(res, hashes);
493473
return hashes;
@@ -541,12 +521,7 @@ std::vector<std::shared_ptr<PyMoneroPeer>> PyMoneroDaemonRpc::get_peers() {
541521
}
542522

543523
std::vector<std::shared_ptr<PyMoneroPeer>> PyMoneroDaemonRpc::get_known_peers() {
544-
PyMoneroPathRequest request("get_peer_list");
545-
std::shared_ptr<PyMoneroPathResponse> response = m_rpc->send_path_request(request);
546-
547-
if (response->m_response == boost::none) throw std::runtime_error("Invalid Monero JSONRPC response");
548-
auto res = response->m_response.get();
549-
524+
auto res = m_rpc->send_path_request("get_peer_list");
550525
std::vector<std::shared_ptr<PyMoneroPeer>> peers;
551526
PyMoneroPeer::from_property_tree(res, peers);
552527
return peers;
@@ -556,18 +531,16 @@ void PyMoneroDaemonRpc::set_outgoing_peer_limit(int limit) {
556531
if (limit < 0) throw std::runtime_error("Outgoing peer limit must be >= 0");
557532
auto params = std::make_shared<PyMoneroPeerLimits>();
558533
params->m_out_peers = limit;
559-
PyMoneroPathRequest request("out_peers", params);
560-
std::shared_ptr<PyMoneroPathResponse> response = m_rpc->send_path_request(request);
561-
check_response_status(response);
534+
auto res = m_rpc->send_path_request("out_peers", params);
535+
check_response_status(res);
562536
}
563537

564538
void PyMoneroDaemonRpc::set_incoming_peer_limit(int limit) {
565539
if (limit < 0) throw std::runtime_error("Incoming peer limit must be >= 0");
566540
auto params = std::make_shared<PyMoneroPeerLimits>();
567541
params->m_in_peers = limit;
568-
PyMoneroPathRequest request("in_peers", params);
569-
std::shared_ptr<PyMoneroPathResponse> response = m_rpc->send_path_request(request);
570-
check_response_status(response);
542+
auto res = m_rpc->send_path_request("in_peers", params);
543+
check_response_status(res);
571544
}
572545

573546
std::vector<std::shared_ptr<PyMoneroBan>> PyMoneroDaemonRpc::get_peer_bans() {
@@ -587,23 +560,19 @@ void PyMoneroDaemonRpc::start_mining(const std::string &address, int num_threads
587560
if (address.empty()) throw std::runtime_error("Must provide address to mine to");
588561
if (num_threads <= 0) throw std::runtime_error("Number of threads must be an integer greater than 0");
589562
auto params = std::make_shared<PyMoneroStartMiningParams>(address, num_threads, is_background, ignore_battery);
590-
PyMoneroPathRequest request("start_mining", params);
591-
auto response = m_rpc->send_path_request(request);
592-
check_response_status(response);
563+
auto res = m_rpc->send_path_request("start_mining", params);
564+
check_response_status(res);
593565
}
594566

595567
void PyMoneroDaemonRpc::stop_mining() {
596-
PyMoneroPathRequest request("stop_mining");
597-
auto response = m_rpc->send_path_request(request);
598-
check_response_status(response);
568+
auto res = m_rpc->send_path_request("stop_mining");
569+
check_response_status(res);
599570
}
600571

601572
std::shared_ptr<PyMoneroMiningStatus> PyMoneroDaemonRpc::get_mining_status() {
602-
PyMoneroPathRequest request("mining_status");
603-
auto response = m_rpc->send_path_request(request);
604-
check_response_status(response);
573+
auto res = m_rpc->send_path_request("mining_status");
574+
check_response_status(res);
605575
auto result = std::make_shared<PyMoneroMiningStatus>();
606-
auto res = response->m_response.get();
607576
PyMoneroMiningStatus::from_property_tree(res, result);
608577
return result;
609578
}
@@ -625,30 +594,25 @@ std::shared_ptr<PyMoneroPruneResult> PyMoneroDaemonRpc::prune_blockchain(bool ch
625594

626595
std::shared_ptr<PyMoneroDaemonUpdateCheckResult> PyMoneroDaemonRpc::check_for_update() {
627596
auto params = std::make_shared<PyMoneroDownloadUpdateParams>("check");
628-
PyMoneroPathRequest request("update", params);
629-
auto response = m_rpc->send_path_request(request);
630-
check_response_status(response);
597+
auto res = m_rpc->send_path_request("update", params);
598+
check_response_status(res);
631599
auto result = std::make_shared<PyMoneroDaemonUpdateCheckResult>();
632-
auto res = response->m_response.get();
633600
PyMoneroDaemonUpdateCheckResult::from_property_tree(res, result);
634601
return result;
635602
}
636603

637604
std::shared_ptr<PyMoneroDaemonUpdateDownloadResult> PyMoneroDaemonRpc::download_update(const std::string& path) {
638605
auto params = std::make_shared<PyMoneroDownloadUpdateParams>("download", path);
639-
PyMoneroPathRequest request("update", params);
640-
auto response = m_rpc->send_path_request(request);
641-
check_response_status(response);
606+
auto res = m_rpc->send_path_request("update", params);
607+
check_response_status(res);
642608
auto result = std::make_shared<PyMoneroDaemonUpdateDownloadResult>();
643-
auto res = response->m_response.get();
644609
PyMoneroDaemonUpdateDownloadResult::from_property_tree(res, result);
645610
return result;
646611
}
647612

648613
void PyMoneroDaemonRpc::stop() {
649-
PyMoneroPathRequest request("stop_daemon");
650-
std::shared_ptr<PyMoneroPathResponse> response = m_rpc->send_path_request(request);
651-
check_response_status(response);
614+
auto res = m_rpc->send_path_request("stop_daemon");
615+
check_response_status(res);
652616
}
653617

654618
std::shared_ptr<monero::monero_block_header> PyMoneroDaemonRpc::wait_for_next_block_header() {
@@ -674,21 +638,17 @@ std::shared_ptr<monero::monero_block_header> PyMoneroDaemonRpc::wait_for_next_bl
674638
}
675639

676640
std::shared_ptr<PyMoneroBandwithLimits> PyMoneroDaemonRpc::get_bandwidth_limits() {
677-
PyMoneroPathRequest request("get_limit");
678-
auto response = m_rpc->send_path_request(request);
679-
check_response_status(response);
680-
auto res = response->m_response.get();
641+
auto res = m_rpc->send_path_request("get_limit");
642+
check_response_status(res);
681643
auto limits = std::make_shared<PyMoneroBandwithLimits>();
682644
PyMoneroBandwithLimits::from_property_tree(res, limits);
683645
return limits;
684646
}
685647

686648
std::shared_ptr<PyMoneroBandwithLimits> PyMoneroDaemonRpc::set_bandwidth_limits(int up, int down) {
687649
auto limits = std::make_shared<PyMoneroBandwithLimits>(up, down);
688-
PyMoneroPathRequest request("set_limit", limits);
689-
auto response = m_rpc->send_path_request(request);
690-
check_response_status(response);
691-
auto res = response->m_response.get();
650+
auto res = m_rpc->send_path_request("set_limit", limits);
651+
check_response_status(res);
692652
PyMoneroBandwithLimits::from_property_tree(res, limits);
693653
return limits;
694654
}

0 commit comments

Comments
 (0)