* Renamed RustTls to Rustls to match the rustls library's naming.

Author: DobromirM

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, RustTlsListener, RustlsClientNetworking, RustlsServerNetworking};
+pub use net::{RustlsNetworking, RustlsListener, RustlsClientNetworking, RustlsServerNetworking};

runtime/swimos_tls/src/net/mod.rs

@@ -23,7 +23,7 @@ pub use client::RustlsClientNetworking;
 use futures::future::Either;
 use futures::TryFutureExt;
 use futures::{future::BoxFuture, FutureExt};
-pub use server::{RustTlsListener, RustlsServerNetworking};
+pub use server::{RustlsListener, RustlsServerNetworking};
 use swimos_api::net::Scheme;
 use swimos_remote::net::plain::TokioPlainTextNetworking;
 use swimos_remote::net::{
@@ -55,31 +55,31 @@ fn load_cert_file(file: CertificateFile) -> Result<Vec<rustls::Certificate>, Tls
 /// produce [`MaybeTlsStream`] connections so that there is a unified client/server socket type,
 /// inducing an implementation of [`super::ExternalConnections`].
 #[derive(Clone)]
-pub struct RustNetworking {
+pub struct RustlsNetworking {
     client: RustlsClientNetworking,
     server: Either<TokioPlainTextNetworking, RustlsServerNetworking>,
 }
 
-impl RustNetworking {
+impl RustlsNetworking {
     pub fn new_plain_text(
         client: RustlsClientNetworking,
         server: TokioPlainTextNetworking,
     ) -> Self {
-        RustNetworking {
+        RustlsNetworking {
             client,
             server: Either::Left(server),
         }
     }
 
     pub fn new_tls(client: RustlsClientNetworking, server: RustlsServerNetworking) -> Self {
-        RustNetworking {
+        RustlsNetworking {
             client,
             server: Either::Right(server),
         }
     }
 }
 
-impl ClientConnections for RustNetworking {
+impl ClientConnections for RustlsNetworking {
     type ClientSocket = MaybeTlsStream;
 
     fn try_open(
@@ -100,7 +100,7 @@ impl ClientConnections for RustNetworking {
     }
 }
 
-impl ServerConnections for RustNetworking {
+impl ServerConnections for RustlsNetworking {
     type ServerSocket = MaybeTlsStream;
 
     type ListenerType = MaybeRustTlsListener;

runtime/swimos_tls/src/net/server.rs

@@ -44,17 +44,17 @@ pub struct RustlsServerNetworking {
 async fn accept_tls(
     acceptor: TlsAcceptor,
     addr: SocketAddr,
-) -> ConnResult<(SocketAddr, RustTlsListener)> {
+) -> ConnResult<(SocketAddr, RustlsListener)> {
     let listener = TcpListener::bind(addr).await?;
     let bound_to = listener.local_addr()?;
-    Ok((bound_to, RustTlsListener { listener, acceptor }))
+    Ok((bound_to, RustlsListener { listener, acceptor }))
 }
 
 impl RustlsServerNetworking {
     pub fn make_listener(
         &self,
         addr: SocketAddr,
-    ) -> impl Future<Output = ConnResult<(SocketAddr, RustTlsListener)>> + Send + 'static {
+    ) -> impl Future<Output = ConnResult<(SocketAddr, RustlsListener)>> + Send + 'static {
         let RustlsServerNetworking { acceptor } = self;
         let acc = acceptor.clone();
         accept_tls(acc, addr)
@@ -115,7 +115,7 @@ impl TryFrom<ServerConfig> for RustlsServerNetworking {
 impl ServerConnections for RustlsServerNetworking {
     type ServerSocket = TlsStream<TcpStream>;
 
-    type ListenerType = RustTlsListener;
+    type ListenerType = RustlsListener;
 
     fn bind(
         &self,
@@ -127,16 +127,16 @@ impl ServerConnections for RustlsServerNetworking {
 
 /// A listener that will listen for incoming TCP connections and attempt to negotiate a
 /// TLS connection over them.
-pub struct RustTlsListener {
+pub struct RustlsListener {
     listener: TcpListener,
     acceptor: TlsAcceptor,
 }
 
-impl Listener<TlsStream<TcpStream>> for RustTlsListener {
+impl Listener<TlsStream<TcpStream>> for RustlsListener {
     type AcceptStream = BoxListenerStream<TlsStream<TcpStream>>;
 
     fn into_stream(self) -> Self::AcceptStream {
-        let RustTlsListener { listener, acceptor } = self;
+        let RustlsListener { listener, acceptor } = self;
         tls_accept_stream(listener, acceptor).boxed()
     }
 }
@@ -226,10 +226,10 @@ fn tls_accept_stream(
     })
 }
 
-/// This wraps connections for [`TcpListener`] and [`RustTlsListener`] as [`crate::maybe::MaybeTlsStream`] to unify server and client
+/// This wraps connections for [`TcpListener`] and [`RustlsListener`] as [`crate::maybe::MaybeTlsStream`] to unify server and client
 /// connection types.
 pub struct MaybeRustTlsListener {
-    inner: Either<TcpListener, RustTlsListener>,
+    inner: Either<TcpListener, RustlsListener>,
 }
 
 impl From<TcpListener> for MaybeRustTlsListener {
@@ -240,8 +240,8 @@ impl From<TcpListener> for MaybeRustTlsListener {
     }
 }
 
-impl From<RustTlsListener> for MaybeRustTlsListener {
-    fn from(inner: RustTlsListener) -> Self {
+impl From<RustlsListener> for MaybeRustTlsListener {
+    fn from(inner: RustlsListener) -> Self {
         MaybeRustTlsListener {
             inner: Either::Right(inner),
         }
@@ -260,7 +260,7 @@ impl Listener<MaybeTlsStream> for MaybeRustTlsListener {
                 .map_ok(|(sock, scheme, addr)| (MaybeTlsStream::Plain(sock), scheme, addr))
                 .boxed(),
 
-            Either::Right(RustTlsListener { listener, acceptor }) => {
+            Either::Right(RustlsListener { listener, acceptor }) => {
                 tls_accept_stream(listener, acceptor)
                     .map_ok(|(sock, scheme, addr)| (MaybeTlsStream::Tls(sock), scheme, addr))
                     .boxed()

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

@@ -25,7 +25,7 @@ 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, RustlsClientNetworking, RustlsServerNetworking, TlsConfig,
+    ClientConfig, RustlsNetworking, RustlsClientNetworking, RustlsServerNetworking, TlsConfig,
 };
 use swimos_utilities::routing::route_pattern::RoutePattern;
 
@@ -180,13 +180,13 @@ impl ServerBuilder {
         if let Some(tls_conf) = tls_config {
             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);
+            let networking = RustlsNetworking::new_tls(client, server);
             Ok(with_store(bind_to, routes, networking, config)?)
         } else {
             let client =
                 RustlsClientNetworking::try_from_config(resolver.clone(), ClientConfig::default())?;
             let server = TokioPlainTextNetworking::new(resolver);
-            let networking = RustNetworking::new_plain_text(client, server);
+            let networking = RustlsNetworking::new_plain_text(client, server);
             Ok(with_store(bind_to, routes, networking, config)?)
         }
     }