github/darkfi
1
1
Fork 0
mirror of https://github.com/darkrenaissance/darkfi.git synced 2026-04-28 03:00:18 -04:00
Code Issues Packages Projects Releases Wiki Activity

darkfid2: log targets cleanup

Browse Source
This commit is contained in:
aggstam
2023-07-18 19:32:52 +03:00
parent 2af5558273
commit e62faa1b75
4 changed files with 31 additions and 31 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
bin/darkfid2/src/main.rs
View File

@@ -110,10 +110,10 @@ impl Darkfid {
async_daemonize!(realmain);
async fn realmain(args: Args, ex: Arc<smol::Executor<'_>>) -> Result<()> {
info!("Initializing DarkFi node...");
info!(target: "darkfid", "Initializing DarkFi node...");
if args.testing_mode {
info!("Node is configured to run in testing mode!");
info!(target: "darkfid", "Node is configured to run in testing mode!");
}
// Initialize syncing P2P network
@@ -151,10 +151,10 @@ async fn realmain(args: Args, ex: Arc<smol::Executor<'_>>) -> Result<()> {
// Initialize node
let darkfid = Darkfid::new(sync_p2p, consensus_p2p, validator).await;
let darkfid = Arc::new(darkfid);
info!("Node initialized successfully!");
info!(target: "darkfid", "Node initialized successfully!");
// JSON-RPC server
info!("Starting JSON-RPC server");
info!(target: "darkfid", "Starting JSON-RPC server");
let _ex = ex.clone();
ex.spawn(listen_and_serve(args.rpc_listen, darkfid.clone(), _ex)).detach();
@@ -164,19 +164,19 @@ async fn realmain(args: Args, ex: Arc<smol::Executor<'_>>) -> Result<()> {
// Signal handling for graceful termination.
let (signals_handler, signals_task) = SignalHandler::new()?;
signals_handler.wait_termination(signals_task).await?;
info!("Caught termination signal, cleaning up and exiting...");
info!(target: "darkfid", "Caught termination signal, cleaning up and exiting...");
info!("Stopping syncing P2P network...");
info!(target: "darkfid", "Stopping syncing P2P network...");
darkfid.sync_p2p.stop().await;
if args.consensus {
info!("Stopping consensus P2P network...");
info!(target: "darkfid", "Stopping consensus P2P network...");
darkfid.consensus_p2p.clone().unwrap().stop().await;
}
info!("Flushing sled database...");
info!(target: "darkfid", "Flushing sled database...");
let flushed_bytes = sled_db.flush_async().await?;
info!("Flushed {} bytes", flushed_bytes);
info!(target: "darkfid", "Flushed {} bytes", flushed_bytes);
Ok(())
}

2
bin/darkfid2/src/rpc.rs
View File

@@ -40,7 +40,7 @@ impl RequestHandler for Darkfid {
let params = req.params.as_array().unwrap();
debug!(target: "RPC", "--> {}", serde_json::to_string(&req).unwrap());
debug!(target: "darkfid::rpc", "--> {}", serde_json::to_string(&req).unwrap());
match req.method.as_str() {
// =====================

12
bin/darkfid2/src/rpc_blockchain.rs
View File

@@ -61,7 +61,7 @@ impl Darkfid {
v
}
Err(e) => {
error!("[RPC] blockchain.get_slot: Failed fetching block by slot: {}", e);
error!(target: "darkfid::rpc::blockchain_get_slot", "Failed fetching block by slot: {}", e);
return JsonError::new(InternalError, None, id).into()
}
};
@@ -111,7 +111,7 @@ impl Darkfid {
txs
}
Err(e) => {
error!("[RPC] blockchain.get_tx: Failed fetching tx by hash: {}", e);
error!(target: "darkfid::rpc::blockchain_get_tx", "Failed fetching tx by hash: {}", e);
return JsonError::new(InternalError, None, id).into()
}
};
@@ -169,7 +169,7 @@ impl Darkfid {
let contract_id = match ContractId::from_str(params[0].as_str().unwrap()) {
Ok(v) => v,
Err(e) => {
error!("[RPC] blockchain.lookup_zkas: Error decoding string to ContractId: {}", e);
error!(target: "darkfid::rpc::blockchain_lookup_zkas", "Error decoding string to ContractId: {}", e);
return JsonError::new(InvalidParams, None, id).into()
}
};
@@ -182,7 +182,7 @@ impl Darkfid {
SMART_CONTRACT_ZKAS_DB_NAME,
) else {
error!(
"[RPC] blockchain.lookup_zkas: Did not find zkas db for ContractId: {}",
target: "darkfid::rpc::blockchain_lookup_zkas", "Did not find zkas db for ContractId: {}",
contract_id
);
return server_error(RpcError::ContractZkasDbNotFound, id, None)
@@ -191,9 +191,9 @@ impl Darkfid {
let mut ret: Vec<(String, Vec<u8>)> = vec![];
for i in zkas_db.iter() {
debug!("Iterating over zkas db");
debug!(target: "darkfid::rpc::blockchain_lookup_zkas", "Iterating over zkas db");
let Ok((zkas_ns, zkas_bytes)) = i else {
error!("Internal sled error iterating db");
error!(target: "darkfid::rpc::blockchain_lookup_zkas", "Internal sled error iterating db");
return JsonError::new(InternalError, None, id).into()
};

30
bin/darkfid2/src/rpc_tx.rs
View File

@@ -45,7 +45,7 @@ impl Darkfid {
}
if !(*self.synced.lock().await) {
error!("[RPC] tx.simulate: Blockchain is not synced");
error!(target: "darkfid::rpc::tx_simulate", "Blockchain is not synced");
return server_error(RpcError::NotSynced, id, None)
}
@@ -53,7 +53,7 @@ impl Darkfid {
let tx_bytes = match bs58::decode(params[0].as_str().unwrap().trim()).into_vec() {
Ok(v) => v,
Err(e) => {
error!("[RPC] tx.simulate: Failed decoding base58 transaction: {}", e);
error!(target: "darkfid::rpc::tx_simulate", "Failed decoding base58 transaction: {}", e);
return server_error(RpcError::ParseError, id, None)
}
};
@@ -61,7 +61,7 @@ impl Darkfid {
let tx: Transaction = match deserialize(&tx_bytes) {
Ok(v) => v,
Err(e) => {
error!("[RPC] tx.simulate: Failed deserializing bytes into Transaction: {}", e);
error!(target: "darkfid::rpc::tx_simulate", "Failed deserializing bytes into Transaction: {}", e);
return server_error(RpcError::ParseError, id, None)
}
};
@@ -72,7 +72,7 @@ impl Darkfid {
let result = lock.add_transactions(&[tx], current_slot, false).await;
if result.is_err() {
error!(
"[RPC] tx.simulate: Failed to validate state transition: {}",
target: "darkfid::rpc::tx_simulate", "Failed to validate state transition: {}",
result.err().unwrap()
);
return server_error(RpcError::TxSimulationFail, id, None)
@@ -95,7 +95,7 @@ impl Darkfid {
}
if !(*self.synced.lock().await) {
error!("[RPC] tx.transfer: Blockchain is not synced");
error!(target: "darkfid::rpc::tx_broadcast", "Blockchain is not synced");
return server_error(RpcError::NotSynced, id, None)
}
@@ -103,7 +103,7 @@ impl Darkfid {
let tx_bytes = match bs58::decode(params[0].as_str().unwrap().trim()).into_vec() {
Ok(v) => v,
Err(e) => {
error!("[RPC] tx.broadcast: Failed decoding base58 transaction: {}", e);
error!(target: "darkfid::rpc::tx_broadcast", "Failed decoding base58 transaction: {}", e);
return server_error(RpcError::ParseError, id, None)
}
};
@@ -111,7 +111,7 @@ impl Darkfid {
let tx: Transaction = match deserialize(&tx_bytes) {
Ok(v) => v,
Err(e) => {
error!("[RPC] tx.broadcast: Failed deserializing bytes into Transaction: {}", e);
error!(target: "darkfid::rpc::tx_broadcast", "Failed deserializing bytes into Transaction: {}", e);
return server_error(RpcError::ParseError, id, None)
}
};
@@ -120,7 +120,7 @@ impl Darkfid {
// Consider we're participating in consensus here?
// The append_tx function performs a state transition check.
if self.validator.write().await.append_tx(tx.clone()).await.is_err() {
error!("[RPC] tx.broadcast: Failed to append transaction to mempool");
error!(target: "darkfid::rpc::tx_broadcast", "Failed to append transaction to mempool");
return server_error(RpcError::TxSimulationFail, id, None)
}
} else {
@@ -130,7 +130,7 @@ impl Darkfid {
let result = lock.add_transactions(&[tx.clone()], current_slot, false).await;
if result.is_err() {
error!(
"[RPC] tx.simulate: Failed to validate state transition: {}",
target: "darkfid::rpc::tx_broadcast", "Failed to validate state transition: {}",
result.err().unwrap()
);
return server_error(RpcError::TxSimulationFail, id, None)
@@ -139,7 +139,7 @@ impl Darkfid {
self.sync_p2p.broadcast(&tx).await;
if self.sync_p2p.channels().lock().await.is_empty() {
error!("[RPC] tx.broadcast: Failed broadcasting tx, no connected channels");
error!(target: "darkfid::rpc::tx_broadcast", "Failed broadcasting tx, no connected channels");
return server_error(RpcError::TxBroadcastFail, id, None)
}
@@ -159,7 +159,7 @@ impl Darkfid {
}
if !(*self.synced.lock().await) {
error!("[RPC] tx.transfer: Blockchain is not synced");
error!(target: "darkfid::rpc::tx_pending", "Blockchain is not synced");
return server_error(RpcError::NotSynced, id, None)
}
@@ -170,7 +170,7 @@ impl Darkfid {
v
}
Err(e) => {
error!("[RPC] blockchain.get_pending_txs: Failed fetching pending txs: {}", e);
error!(target: "darkfid::rpc::tx_pending", "Failed fetching pending txs: {}", e);
return JsonError::new(InternalError, None, id).into()
}
};
@@ -190,7 +190,7 @@ impl Darkfid {
}
if !(*self.synced.lock().await) {
error!("[RPC] tx.transfer: Blockchain is not synced");
error!(target: "darkfid::rpc::tx_clean_pending", "Blockchain is not synced");
return server_error(RpcError::NotSynced, id, None)
}
@@ -198,7 +198,7 @@ impl Darkfid {
let pending_txs = match validator.blockchain.get_pending_txs() {
Ok(v) => v,
Err(e) => {
error!("[RPC] blockchain.get_pending_txs: Failed fetching pending txs: {}", e);
error!(target: "darkfid::rpc::tx_clean_pending", "Failed fetching pending txs: {}", e);
return JsonError::new(InternalError, None, id).into()
}
};
@@ -206,7 +206,7 @@ impl Darkfid {
match validator.blockchain.remove_pending_txs(&pending_txs) {
Ok(()) => drop(validator),
Err(e) => {
error!("[RPC] blockchain.get_pending_txs: Failed fetching pending txs: {}", e);
error!(target: "darkfid::rpc::tx_clean_pending", "Failed fetching pending txs: {}", e);
return JsonError::new(InternalError, None, id).into()
}
};