chore(docs): Add help and readme

Signed-off-by: Kasama <robertoaall@gmail.com>

Author: Kasama

README.md

@@ -0,0 +1,20 @@
+Server Knocker
+==============
+
+Server knocker is an application that can listen to a port and proxy packets to another application.
+
+The proxy will also wait for a idle timeout. If it doesn't get any new packets in this time, it will kill the child application.
+
+Then, if it receives a new packet, it will spawn the child application again so it can continue proxying packets to it.
+
+Motivation
+==========
+
+The goal of server knocker is to save resources when running some expensive application that is not used often. For example, a game server to play with friends every once in a while without wasting resources in the server.
+
+Think a minecraft server that can automatically shut down during the night, and spin up automatically when someone tries to join in.
+
+Usage
+=====
+
+Use `server-knocker --help` for detailed up-to-date information.

src/main.rs

@@ -20,24 +20,49 @@ mod proxy;
 mod timer;
 
 #[derive(Clone, Debug, Parser)]
+/// Server Knocker runs a child application and acts like a proxy to it.
+///
+/// It expects to run a child application and proxy all packets to the port that this child is listening on.
+///
+/// After a time without receiving any packets (idle_timeout), the child is terminated.
 struct Command {
     #[arg(long)]
-    dest: SocketAddr,
+    /// Address for the proxy to listen on
+    listen: SocketAddr,
     #[arg(long)]
-    bind: SocketAddr,
+    /// Destination address for the proxy
+    destination: SocketAddr,
 
+    #[arg(long, default_value_t = String::from("1h"))]
+    /// Time between received packets to consider the child applicaiton idle
+    ///
+    /// Use `h` for hour, `m` for minute, `s` for second or any combination
+    idle_timeout: String,
     #[arg(long, default_value_t = String::from("10s"))]
+    /// Time to wait between trying to terminate the idle application (SIGTERM) and killing it
+    /// (SIGKILL)
+    ///
+    /// Use `h` for hour, `m` for minute, `s` for second or any combination
     grace_period: String,
-    #[arg(long, default_value_t = String::from("10s"))]
-    idle_timeout: String,
 
     #[arg(long, default_value_t = false)]
+    /// (experimental) For TCP proxies: if set the proxy will hold off the request until the child is ready if it
+    /// was down.
+    ///
+    /// This is experimental because it doesn't work properly with child applications that take a
+    /// long time to become ready. It will probably need to be paired with a "readiness probe" of sorts in the future.
     hold_packets: bool,
 
     #[arg(short = 'u', long, default_value_t = false)]
+    /// Whether to use UDP instead of the default TCP for the proxy
     udp: bool,
 
     #[arg(long)]
+    /// Command to run as a child. It's expected that it listens on the port set by `dest` and can
+    /// be terminated
+    ///
+    /// Make sure that terminating this command also terminates the child application. If using
+    /// Server Knocker with Docker, for example, make sure to not set `-d`.
     command: String,
 }
 
@@ -114,11 +139,11 @@ async fn main() -> anyhow::Result<()> {
     info!("Proxy starting...");
 
     if cmd.udp {
-        UDPProxy::new(cmd.dest, cmd.bind, network_sender)
-            .start(None)
+        UDPProxy::new(cmd.destination, cmd.listen, network_sender)
+            .start()
             .await?;
     } else {
-        TCPProxy::new(cmd.dest, cmd.bind, network_sender)
+        TCPProxy::new(cmd.destination, cmd.listen, network_sender)
             .start(if cmd.hold_packets {
                 Some(can_proxy_resume)
             } else {

src/proxy/udp.rs

@@ -7,7 +7,6 @@ use log::{error, info};
 use tokio::net::UdpSocket;
 use tokio::sync::mpsc::{channel, Receiver};
 use tokio::sync::watch::Sender;
-use tokio::sync::Notify;
 
 use super::ProxyEvent;
 
@@ -55,7 +54,7 @@ impl UDPProxy {
         Ok(()) as anyhow::Result<()>
     }
 
-    pub async fn start(&self, can_resume: Option<Arc<Notify>>) -> anyhow::Result<()> {
+    pub async fn start(&self) -> anyhow::Result<()> {
         let local = Arc::new(UdpSocket::bind(self.listen_addr).await?);
 
         let (response_sender, receiver) = channel::<(SocketAddr, Vec<u8>)>(512);