Merge pull request #214 from alan-turing-institute/206-cli-status

CLI status command

Author: thobson88

crates/trustchain-cli/src/bin/main.rs

@@ -13,7 +13,7 @@ use trustchain_api::{
     api::{TrustchainDIDAPI, TrustchainDataAPI, TrustchainVCAPI},
     TrustchainAPI,
 };
-use trustchain_cli::config::cli_config;
+use trustchain_cli::{config::cli_config, print_status};
 use trustchain_core::{
     utils::extract_keys,
     vc::{CredentialError, DataCredentialError},
@@ -44,6 +44,13 @@ fn cli() -> Command {
         .subcommand_required(true)
         .arg_required_else_help(true)
         .allow_external_subcommands(true)
+        .subcommand(
+            Command::new("status")
+                .about("Trustchain node status.")
+                .subcommand_required(false)
+                .arg_required_else_help(false)
+                .allow_external_subcommands(false)
+        )
         .subcommand(
             Command::new("did")
                 .about("DID functionality: create, attest, resolve, verify.")
@@ -125,7 +132,7 @@ fn cli() -> Command {
         )
         .subcommand(
             Command::new("cr")
-                .about("Challenge-response functionality for attestation challenge response process (identity and content challenge-response).")
+                .about("Challenge-response functionality for downstream DID attestation.")
                 .subcommand_required(true)
                 .arg_required_else_help(true)
                 .allow_external_subcommands(true)
@@ -189,6 +196,9 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let resolver = verifier.resolver();
     let mut context_loader = ContextLoader::default();
     match matches.subcommand() {
+        Some(("status", _)) => {
+            print_status().await;
+        }
         Some(("did", sub_matches)) => {
             match sub_matches.subcommand() {
                 Some(("create", sub_matches)) => {

crates/trustchain-cli/src/lib.rs

@@ -1 +1,71 @@
+use config::cli_config;
+use trustchain_ion::{
+    utils::{bitcoind_status, ion_ok, ipfs_ok, mongodb_ok, BitcoindStatus},
+    TrustchainBitcoinError,
+};
+
 pub mod config;
+
+/// Prints the current status of ION and its dependencies.
+pub async fn print_status() {
+    let str = "IPFS......... ".to_string();
+    let msg = Some("IPFS daemon not found");
+    println!("{}", status_str(str, ipfs_ok().await, msg));
+
+    // Check bitcoind status to determine network (mainnet or testnet).
+    let bitcoind_status = bitcoind_status().await;
+    let bitcoin_str = "Bitcoin...... ".to_string();
+    match bitcoind_status {
+        BitcoindStatus::Ok(network) => {
+            let mongo_str = "MongoDB...... ".to_string();
+            let msg = Some("Mongo daemon not found");
+            println!("{}", status_str(mongo_str, mongodb_ok(&network).await, msg));
+
+            println!("{}", status_str(bitcoin_str, true, None));
+
+            let ion_str = "ION.......... ".to_string();
+            let msg = Some("ION DID resolution attempt failed");
+            let is_ok = ion_ok(&network, cli_config().ion_endpoint.port).await;
+            println!("{}", status_str(ion_str, is_ok, msg));
+        }
+        BitcoindStatus::Synching(blocks, headers) => {
+            let msg = Some(format!("Synching blocks: {}/{}", blocks, headers));
+            println!("{}", status_str(bitcoin_str, false, msg.as_deref()));
+        }
+        BitcoindStatus::Error(e) => {
+            let msg = match e {
+                err @ TrustchainBitcoinError::BitcoinCoreRPCError(_) => err.to_string(),
+                _ => "Bitcoin RPC returned an error".to_string(),
+            };
+            println!("{}", status_str(bitcoin_str, false, Some(&msg)));
+        }
+        BitcoindStatus::UnexpectedNetwork(network) => {
+            let msg = Some(format!(
+                "Trustchain is not configured for network: {}",
+                network.to_string()
+            ));
+            println!("{}", status_str(bitcoin_str, false, msg.as_deref()));
+        }
+        BitcoindStatus::UnsupportedNetwork(network) => {
+            let msg = Some(format!(
+                "Trustchain does not support network: {}",
+                network.to_string()
+            ));
+            println!("{}", status_str(bitcoin_str, false, msg.as_deref()));
+        }
+    };
+}
+
+pub fn status_str(mut str: String, is_ok: bool, details: Option<&str>) -> String {
+    if is_ok {
+        str.push_str("✅");
+        return str;
+    }
+    str.push_str("❌");
+    if let Some(detail) = details {
+        str.push_str(" [");
+        str.push_str(detail);
+        str.push_str("]");
+    }
+    str
+}

crates/trustchain-ion/src/data.rs

@@ -1,8 +1,29 @@
 //! Test fixtures for crate.
 #![allow(dead_code)]
 
+use bitcoin::Network;
+
+use crate::TrustchainBitcoinError;
+
+pub(crate) const SAMPLE_CID: &str = "QmRvgZm4J3JSxfk4wRjE2u2Hi2U7VmobYnpqhqH5QP6J97";
+pub(crate) const SAMPLE_DID_MAINNET: &str =
+    "did:ion:EiClkZMDxPKqC9c-umQfTkR8vvZ9JPhl_xLDI9Nfk38w5w";
+pub(crate) const SAMPLE_DID_TESTNET3: &str =
+    "did:ion:test:EiCClfEdkTv_aM3UnBBhlOV89LlGhpQAbfeZLFdFxVFkEg";
+pub(crate) const SAMPLE_DID_TESTNET4: &str =
+    "did:ion:test:EiDnaq8k5I4xGy1NjKZkNgcFwNt1Jm6mLm0TVVes7riyMA";
+
+pub fn sample_did(network: &Network) -> Result<String, TrustchainBitcoinError> {
+    match network {
+        Network::Bitcoin => Ok(SAMPLE_DID_MAINNET.to_string()),
+        Network::Testnet => Ok(SAMPLE_DID_TESTNET3.to_string()),
+        Network::Testnet4 => Ok(SAMPLE_DID_TESTNET4.to_string()),
+        _ => Err(TrustchainBitcoinError::UnsupportedNetwork(*network)),
+    }
+}
+
 //
-// Testnet fixtures
+// Testnet3 fixtures
 //
 
 // Note on Testnet test fixtures (see below for Testnet4 fixtures):

crates/trustchain-ion/src/lib.rs

@@ -165,6 +165,9 @@ pub enum TrustchainBitcoinError {
     /// Target date precedes start block timestamp or succeeds end block timestamp.
     #[error("Target date out of range of block timestamps.")]
     TargetDateOutOfRange,
+    /// Unsupported Bitcoin network.
+    #[error("Unsupported Bitcoin network: {0}")]
+    UnsupportedNetwork(Network),
 }
 
 // DID

crates/trustchain-ion/src/utils.rs

@@ -1,13 +1,14 @@
 //! ION-related utilities.
+use crate::data::{sample_did, SAMPLE_CID};
 use crate::data::{
     TESTNET3_TEST_ROOT_PLUS_1_SIGNING_KEY, TESTNET3_TEST_ROOT_PLUS_2_SIGNING_KEYS,
     TESTNET4_TEST_ROOT_PLUS_1_SIGNING_KEY, TESTNET4_TEST_ROOT_PLUS_2_SIGNING_KEYS,
 };
 use crate::{
     config::ion_config, MONGO_FILTER_OP_INDEX, MONGO_FILTER_TXN_NUMBER, MONGO_FILTER_TXN_TIME,
 };
-use bitcoin::Network;
-use bitcoin::{block::Header, blockdata::block::BlockHash, Transaction};
+use bitcoin::{block::Header, blockdata::block::BlockHash, Network, Transaction};
+use bitcoincore_rpc::json::GetBlockchainInfoResult;
 use bitcoincore_rpc::{bitcoincore_rpc_json::BlockStatsFields, RpcApi};
 use chrono::NaiveDate;
 use flate2::read::GzDecoder;
@@ -23,13 +24,15 @@ use std::path::Path;
 use std::sync::Once;
 use std::{cmp::Ordering, collections::HashMap};
 use trustchain_core::key_manager::{KeyManager, KeyType};
+use trustchain_core::resolver::TrustchainResolver;
 use trustchain_core::TRUSTCHAIN_DATA;
 use trustchain_core::{utils::get_did_suffix, verifier::VerifierError};
 
 use crate::{
-    TrustchainBitcoinError, TrustchainIpfsError, TrustchainMongodbError, BITS_KEY,
-    HASH_PREV_BLOCK_KEY, MERKLE_ROOT_KEY, MONGO_COLLECTION_OPERATIONS, MONGO_CREATE_OPERATION,
-    MONGO_FILTER_DID_SUFFIX, MONGO_FILTER_TYPE, NONCE_KEY, TIMESTAMP_KEY, VERSION_KEY,
+    trustchain_resolver, TrustchainBitcoinError, TrustchainIpfsError, TrustchainMongodbError,
+    BITS_KEY, HASH_PREV_BLOCK_KEY, MERKLE_ROOT_KEY, MONGO_COLLECTION_OPERATIONS,
+    MONGO_CREATE_OPERATION, MONGO_FILTER_DID_SUFFIX, MONGO_FILTER_TYPE, NONCE_KEY, TIMESTAMP_KEY,
+    VERSION_KEY,
 };
 
 const ION_METHOD_WITH_DELIMITER: &str = "ion:";
@@ -286,16 +289,23 @@ pub fn rpc_client() -> bitcoincore_rpc::Client {
     .unwrap()
 }
 
-/// Gets the Bitcoin chain via the RPC API.
-pub fn bitcoin_network(
+/// Gets Bitcoin blockchain info via the RPC API.
+pub fn blockchain_info(
     client: Option<&bitcoincore_rpc::Client>,
-) -> Result<Network, TrustchainBitcoinError> {
+) -> Result<GetBlockchainInfoResult, TrustchainBitcoinError> {
     // If necessary, construct a Bitcoin RPC client to communicate with the ION Bitcoin node.
     if client.is_none() {
         let rpc_client = rpc_client();
-        return bitcoin_network(Some(&rpc_client));
+        return blockchain_info(Some(&rpc_client));
     };
-    Ok(client.unwrap().get_blockchain_info()?.chain)
+    Ok(client.unwrap().get_blockchain_info()?)
+}
+
+/// Gets the Bitcoin chain via the RPC API.
+pub fn bitcoin_network(
+    client: Option<&bitcoincore_rpc::Client>,
+) -> Result<Network, TrustchainBitcoinError> {
+    Ok(blockchain_info(client)?.chain)
 }
 
 /// Gets a Bitcoin block header via the RPC API.
@@ -522,6 +532,76 @@ pub fn block_height_range_on_date(
     Ok((first_block, last_block))
 }
 
+#[derive(Debug)]
+pub enum BitcoindStatus {
+    Ok(Network),
+    Synching(u64, u64),
+    UnexpectedNetwork(Network),
+    UnsupportedNetwork(Network),
+    Error(TrustchainBitcoinError),
+}
+
+/// Returns the current status of bitcoind.
+pub async fn bitcoind_status() -> BitcoindStatus {
+    let info = blockchain_info(None);
+    if info.is_err() {
+        return BitcoindStatus::Error(info.err().unwrap());
+    }
+    let info = info.unwrap();
+    if info.blocks != info.headers {
+        return BitcoindStatus::Synching(info.blocks, info.headers);
+    }
+    let ion_core_config = &ion_config().mongo_database_ion_core;
+    match info.chain {
+        Network::Bitcoin => {
+            if ion_core_config.contains("testnet") {
+                return BitcoindStatus::UnexpectedNetwork(info.chain);
+            }
+            BitcoindStatus::Ok(Network::Bitcoin)
+        }
+        Network::Testnet => {
+            if ion_core_config.contains("mainnet") {
+                return BitcoindStatus::UnexpectedNetwork(info.chain);
+            }
+            BitcoindStatus::Ok(Network::Testnet)
+        }
+        Network::Testnet4 => {
+            if ion_core_config.contains("mainnet") {
+                return BitcoindStatus::UnexpectedNetwork(info.chain);
+            }
+            BitcoindStatus::Ok(Network::Testnet4)
+        }
+        _ => BitcoindStatus::UnsupportedNetwork(info.chain),
+    }
+}
+
+/// Returns true if the IPFS daemon is running on the expected port.
+pub async fn ipfs_ok() -> bool {
+    query_ipfs(SAMPLE_CID, &IpfsClient::default()).await.is_ok()
+}
+
+/// Returns true if the MongoDB daemon is running on the expected port.
+pub async fn mongodb_ok(network: &Network) -> bool {
+    if let Ok(sample_did) = sample_did(network) {
+        query_mongodb(get_did_suffix(&sample_did)).await.is_ok()
+    } else {
+        // If the given Bitcoin network is unsupported, return false.
+        false
+    }
+}
+
+/// Returns true if the ION Core microservice is running on the expected port.
+pub async fn ion_ok(network: &Network, ion_port: u16) -> bool {
+    let resolver = trustchain_resolver(&format!("http://localhost:{}/", ion_port));
+    if let Ok(sample_did) = sample_did(network) {
+        let result = resolver.resolve_as_result(&sample_did).await;
+        result.is_ok()
+    } else {
+        // If the given Bitcoin network is unsupported, return false.
+        false
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -1104,4 +1184,10 @@ mod tests {
             }
         }
     }
+
+    #[tokio::test]
+    #[ignore = "Integration test requires Bitcoin"]
+    async fn test_bitcoind_status() {
+        let _ = bitcoind_status().await;
+    }
 }