From 3891745a6ec1ea50fb05f92b7d780fea6bb41034 Mon Sep 17 00:00:00 2001 From: Rob Ede Date: Mon, 29 Nov 2021 20:58:50 +0000 Subject: [PATCH] rename to connectinfo --- actix-tls/CHANGES.md | 2 +- actix-tls/src/connect/connector.rs | 30 +++++++++++++++--------------- actix-tls/src/connect/info.rs | 28 ++++++++++++++-------------- actix-tls/src/connect/mod.rs | 2 +- actix-tls/src/connect/openssl.rs | 0 actix-tls/src/connect/resolver.rs | 24 +++++++++++------------- actix-tls/src/connect/rustls.rs | 0 actix-tls/src/connect/tcp.rs | 14 ++++++-------- actix-tls/tests/test_connect.rs | 12 ++++++------ actix-tls/tests/test_resolvers.rs | 6 +++--- 10 files changed, 57 insertions(+), 61 deletions(-) mode change 100755 => 100644 actix-tls/src/connect/connector.rs mode change 100755 => 100644 actix-tls/src/connect/info.rs mode change 100755 => 100644 actix-tls/src/connect/openssl.rs mode change 100755 => 100644 actix-tls/src/connect/resolver.rs mode change 100755 => 100644 actix-tls/src/connect/rustls.rs mode change 100755 => 100644 actix-tls/src/connect/tcp.rs mode change 100755 => 100644 actix-tls/tests/test_connect.rs diff --git a/actix-tls/CHANGES.md b/actix-tls/CHANGES.md index 514b3e94..78ba3665 100644 --- a/actix-tls/CHANGES.md +++ b/actix-tls/CHANGES.md @@ -16,7 +16,7 @@ * Rename `accept::native_tls::{NativeTlsAcceptorService => AcceptorService}`. [#422] * Rename `connect::{Address => Host}` trait. [#422] * Rename method `connect::Connection::{host => hostname}`. [#422] -* Rename struct `connect::{Connect => ConnectionInfo}`. [#422] +* Rename struct `connect::{Connect => ConnectInfo}`. [#422] * Rename struct `connect::{ConnectService => ConnectorService}`. [#422] * Rename struct `connect::{ConnectServiceFactory => Connector}`. [#422] * Rename TLS acceptor service future types and hide from docs. [#422] diff --git a/actix-tls/src/connect/connector.rs b/actix-tls/src/connect/connector.rs old mode 100755 new mode 100644 index d749a70f..f5717661 --- a/actix-tls/src/connect/connector.rs +++ b/actix-tls/src/connect/connector.rs @@ -13,7 +13,7 @@ use super::{ error::ConnectError, resolver::{Resolver, ResolverService}, tcp::{TcpConnector, TcpConnectorService}, - Connection, ConnectionInfo, Host, + ConnectInfo, Connection, Host, }; /// Combined resolver and TCP connector service factory. @@ -40,7 +40,7 @@ impl Connector { } } -impl ServiceFactory> for Connector { +impl ServiceFactory> for Connector { type Response = Connection; type Error = ConnectError; type Config = (); @@ -63,43 +63,43 @@ pub struct ConnectorService { resolver: ResolverService, } -impl Service> for ConnectorService { +impl Service> for ConnectorService { type Response = Connection; type Error = ConnectError; type Future = ConnectServiceResponse; actix_service::always_ready!(); - fn call(&self, req: ConnectionInfo) -> Self::Future { + fn call(&self, req: ConnectInfo) -> Self::Future { ConnectServiceResponse { - fut: ConnectFuture::Resolve(self.resolver.call(req)), + fut: ConnectFut::Resolve(self.resolver.call(req)), tcp: self.tcp, } } } -// helper enum to generic over futures of resolve and connect phase. -pub(crate) enum ConnectFuture { - Resolve(>>::Future), - Connect(>>::Future), +/// Helper enum to generic over futures of resolve and connect steps. +pub(crate) enum ConnectFut { + Resolve(>>::Future), + Connect(>>::Future), } /// Helper enum to contain the future output of `ConnectFuture`. pub(crate) enum ConnectOutput { - Resolved(ConnectionInfo), + Resolved(ConnectInfo), Connected(Connection), } -impl ConnectFuture { +impl ConnectFut { fn poll_connect( &mut self, cx: &mut Context<'_>, ) -> Poll, ConnectError>> { match self { - ConnectFuture::Resolve(ref mut fut) => { + ConnectFut::Resolve(ref mut fut) => { Pin::new(fut).poll(cx).map_ok(ConnectOutput::Resolved) } - ConnectFuture::Connect(ref mut fut) => { + ConnectFut::Connect(ref mut fut) => { Pin::new(fut).poll(cx).map_ok(ConnectOutput::Connected) } } @@ -107,7 +107,7 @@ impl ConnectFuture { } pub struct ConnectServiceResponse { - fut: ConnectFuture, + fut: ConnectFut, tcp: TcpConnectorService, } @@ -118,7 +118,7 @@ impl Future for ConnectServiceResponse { loop { match ready!(self.fut.poll_connect(cx))? { ConnectOutput::Resolved(res) => { - self.fut = ConnectFuture::Connect(self.tcp.call(res)); + self.fut = ConnectFut::Connect(self.tcp.call(res)); } ConnectOutput::Connected(res) => return Poll::Ready(Ok(res)), } diff --git a/actix-tls/src/connect/info.rs b/actix-tls/src/connect/info.rs old mode 100755 new mode 100644 index af293b04..85f9c961 --- a/actix-tls/src/connect/info.rs +++ b/actix-tls/src/connect/info.rs @@ -17,19 +17,19 @@ use super::{ /// /// May contain known/pre-resolved socket address(es) or a host that needs resolving with DNS. #[derive(Debug, PartialEq, Eq, Hash)] -pub struct ConnectionInfo { +pub struct ConnectInfo { pub(crate) request: R, pub(crate) port: u16, pub(crate) addr: ConnectAddrs, pub(crate) local_addr: Option, } -impl ConnectionInfo { +impl ConnectInfo { /// Constructs new connection info using a request. - pub fn new(request: R) -> ConnectionInfo { + pub fn new(request: R) -> ConnectInfo { let port = request.port(); - ConnectionInfo { + ConnectInfo { request, port: port.unwrap_or(0), addr: ConnectAddrs::None, @@ -41,8 +41,8 @@ impl ConnectionInfo { /// /// Since socket address is known, [`Connector`](super::Connector) will skip the DNS /// resolution step. - pub fn with_addr(request: R, addr: SocketAddr) -> ConnectionInfo { - ConnectionInfo { + pub fn with_addr(request: R, addr: SocketAddr) -> ConnectInfo { + ConnectInfo { request, port: 0, addr: ConnectAddrs::One(addr), @@ -165,13 +165,13 @@ impl ConnectionInfo { } } -impl From for ConnectionInfo { +impl From for ConnectInfo { fn from(addr: R) -> Self { - ConnectionInfo::new(addr) + ConnectInfo::new(addr) } } -impl fmt::Display for ConnectionInfo { +impl fmt::Display for ConnectInfo { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!(f, "{}:{}", self.hostname(), self.port()) } @@ -217,7 +217,7 @@ mod tests { #[test] fn test_local_addr() { - let conn = ConnectionInfo::new("hello").set_local_addr([127, 0, 0, 1]); + let conn = ConnectInfo::new("hello").set_local_addr([127, 0, 0, 1]); assert_eq!( conn.local_addr.unwrap(), IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)) @@ -226,7 +226,7 @@ mod tests { #[test] fn request_ref() { - let conn = ConnectionInfo::new("hello"); + let conn = ConnectInfo::new("hello"); assert_eq!(conn.request(), &"hello") } @@ -234,15 +234,15 @@ mod tests { fn set_connect_addr_into_option() { let addr = SocketAddr::from(([127, 0, 0, 1], 4242)); - let conn = ConnectionInfo::new("hello").set_addr(None); + let conn = ConnectInfo::new("hello").set_addr(None); let mut addrs = conn.addrs(); assert!(addrs.next().is_none()); - let conn = ConnectionInfo::new("hello").set_addr(addr); + let conn = ConnectInfo::new("hello").set_addr(addr); let mut addrs = conn.addrs(); assert_eq!(addrs.next().unwrap(), addr); - let conn = ConnectionInfo::new("hello").set_addr(Some(addr)); + let conn = ConnectInfo::new("hello").set_addr(Some(addr)); let mut addrs = conn.addrs(); assert_eq!(addrs.next().unwrap(), addr); } diff --git a/actix-tls/src/connect/mod.rs b/actix-tls/src/connect/mod.rs index a66b750f..3511dd58 100644 --- a/actix-tls/src/connect/mod.rs +++ b/actix-tls/src/connect/mod.rs @@ -41,6 +41,6 @@ pub use self::connection::Connection; pub use self::connector::{Connector, ConnectorService}; pub use self::error::ConnectError; pub use self::host::Host; -pub use self::info::ConnectionInfo; +pub use self::info::ConnectInfo; pub use self::resolve::Resolve; pub use self::resolver::{Resolver, ResolverService}; diff --git a/actix-tls/src/connect/openssl.rs b/actix-tls/src/connect/openssl.rs old mode 100755 new mode 100644 diff --git a/actix-tls/src/connect/resolver.rs b/actix-tls/src/connect/resolver.rs old mode 100755 new mode 100644 index b429b0ba..d54d4217 --- a/actix-tls/src/connect/resolver.rs +++ b/actix-tls/src/connect/resolver.rs @@ -14,7 +14,7 @@ use actix_utils::future::{ok, Ready}; use futures_core::{future::LocalBoxFuture, ready}; use log::trace; -use super::{ConnectError, ConnectionInfo, Host, Resolve}; +use super::{ConnectError, ConnectInfo, Host, Resolve}; /// DNS resolver service factory. #[derive(Clone, Default)] @@ -36,8 +36,8 @@ impl Resolver { } } -impl ServiceFactory> for Resolver { - type Response = ConnectionInfo; +impl ServiceFactory> for Resolver { + type Response = ConnectInfo; type Error = ConnectError; type Config = (); type Service = ResolverService; @@ -81,9 +81,7 @@ impl ResolverService { } /// Resolve DNS with default resolver. - fn look_up( - req: &ConnectionInfo, - ) -> JoinHandle>> { + fn look_up(req: &ConnectInfo) -> JoinHandle>> { let host = req.hostname(); // TODO: Connect should always return host(name?) with port if possible; basically try to // reduce ability to create conflicting lookup info by having port in host string being @@ -109,14 +107,14 @@ impl ResolverService { } } -impl Service> for ResolverService { - type Response = ConnectionInfo; +impl Service> for ResolverService { + type Response = ConnectInfo; type Error = ConnectError; type Future = ResolverFut; actix_service::always_ready!(); - fn call(&self, req: ConnectionInfo) -> Self::Future { + fn call(&self, req: ConnectInfo) -> Self::Future { if req.addr.is_some() { ResolverFut::Connected(Some(req)) } else if let Ok(ip) = req.hostname().parse() { @@ -157,16 +155,16 @@ impl Service> for ResolverService { /// Future for resolver service. pub enum ResolverFut { - Connected(Option>), + Connected(Option>), LookUp( JoinHandle>>, - Option>, + Option>, ), - LookupCustom(LocalBoxFuture<'static, Result, ConnectError>>), + LookupCustom(LocalBoxFuture<'static, Result, ConnectError>>), } impl Future for ResolverFut { - type Output = Result, ConnectError>; + type Output = Result, ConnectError>; fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { match self.get_mut() { diff --git a/actix-tls/src/connect/rustls.rs b/actix-tls/src/connect/rustls.rs old mode 100755 new mode 100644 diff --git a/actix-tls/src/connect/tcp.rs b/actix-tls/src/connect/tcp.rs old mode 100755 new mode 100644 index a4b6efc9..a2a9fb94 --- a/actix-tls/src/connect/tcp.rs +++ b/actix-tls/src/connect/tcp.rs @@ -18,9 +18,7 @@ use futures_core::ready; use log::{error, trace}; use tokio_util::sync::ReusableBoxFuture; -use super::{ - connect_addrs::ConnectAddrs, error::ConnectError, Connection, ConnectionInfo, Host, -}; +use super::{connect_addrs::ConnectAddrs, error::ConnectError, ConnectInfo, Connection, Host}; /// TCP connector service factory. #[derive(Debug, Copy, Clone)] @@ -33,7 +31,7 @@ impl TcpConnector { } } -impl ServiceFactory> for TcpConnector { +impl ServiceFactory> for TcpConnector { type Response = Connection; type Error = ConnectError; type Config = (); @@ -50,17 +48,17 @@ impl ServiceFactory> for TcpConnector { #[derive(Debug, Copy, Clone)] pub struct TcpConnectorService; -impl Service> for TcpConnectorService { +impl Service> for TcpConnectorService { type Response = Connection; type Error = ConnectError; type Future = TcpConnectorFut; actix_service::always_ready!(); - fn call(&self, req: ConnectionInfo) -> Self::Future { + fn call(&self, req: ConnectInfo) -> Self::Future { let port = req.port(); - let ConnectionInfo { + let ConnectInfo { request: req, addr, local_addr, @@ -178,7 +176,7 @@ impl Future for TcpConnectorFut { } async fn connect(addr: SocketAddr, local_addr: Option) -> io::Result { - // use local addr if connect asks for it. + // use local addr if connect asks for it match local_addr { Some(ip_addr) => { let socket = match ip_addr { diff --git a/actix-tls/tests/test_connect.rs b/actix-tls/tests/test_connect.rs old mode 100755 new mode 100644 index d57ceed6..d3373c90 --- a/actix-tls/tests/test_connect.rs +++ b/actix-tls/tests/test_connect.rs @@ -12,7 +12,7 @@ use actix_service::{fn_service, Service, ServiceFactory}; use bytes::Bytes; use futures_util::sink::SinkExt; -use actix_tls::connect::{ConnectError, Connection, ConnectionInfo, Connector, Host}; +use actix_tls::connect::{ConnectError, ConnectInfo, Connection, Connector, Host}; #[cfg(feature = "openssl")] #[actix_rt::test] @@ -58,12 +58,12 @@ async fn test_static_str() { }) }); - let info = ConnectionInfo::with_addr("10", srv.addr()); + let info = ConnectInfo::with_addr("10", srv.addr()); let connector = Connector::default().service(); let conn = connector.call(info).await.unwrap(); assert_eq!(conn.peer_addr().unwrap(), srv.addr()); - let info = ConnectionInfo::new(srv.host().to_owned()); + let info = ConnectInfo::new(srv.host().to_owned()); let connector = Connector::default().service(); let conn = connector.call(info).await; assert!(conn.is_err()); @@ -72,7 +72,7 @@ async fn test_static_str() { #[actix_rt::test] async fn service_factory() { pub fn default_connector_factory() -> impl ServiceFactory< - ConnectionInfo, + ConnectInfo, Config = (), Response = Connection, Error = ConnectError, @@ -89,7 +89,7 @@ async fn service_factory() { }) }); - let info = ConnectionInfo::with_addr("10", srv.addr()); + let info = ConnectInfo::with_addr("10", srv.addr()); let factory = default_connector_factory(); let connector = factory.new_service(()).await.unwrap(); let con = connector.call(info).await; @@ -148,7 +148,7 @@ async fn test_local_addr() { let local = IpAddr::V4(Ipv4Addr::new(127, 0, 0, 3)); let (con, _) = conn - .call(ConnectionInfo::with_addr("10", srv.addr()).set_local_addr(local)) + .call(ConnectInfo::with_addr("10", srv.addr()).set_local_addr(local)) .await .unwrap() .into_parts(); diff --git a/actix-tls/tests/test_resolvers.rs b/actix-tls/tests/test_resolvers.rs index e19e4269..987b229c 100644 --- a/actix-tls/tests/test_resolvers.rs +++ b/actix-tls/tests/test_resolvers.rs @@ -11,7 +11,7 @@ use actix_service::{fn_service, Service, ServiceFactory}; use futures_core::future::LocalBoxFuture; use actix_tls::connect::{ - ConnectError, Connection, ConnectionInfo, Connector, Host, Resolve, Resolver, + ConnectError, ConnectInfo, Connection, Connector, Host, Resolve, Resolver, }; #[actix_rt::test] @@ -41,7 +41,7 @@ async fn custom_resolver_connect() { pub fn connector_factory( resolver: Resolver, ) -> impl ServiceFactory< - ConnectionInfo, + ConnectInfo, Config = (), Response = Connection, Error = ConnectError, @@ -86,7 +86,7 @@ async fn custom_resolver_connect() { let conn = factory.new_service(()).await.unwrap(); let con = conn - .call(ConnectionInfo::with_addr("example.com", srv.addr())) + .call(ConnectInfo::with_addr("example.com", srv.addr())) .await .unwrap(); assert_eq!(con.peer_addr().unwrap(), srv.addr());