//! A relay binary used to join the Tor network to relay anonymous communication.

//!

//! NOTE: This binary is still highly experimental as in active development, not stable and

//! without any type of guarantee of running or even working.

//!

//! ## Error handling

//!

//! We return [`anyhow::Error`] for functions whose errors will always result in an exit and don't

//! need to be handled individually.

//! When we do need to handle errors, functions should return a more comprehensive error type (for

//! example one created with `thiserror`).

// @@ begin lint list maintained by maint/add_warning @@

#![allow(renamed_and_removed_lints)] // @@REMOVE_WHEN(ci_arti_stable)

#![allow(unknown_lints)] // @@REMOVE_WHEN(ci_arti_nightly)

#![warn(missing_docs)]

#![warn(noop_method_call)]

#![warn(unreachable_pub)]

#![warn(clippy::all)]

#![deny(clippy::await_holding_lock)]

#![deny(clippy::cargo_common_metadata)]

#![deny(clippy::cast_lossless)]

#![deny(clippy::checked_conversions)]

#![allow(clippy::cognitive_complexity)] // See arti#2556

#![deny(clippy::debug_assert_with_mut_call)]

#![deny(clippy::exhaustive_enums)]

#![deny(clippy::exhaustive_structs)]

#![deny(clippy::expl_impl_clone_on_copy)]

#![deny(clippy::fallible_impl_from)]

#![deny(clippy::implicit_clone)]

#![deny(clippy::large_stack_arrays)]

#![warn(clippy::manual_ok_or)]

#![deny(clippy::missing_docs_in_private_items)]

#![warn(clippy::needless_borrow)]

#![warn(clippy::needless_pass_by_value)]

#![warn(clippy::option_option)]

#![deny(clippy::print_stderr)]

#![deny(clippy::print_stdout)]

#![warn(clippy::rc_buffer)]

#![deny(clippy::ref_option_ref)]

#![warn(clippy::semicolon_if_nothing_returned)]

#![warn(clippy::trait_duplication_in_bounds)]

#![deny(clippy::unchecked_time_subtraction)]

#![deny(clippy::unnecessary_wraps)]

#![warn(clippy::unseparated_literal_suffix)]

#![deny(clippy::unwrap_used)]

#![deny(clippy::mod_module_files)]

#![allow(clippy::let_unit_value)] // This can reasonably be done for explicitness

#![allow(clippy::uninlined_format_args)]

#![allow(clippy::significant_drop_in_scrutinee)] // arti/-/merge_requests/588/#note_2812945

#![allow(clippy::result_large_err)] // temporary workaround for arti#587

#![allow(clippy::needless_raw_string_hashes)] // complained-about code is fine, often best

#![allow(clippy::needless_lifetimes)] // See arti#1765

#![allow(mismatched_lifetime_syntaxes)] // temporary workaround for arti#2060

#![allow(clippy::collapsible_if)] // See arti#2342

#![deny(clippy::unused_async)]

#![deny(clippy::string_slice)] // See arti#2571

#![allow(recursion_depth_exceeding_limit)] // arti#2715, rust/issues/159228

//! <!-- @@ end lint list maintained by maint/add_warning @@ -->

#![allow(clippy::redundant_field_names)] // TODO beta clippy bug, rust-clippy/issues/17525

/// Dummy module

///

/// TODO MSRV 1.100, change this to `[lints.cargo]` in `Cargo.toml`.

/// See <https://github.com/rust-lang/cargo/issues/17461>.

#[allow(unused, clippy::single_component_path_imports)]

mod _suppress_unused_crate_warnings {

    // TODO RELAY drop these suppressions (deleting the dep from Cargo.toml too if not needed)

    #[cfg(feature = "opentelemetry")]

    use {opentelemetry_appender_tracing, otlp_file_exporter, tracing_opentelemetry};

}

mod cli;

mod client;

mod config;

mod keys;

mod relay;

mod stream;

mod tasks;

mod util;

use std::io::IsTerminal as _;

use anyhow::Context;

use cfg_if::cfg_if;

use clap::Parser;

use futures::FutureExt;

use safelog::with_safe_logging_suppressed;

use tor_basic_utils::iter_join;

use tor_error::warn_report;

