chore: rename socket to tcp

README.md

@@ -32,7 +32,7 @@ wait-on file /path/to/file
 ### Wait for a Socket to be available using TCP Protocol
 
 ```bash
-wait-on socket -i 127.0.0.1 -p 8080
+wait-on tcp -i 127.0.0.1 -p 8080
 ```
 
 ## License

src/bin/command/mod.rs

@@ -1,2 +1,2 @@
 pub mod file;
-pub mod socket;
+pub mod tcp;

src/bin/command/socket.rs → src/bin/command/tcp.rs

@@ -3,20 +3,20 @@ use std::net::IpAddr;
 use anyhow::Result;
 use clap::Args;
 
-use wait_on::resource::socket::SocketWaiter;
+use wait_on::resource::tcp::TcpWaiter;
 use wait_on::{WaitOptions, Waitable};
 
 #[derive(Args, Debug)]
-pub struct SocketOpt {
+pub struct TcpOpt {
     #[clap(short = 'p', long = "port")]
     pub port: u16,
     #[clap(short = 'i', long = "ip", default_value = "127.0.0.1")]
     pub addr: IpAddr,
 }
 
-impl SocketOpt {
+impl TcpOpt {
     pub async fn exec(&self) -> Result<()> {
-        let waiter = SocketWaiter::new(self.addr, self.port);
+        let waiter = TcpWaiter::new(self.addr, self.port);
         waiter.wait(WaitOptions::default()).await
     }
 }

src/bin/main.rs

@@ -4,7 +4,7 @@ use anyhow::Result;
 use clap::Parser;
 
 use self::command::file::FileOpt;
-use self::command::socket::SocketOpt;
+use self::command::tcp::TcpOpt;
 
 #[derive(Debug, Parser)]
 #[command(
@@ -16,8 +16,8 @@ use self::command::socket::SocketOpt;
 pub enum Command {
     /// Wait on a file to be available
     File(FileOpt),
-    /// Wait on a socket to be available using the TCP Protocol
-    Socket(SocketOpt),
+    /// Wait on a TCP connection to be available
+    Tcp(TcpOpt),
 }
 
 #[derive(Debug, Parser)]
@@ -32,6 +32,6 @@ async fn main() -> Result<()> {
 
     match args.command {
         Command::File(opt) => opt.exec().await,
-        Command::Socket(opt) => opt.exec().await,
+        Command::Tcp(opt) => opt.exec().await,
     }
 }

src/resource/file.rs

@@ -16,6 +16,24 @@ impl FileWaiter {
     }
 }
 
+impl Waitable for FileWaiter {
+    async fn wait(self, _: WaitOptions) -> Result<()> {
+        let (file_exists_handler, rx) = FileExistsHandler::new();
+        let mut watcher = notify::recommended_watcher(file_exists_handler).unwrap();
+        let parent = self.path.parent().unwrap();
+
+        watcher
+            .watch(parent, notify::RecursiveMode::NonRecursive)
+            .unwrap();
+
+        if rx.recv().is_ok() {
+            watcher.unwatch(parent).unwrap();
+        }
+
+        Ok(())
+    }
+}
+
 struct FileExistsHandler {
     tx: Sender<()>,
 }
@@ -37,21 +55,3 @@ impl EventHandler for FileExistsHandler {
         }
     }
 }
-
-impl Waitable for FileWaiter {
-    async fn wait(self, _: WaitOptions) -> Result<()> {
-        let (file_exists_handler, rx) = FileExistsHandler::new();
-        let mut watcher = notify::recommended_watcher(file_exists_handler).unwrap();
-        let parent = self.path.parent().unwrap();
-
-        watcher
-            .watch(parent, notify::RecursiveMode::NonRecursive)
-            .unwrap();
-
-        if rx.recv().is_ok() {
-            watcher.unwatch(parent).unwrap();
-        }
-
-        Ok(())
-    }
-}

src/resource/mod.rs

@@ -2,25 +2,25 @@
 //! own configuration based on the protocols used.
 
 pub mod file;
-pub mod socket;
+pub mod tcp;
 
 use anyhow::Result;
 
 use crate::{WaitOptions, Waitable};
 
 use self::file::FileWaiter;
-use self::socket::SocketWaiter;
+use self::tcp::TcpWaiter;
 
 pub enum Resource {
     File(FileWaiter),
-    Socket(SocketWaiter),
+    Tcp(TcpWaiter),
 }
 
 impl Waitable for Resource {
     async fn wait(self, options: WaitOptions) -> Result<()> {
         match self {
             Resource::File(file) => file.wait(options).await,
-            Resource::Socket(socket) => socket.wait(options).await,
+            Resource::Tcp(tcp) => tcp.wait(options).await,
         }
     }
 }

src/resource/socket.rs → src/resource/tcp.rs

@@ -10,12 +10,12 @@ use tokio::net::{TcpListener, TcpStream};
 use crate::{WaitOptions, Waitable};
 
 /// Listens on a specific IP Address and Port using TCP protocol
-pub struct SocketWaiter {
+pub struct TcpWaiter {
     pub addr: IpAddr,
     pub port: u16,
 }
 
-impl SocketWaiter {
+impl TcpWaiter {
     pub fn new(addr: IpAddr, port: u16) -> Self {
         Self { addr, port }
     }
@@ -25,6 +25,34 @@ impl SocketWaiter {
     }
 }
 
+impl Waitable for TcpWaiter {
+    async fn wait(self, _: WaitOptions) -> Result<()> {
+        let tcp_listener = TcpListener::bind(self.socket()).await?;
+        let (socket, _) = tcp_listener.accept().await?;
+        let mut socket = PacketExtractor::<8>::read(socket).await?;
+
+        tokio::spawn(async move {
+            let mut buf = vec![0; 1024];
+
+            loop {
+                let n = socket
+                    .read(&mut buf)
+                    .await
+                    .expect("failed to read data from socket");
+
+                if n == 0 {
+                    // socket closed
+                    return;
+                }
+            }
+        })
+        .await
+        .map_err(|err| Error::msg(err.to_string()))?;
+
+        Ok(())
+    }
+}
+
 #[pin_project]
 pub struct PacketExtractor<const B: usize> {
     pub header: [u8; B],
@@ -97,31 +125,3 @@ impl<const B: usize> AsyncWrite for PacketExtractor<B> {
         extractor.socket.poll_shutdown(cx)
     }
 }
-
-impl Waitable for SocketWaiter {
-    async fn wait(self, _: WaitOptions) -> Result<()> {
-        let tcp_listener = TcpListener::bind(self.socket()).await?;
-        let (socket, _) = tcp_listener.accept().await?;
-        let mut socket = PacketExtractor::<8>::read(socket).await?;
-
-        tokio::spawn(async move {
-            let mut buf = vec![0; 1024];
-
-            loop {
-                let n = socket
-                    .read(&mut buf)
-                    .await
-                    .expect("failed to read data from socket");
-
-                if n == 0 {
-                    // socket closed
-                    return;
-                }
-            }
-        })
-        .await
-        .map_err(|err| Error::msg(err.to_string()))?;
-
-        Ok(())
-    }
-}