Bump Rust toolchain to 1.57, fix lints (#1642)

* Bump Rust toolchain to 1.57

* Fix trivial lints introduced in clippy 0.1.57

* Box the value in SupervisorCmd::UpdateConfig

The clippy lint has a point: the enum may be too large to be efficiently
sent over a channel.

* Factor config errors out into a smaller error type

There's been a layering violation, the config module should use its own
smaller domain error. This gets rid of a clippy lint, too.

* Remove reload handles for tracing subscribers

They don't seem to be used for anything, and this triggers a clippy
lint.

* relayer-cli: Remove trivial casts in components

modules/src/clients/ics07_tendermint/client_def.rs

@@ -29,19 +29,11 @@ use crate::Height;
 
 use crate::downcast;
 
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
 pub struct TendermintClient {
     verifier: ProdVerifier,
 }
 
-impl Default for TendermintClient {
-    fn default() -> Self {
-        Self {
-            verifier: ProdVerifier::default(),
-        }
-    }
-}
-
 impl ClientDef for TendermintClient {
     type Header = Header;
     type ClientState = ClientState;

modules/src/core/ics03_connection/connection.rs

@@ -235,23 +235,13 @@ impl ConnectionEnd {
     }
 }
 
-#[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
 pub struct Counterparty {
     client_id: ClientId,
     pub connection_id: Option<ConnectionId>,
     prefix: CommitmentPrefix,
 }
 
-impl Default for Counterparty {
-    fn default() -> Self {
-        Counterparty {
-            client_id: Default::default(),
-            connection_id: None,
-            prefix: Default::default(),
-        }
-    }
-}
-
 impl Protobuf<RawCounterparty> for Counterparty {}
 
 // Converts from the wire format RawCounterparty. Typically used from the relayer side

modules/src/core/ics03_connection/events.rs

@@ -71,7 +71,7 @@ fn extract_attributes_from_tx(event: &tendermint::abci::Event) -> Result<Attribu
     Ok(attr)
 }
 
-#[derive(Debug, Deserialize, Serialize, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Debug, Default, Deserialize, Serialize, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct Attributes {
     pub height: Height,
     pub connection_id: Option<ConnectionId>,
@@ -80,18 +80,6 @@ pub struct Attributes {
     pub counterparty_client_id: ClientId,
 }
 
-impl Default for Attributes {
-    fn default() -> Self {
-        Attributes {
-            height: Default::default(),
-            connection_id: Default::default(),
-            client_id: Default::default(),
-            counterparty_connection_id: Default::default(),
-            counterparty_client_id: Default::default(),
-        }
-    }
-}
-
 /// Convert attributes to Tendermint ABCI tags
 ///
 /// # Note

modules/src/core/ics04_channel/channel.rs

@@ -244,21 +244,12 @@ impl ChannelEnd {
     }
 }
 
-#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
 pub struct Counterparty {
     pub port_id: PortId,
     pub channel_id: Option<ChannelId>,
 }
 
-impl Default for Counterparty {
-    fn default() -> Self {
-        Counterparty {
-            port_id: Default::default(),
-            channel_id: None,
-        }
-    }
-}
-
 impl Counterparty {
     pub fn new(port_id: PortId, channel_id: Option<ChannelId>) -> Self {
         Self {

modules/src/core/ics04_channel/events.rs

@@ -180,7 +180,7 @@ fn extract_packet_and_write_ack_from_tx(
     Ok((packet, write_ack))
 }
 
-#[derive(Debug, Deserialize, Serialize, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Debug, Default, Deserialize, Serialize, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct Attributes {
     pub height: Height,
     pub port_id: PortId,
@@ -199,19 +199,6 @@ impl Attributes {
     }
 }
 
-impl Default for Attributes {
-    fn default() -> Self {
-        Attributes {
-            height: Default::default(),
-            port_id: Default::default(),
-            channel_id: Default::default(),
-            connection_id: Default::default(),
-            counterparty_port_id: Default::default(),
-            counterparty_channel_id: Default::default(),
-        }
-    }
-}
-
 /// Convert attributes to Tendermint ABCI tags
 ///
 /// # Note

modules/src/core/ics04_channel/packet.rs

@@ -54,15 +54,11 @@ impl core::fmt::Display for PacketMsgType {
 }
 
 /// The sequence number of a packet enforces ordering among packets from the same source.
-#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, Deserialize, Serialize, PartialOrd, Ord)]
+#[derive(
+    Copy, Clone, Debug, Default, PartialEq, Eq, Hash, PartialOrd, Ord, Deserialize, Serialize,
+)]
 pub struct Sequence(u64);
 
