Function main

plugins/wss-proxy-plugin/src/main.rs:18–93

()

#[tokio::main]
async fn main() -> Result<(), anyhow::Error> {
    unsafe {
        // SAFETY:
        // `std::env::set_var` is unsafe in Rust 2024 because environment variables
        // are process-global and unsynchronized. Concurrent reads/writes from
        // multiple threads can cause undefined behavior.
        //
        // This call happens at process startup, before any threads are spawned and
        // before any code that may read environment variables is executed.
        // Therefore, no concurrent access is possible.
        std::env::set_var(
            "CLN_PLUGIN_LOG",
            "cln_plugin=info,cln_rpc=info,wss_proxy=debug,warn",
        )
    };

    log_panics::init();

    let opt_wss_proxy_bind_addr = ConfigOption::new_str_arr_no_default(
        OPT_WSS_BIND_ADDR,
        "WSS proxy address to connect with WS",
    );

    let default_certs_dir = std::env::current_dir()?;
    let default_certs_dir_str = default_certs_dir
        .to_str()
        .ok_or_else(|| anyhow!("Invalid working directory: {:?}", default_certs_dir))?;

    let opt_wss_proxy_certs = ConfigOption::new_str_with_default(
        OPT_WSS_CERTS_DIR,
        default_certs_dir_str,
        "Certificate location for WSS proxy",
    );

    let conf_plugin = match Builder::new(tokio::io::stdin(), tokio::io::stdout())
        .option(opt_wss_proxy_bind_addr)
        .option(opt_wss_proxy_certs)
        .dynamic()
        .configure()
        .await?
    {
        Some(p) => p,
        None => return Ok(()),
    };

    let wss_proxy_options = match parse_options(&conf_plugin).await {
        Ok(opts) => opts,
        Err(e) => return conf_plugin.disable(&e.to_string()).await,
    };

    let plugin = conf_plugin.start(()).await?;

    let tls_config = match get_tls_config(&wss_proxy_options).await {
        Ok(tls) => tls,
        Err(err) => {
            log_error(err.to_string());
            process::exit(1)
        }