diff --git a/dap_chain_net.c b/dap_chain_net.c
index 688a4f1d2052094cfe023b4721996d64a8f1c9ed..842db6a27203521b80e4abee2f1cdb90e3db0fb1 100644
--- a/dap_chain_net.c
+++ b/dap_chain_net.c
@@ -39,6 +39,12 @@
#include "dap_chain_node_cli.h"
#include "dap_chain_node_cli_cmd.h"
+#include "dap_stream_ch_chain_net.h"
+#include "dap_stream_ch_chain.h"
+#include "dap_stream_ch_chain_pkt.h"
+#include "dap_stream_ch.h"
+#include "dap_stream_ch_pkt.h"
+
#include "dap_module.h"
#define _XOPEN_SOURCE 700
@@ -59,10 +65,10 @@ typedef struct dap_chain_net_pvt{
dap_chain_node_role_t node_role;
uint8_t padding[4];
- dap_chain_node_client_t * links_by_node_addr;
- dap_chain_node_client_t * clients_by_ipv4;
- dap_chain_node_client_t * clients_by_ipv6;
- size_t clients_count;
+ dap_chain_node_info_t * node_info; // Current node's info
+
+ dap_chain_node_client_t * links;
+ size_t links_count;
char ** seed_aliases;
uint16_t seed_aliases_count;
@@ -92,7 +98,7 @@ static const char * c_net_states[]={
[NET_STATE_LINKS_ESTABLISHED]= "NET_STATE_LINKS_ESTABLISHED",
[NET_STATE_SYNC_GDB]= "NET_STATE_SYNC_GDB",
[NET_STATE_SYNC_CHAINS]= "NET_STATE_SYNC_CHAINS",
- [NET_STATE_SYNC_ALL]= "NET_STATE_STAND_BY"
+ [NET_STATE_STAND_BY]= "NET_STATE_STAND_BY"
};
static dap_chain_net_t * s_net_new(const char * a_id, const char * a_name , const char * a_node_role);
@@ -140,55 +146,136 @@ int dap_chain_net_state_go_to(dap_chain_net_t * a_net, dap_chain_net_state_t a_n
static int s_net_states_proc(dap_chain_net_t * l_net)
{
int ret=0;
+ pthread_mutex_lock(&PVT(l_net)->state_mutex );
+lb_proc_state:
switch ( PVT(l_net)->state ){
case NET_STATE_OFFLINE:{
+ log_it(L_NOTICE,"%s.state: NET_STATE_OFFLINE",l_net->pub.name);
if ( PVT(l_net)->state_target != NET_STATE_OFFLINE ){
- // Check if there are root nodes in list
- switch ( PVT(l_net)->node_role.enums){
- case NODE_ROLE_ROOT_MASTER:
- case NODE_ROLE_ROOT:{
- }break;
- case NODE_ROLE_ARCHIVE:
- case NODE_ROLE_CELL_MASTER:
- case NODE_ROLE_MASTER:
- case NODE_ROLE_FULL:
- case NODE_ROLE_LIGHT:
- default:{};
- };
+ PVT(l_net)->state_target = NET_STATE_LINKS_PING;
+ goto lb_proc_state;
}
- }break;
- case NET_STATE_LINKS_PINGING:{
- switch ( PVT(l_net)->node_role.enums){
- case NODE_ROLE_ROOT_MASTER:
- case NODE_ROLE_ROOT:{
- }break;
- case NODE_ROLE_ARCHIVE:
- case NODE_ROLE_CELL_MASTER:
- case NODE_ROLE_MASTER:
- case NODE_ROLE_FULL:
- case NODE_ROLE_LIGHT:
- default:{}
- };
-
+ } break;
+ case NET_STATE_LINKS_PING:{
+ log_it(L_NOTICE,"%s.state: NET_STATE_LINKS_PING",l_net->pub.name);
+ PVT(l_net)->state_target = NET_STATE_LINKS_CONNECTING;
+ goto lb_proc_state;
}break;
case NET_STATE_LINKS_CONNECTING:{
-
- log_it(L_DEBUG,"Connected %u/% links", PVT(l_net)->clients_count );
- ret = 1;
- }break;
+ log_it(L_NOTICE,"%s.state: NET_STATE_LINKS_CONNECTING",l_net->pub.name);
+ if ( PVT(l_net)->node_info ) {
+ size_t l_links_established = 0;
+ for (size_t i =0 ; i < PVT(l_net)->node_info->hdr.links_number; i++ ){
+ dap_chain_node_info_t *l_link_node_info = dap_chain_node_info_read( &PVT(l_net)->node_info->links[i] );
+ if ( l_link_node_info ) {
+ dap_chain_node_client_t *l_node_client = dap_chain_node_client_connect(l_link_node_info );
+ if(!l_node_client) {
+ DAP_DELETE(l_link_node_info);
+ ret = -1;
+ break;
+ }
+ // wait connected
+ int timeout_ms = 15000; //15 sec = 15000 ms
+ int res = dap_chain_node_client_wait(l_node_client, NODE_CLIENT_STATE_CONNECTED, timeout_ms);
+ if (res == 0 ){
+ log_it(L_NOTICE, "Connected link %u",i);
+ l_links_established++;
+ HASH_ADD(hh,PVT(l_net)->links, remote_node_addr,sizeof(l_node_client->remote_node_addr), l_node_client);
+ }else {
+ log_it(L_NOTICE, "Cant establish link %u",i);
+ dap_chain_node_client_close(l_node_client);
+ }
+ }
+ }
+ if (l_links_established >0 ){
+ log_it(L_NOTICE, "Established %u links",l_links_established);
+ PVT(l_net)->state = NET_STATE_LINKS_ESTABLISHED;
+ goto lb_proc_state;
+ }
+ }
+ } break;
case NET_STATE_LINKS_ESTABLISHED:{
-
+ log_it(L_NOTICE,"%s.state: NET_STATE_LINKS_ESTABLISHED",l_net->pub.name);
+ switch (PVT(l_net)->state_target) {
+ case NET_STATE_STAND_BY:
+ case NET_STATE_SYNC_GDB: PVT(l_net)->state = NET_STATE_SYNC_GDB ; goto lb_proc_state;
+ case NET_STATE_SYNC_CHAINS: PVT(l_net)->state = NET_STATE_SYNC_CHAINS ; goto lb_proc_state;
+ default:{}
+ }
}break;
case NET_STATE_SYNC_GDB:{
+ // send request
+ dap_chain_node_client_t * l_node_client = NULL, *l_node_client_tmp = NULL;
+ HASH_ITER(hh,PVT(l_net)->links,l_node_client,l_node_client_tmp){
+ size_t l_data_size_out = 0;
+ // Get last timestamp in log
+ time_t l_timestamp_start = dap_db_log_get_last_timestamp();
+ size_t l_data_send_len = 0;
+ uint8_t *l_data_send = dap_stream_ch_chain_net_make_packet(PVT(l_net)->node_info->hdr.address.uint64 ,
+ l_node_client->remote_node_addr.uint64,
+ l_timestamp_start, NULL, 0, &l_data_send_len);
+
+ uint8_t l_ch_id = dap_stream_ch_chain_net_get_id(); // Channel id for global_db sync
+ int res = dap_chain_node_client_send_chain_net_request(l_node_client, l_ch_id,
+ STREAM_CH_CHAIN_NET_PKT_TYPE_GLOBAL_DB_REQUEST_SYNC, l_data_send, l_data_send_len); //, NULL);
+ DAP_DELETE(l_data_send);
+ if(res != 1) {
+ log_it(L_WARNING,"Can't send GDB sync request");
+ HASH_DEL(PVT(l_net)->links,l_node_client);
+ dap_chain_node_client_close(l_node_client);
+ continue;
+ }
+ // wait for finishing of request
+ int timeout_ms = 120000; // 2 min = 120 sec = 120 000 ms
+ // TODO add progress info to console
+ res = dap_chain_node_client_wait(l_node_client, NODE_CLIENT_STATE_END, timeout_ms);
+ switch (res) {
+ case 0:
+ log_it(L_WARNING,"Timeout with link sync");
+ break;
+ case 1:
+ log_it(L_INFO, "Node sync completed");
+ break;
+ default:
+ log_it(L_INFO, "Node sync error %d",res);
+ }
+ }
+ if ( PVT(l_net)->state_target == NET_STATE_STAND_BY ){
+ PVT(l_net)->state = NET_STATE_SYNC_CHAINS;
+ }else {
+ PVT(l_net)->state = NET_STATE_STAND_BY;
+ }
+ goto lb_proc_state;
}break;
case NET_STATE_SYNC_CHAINS:{
+ dap_chain_node_client_t * l_node_client = NULL, *l_node_client_tmp = NULL;
+ HASH_ITER(hh,PVT(l_net)->links,l_node_client,l_node_client_tmp){
+ uint8_t l_ch_id = dap_stream_ch_chain_get_id(); // Channel id for global_db sync
+ dap_chain_t * l_chain = NULL;
+ DL_FOREACH(l_net->pub.chains, l_chain ){
+ dap_stream_t * l_stream = dap_client_get_stream( l_node_client->client );
+ if ( l_stream ){
+ dap_stream_ch_t * l_ch = l_stream->channel [l_ch_id];
+ if ( l_ch ) {
+ dap_stream_ch_chain_pkt_t * l_chain_pkt;
+ size_t l_chain_pkt_size = sizeof (l_chain_pkt->hdr) + sizeof (dap_stream_ch_chain_request_t );
+ dap_stream_ch_chain_request_t * l_request = (dap_stream_ch_chain_request_t *) l_chain_pkt->data;
+
+ dap_stream_ch_pkt_write(l_ch,'b',l_chain_pkt,l_chain_pkt_size);
+ }
+ }
+ }
+ }
+ PVT(l_net)->state = NET_STATE_STAND_BY;
+ goto lb_proc_state;
}break;
- case NET_STATE_SYNC_ALL:{
+ case NET_STATE_STAND_BY:{
} break;
}
+ pthread_mutex_unlock(&PVT(l_net)->state_mutex );
return ret;
}
@@ -409,6 +496,10 @@ int dap_chain_net_load(const char * a_net_name)
dap_config_get_item_str(l_cfg , "general" , "name" ),
dap_config_get_item_str(l_cfg , "general" , "node-role" )
);
+ if(!l_net) {
+ log_it(L_ERROR,"Can't create l_net");
+ return -1;
+ }
l_net->pub.gdb_groups_prefix = dap_strdup (
dap_config_get_item_str_default(l_cfg , "general" , "gdb_groups_prefix","" ) );
@@ -437,7 +528,42 @@ int dap_chain_net_load(const char * a_net_name)
// Check if seed nodes are present in local db alias
PVT(l_net)->seed_aliases = dap_config_get_array_str( l_cfg , "general" ,"seed_nodes_aliases"
,&PVT(l_net)->seed_aliases_count);
+ const char * l_node_ipv4_str = dap_config_get_item_str(l_cfg , "general" ,"node-ipv4");
+ const char * l_node_addr_str = dap_config_get_item_str(l_cfg , "general" ,"node-addr");
+ const char * l_node_alias_str = dap_config_get_item_str(l_cfg , "general" , "node-alias");
+ if ( l_node_alias_str ){
+ dap_chain_node_addr_t * l_node_addr;
+ if ( l_node_addr_str == NULL)
+ l_node_addr = dap_chain_node_alias_find(l_node_alias_str);
+ else{
+ l_node_addr = DAP_NEW_Z(dap_chain_node_addr_t);
+ if ( sscanf(l_node_addr_str, "0x%016lx",&l_node_addr->uint64 ) != 1 ){
+ sscanf(l_node_addr_str,"0x%016lX",&l_node_addr->uint64);
+ }
+ if( l_node_addr->uint64 == 0 ){
+ log_it(L_ERROR,"Can't parse node address");
+ DAP_DELETE(l_node_addr);
+ l_node_addr = NULL;
+ }
+ //}
+ }
+ if ( l_node_addr ) {
+ char *l_addr_hash_str = dap_chain_node_addr_to_hash_str(l_node_addr);
+ if(!l_addr_hash_str){
+ log_it(L_ERROR,"Can't get hash string for node address!");
+ } else {
+ PVT(l_net)->node_info = dap_chain_node_info_read (l_node_addr);
+ if ( PVT(l_net)->node_info ) {
+ log_it(L_NOTICE,"GDB Info: node_addr_hash: %s links: %u cell_id: 0x%016X ",
+ l_addr_hash_str,
+ PVT(l_net)->node_info->hdr.links_number,
+ PVT(l_net)->node_info->hdr.cell_id.uint64);
+ }
+ }
+ }
+
+ }
// Init chains
size_t l_chains_path_size =strlen(dap_config_path())+1+strlen(l_net->pub.name)+1+strlen("network")+1;
char * l_chains_path = DAP_NEW_Z_SIZE (char,l_chains_path_size);
@@ -490,7 +616,7 @@ int dap_chain_net_load(const char * a_net_name)
if (l_chain )
l_chain->is_datum_pool_proc = true;
- PVT(l_net)->state_target = NET_STATE_SYNC_ALL;
+ PVT(l_net)->state_target = NET_STATE_STAND_BY;
log_it(L_INFO,"Root node role established");
} break;
case NODE_ROLE_CELL_MASTER:
@@ -499,12 +625,12 @@ int dap_chain_net_load(const char * a_net_name)
dap_chain_id_t l_chain_id = { .raw = {0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x01} };
dap_chain_t * l_chain = dap_chain_find_by_id(l_net->pub.id, l_chain_id );
l_chain->is_datum_pool_proc = true;
- PVT(l_net)->state_target = NET_STATE_SYNC_ALL;
+ PVT(l_net)->state_target = NET_STATE_STAND_BY;
log_it(L_INFO,"Master node role established");
} break;
case NODE_ROLE_FULL:{
log_it(L_INFO,"Full node role established");
- PVT(l_net)->state_target = NET_STATE_SYNC_ALL;
+ PVT(l_net)->state_target = NET_STATE_STAND_BY;
} break;
case NODE_ROLE_LIGHT:
default:
@@ -603,7 +729,20 @@ dap_chain_t * dap_chain_net_get_chain_by_name( dap_chain_net_t * l_net, const ch
return NULL;
}
+/**
+ * @brief dap_chain_net_get_cur_addr
+ * @param l_net
+ * @return
+ */
+dap_chain_node_addr_t * dap_chain_net_get_cur_addr( dap_chain_net_t * l_net)
+{
+ return PVT(l_net)->node_info? &PVT(l_net)->node_info->hdr.address: NULL;
+}
+/**
+ * @brief dap_chain_net_proc_datapool
+ * @param a_net
+ */
void dap_chain_net_proc_datapool (dap_chain_net_t * a_net)
{
diff --git a/dap_chain_net.h b/dap_chain_net.h
index e738dd252771315d0a12191692c94491a45d3c6a..f0b183e741622219ef00fd7828afa8b323024c76 100644
--- a/dap_chain_net.h
+++ b/dap_chain_net.h
@@ -28,6 +28,7 @@
#include <stdint.h>
#include <string.h>
#include "dap_chain_common.h"
+#include "dap_chain_node.h"
#include "dap_chain.h"
@@ -35,12 +36,12 @@
typedef enum dap_chain_net_state{
NET_STATE_OFFLINE = 0,
- NET_STATE_LINKS_PINGING,
+ NET_STATE_LINKS_PING,
NET_STATE_LINKS_CONNECTING,
NET_STATE_LINKS_ESTABLISHED,
NET_STATE_SYNC_GDB,
NET_STATE_SYNC_CHAINS,
- NET_STATE_SYNC_ALL,
+ NET_STATE_STAND_BY,
} dap_chain_net_state_t;
@@ -63,12 +64,12 @@ int dap_chain_net_load(const char * a_net_name);
int dap_chain_net_state_go_to(dap_chain_net_t * a_net, dap_chain_net_state_t a_new_state);
-inline static int dap_chain_net_start(dap_chain_net_t * a_net){ return dap_chain_net_state_go_to(a_net,NET_STATE_SYNC_ALL); }
+inline static int dap_chain_net_start(dap_chain_net_t * a_net){ return dap_chain_net_state_go_to(a_net,NET_STATE_STAND_BY); }
inline static int dap_chain_net_stop(dap_chain_net_t * a_net) { return dap_chain_net_state_go_to(a_net,NET_STATE_OFFLINE); }
inline static int dap_chain_net_links_establish(dap_chain_net_t * a_net) { return dap_chain_net_state_go_to(a_net,NET_STATE_LINKS_ESTABLISHED); }
inline static int dap_chain_net_sync_chains(dap_chain_net_t * a_net) { return dap_chain_net_state_go_to(a_net,NET_STATE_SYNC_CHAINS); }
inline static int dap_chain_net_sync_gdb(dap_chain_net_t * a_net) { return dap_chain_net_state_go_to(a_net,NET_STATE_SYNC_GDB); }
-inline static int dap_chain_net_sync_all(dap_chain_net_t * a_net) { return dap_chain_net_state_go_to(a_net,NET_STATE_SYNC_ALL); }
+inline static int dap_chain_net_sync_all(dap_chain_net_t * a_net) { return dap_chain_net_state_go_to(a_net,NET_STATE_STAND_BY); }
void dap_chain_net_delete( dap_chain_net_t * a_net);
void dap_chain_net_proc_datapool (dap_chain_net_t * a_net);
@@ -79,8 +80,11 @@ dap_chain_net_id_t dap_chain_net_id_by_name( const char * a_name);
dap_chain_t * dap_chain_net_get_chain_by_name( dap_chain_net_t * l_net, const char * a_name);
+dap_chain_node_addr_t * dap_chain_net_get_cur_addr( dap_chain_net_t * l_net);
+
void dap_chain_net_links_connect(dap_chain_net_t * a_net);
+
/**
* @brief dap_chain_net_get_gdb_group_mempool
* @param l_chain
diff --git a/dap_chain_node.c b/dap_chain_node.c
index 980ce0bd52e15a45e7d15e6641ac1e7dddfbff85..290a4ce4bca5a769a780f5fe9a48d0491213d4b0 100644
--- a/dap_chain_node.c
+++ b/dap_chain_node.c
@@ -72,7 +72,7 @@ bool dap_chain_node_alias_register(const char *alias, dap_chain_node_addr_t *add
// if(bin2hex(a_value, (const unsigned char *) addr, sizeof(dap_chain_node_addr_t)) == -1)
// return false;
// a_value[2 * sizeof(dap_chain_node_addr_t)] = '\0';
- bool res = dap_chain_global_db_gr_set(a_key, (const uint8_t*) addr, sizeof(dap_chain_node_addr_t), GROUP_ALIAS);
+ bool res = dap_chain_global_db_gr_set(a_key, (const uint8_t*) addr, sizeof(dap_chain_node_addr_t), GROUP_GLOBAL_ALIAS);
return res;
}
@@ -85,7 +85,7 @@ dap_chain_node_addr_t * dap_chain_node_alias_find(const char *a_alias)
{
size_t l_addr_size =0;
dap_chain_node_addr_t * l_addr = (dap_chain_node_addr_t *)
- dap_chain_global_db_gr_get(a_alias, &l_addr_size, GROUP_ALIAS);
+ dap_chain_global_db_gr_get(a_alias, &l_addr_size, GROUP_GLOBAL_ALIAS);
return l_addr;
}
@@ -95,7 +95,7 @@ dap_chain_node_addr_t * dap_chain_node_alias_find(const char *a_alias)
bool dap_chain_node_alias_delete(const char *alias)
{
const char *a_key = alias;
- bool res = dap_chain_global_db_gr_del(a_key, GROUP_ALIAS);
+ bool res = dap_chain_global_db_gr_del(a_key, GROUP_GLOBAL_ALIAS);
return res;
}
@@ -114,8 +114,66 @@ size_t dap_chain_node_info_get_size(dap_chain_node_info_t *node_info)
return (sizeof(dap_chain_node_info_t) + node_info->hdr.links_number * sizeof(dap_chain_node_addr_t));
}
+/**
+ * @brief dap_chain_node_info_save
+ * @param node_info
+ * @return
+ */
+int dap_chain_node_info_save(dap_chain_node_info_t *node_info)
+{
+ if(!node_info || !node_info->hdr.address.uint64)
+ return -1;
+
+ char *l_key = dap_chain_node_addr_to_hash_str(&node_info->hdr.address);
+
+ if(!l_key)
+ return -2;
+ //char *a_value = dap_chain_node_info_serialize(node_info, NULL);
+ size_t node_info_size = dap_chain_node_info_get_size(node_info);
+ bool res = dap_chain_global_db_gr_set(l_key, (const uint8_t *) node_info, node_info_size, GROUP_GLOBAL_ADDRS_LEASED);
+ DAP_DELETE(l_key);
+ //DAP_DELETE(a_value);
+ return res;
+}
+/**
+ * Read node from base
+ */
+dap_chain_node_info_t* dap_chain_node_info_read(dap_chain_node_addr_t *address)
+{
+ char *l_key = dap_chain_node_addr_to_hash_str(address);
+ if(!l_key) {
+ log_it(L_WARNING,"Can't calculate hash of addr");
+ return NULL;
+ }
+ size_t node_info_size = 0;
+ dap_chain_node_info_t *node_info;
+ // read node
+ node_info = (dap_chain_node_info_t *) dap_chain_global_db_gr_get(l_key, &node_info_size, GROUP_GLOBAL_ADDRS_LEASED);
+
+ if(!node_info) {
+ log_it(L_ERROR, "node not found in base");
+ DAP_DELETE(l_key);
+ return NULL;
+ }
+
+ size_t node_info_size_must_be = dap_chain_node_info_get_size(node_info);
+ if(node_info_size_must_be != node_info_size) {
+ log_it(L_ERROR, "Node has bad size in base=%u (must be %u)", node_info_size, node_info_size_must_be);
+ DAP_DELETE(node_info);
+ DAP_DELETE(l_key);
+ return NULL;
+ }
+
+// dap_chain_node_info_t *node_info = dap_chain_node_info_deserialize(str, (str) ? strlen(str) : 0);
+// if(!node_info) {
+// set_reply_text(str_reply, "node has invalid format in base");
+// }
+// DAP_DELETE(str);
+ DAP_DELETE(l_key);
+ return node_info;
+}
/**
diff --git a/dap_chain_node.h b/dap_chain_node.h
index 62b3f3a44a8aae24815849f3e6fb1323ef187393..be639a86f1f3c6b4a252f458e25d584bcb656eff 100644
--- a/dap_chain_node.h
+++ b/dap_chain_node.h
@@ -30,6 +30,7 @@
#include "dap_common.h"
#include "dap_chain_common.h"
+#include "dap_chain_global_db.h"
/**
* @struct Node address
@@ -124,4 +125,13 @@ dap_chain_node_addr_t * dap_chain_node_alias_find(const char *alias);
bool dap_chain_node_alias_register(const char *alias, dap_chain_node_addr_t *addr);
bool dap_chain_node_alias_delete(const char *alias);
+int dap_chain_node_info_save(dap_chain_node_info_t *node_info);
+dap_chain_node_info_t* dap_chain_node_info_read(dap_chain_node_addr_t *address);
+
+inline static char* dap_chain_node_addr_to_hash_str(dap_chain_node_addr_t *address)
+{
+ char *a_key = dap_chain_global_db_hash((const uint8_t*) address, sizeof(dap_chain_node_addr_t));
+ return a_key;
+}
+
diff --git a/dap_chain_node_cli.c b/dap_chain_node_cli.c
index 4913852c03a7f9f15a013a65904addba881f2d94..c82d0f28149921c3be85438a139794a9c269f359 100644
--- a/dap_chain_node_cli.c
+++ b/dap_chain_node_cli.c
@@ -356,7 +356,7 @@ void dap_chain_node_cli_set_reply_text(char **str_reply, const char *str, ...)
{
if(str_reply) {
if(*str_reply) {
- assert(!*str_reply);
+ assert(! *str_reply );
DAP_DELETE(*str_reply);
*str_reply = NULL;
}
@@ -459,9 +459,9 @@ int dap_chain_node_cli_init(dap_config_t * g_config)
"global_db node link {add|del} -net <net name> {-addr <node address> | -alias <node alias>} -link <node address>\n\n"
"global_db node dump -net <net name>\n\n"
"global_db node dump -net <net name> -addr <node address> | -alias <node alias>\n\n"
- "global_db node get -net <net name>\n\n"
- "global_db node set -net <net name> -addr <node address> | -alias <node alias>\n\n"
- "global_db node remote_set -addr <node address> | -alias <node alias>\n");
+ "global_db node cur_node get -net <net name>\n\n"
+ "global_db node cur_node_set -net <net name> -addr <node address> | -alias <node alias>\n\n"
+ "global_db node cur_node_set_from_remote -addr <node address> | -alias <node alias>\n");
dap_chain_node_cli_cmd_item_create ("node", com_node, "Work with node",
"node alias {<node address> | -alias <node alias>}\n\n"
"node connect {<node address> | -alias <node alias>}\n\n"
diff --git a/dap_chain_node_cli_cmd.h b/dap_chain_node_cli_cmd.h
index c8aeecae1631e9e3b403ba62909716a239dfb858..98b77ac556cf053ef74c9fc6ab547995011e5ad9 100644
--- a/dap_chain_node_cli_cmd.h
+++ b/dap_chain_node_cli_cmd.h
@@ -115,6 +115,10 @@ int com_tx_cond_create(int argc, const char ** argv, char **str_reply);
*/
int com_tx_verify(int argc, const char ** argv, char **str_reply);
+// Print log info
+int com_print_log(int argc, const char ** argv, char **str_reply);
+
int com_mempool_delete(int argc, const char ** argv, char ** a_str_reply);
int com_mempool_list(int argc, const char ** argv, char ** a_str_reply);
int com_mempool_proc(int argc, const char ** argv, char ** a_str_reply);
+
diff --git a/dap_chain_node_client.c b/dap_chain_node_client.c
index b3171682fb21cafdb603178e6527326b58477914..28b09a0a53c5c8b83585594706609299da838399 100644
--- a/dap_chain_node_client.c
+++ b/dap_chain_node_client.c
@@ -49,8 +49,6 @@ static int listen_port_tcp = 8079;
int dap_chain_node_client_init(void)
{
- int res = dap_client_init();
- res = dap_http_client_simple_init();
dap_config_t *g_config;
// read listen_port_tcp from settings
dap_config_init(SYSTEM_CONFIGS_DIR);
@@ -63,7 +61,7 @@ int dap_chain_node_client_init(void)
}
if(g_config)
dap_config_close(g_config);
- return res;
+ return 0;
}
void dap_chain_node_client_deinit()
@@ -86,13 +84,15 @@ static void stage_status_error_callback(dap_client_t *a_client, void *a_arg)
// callback for the end of connection in dap_chain_node_client_connect()->dap_client_go_stage()
static void a_stage_end_callback(dap_client_t *a_client, void *a_arg)
{
- dap_chain_node_client_t *client = a_client->_inheritor;
- assert(client);
- if(client) {
- pthread_mutex_lock(&client->wait_mutex);
- client->state = NODE_CLIENT_STATE_CONNECTED;
- pthread_cond_signal(&client->wait_cond);
- pthread_mutex_unlock(&client->wait_mutex);
+ dap_chain_node_client_t *l_node_client = a_client->_inheritor;
+ assert(l_node_client);
+ if(l_node_client) {
+ pthread_mutex_lock(&l_node_client->wait_mutex);
+ l_node_client->state = NODE_CLIENT_STATE_CONNECTED;
+ if ( l_node_client->callback_connected )
+ l_node_client->callback_connected(l_node_client,a_arg);
+ pthread_cond_signal(&l_node_client->wait_cond);
+ pthread_mutex_unlock(&l_node_client->wait_mutex);
}
}
@@ -295,7 +295,7 @@ int dap_chain_node_client_send_chain_net_request(dap_chain_node_client_t *a_clie
* waited_state state which we will wait, sample NODE_CLIENT_STATE_CONNECT or NODE_CLIENT_STATE_SENDED
* return -1 false, 0 timeout, 1 end of connection or sending data
*/
-int chain_node_client_wait(dap_chain_node_client_t *a_client, int a_waited_state, int timeout_ms)
+int dap_chain_node_client_wait(dap_chain_node_client_t *a_client, int a_waited_state, int timeout_ms)
{
int ret = -1;
if(!a_client)
diff --git a/dap_chain_node_client.h b/dap_chain_node_client.h
index a9fd376732a8c113d9266b97cd66ffebceb32b9a..46158cf7338ee393bbc0d54b6c265c7a1c7485a9 100644
--- a/dap_chain_node_client.h
+++ b/dap_chain_node_client.h
@@ -57,7 +57,7 @@ typedef struct dap_chain_node_client {
dap_client_t *client;
dap_events_t *events;
- dap_chain_node_client_callback_t callback_stream_connected;
+ dap_chain_node_client_callback_t callback_connected;
pthread_cond_t wait_cond;
pthread_mutex_t wait_mutex;
uint8_t *recv_data;
@@ -102,5 +102,5 @@ int dap_chain_node_client_send_chain_net_request(dap_chain_node_client_t *a_clie
* waited_state state which we will wait, sample NODE_CLIENT_STATE_CONNECT or NODE_CLIENT_STATE_SENDED
* return -1 false, 0 timeout, 1 end of connection or sending data
*/
-int chain_node_client_wait(dap_chain_node_client_t *client, dap_chain_node_client_state_t waited_state, int timeout_ms);
+int dap_chain_node_client_wait(dap_chain_node_client_t *client, dap_chain_node_client_state_t waited_state, int timeout_ms);