* Addressed PR comments.

Author: DobromirM

client/swimos_client/src/lib.rs

@@ -42,7 +42,7 @@ use swimos_remote::net::plain::TokioPlainTextNetworking;
 use swimos_remote::net::ClientConnections;
 use swimos_runtime::downlink::{DownlinkOptions, DownlinkRuntimeConfig};
 #[cfg(feature = "tls")]
-use swimos_tls::{ClientConfig as TlsConfig, RustTlsClientNetworking, TlsError};
+use swimos_tls::{ClientConfig as TlsConfig, RustlsClientNetworking, TlsError};
 use swimos_utilities::trigger;
 use swimos_utilities::trigger::promise;
 use tokio::sync::mpsc;
@@ -106,7 +106,7 @@ impl SwimClientBuilder {
         let SwimClientBuilder { config } = self;
         Ok(open_client(
             config,
-            RustTlsClientNetworking::try_from_config(Arc::new(Resolver::new().await), tls_config)?,
+            RustlsClientNetworking::try_from_config(Arc::new(Resolver::new().await), tls_config)?,
         )
         .await)
     }

runtime/swimos_tls/src/lib.rs

@@ -22,4 +22,4 @@ pub use config::{
 };
 pub use errors::TlsError;
 pub use maybe::MaybeTlsStream;
-pub use net::{RustNetworking, RustTlsClientNetworking, RustTlsListener, RustTlsServerNetworking};
+pub use net::{RustNetworking, RustTlsListener, RustlsClientNetworking, RustlsServerNetworking};

runtime/swimos_tls/src/net/client.rs

@@ -29,14 +29,14 @@ use crate::{config::ClientConfig, errors::TlsError, maybe::MaybeTlsStream};
 
 /// [`ClientConnections`] implementation that supports opening both secure and insecure connections.
 #[derive(Clone)]
