cli_helpers: use anyhow in app fn; aquatic_ws: reorganize error handling

aquatic_ws/src/lib/lib.rs

@@ -1,4 +1,7 @@
 use std::time::Duration;
+use std::fs::File;
+use std::io::Read;
+use native_tls::{Identity, TlsAcceptor};
 
 pub mod common;
 pub mod config;
@@ -11,7 +14,9 @@ use common::*;
 use config::Config;
 
 
-pub fn run(config: Config){
+pub fn run(config: Config) -> anyhow::Result<()> {
+    let opt_tls_acceptor = create_tls_acceptor(&config)?;
+
     let state = State::default();
 
     let (in_message_sender, in_message_receiver) = ::flume::unbounded();
@@ -21,6 +26,7 @@ pub fn run(config: Config){
     for i in 0..config.socket_workers {
         let config = config.clone();
         let in_message_sender = in_message_sender.clone();
+        let opt_tls_acceptor = opt_tls_acceptor.clone();
 
         let (out_message_sender, out_message_receiver) = ::flume::unbounded();
 
@@ -32,6 +38,7 @@ pub fn run(config: Config){
                 i,
                 in_message_sender,
                 out_message_receiver,
+                opt_tls_acceptor
             );
         });
     }
@@ -57,4 +64,27 @@ pub fn run(config: Config){
 
         tasks::clean_torrents(&state);
     }
+}
+
+
+pub fn create_tls_acceptor(
+    config: &Config,
+) -> anyhow::Result<Option<TlsAcceptor>> {
+    if config.network.use_tls {
+        let mut identity_bytes = Vec::new();
+        let mut file = File::open(&config.network.tls_pkcs12_path)?;
+
+        file.read_to_end(&mut identity_bytes)?;
+
+        let identity = Identity::from_pkcs12(
+            &mut identity_bytes,
+            &config.network.tls_pkcs12_password
+        )?;
+
+        let acceptor = TlsAcceptor::new(identity)?;
+
+        Ok(Some(acceptor))
+    } else {
+        Ok(None)
+    }
 }

aquatic_ws/src/lib/network/mod.rs

@@ -23,12 +23,39 @@ pub fn run_socket_worker(
     socket_worker_index: usize,
     in_message_sender: InMessageSender,
     out_message_receiver: OutMessageReceiver,
+    opt_tls_acceptor: Option<TlsAcceptor>,
+){
+    match create_listener(&config){
+        Ok(listener) => {
+            run_poll_loop(
+                config,
+                socket_worker_index,
+                in_message_sender,
+                out_message_receiver,
+                listener,
+                opt_tls_acceptor
+            );
+        },
+        Err(err) => {
+            eprintln!("Couldn't create TCP listener: {}", err)
+        }
+    }
+}
+
+
+pub fn run_poll_loop(
+    config: Config,
+    socket_worker_index: usize,
+    in_message_sender: InMessageSender,
+    out_message_receiver: OutMessageReceiver,
+    listener: ::std::net::TcpListener,
+    opt_tls_acceptor: Option<TlsAcceptor>,
 ){
     let poll_timeout = Duration::from_millis(
         config.network.poll_timeout_milliseconds
     );
 
-    let mut listener = TcpListener::from_std(create_listener(&config));
+    let mut listener = TcpListener::from_std(listener);
     let mut poll = Poll::new().expect("create poll");
     let mut events = Events::with_capacity(config.network.poll_event_capacity);
 
@@ -36,12 +63,6 @@ pub fn run_socket_worker(
         .register(&mut listener, Token(0), Interest::READABLE)
         .unwrap();
 
-    let opt_tls_acceptor = if config.network.use_tls {
-        Some(create_tls_acceptor(&config))
-    } else {
-        None
-    };
-
     let mut connections: ConnectionMap = HashMap::new();
 
     let mut poll_token_counter = Token(0usize);

aquatic_ws/src/lib/network/utils.rs

@@ -1,9 +1,6 @@
-use std::fs::File;
-use std::io::Read;
 use std::time::Instant;
 
 use mio::Token;
-use native_tls::{Identity, TlsAcceptor};
 use net2::{TcpBuilder, unix::UnixTcpBuilderExt};
 
 use crate::config::Config;
@@ -11,53 +8,26 @@ use crate::config::Config;
 use super::connection::*;
 
 
-pub fn create_listener(config: &Config) -> ::std::net::TcpListener {
-    let mut builder = &{
-        if config.network.address.is_ipv4(){
-            TcpBuilder::new_v4().expect("socket: build")
-        } else {
-            TcpBuilder::new_v6().expect("socket: build")
-        }
-    };
+pub fn create_listener(
+    config: &Config
+) -> ::anyhow::Result<::std::net::TcpListener> {
+    let builder = if config.network.address.is_ipv4(){
+        TcpBuilder::new_v4()
+    } else {
+        TcpBuilder::new_v6()
+    }?;
 
-    builder = builder.reuse_port(true)
-        .expect("socket: set reuse port");
+    let builder = builder.reuse_port(true)?;
+    let builder = builder.bind(&config.network.address)?;
 
-    builder = builder.bind(&config.network.address)
-        .expect(&format!("socket: bind to {}", &config.network.address));
+    let listener = builder.listen(128)?;
 
-    let listener = builder.listen(128)
-        .expect("tcpbuilder to tcp listener");
+    listener.set_nonblocking(true)?;
 
-    listener.set_nonblocking(true)
-        .expect("socket: set nonblocking");
-
-    listener
+    Ok(listener)
 }
 
 
-pub fn create_tls_acceptor(
-    config: &Config,
-) -> TlsAcceptor {
-    let mut identity_bytes = Vec::new();
-    let mut file = File::open(&config.network.tls_pkcs12_path)
-        .expect("open pkcs12 file");
-
-    file.read_to_end(&mut identity_bytes).expect("read pkcs12 file");
-
-    let identity = Identity::from_pkcs12(
-        &mut identity_bytes,
-        &config.network.tls_pkcs12_password
-    ).expect("create pkcs12 identity");
-
-    let acceptor = TlsAcceptor::new(identity)   
-        .expect("create TlsAcceptor");
-
-    acceptor
-}
-
-
-
 /// Don't bother with deregistering from Poll. In my understanding, this is
 /// done automatically when the stream is dropped, as long as there are no
 /// other references to the file descriptor, such as when it is accessed