Hermes: replace default JSON with human-readable output

ci/simple_config.toml

@@ -2,6 +2,7 @@
 timeout = '10s'
 strategy = 'naive'
 log_level = 'info'
+log_json = false
 
 [[chains]]
 id = 'ibc-0'

config.toml

@@ -2,6 +2,7 @@
 timeout = '10s'
 strategy = 'naive'
 log_level = 'error'
+log_json = false
 
 [[chains]]
 id = 'ibc-0'

config_example.toml

@@ -2,6 +2,7 @@
 timeout = '10s'
 strategy = 'naive'
 log_level = 'error'
+log_json = false
 
 [[chains]]
 id = 'ibc-0'

relayer-cli/Cargo.toml

@@ -13,7 +13,6 @@ authors = [
 
 description = """
     Implementation of `hermes`, an IBC Relayer developed in Rust.
-    This crate is a CLI wrapper over the `ibc-relayer` library.
 """
 
 [[bin]]

relayer-cli/src/application.rs

@@ -1,15 +1,16 @@
 //! Cli Abscissa Application
 
-use crate::components::Tracing;
-use crate::{commands::CliCmd, config::Config};
-
 use abscissa_core::terminal::component::Terminal;
 use abscissa_core::{
     application::{self, AppCell},
     component::Component,
-    config, trace, Application, Configurable, EntryPoint, FrameworkError, StandardPaths,
+    config, trace, Application, Configurable, FrameworkError, StandardPaths,
 };
 
+use crate::components::Tracing;
+use crate::entry::EntryPoint;
+use crate::{commands::CliCmd, config::Config};
+
 /// Application state
 pub static APPLICATION: AppCell<CliApp> = AppCell::new();
 
@@ -116,17 +117,12 @@ impl Application for CliApp {
             .transpose()?
             .unwrap_or_default();
 
-        // For `start` and `start-multi` commands exclusively we disable JSON; otherwise output is JSON-only
-        let json_on = if let Some(c) = &command.command {
-            !matches!(c, CliCmd::Start(_) | CliCmd::StartMulti(_))
-        } else {
-            true
-        };
-
-        if json_on {
+        if command.json {
+            // Enable JSON by using the crate-level `Tracing`
             let tracing = Tracing::new(config.global)?;
             Ok(vec![Box::new(terminal), Box::new(tracing)])
         } else {
+            // Use abscissa's tracing, which pretty-prints to the terminal obeying log levels
             let alt_tracing = abscissa_core::trace::Tracing::new(
                 abscissa_core::trace::Config::from(config.global.log_level),
                 abscissa_core::terminal::ColorChoice::Auto,
@@ -136,12 +132,9 @@ impl Application for CliApp {
         }
     }
 
-    /// Get tracing configuration from command-line options
+    // This method used to be called from `framework_components`, no longer relevant since we
+    // customized the framework.
     fn tracing_config(&self, command: &EntryPoint<CliCmd>) -> trace::Config {
-        if command.verbose {
-            trace::Config::verbose()
-        } else {
-            trace::Config::default()
-        }
+        unimplemented!()
     }
 }

relayer-cli/src/commands.rs

@@ -8,6 +8,7 @@
 use std::path::PathBuf;
 
 use abscissa_core::{Command, Configurable, FrameworkError, Help, Options, Runnable};
+use tracing::info;
 
 use crate::config::Config;
 
@@ -31,6 +32,7 @@ mod version;
 
 /// Default configuration file path
 pub fn default_config_file() -> Option<PathBuf> {
+    info!("Using default configuration from: '.hermes/config.toml'");
     dirs_next::home_dir().map(|home| home.join(".hermes/config.toml"))
 }
 

relayer-cli/src/components.rs

@@ -1,5 +1,4 @@
 use abscissa_core::{Component, FrameworkError};
-use ibc_relayer::config::GlobalConfig;
 use tracing_subscriber::fmt::{
     format::{Format, Json, JsonFields},
     time::SystemTime,
@@ -8,6 +7,8 @@ use tracing_subscriber::fmt::{
 use tracing_subscriber::util::SubscriberInitExt;
 use tracing_subscriber::{reload::Handle, EnvFilter, FmtSubscriber};
 
+use ibc_relayer::config::GlobalConfig;
+
 /// Abscissa component for initializing the `tracing` subsystem
 #[derive(Component, Debug)]
 pub struct Tracing {

relayer-cli/src/conclude.rs

@@ -55,7 +55,7 @@
 //! Output::success(h).with_result(end).exit();
 //! ```
 
-use std::fmt::Display;
+use std::fmt;
 
 use serde::Serialize;
 use tracing::error;
@@ -65,7 +65,6 @@ use tracing::error;
 /// ## Note: See `Output::exit()` for the preferred method of exiting a relayer command.
 pub fn exit_with(out: Output) {
     // Handle the output message
-    // TODO: To unify all relayer output, consider replacing `println` with a `tracing` macro below.
     println!("{}", serde_json::to_string(&out).unwrap());
 
     // The return code
@@ -93,7 +92,7 @@ pub fn exit_with(out: Output) {
 /// let client_a = ForeignClient::new(chains.src.clone(), chains.dst.clone())
 ///     .unwrap_or_else(exit_with_unrecoverable_error);
 /// ```
-pub fn exit_with_unrecoverable_error<T, E: Display>(err: E) -> T {
+pub fn exit_with_unrecoverable_error<T, E: fmt::Display>(err: E) -> T {
     // TODO(@romac): Once never (!) stabilizes, adapt `Output::exit` to return !
     //  https://github.com/informalsystems/ibc-rs/pull/688#discussion_r583758439
     Output::error(format!("{}", err)).exit();
@@ -183,3 +182,12 @@ pub enum Status {
     #[serde(rename(serialize = "error"))]
     Error,
 }
+
+impl fmt::Display for Status {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Status::Success => write!(f, "Success"),
+            Status::Error => write!(f, "Error"),
+        }
+    }
+}

relayer-cli/src/entry.rs

@@ -0,0 +1,109 @@
+use std::path::PathBuf;
+
+use abscissa_core::command::Usage;
+use abscissa_core::{Command, Config, Configurable, FrameworkError, Options, Runnable};
+
+/// Custom entry point for Hermes.
+///
+/// Replaces `abscissa_core::EntryPoint` with custom-made flag (for JSON output).
+#[derive(Debug, Options)]
+pub struct EntryPoint<Cmd>
+where
+    Cmd: Command + Runnable,
+{
+    /// Path to the configuration file
+    #[options(short = "c", help = "path to configuration file")]
+    pub config: Option<PathBuf>,
+
+    /// Obtain help about the current command
+    #[options(short = "h", help = "print help message")]
+    pub help: bool,
+
+    /// Toggle JSON output mode one verbosity setting
+    #[options(short = "j", help = "enable JSON output")]
+    pub json: bool,
+
+    /// Subcommand to execute.
+    ///
+    /// The `command` option will delegate option parsing to the command type,
+    /// starting at the first free argument.
+    #[options(command)]
+    pub command: Option<Cmd>,
+}
+
+impl<Cmd> EntryPoint<Cmd>
+where
+    Cmd: Command + Runnable,
+{
+    /// Borrow the underlying command type or print usage info and exit
+    fn command(&self) -> &Cmd {
+        self.command
+            .as_ref()
+            .unwrap_or_else(|| Cmd::print_usage_and_exit(&[]))
+    }
+}
+
+impl<Cmd> Runnable for EntryPoint<Cmd>
+where
+    Cmd: Command + Runnable,
+{
+    fn run(&self) {
+        self.command().run()
+    }
+}
+
+impl<Cmd> Command for EntryPoint<Cmd>
+where
+    Cmd: Command + Runnable,
+{
+    /// Name of this program as a string
+    fn name() -> &'static str {
+        "hermes"
+    }
+
+    /// Description of this program
+    fn description() -> &'static str {
+        Cmd::description()
+    }
+
+    /// Version of this program
+    fn version() -> &'static str {
+        Cmd::version()
+    }
+
+    /// Authors of this program
+    fn authors() -> &'static str {
+        Cmd::authors()
+    }
+
+    /// Get usage information for a particular subcommand (if available)
+    fn subcommand_usage(command: &str) -> Option<Usage> {
+        Cmd::subcommand_usage(command)
+    }
+}
+
+impl<Cfg, Cmd> Configurable<Cfg> for EntryPoint<Cmd>
+where
+    Cmd: Command + Configurable<Cfg> + Runnable,
+    Cfg: Config,
+{
+    /// Path to the command's configuration file
+    fn config_path(&self) -> Option<PathBuf> {
+        match &self.config {
+            // Use explicit `-c`/`--config` argument if passed
+            Some(cfg) => Some(cfg.clone()),
+
+            // Otherwise defer to the toplevel command's config path logic
+            None => self.command.as_ref().and_then(|cmd| cmd.config_path()),
+        }
+    }
+
+    /// Process the configuration after it has been loaded, potentially
+    /// modifying it or returning an error if options are incompatible
+    fn process_config(&self, config: Cfg) -> Result<Cfg, FrameworkError> {
+        match &self.command {
+            Some(cmd) => cmd.process_config(config),
+            None => Ok(config),
+        }
+    }
+}

relayer-cli/src/lib.rs

@@ -26,3 +26,4 @@ pub mod registry;
 pub(crate) mod cli_utils;
 pub(crate) mod components;
 pub(crate) mod conclude;
+pub(crate) mod entry;

relayer/tests/config/fixtures/relayer_conf_example.toml

@@ -2,6 +2,7 @@
 timeout = '10s'
 strategy = 'naive'
 log_level = 'error'
+log_json = false
 
 [[chains]]
 id = 'chain_A'