use tor_rtcompat::SpawnExt;

use tor_rtcompat::tokio::TokioRustlsRuntime;

use tor_rtcompat::{Runtime, ToplevelRuntime};

use tracing::{debug, info, trace, warn};

use tracing_subscriber::FmtSubscriber;

use tracing_subscriber::filter::EnvFilter;

use tracing_subscriber::util::SubscriberInitExt;

use crate::config::{DEFAULT_LOG_LEVEL, TorRelayConfig, base_resolver};

use crate::relay::InertTorRelay;

    // Will exit if '--help' used or there's a parse error.

        // TODO: Use arti_client's `HintableError` here (see `arti::main`)?

        // TODO: Why do we suppress safe logging?

        // TODO: Do we want to log the error?

        // We use anyhow's error formatting here rather than `tor_error::report_and_exit` since the

        // latter seems to omit some error info and anyhow's error formatting is nicer.

        #[allow(clippy::print_stderr)]

            // The 127 is copied from `tor_error::report_and_exit`.

            // It's unclear why 127 was chosen there.

        });

/// The real main without the error formatting.

    // Register a basic stderr logger until we have enough info to configure the main logger.

    // Unlike arti, we enable timestamps for this pre-config logger.

    // TODO: Consider using timestamps with reduced-granularity (see `LogPrecision`).

        #[allow(clippy::print_stdout)]

    }

/// Initialize and start the relay.

// Pass by value so that we don't need to clone fields, which keeps the code simpler.

#[allow(clippy::needless_pass_by_value)]

    // TODO: Warn (or exit?) if running as root; see 'arti::process::running_as_root()'.

        "Using override options: {}",

    );

    // A Mistrust object to use for loading our configuration.

    // Elsewhere, we use the value _from_ the configuration.

    } else {

    };

    // TODO: Configure a proper logger, not just a simple stderr logger.

    // TODO: We may want this to be the global logger, but if we use arti's `setup_logging` in the

    // future, it returns a `LogGuards` which we'd have no way of holding on to until the

    // application exits (see https://gitlab.torproject.org/tpo/core/arti/-/issues/1791).

                "Failed to parse console logging directive {:?}",

                config.logging.console,

            )

    // Disable safe logging if requested.

    // This guard will be dropped at the end of this function,

    // which means we effectively re-enable safe logging once this function returns.

    // TODO: Do we want this guard behaviour?

    // I think it would be better to enable safe-logging forever?

                // We don't need to propagate this error;

                // it isn't the end of the world if we were unable to disable safe logging.

            }

        }

    } else {

    };

        // https://github.com/metrics-rs/metrics/issues/567

    } {

        cfg_if! {

            if #[cfg(feature = "metrics")] {

                        "set up Prometheus metrics exporter on {listen}"

            } else {

                let _ = listen;

                warn!("`metrics.prometheus.listen` config set but `metrics` cargo feature compiled out in `arti-relay` crate");

            }

        }

        // Configure tor-log-ratelim early before we begin logging.

            MainloopStatus::CtrlC => {

            }

        }

/// A helper to drive a future using a runtime.

///

/// This calls `block_on` on the runtime.

/// The future will be cancelled on a ctrl-c event.

        // Code running in 'block_on' runs slower than in a task (in tokio at least),

        // so the future is run on a task.

            // Signal handler is registered on the first poll.

                // Dropping the handle will cancel the task, so we do that explicitly here.

            }

        )

/// Run the relay.

///

/// This blocks until the relay stops.

    // This blocks until end of time or an error.

/// Initialize a runtime.

///

/// Any cli commands that need a runtime should call this so that we use a consistent runtime.

    // Use the tokio runtime from tor_rtcompat unless we later find a reason to use tokio directly.

    // See https://gitlab.torproject.org/tpo/core/arti/-/work_items/1744.

    // Relays must use rustls as native-tls doesn't support

    // `CertifiedConn::export_keying_material()`.

    // Note: See comments in `tor_rtcompat::impls::rustls::RustlsProvider`

    // about choice of default crypto provider.

    );

/// The result of [`mainloop`].

enum MainloopStatus<T> {

    /// The result from the completed future.

    Finished(T),

    /// The future was cancelled due to a ctrl-c event.

    CtrlC,

}