wip: refactoring all the structure and improve error messages

rpxy-lib/src/proxy/mod.rs

@@ -0,0 +1,22 @@
+mod proxy_main;
+mod socket;
+
+use crate::{globals::Globals, hyper_executor::LocalExecutor};
+use hyper_util::server::{self, conn::auto::Builder as ConnectionBuilder};
+use std::sync::Arc;
+
+pub(crate) use proxy_main::Proxy;
+
+/// build connection builder shared with proxy instances
+pub(crate) fn connection_builder(globals: &Arc<Globals>) -> Arc<ConnectionBuilder<LocalExecutor>> {
+  let executor = LocalExecutor::new(globals.runtime_handle.clone());
+  let mut http_server = server::conn::auto::Builder::new(executor);
+  http_server
+    .http1()
+    .keep_alive(globals.proxy_config.keepalive)
+    .pipeline_flush(true);
+  http_server
+    .http2()
+    .max_concurrent_streams(globals.proxy_config.max_concurrent_streams);
+  Arc::new(http_server)
+}

rpxy-lib/src/proxy/proxy_main.rs

@@ -0,0 +1,63 @@
+use super::socket::bind_tcp_socket;
+use crate::{error::RpxyResult, globals::Globals, hyper_executor::LocalExecutor, log::*};
+use hyper_util::server::conn::auto::Builder as ConnectionBuilder;
+use std::{net::SocketAddr, sync::Arc};
+
+/// Proxy main object responsible to serve requests received from clients at the given socket address.
+pub(crate) struct Proxy<E = LocalExecutor> {
+  /// global context shared among async tasks
+  pub globals: Arc<Globals>,
+  /// listen socket address
+  pub listening_on: SocketAddr,
+  /// whether TLS is enabled or not
+  pub tls_enabled: bool,
+  /// hyper connection builder serving http request
+  pub connection_builder: Arc<ConnectionBuilder<E>>,
+}
+
+impl Proxy {
+  /// Start without TLS (HTTP cleartext)
+  async fn start_without_tls(&self) -> RpxyResult<()> {
+    let listener_service = async {
+      let tcp_socket = bind_tcp_socket(&self.listening_on)?;
+      let tcp_listener = tcp_socket.listen(self.globals.proxy_config.tcp_listen_backlog)?;
+      info!("Start TCP proxy serving with HTTP request for configured host names");
+      while let Ok((stream, client_addr)) = tcp_listener.accept().await {
+        //   self.serve_connection(TokioIo::new(stream), client_addr, None);
+      }
+      Ok(()) as RpxyResult<()>
+    };
+    listener_service.await?;
+    Ok(())
+  }
+
+  /// Entrypoint for HTTP/1.1, 2 and 3 servers
+  pub async fn start(&self) -> RpxyResult<()> {
+    let proxy_service = async {
+      // if self.tls_enabled {
+      // self.start_with_tls().await
+      // } else {
+      self.start_without_tls().await
+      // }
+    };
+
+    match &self.globals.term_notify {
+      Some(term) => {
+        tokio::select! {
+          _ = proxy_service => {
+            warn!("Proxy service got down");
+          }
+          _ = term.notified() => {
+            info!("Proxy service listening on {} receives term signal", self.listening_on);
+          }
+        }
+      }
+      None => {
+        proxy_service.await?;
+        warn!("Proxy service got down");
+      }
+    }
+
+    Ok(())
+  }
+}

rpxy-lib/src/proxy/socket.rs

@@ -0,0 +1,46 @@
+use crate::{error::*, log::*};
+#[cfg(feature = "http3-quinn")]
+use socket2::{Domain, Protocol, Socket, Type};
+use std::net::SocketAddr;
+#[cfg(feature = "http3-quinn")]
+use std::net::UdpSocket;
+use tokio::net::TcpSocket;
+
+/// Bind TCP socket to the given `SocketAddr`, and returns the TCP socket with `SO_REUSEADDR` and `SO_REUSEPORT` options.
+/// This option is required to re-bind the socket address when the proxy instance is reconstructed.
+pub(super) fn bind_tcp_socket(listening_on: &SocketAddr) -> RpxyResult<TcpSocket> {
+  let tcp_socket = if listening_on.is_ipv6() {
+    TcpSocket::new_v6()
+  } else {
+    TcpSocket::new_v4()
+  }?;
+  tcp_socket.set_reuseaddr(true)?;
+  tcp_socket.set_reuseport(true)?;
+  if let Err(e) = tcp_socket.bind(*listening_on) {
+    error!("Failed to bind TCP socket: {}", e);
+    return Err(RpxyError::Io(e));
+  };
+  Ok(tcp_socket)
+}
+
+#[cfg(feature = "http3-quinn")]
+/// Bind UDP socket to the given `SocketAddr`, and returns the UDP socket with `SO_REUSEADDR` and `SO_REUSEPORT` options.
+/// This option is required to re-bind the socket address when the proxy instance is reconstructed.
+pub(super) fn bind_udp_socket(listening_on: &SocketAddr) -> RpxyResult<UdpSocket> {
+  let socket = if listening_on.is_ipv6() {
+    Socket::new(Domain::IPV6, Type::DGRAM, Some(Protocol::UDP))
+  } else {
+    Socket::new(Domain::IPV4, Type::DGRAM, Some(Protocol::UDP))
+  }?;
+  socket.set_reuse_address(true)?; // This isn't necessary?
+  socket.set_reuse_port(true)?;
+  socket.set_nonblocking(true)?; // This was made true inside quinn. so this line isn't necessary here. but just in case.
+
+  if let Err(e) = socket.bind(&(*listening_on).into()) {
+    error!("Failed to bind UDP socket: {}", e);
+    return Err(RpxyError::Io(e));
+  };
+  let udp_socket: UdpSocket = socket.into();
+
+  Ok(udp_socket)
+}