Add Lua prefix to net types

Author: khvzak

src/net/common.rs

@@ -8,12 +8,15 @@ use std::{fmt, io};
 
 use mlua::{AnyUserData, Error, FromLua, IntoLua, Lua, MaybeSend, Result, Value};
 use tokio::io::{AsyncRead, AsyncWrite, ReadBuf};
+use tokio::net::TcpStream;
+#[cfg(unix)]
+use tokio::net::UnixStream;
 
-use super::tcp::{TcpListener, TcpStream};
+use super::tcp::{LuaTcpListener, LuaTcpStream};
 #[cfg(feature = "tls")]
-use super::tls::{TlsListener, TlsStream};
+use super::tls::{LuaTlsListener, LuaTlsStream};
 #[cfg(unix)]
-use super::unix::{UnixListener, UnixStream};
+use super::unix::{LuaUnixListener, LuaUnixStream};
 
 /// Socket address that can be either TCP or Unix domain socket.
 pub enum AnySocketAddr {
@@ -50,7 +53,7 @@ pub trait AddressProvider {
     fn peer_addr(&self) -> io::Result<AnySocketAddr>;
 }
 
-impl AddressProvider for tokio::net::TcpStream {
+impl AddressProvider for TcpStream {
     fn local_addr(&self) -> io::Result<AnySocketAddr> {
         Ok(AnySocketAddr::IP(self.local_addr()?))
     }
@@ -61,7 +64,7 @@ impl AddressProvider for tokio::net::TcpStream {
 }
 
 #[cfg(unix)]
-impl AddressProvider for tokio::net::UnixStream {
+impl AddressProvider for UnixStream {
     fn local_addr(&self) -> io::Result<AnySocketAddr> {
         Ok(AnySocketAddr::Unix(self.local_addr()?))
     }
@@ -73,13 +76,13 @@ impl AddressProvider for tokio::net::UnixStream {
 
 /// A stream that can be either TCP or Unix domain socket, possibly wrapped in TLS.
 pub enum AnyStream {
-    Tcp(TcpStream),
+    Tcp(LuaTcpStream),
     #[cfg(unix)]
-    Unix(UnixStream),
+    Unix(LuaUnixStream),
     #[cfg(feature = "tls")]
-    TcpTls(TlsStream<TcpStream>),
+    TcpTls(LuaTlsStream<LuaTcpStream>),
     #[cfg(all(unix, feature = "tls"))]
-    UnixTls(TlsStream<UnixStream>),
+    UnixTls(LuaTlsStream<LuaUnixStream>),
 }
 
 impl AsyncRead for AnyStream {
@@ -152,23 +155,23 @@ impl FromLua for AnyStream {
     fn from_lua(value: Value, lua: &Lua) -> Result<Self> {
         let value = lua.unpack::<AnyUserData>(value)?;
         match value.type_id() {
-            Some(id) if id == TypeId::of::<TcpStream>() => {
-                let stream = value.take::<TcpStream>()?;
+            Some(id) if id == TypeId::of::<LuaTcpStream>() => {
+                let stream = value.take::<LuaTcpStream>()?;
                 Ok(AnyStream::Tcp(stream))
             }
             #[cfg(unix)]
-            Some(id) if id == TypeId::of::<UnixStream>() => {
-                let stream = value.take::<UnixStream>()?;
+            Some(id) if id == TypeId::of::<LuaUnixStream>() => {
+                let stream = value.take::<LuaUnixStream>()?;
                 Ok(AnyStream::Unix(stream))
             }
             #[cfg(feature = "tls")]
-            Some(id) if id == TypeId::of::<TlsStream<TcpStream>>() => {
-                let stream = value.take::<TlsStream<TcpStream>>()?;
+            Some(id) if id == TypeId::of::<LuaTlsStream<LuaTcpStream>>() => {
+                let stream = value.take::<LuaTlsStream<LuaTcpStream>>()?;
                 Ok(AnyStream::TcpTls(stream))
             }
             #[cfg(all(unix, feature = "tls"))]
-            Some(id) if id == TypeId::of::<TlsStream<UnixStream>>() => {
-                let stream = value.take::<TlsStream<UnixStream>>()?;
+            Some(id) if id == TypeId::of::<LuaTlsStream<LuaUnixStream>>() => {
+                let stream = value.take::<LuaTlsStream<LuaUnixStream>>()?;
                 Ok(AnyStream::UnixTls(stream))
             }
             _ => {
@@ -186,13 +189,13 @@ impl FromLua for AnyStream {
 
 /// A listener that can be either TCP or Unix domain socket, possibly wrapped in TLS.
 pub enum AnyListener {
-    Tcp(TcpListener),
+    Tcp(LuaTcpListener),
     #[cfg(unix)]
-    Unix(UnixListener),
+    Unix(LuaUnixListener),
     #[cfg(feature = "tls")]
-    TcpTls(TlsListener<TcpListener>),
+    TcpTls(LuaTlsListener<LuaTcpListener>),
     #[cfg(all(unix, feature = "tls"))]
-    UnixTls(TlsListener<UnixListener>),
+    UnixTls(LuaTlsListener<LuaUnixListener>),
 }
 
 /// Trait for accepting incoming connections from various listener types.
@@ -251,23 +254,23 @@ impl FromLua for AnyListener {
     fn from_lua(value: Value, lua: &Lua) -> Result<Self> {
         let value = lua.unpack::<AnyUserData>(value)?;
         match value.type_id() {
-            Some(id) if id == TypeId::of::<TcpListener>() => {
-                let listener = value.take::<TcpListener>()?;
+            Some(id) if id == TypeId::of::<LuaTcpListener>() => {
+                let listener = value.take::<LuaTcpListener>()?;
                 Ok(AnyListener::Tcp(listener))
             }
             #[cfg(unix)]
-            Some(id) if id == TypeId::of::<UnixListener>() => {
-                let listener = value.take::<UnixListener>()?;
+            Some(id) if id == TypeId::of::<LuaUnixListener>() => {
+                let listener = value.take::<LuaUnixListener>()?;
                 Ok(AnyListener::Unix(listener))
             }
             #[cfg(feature = "tls")]
-            Some(id) if id == TypeId::of::<TlsListener<TcpListener>>() => {
-                let listener = value.take::<TlsListener<TcpListener>>()?;
+            Some(id) if id == TypeId::of::<LuaTlsListener<LuaTcpListener>>() => {
+                let listener = value.take::<LuaTlsListener<LuaTcpListener>>()?;
                 Ok(AnyListener::TcpTls(listener))
             }
             #[cfg(all(unix, feature = "tls"))]
-            Some(id) if id == TypeId::of::<TlsListener<UnixListener>>() => {
-                let listener = value.take::<TlsListener<UnixListener>>()?;
+            Some(id) if id == TypeId::of::<LuaTlsListener<LuaUnixListener>>() => {
+                let listener = value.take::<LuaTlsListener<LuaUnixListener>>()?;
                 Ok(AnyListener::UnixTls(listener))
             }
             _ => {

src/net/mod.rs

@@ -1,7 +1,7 @@
 use mlua::{Lua, Result, Table};
 
 pub use common::{AddressProvider, AnyListener, AnySocketAddr, AnyStream};
-pub use tcp::{TcpListener, TcpStream};
+pub use tcp::{LuaTcpListener, LuaTcpStream};
 
 /// A loader for the `net` module.
 fn loader(lua: &Lua) -> Result<Table> {

src/net/tcp/listener.rs

@@ -1,60 +1,94 @@
 use std::io;
 use std::net::SocketAddr;
+use std::ops::{Deref, DerefMut};
 use std::result::Result as StdResult;
 
 use mlua::{Lua, Result, Table, UserData, UserDataMethods, UserDataRegistry};
-use tokio::net::lookup_host;
+use tokio::net::{TcpListener, lookup_host};
 
-use super::{SocketOptions, TcpSocket, TcpStream};
+use super::{LuaTcpSocket, LuaTcpStream, SocketOptions};
 use crate::net::common::{Accept, AnySocketAddr};
 
-pub struct TcpListener(pub(crate) tokio::net::TcpListener);
+/// Lua wrapper around tokio [`TcpListener`].
+#[derive(Debug)]
+pub struct LuaTcpListener(pub(crate) TcpListener);
 
-impl Accept for TcpListener {
-    type Stream = TcpStream;
+impl Deref for LuaTcpListener {
+    type Target = TcpListener;
+
+    #[inline]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl DerefMut for LuaTcpListener {
+    #[inline]
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+
+impl From<TcpListener> for LuaTcpListener {
+    #[inline]
+    fn from(listener: TcpListener) -> Self {
+        LuaTcpListener(listener)
+    }
+}
+
+impl Accept for LuaTcpListener {
+    type Stream = LuaTcpStream;
 
     fn local_addr(&self) -> io::Result<AnySocketAddr> {
         self.0.local_addr().map(AnySocketAddr::IP)
     }
 
     async fn accept(&self) -> io::Result<(Self::Stream, AnySocketAddr)> {
         let (stream, addr) = self.0.accept().await?;
-        let io = TcpStream::from(stream);
-        let addr = AnySocketAddr::IP(addr);
-        Ok((io, addr))
+        Ok((stream.into(), AnySocketAddr::IP(addr)))
     }
 }
 
-impl UserData for TcpListener {
+impl UserData for LuaTcpListener {
     fn register(registry: &mut UserDataRegistry<Self>) {
         registry.add_method("local_addr", |_, this, ()| Ok(this.local_addr()?));
 
         registry.add_async_function("listen", listen);
 
         registry.add_async_method("accept", |_, this, ()| async move {
             let (stream, _) = lua_try!(this.0.accept().await);
-            Ok(Ok(TcpStream::from(stream)))
+            Ok(Ok(LuaTcpStream::from(stream)))
         });
     }
 }
 
+/// Creates a TCP listener bound to the specified address.
+///
+/// # Arguments
+/// * `addr`: The address to bind to.
+/// * `port`: The port to bind to. If `None`, a random available port will be used.
+/// * `params` (optional): A table of socket options.
+///
+/// The following options can be specified:
+/// * `backlog`: The maximum number of pending connections. Default is 1024.
 pub async fn listen(
     _: Lua,
     (addr, port, params): (String, Option<u16>, Option<Table>),
-) -> Result<StdResult<TcpListener, String>> {
+) -> Result<StdResult<LuaTcpListener, String>> {
     let port = port.unwrap_or(0);
     let addrs = lua_try!(lookup_host((addr, port)).await);
 
     let sock_options = SocketOptions::from_table(&params)?;
     let backlog = opt_param!(params, "backlog")?;
 
     let try_listen = |addr: SocketAddr| {
-        let sock = TcpSocket::new_for_addr(addr)?;
+        let sock = LuaTcpSocket::new_for_addr(addr)?;
         sock.set_options(sock_options)?;
         sock.0.set_reuseaddr(true)?;
         sock.0.bind(addr)?;
-        let listener = TcpListener(sock.0.listen(backlog.unwrap_or(1024))?);
-        io::Result::Ok(listener)
+        let backlog = backlog.unwrap_or(1024);
+        let listener = sock.0.listen(backlog)?;
+        io::Result::Ok(listener.into())
     };
 
     let mut last_err = None;

src/net/tcp/mod.rs

@@ -1,15 +1,15 @@
 use mlua::{Lua, Result, Table};
 
-pub use listener::{TcpListener, listen};
-pub use stream::{TcpStream, connect};
+pub use listener::{LuaTcpListener, listen};
+pub use stream::{LuaTcpStream, connect};
 
-use socket::{SocketOptions, TcpSocket};
+use socket::{SocketOptions, LuaTcpSocket};
 
 /// A loader for the `net/tcp` module.
 fn loader(lua: &Lua) -> Result<Table> {
     let t = lua.create_table()?;
-    t.set("TcpListener", lua.create_proxy::<TcpListener>()?)?;
-    t.set("TcpStream", lua.create_proxy::<TcpStream>()?)?;
+    t.set("TcpListener", lua.create_proxy::<LuaTcpListener>()?)?;
+    t.set("TcpStream", lua.create_proxy::<LuaTcpStream>()?)?;
     t.set("listen", lua.create_async_function(listen)?)?;
     t.set("connect", lua.create_async_function(connect)?)?;
     Ok(t)

src/net/tcp/socket.rs

@@ -3,11 +3,12 @@ use std::net::SocketAddr;
 use std::ops::Deref;
 
 use mlua::{Result, Table};
+use tokio::net::TcpSocket;
 
-pub(crate) struct TcpSocket(pub(crate) tokio::net::TcpSocket);
+pub(crate) struct LuaTcpSocket(pub(crate) TcpSocket);
 
-impl Deref for TcpSocket {
-    type Target = tokio::net::TcpSocket;
+impl Deref for LuaTcpSocket {
+    type Target = TcpSocket;
 
     #[inline]
     fn deref(&self) -> &Self::Target {
@@ -25,13 +26,13 @@ pub(super) struct SocketOptions {
     reuseport: Option<bool>,
 }
 
-impl TcpSocket {
+impl LuaTcpSocket {
     pub(crate) fn new_for_addr(addr: SocketAddr) -> io::Result<Self> {
         let sock = match addr {
-            SocketAddr::V4(_) => tokio::net::TcpSocket::new_v4()?,
-            SocketAddr::V6(_) => tokio::net::TcpSocket::new_v6()?,
+            SocketAddr::V4(_) => TcpSocket::new_v4()?,
+            SocketAddr::V6(_) => TcpSocket::new_v6()?,
         };
-        Ok(TcpSocket(sock))
+        Ok(LuaTcpSocket(sock))
     }
 
     pub(crate) fn set_options(&self, options: SocketOptions) -> io::Result<()> {