-impl Default for Sequence {
-    fn default() -> Self {
-        Sequence(0)
-    }
-}
-
 impl FromStr for Sequence {
     type Err = Error;
 

modules/src/timestamp.rs

@@ -20,7 +20,7 @@ pub const ZERO_DURATION: Duration = Duration::from_secs(0);
 /// a `u64` value and a raw timestamp. In protocol buffer, the timestamp is
 /// represented as a `u64` Unix timestamp in nanoseconds, with 0 representing the absence
 /// of timestamp.
-#[derive(PartialEq, Eq, Copy, Clone, Debug, Deserialize, Serialize, Hash)]
+#[derive(PartialEq, Eq, Copy, Clone, Debug, Default, Deserialize, Serialize, Hash)]
 pub struct Timestamp {
     time: Option<DateTime<Utc>>,
 }
@@ -241,12 +241,6 @@ impl From<Time> for Timestamp {
     }
 }
 
-impl Default for Timestamp {
-    fn default() -> Self {
-        Timestamp { time: None }
-    }
-}
-
 pub mod util {
 
     const NANOS_PER_SEC: u64 = 1_000_000_000;

relayer-cli/src/components.rs

@@ -1,41 +1,21 @@
-use std::io;
-
 use abscissa_core::{Component, FrameworkError, FrameworkErrorKind};
-use tracing_subscriber::{
-    filter::EnvFilter,
-    fmt::{
-        format::{DefaultFields, Format, Full, Json, JsonFields},
-        time::SystemTime,
-        Formatter as TracingFormatter,
-    },
-    reload::Handle,
-    util::SubscriberInitExt,
-    FmtSubscriber,
-};
+use tracing_subscriber::{filter::EnvFilter, util::SubscriberInitExt, FmtSubscriber};
 
 use ibc_relayer::config::GlobalConfig;
 
 use crate::config::Error;
 
-/// Custom types to simplify the `Tracing` definition below
-type JsonFormatter = TracingFormatter<JsonFields, Format<Json, SystemTime>, StdWriter>;
-type PrettyFormatter = TracingFormatter<DefaultFields, Format<Full, SystemTime>, StdWriter>;
-type StdWriter = fn() -> io::Stderr;
-
 /// A custom component for parametrizing `tracing` in the relayer.
 /// Primarily used for:
 ///
 /// - Customizing the log output level, for filtering the output produced via tracing macros
 ///   (`debug!`, `info!`, etc.) or abscissa macros (`status_err`, `status_info`, etc.).
 /// - Enabling JSON-formatted output without coloring
 #[derive(Component, Debug)]
-pub struct JsonTracing {
-    filter_handle: Handle<EnvFilter, JsonFormatter>,
-}
+pub struct JsonTracing;
 
 impl JsonTracing {
     /// Creates a new [`JsonTracing`] component
-    #[allow(trivial_casts)]
     pub fn new(cfg: GlobalConfig) -> Result<Self, FrameworkError> {
         let filter = build_tracing_filter(cfg.log_level.to_string())?;
         // Note: JSON formatter is un-affected by ANSI 'color' option. Set to 'false'.
@@ -45,47 +25,38 @@ impl JsonTracing {
         let builder = FmtSubscriber::builder()
             .with_target(false)
             .with_env_filter(filter)
-            .with_writer(std::io::stderr as StdWriter)
+            .with_writer(std::io::stderr)
             .with_ansi(use_color)
             .with_thread_ids(true)
-            .json()
-            .with_filter_reloading();
-
-        let filter_handle = builder.reload_handle();
+            .json();
 
         let subscriber = builder.finish();
         subscriber.init();
 
-        Ok(Self { filter_handle })
+        Ok(Self)
     }
 }
 
 #[derive(Component, Debug)]
-pub struct PrettyTracing {
-    filter_handle: Handle<EnvFilter, PrettyFormatter>,
-}
+pub struct PrettyTracing;
 
 impl PrettyTracing {
     /// Creates a new [`PrettyTracing`] component
-    #[allow(trivial_casts)]
     pub fn new(cfg: GlobalConfig) -> Result<Self, FrameworkError> {
         let filter = build_tracing_filter(cfg.log_level.to_string())?;
 
         // Construct a tracing subscriber with the supplied filter and enable reloading.
         let builder = FmtSubscriber::builder()
             .with_target(false)
             .with_env_filter(filter)
-            .with_writer(std::io::stderr as StdWriter)
+            .with_writer(std::io::stderr)
             .with_ansi(enable_ansi())
-            .with_thread_ids(true)
-            .with_filter_reloading();
-
-        let filter_handle = builder.reload_handle();
+            .with_thread_ids(true);
 
         let subscriber = builder.finish();
         subscriber.init();
 
-        Ok(Self { filter_handle })
+        Ok(Self)
     }
 }
 

relayer/src/config.rs

@@ -1,5 +1,6 @@
 //! Relayer configuration
 
+mod error;
 mod proof_specs;
 pub mod reload;
 pub mod types;
@@ -18,9 +19,10 @@ use ibc::core::ics24_host::identifier::{ChainId, ChannelId, PortId};
 use ibc::timestamp::ZERO_DURATION;
 
 use crate::config::types::{MaxMsgNum, MaxTxSize, Memo};
-use crate::error::Error;
 use crate::keyring::Store;
 
+pub use error::Error;
+
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
 pub struct GasPrice {
     pub price: f64,
@@ -286,20 +288,12 @@ impl fmt::Display for LogLevel {
     }
 }
 
-#[derive(Clone, Debug, Deserialize, Serialize)]
+#[derive(Clone, Debug, Default, Deserialize, Serialize)]
 #[serde(default, deny_unknown_fields)]
 pub struct GlobalConfig {
     pub log_level: LogLevel,
 }
 
-impl Default for GlobalConfig {
-    fn default() -> Self {
-        Self {
-            log_level: LogLevel::default(),
-        }
-    }
-}
-
 #[derive(Clone, Debug, Deserialize, Serialize)]
 #[serde(deny_unknown_fields)]
 pub struct TelemetryConfig {
@@ -411,9 +405,9 @@ pub struct ChainConfig {
 
 /// Attempt to load and parse the TOML config file as a `Config`.
 pub fn load(path: impl AsRef<Path>) -> Result<Config, Error> {
-    let config_toml = std::fs::read_to_string(&path).map_err(Error::config_io)?;
+    let config_toml = std::fs::read_to_string(&path).map_err(Error::io)?;
 
-    let config = toml::from_str::<Config>(&config_toml[..]).map_err(Error::config_decode)?;
+    let config = toml::from_str::<Config>(&config_toml[..]).map_err(Error::decode)?;
 
     Ok(config)
 }
@@ -425,16 +419,16 @@ pub fn store(config: &Config, path: impl AsRef<Path>) -> Result<(), Error> {
     } else {
         File::create(path)
     }
-    .map_err(Error::config_io)?;
+    .map_err(Error::io)?;
 
     store_writer(config, &mut file)
 }
 
 /// Serialize the given `Config` as TOML to the given writer.
 pub(crate) fn store_writer(config: &Config, mut writer: impl Write) -> Result<(), Error> {
-    let toml_config = toml::to_string_pretty(&config).map_err(Error::config_encode)?;
+    let toml_config = toml::to_string_pretty(&config).map_err(Error::encode)?;
 
-    writeln!(writer, "{}", toml_config).map_err(Error::config_io)?;
+    writeln!(writer, "{}", toml_config).map_err(Error::io)?;
 
     Ok(())
 }

relayer/src/config/error.rs

@@ -0,0 +1,18 @@
+use flex_error::{define_error, TraceError};
+
+define_error! {
+    Error {
+        Io
+            [ TraceError<std::io::Error> ]
+            |_| { "config I/O error" },
+
+        Decode
+            [ TraceError<toml::de::Error> ]
+            |_| { "invalid configuration" },
+
+        Encode
+            [ TraceError<toml::ser::Error> ]
+            |_| { "invalid configuration" },
+
+    }
+}

relayer/src/config/reload.rs

@@ -20,7 +20,7 @@ use super::{ChainConfig, Config};
 #[derive(Debug, Error)]
 pub enum Error {
     #[error("failed to load configuration from disk")]
-    LoadFailed(#[source] crate::error::Error),
+    LoadFailed(#[source] super::error::Error),
 
     #[error("configuration is inconsistent, did not find config for added/updated chain {0}")]
     InconsistentConfig(ChainId),
@@ -80,7 +80,7 @@ impl ConfigReload {
         for update in updates {
             if self
                 .tx_cmd
-                .send(SupervisorCmd::UpdateConfig(update))
+                .send(SupervisorCmd::UpdateConfig(Box::new(update)))
                 .is_err()
             {
                 debug!("failed to send config update to supervisor, channel is closed");

relayer/src/error.rs

@@ -39,22 +39,10 @@ use crate::sdk_error::SdkError;
 
 define_error! {
     Error {
-        ConfigIo
-            [ TraceError<std::io::Error> ]
-            |_| { "config I/O error" },
-
         Io
             [ TraceError<std::io::Error> ]
             |_| { "I/O error" },
 
-        ConfigDecode
-            [ TraceError<toml::de::Error> ]
-            |_| { "invalid configuration" },
-
-        ConfigEncode
-            [ TraceError<toml::ser::Error> ]
-            |_| { "invalid configuration" },
-
         Rpc
             { url: tendermint_rpc::Url }
             [ TraceClone<TendermintRpcError> ]