-pub struct RustTlsClientNetworking {
+pub struct RustlsClientNetworking {
     resolver: Arc<Resolver>,
     connector: TlsConnector,
 }
 
-impl RustTlsClientNetworking {
+impl RustlsClientNetworking {
     pub fn new(resolver: Arc<Resolver>, connector: TlsConnector) -> Self {
-        RustTlsClientNetworking {
+        RustlsClientNetworking {
             resolver,
             connector,
         }
@@ -75,11 +75,11 @@ impl RustTlsClientNetworking {
             .with_no_client_auth();
 
         let connector = TlsConnector::from(Arc::new(config));
-        Ok(RustTlsClientNetworking::new(resolver, connector))
+        Ok(RustlsClientNetworking::new(resolver, connector))
     }
 }
 
-impl ClientConnections for RustTlsClientNetworking {
+impl ClientConnections for RustlsClientNetworking {
     type ClientSocket = MaybeTlsStream;
 
     fn try_open(
@@ -104,7 +104,7 @@ impl ClientConnections for RustTlsClientNetworking {
                 };
                 async move {
                     let stream = TcpStream::connect(addr).await?;
-                    let RustTlsClientNetworking { connector, .. } = self;
+                    let RustlsClientNetworking { connector, .. } = self;
 
                     let client = connector.connect(domain?, stream).await.map_err(|err| {
                         let tls_err = TlsError::HandshakeFailed(err);

runtime/swimos_tls/src/net/mod.rs

@@ -17,25 +17,23 @@ mod server;
 #[cfg(test)]
 mod tests;
 
-use std::{net::SocketAddr, sync::Arc};
+use std::net::SocketAddr;
 
-pub use client::RustTlsClientNetworking;
+pub use client::RustlsClientNetworking;
 use futures::future::Either;
 use futures::TryFutureExt;
 use futures::{future::BoxFuture, FutureExt};
-pub use server::{RustTlsListener, RustTlsServerNetworking};
+pub use server::{RustTlsListener, RustlsServerNetworking};
 use swimos_api::net::Scheme;
 use swimos_remote::net::plain::TokioPlainTextNetworking;
 use swimos_remote::net::{
-    dns::{BoxDnsResolver, Resolver},
-    ClientConnections, ConnResult, IoResult, ServerConnections,
+    dns::BoxDnsResolver, ClientConnections, ConnResult, IoResult, ServerConnections,
 };
 
 use crate::{
-    config::{CertFormat, CertificateFile, TlsConfig},
+    config::{CertFormat, CertificateFile},
     errors::TlsError,
     maybe::MaybeTlsStream,
-    ClientConfig,
 };
 
 use self::server::MaybeRustTlsListener;
@@ -53,18 +51,18 @@ fn load_cert_file(file: CertificateFile) -> Result<Vec<rustls::Certificate>, Tls
 }
 
 /// Combined implementation of [`ClientConnections`] and [`ServerConnections`] that wraps
-/// [`RustTlsClientNetworking`], [`RustTlsServerNetworking`] and [`TokioPlainTextNetworking`]. The server part is adapted to
+/// [`RustlsClientNetworking`], [`RustlsServerNetworking`] and [`TokioPlainTextNetworking`]. The server part is adapted to
 /// produce [`MaybeTlsStream`] connections so that there is a unified client/server socket type,
 /// inducing an implementation of [`super::ExternalConnections`].
 #[derive(Clone)]
 pub struct RustNetworking {
-    client: RustTlsClientNetworking,
-    server: Either<TokioPlainTextNetworking, RustTlsServerNetworking>,
+    client: RustlsClientNetworking,
+    server: Either<TokioPlainTextNetworking, RustlsServerNetworking>,
 }
 
 impl RustNetworking {
     pub fn new_plain_text(
-        client: RustTlsClientNetworking,
+        client: RustlsClientNetworking,
         server: TokioPlainTextNetworking,
     ) -> Self {
         RustNetworking {
@@ -73,40 +71,12 @@ impl RustNetworking {
         }
     }
 
-    pub fn new_tls(client: RustTlsClientNetworking, server: RustTlsServerNetworking) -> Self {
+    pub fn new_tls(client: RustlsClientNetworking, server: RustlsServerNetworking) -> Self {
         RustNetworking {
             client,
             server: Either::Right(server),
         }
     }
-
-    pub fn try_plain_text_from_config(
-        resolver: Arc<Resolver>,
-        client_config: ClientConfig,
-    ) -> Result<Self, TlsError> {
-        let client = RustTlsClientNetworking::try_from_config(resolver.clone(), client_config)?;
-        let server = TokioPlainTextNetworking::new(resolver);
-        Ok(RustNetworking {
-            client,
-            server: Either::Left(server),
-        })
-    }
-
-    pub fn try_tls_from_config(
-        resolver: Arc<Resolver>,
-        config: TlsConfig,
-    ) -> Result<Self, TlsError> {
-        let TlsConfig {
-            client: client_conf,
-            server: server_conf,
-        } = config;
-        let client = RustTlsClientNetworking::try_from_config(resolver, client_conf)?;
-        let server = RustTlsServerNetworking::try_from(server_conf)?;
-        Ok(RustNetworking {
-            client,
-            server: Either::Right(server),
-        })
-    }
 }
 
 impl ClientConnections for RustNetworking {

runtime/swimos_tls/src/net/server.rs

@@ -37,7 +37,7 @@ use crate::{
 
 /// [`ServerConnections`] implementation that only supports secure connections.
 #[derive(Clone)]
-pub struct RustTlsServerNetworking {
+pub struct RustlsServerNetworking {
     acceptor: TlsAcceptor,
 }
 
@@ -50,24 +50,24 @@ async fn accept_tls(
     Ok((bound_to, RustTlsListener { listener, acceptor }))
 }
 
-impl RustTlsServerNetworking {
+impl RustlsServerNetworking {
     pub fn make_listener(
         &self,
         addr: SocketAddr,
     ) -> impl Future<Output = ConnResult<(SocketAddr, RustTlsListener)>> + Send + 'static {
-        let RustTlsServerNetworking { acceptor } = self;
+        let RustlsServerNetworking { acceptor } = self;
         let acc = acceptor.clone();
         accept_tls(acc, addr)
     }
 }
 
-impl RustTlsServerNetworking {
+impl RustlsServerNetworking {
     pub fn new(acceptor: TlsAcceptor) -> Self {
-        RustTlsServerNetworking { acceptor }
+        RustlsServerNetworking { acceptor }
     }
 }
 
-impl TryFrom<ServerConfig> for RustTlsServerNetworking {
+impl TryFrom<ServerConfig> for RustlsServerNetworking {
     type Error = TlsError;
 
     fn try_from(config: ServerConfig) -> Result<Self, Self::Error> {
@@ -108,11 +108,11 @@ impl TryFrom<ServerConfig> for RustTlsServerNetworking {
             config.key_log = Arc::new(KeyLogFile::new());
         }
         let acceptor = TlsAcceptor::from(Arc::new(config));
-        Ok(RustTlsServerNetworking::new(acceptor))
+        Ok(RustlsServerNetworking::new(acceptor))
     }
 }
 
-impl ServerConnections for RustTlsServerNetworking {
+impl ServerConnections for RustlsServerNetworking {
     type ServerSocket = TlsStream<TcpStream>;
 
     type ListenerType = RustTlsListener;

runtime/swimos_tls/src/net/tests.rs

@@ -21,8 +21,8 @@ use swimos_remote::net::{
 };
 
 use crate::{
-    CertChain, CertificateFile, ClientConfig, PrivateKey, RustTlsClientNetworking,
-    RustTlsServerNetworking, ServerConfig,
+    CertChain, CertificateFile, ClientConfig, PrivateKey, RustlsClientNetworking,
+    RustlsServerNetworking, ServerConfig,
 };
 
 const CERTS_PATH: &str = "test-data/certs";
@@ -68,8 +68,8 @@ fn make_client_config() -> ClientConfig {
 #[tokio::test]
 async fn perform_handshake() {
     let server_net =
-        RustTlsServerNetworking::try_from(make_server_config()).expect("Invalid server config.");
-    let client_net = RustTlsClientNetworking::try_from_config(
+        RustlsServerNetworking::try_from(make_server_config()).expect("Invalid server config.");
+    let client_net = RustlsClientNetworking::try_from_config(
         Arc::new(Resolver::new().await),
         make_client_config(),
     )

server/swimos_server_app/src/server/builder/mod.rs

@@ -22,8 +22,11 @@ use ratchet::{
     NoExtProvider, WebSocketStream,
 };
 use swimos_api::{agent::Agent, error::StoreError, store::StoreDisabled};
+use swimos_remote::net::plain::TokioPlainTextNetworking;
 use swimos_remote::net::{dns::Resolver, ExternalConnections};
-use swimos_tls::{ClientConfig, RustNetworking, TlsConfig};
+use swimos_tls::{
+    ClientConfig, RustNetworking, RustlsClientNetworking, RustlsServerNetworking, TlsConfig,
+};
 use swimos_utilities::routing::route_pattern::RoutePattern;
 
 use crate::{
@@ -175,11 +178,15 @@ impl ServerBuilder {
             introspection,
         };
         if let Some(tls_conf) = tls_config {
-            let networking = RustNetworking::try_tls_from_config(resolver, tls_conf)?;
+            let client = RustlsClientNetworking::try_from_config(resolver, tls_conf.client)?;
+            let server = RustlsServerNetworking::try_from(tls_conf.server)?;
+            let networking = RustNetworking::new_tls(client, server);
             Ok(with_store(bind_to, routes, networking, config)?)
         } else {
-            let networking =
-                RustNetworking::try_plain_text_from_config(resolver, ClientConfig::default())?;
+            let client =
+                RustlsClientNetworking::try_from_config(resolver.clone(), ClientConfig::default())?;
+            let server = TokioPlainTextNetworking::new(resolver);
+            let networking = RustNetworking::new_plain_text(client, server);
             Ok(with_store(bind_to, routes, networking, config)?)
         }
     }