Peerplays_Blockchain/peerplays_migrated
1
0
Fork 0
Code Issues 35 Pull requests 4 Projects Releases 20 Packages Wiki Activity Actions

Comments applied

Browse source 
show_log
move net_utl to other files
single IP resolve
removed custom exception handler
This commit is contained in:
moss9001 2021-10-25 17:28:30 +03:00
parent 876c0fcb71
commit 68b33c816c
5 changed files with 71 additions and 105 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
libraries/plugins/peerplays_sidechain/CMakeLists.txt
View file

@ -15,7 +15,6 @@ add_library( peerplays_sidechain
bitcoin/utils.cpp
bitcoin/sign_bitcoin_transaction.cpp
common/rpc_client.cpp
common/net_utl.cpp
common/utils.cpp
hive/asset.cpp
hive/operations.cpp

25
libraries/plugins/peerplays_sidechain/common/net_utl.cpp
View file

@ -1,25 +0,0 @@
#include "net_utl.hpp"
#include <boost/asio.hpp>
namespace graphene { namespace peerplays_sidechain {
std::string resolve_host_addr(const std::string &host_name) {
using namespace boost::asio;
io_service service;
ip::tcp::resolver resolver(service);
auto query = ip::tcp::resolver::query(host_name, std::string());
auto iter = resolver.resolve(query);
auto endpoint = *iter;
auto addr = ((ip::tcp::endpoint)endpoint).address();
return addr.to_string();
}
std::string strip_proto_name(const std::string &url) {
auto index = url.find("://");
if (index == std::string::npos)
return url;
return url.substr(index + 3);
}
}} // namespace graphene::peerplays_sidechain

15
libraries/plugins/peerplays_sidechain/common/net_utl.hpp
View file

@ -1,15 +0,0 @@
#pragma once
#include <string>
namespace graphene { namespace peerplays_sidechain {
// resolve IP address by host name
// ex: api.hive.blog -> 52.79.10.214
std::string resolve_host_addr(const std::string &host_name);
// remove schema part from URL
// ex: http://api.hive.blog -> api.hive.blog
std::string strip_proto_name(const std::string &url);
}} // namespace graphene::peerplays_sidechain

90
libraries/plugins/peerplays_sidechain/common/rpc_client.cpp
View file

@ -19,8 +19,6 @@
#include <boost/algorithm/string/case_conv.hpp>
#include <boost/algorithm/string/trim.hpp>
#include "net_utl.hpp"
namespace graphene { namespace peerplays_sidechain {
struct http_request {
@ -105,10 +103,6 @@ static const char *crlfcrlf = "\x0D\x0A\x0D\x0A";
using namespace boost::asio;
[[noreturn]] static void throw_error(const std::string &msg) {
throw std::runtime_error(msg);
}
class https_call_impl {
public:
https_call_impl(const https_call &call, const http_request &request, http_response &response) :
@ -200,8 +194,9 @@ private:
const auto &h = m_request.headers;
if (!h.empty()) {
if (h.size() < 2)
throw_error("invalid headers data");
if (h.size() < 2) {
FC_THROW("invalid headers data");
}
stream << h;
// ensure headers finished correctly
if ((h.substr(h.size() - 2) != crlf))
@ -236,7 +231,7 @@ private:
stream >> m_response.status_code;
if (!stream || http_version.substr(0, 5) != "HTTP/") {
throw_error("invalid response");
FC_THROW("invalid response data");
}
// read/skip headers
@ -274,25 +269,28 @@ private:
// check content length
if (content_length < 2) // minimum content is "{}"
throw_error("invalid response body (too short)");
if (content_length < 2) { // minimum content is "{}"
FC_THROW("invalid response body (too short)");
}
if (content_length > m_call.response_size_limit_bytes())
throw_error("response body size limit exceeded");
if (content_length > m_call.response_size_limit_bytes()) {
FC_THROW("response body size limit exceeded");
}
// read body
auto avail = buf.size(); // size of body data already stored in the buffer
if (avail > content_length)
throw_error("invalid response body (content length mismatch)");
if (avail > content_length) {
FC_THROW("invalid response body (content length mismatch)");
}
body.resize(content_length);
if (avail) {
// copy already existing data
if (avail != buf.sgetn(&body[0], avail)) {
throw_error("stream read failed");
FC_THROW("stream read failed");
}
}
@ -438,59 +436,39 @@ rpc_reply rpc_client::send_post_request(std::string body, bool show_log) {
memcpy(&reply.body[0], &response.body[0], response.body.size());
}
if (show_log) {
std::string url = ip + ":" + std::to_string(port);
ilog("### Request URL: ${url}", ("url", url));
ilog("### Request: ${body}", ("body", body));
ilog("### Response code: ${code}", ("code", response.status_code));
ilog("### Response len: ${len}", ("len", response.body.size()));
std::stringstream ss(std::string(reply.body.begin(), reply.body.end()));
ilog("### Response body: ${ss}", ("ss", ss.str()));
}
} else {
return reply;
}
std::string host;
std::string host;
if (start == "http:/")
host = ip.substr(7); // skip "http://"
else
host = ip;
if (start == "http:/")
host = ip.substr(7); // skip "http://"
else
host = ip;
std::string url = "http://" + host + ":" + std::to_string(port);
fc::ip::address addr;
std::string url = "http://" + host + ":" + std::to_string(port);
fc::ip::address addr;
try {
addr = fc::ip::address(host);
} catch (...) {
try {
addr = fc::ip::address(resolve_host_addr(host));
addr = fc::ip::address(host);
} catch (...) {
if (show_log) {
std::string url = ip + ":" + std::to_string(port);
ilog("### Request URL: ${url}", ("url", url));
ilog("### Request: ${body}", ("body", body));
ilog("### Request: error: host address resolve failed");
}
return reply;
}
}
try {
try {
fc::http::connection conn;
conn.connect_to(fc::ip::endpoint(addr, port));
fc::http::connection conn;
conn.connect_to(fc::ip::endpoint(addr, port));
//if (wallet.length() > 0) {
// url = url + "/wallet/" + wallet;
//}
//if (wallet.length() > 0) {
// url = url + "/wallet/" + wallet;
//}
auto r = conn.request("POST", url, body, fc::http::headers{authorization});
reply.status = r.status;
reply.body.assign(r.body.begin(), r.body.end());
auto r = conn.request("POST", url, body, fc::http::headers{authorization});
reply.status = r.status;
reply.body.assign(r.body.begin(), r.body.end());
} catch (...) {
} catch (...) {
}
}
if (show_log) {

45
libraries/plugins/peerplays_sidechain/sidechain_net_handler_hive.cpp
View file

@ -28,7 +28,34 @@
#include <graphene/peerplays_sidechain/hive/transaction.hpp>
#include <graphene/utilities/key_conversion.hpp>
#include "common/net_utl.hpp"
#include <boost/asio.hpp>
namespace graphene { namespace peerplays_sidechain {
std::string resolve_host_addr(const std::string &host_name) {
using namespace boost::asio;
io_service service;
ip::tcp::resolver resolver(service);
auto query = ip::tcp::resolver::query(host_name, std::string());
auto iter = resolver.resolve(query);
auto endpoint = *iter;
auto addr = ((ip::tcp::endpoint)endpoint).address();
return addr.to_string();
}
std::string strip_proto_name(const std::string &url, std::string *schema) {
auto index = url.find("://");
if (index == std::string::npos) {
if (schema)
schema->clear();
return url;
}
if (schema)
schema->assign(&url[0], &url[index + 3]);
return url.substr(index + 3);
}
}} // namespace graphene::peerplays_sidechain
namespace graphene { namespace peerplays_sidechain {
@ -147,31 +174,33 @@ sidechain_net_handler_hive::sidechain_net_handler_hive(peerplays_sidechain_plugi
}
}
fc::http::connection conn;
std::string schema;
auto host = strip_proto_name(node_ip, &schema);
try {
auto host = strip_proto_name(node_ip);
fc::ip::address addr;
fc::ip::address ip_addr;
try {
// IP address assumed
addr = fc::ip::address(host);
ip_addr = fc::ip::address(host);
} catch (...) {
try {
// host name assumed
addr = fc::ip::address(resolve_host_addr(host));
host = resolve_host_addr(host);
ip_addr = fc::ip::address(host);
} catch (...) {
elog("Failed to resolve Hive node address ${ip}", ("ip", node_ip));
FC_ASSERT(false);
}
}
// try to connect to TCP endpoint
conn.connect_to(fc::ip::endpoint(addr, node_rpc_port));
fc::http::connection conn;
conn.connect_to(fc::ip::endpoint(ip_addr, node_rpc_port));
} catch (fc::exception &e) {
elog("No Hive node running at ${ip} or wrong rpc port: ${port}", ("ip", node_ip)("port", node_rpc_port));
FC_ASSERT(false);
}
node_rpc_client = new hive_node_rpc_client(node_ip, node_rpc_port, node_rpc_user, node_rpc_password, debug_rpc_calls);
node_rpc_client = new hive_node_rpc_client(schema + host, node_rpc_port, node_rpc_user, node_rpc_password, debug_rpc_calls);
std::string chain_id_str = node_rpc_client->get_chain_id();
chain_id = chain_id_type(chain_id_str);