diff --git a/README.md b/README.md index 54b2413..8a10d6f 100644 --- a/README.md +++ b/README.md @@ -1,8 +1,3 @@ -# Development -TODO: fill this out -### Nix shell with tmux -In the nix flake there is a devshell setup with cargo and tmux. -When using tmux it uses a set tmux server path, so only this project uses it. # Env variables: ```bash # Address the server should bind to diff --git a/flake.nix b/flake.nix index 2f97def..b64872c 100644 --- a/flake.nix +++ b/flake.nix @@ -142,11 +142,6 @@ # Extra inputs can be added here; cargo and rustc are provided by default. packages = [ pkgs.rust-analyzer - - (pkgs.writers.writeBashBin "tmux" '' - exec ${lib.getExe pkgs.tmux} -S /tmp/tmux-kube_ingress "$@" - '' - ) ]; }; }); diff --git a/src/kube_cache.rs b/src/kube_cache.rs index c8be2e5..ae54ce8 100644 --- a/src/kube_cache.rs +++ b/src/kube_cache.rs @@ -12,7 +12,11 @@ use tracing::Instrument; use crate::{ mc_server::{sanitize_addr, MinecraftAPI, MinecraftServerHandle, ServerDeploymentStatus}, - packets::{clientbound::status::StatusTrait, SendPacket}, + packets::{ + clientbound::status::StatusTrait, + serverbound::handshake::{self}, + SendPacket, + }, OpaqueError, }; @@ -95,19 +99,17 @@ impl MinecraftAPI for McApi { let dep_name = match self.cache.query_dep_addr(&addr, &port).await { Some(x) => x, None => { - return Err(OpaqueError::create_with_kind( - "Failed to find deployment name by addr", - "DepNameLookupFailed", - )) + return Err(OpaqueError::create(&format!( + "Failed to find deployment name by addr" + ))) } }; let srv_name = match self.cache.query_srv_addr(&addr, &port).await { Some(x) => x, None => { - return Err(OpaqueError::create_with_kind( - "Failed to find service name by addr", - "SrvNameLookupFailed", - )) + return Err(OpaqueError::create(&format!( + "Failed to find service name by addr" + ))) } }; @@ -189,7 +191,7 @@ impl MinecraftAPI for McApi { drop(guard); if let Err(err) = server.stop().await { tracing::error!( - trace = %err.print_span_trace(), + trace = err.get_span_trace(), err = err.context, msg = "failed to stop server" ); @@ -434,7 +436,6 @@ impl fmt::Debug for ServerDeploymentStatus { Self::Starting => write!(f, "Starting"), Self::PodOk => write!(f, "PodOk"), Self::Offline => write!(f, "Offline"), - Self::Unavailable(s) => write!(f, "Unavailable ({s})"), } } } diff --git a/src/main.rs b/src/main.rs index 80c5a3c..798ea01 100644 --- a/src/main.rs +++ b/src/main.rs @@ -58,35 +58,12 @@ async fn main() { "Client connected" ); if let Err(e) = process_connection(socket, addr, api, config).await { - match e.level { - tracing::Level::ERROR => tracing::error!( - // addr = format!("{}:{}", addr.ip().to_string(), addr.port().to_string()), - trace = %e.print_span_trace(), - err = format!("{}", e.context), - "Client disconnected" - ), - tracing::Level::WARN => tracing::warn!( - // addr = format!("{}:{}", addr.ip().to_string(), addr.port().to_string()), - trace = %e.print_span_trace(), - err = format!("{}", e.context), - "Client disconnected" - ), - tracing::Level::INFO => tracing::info!( - // addr = format!("{}:{}", addr.ip().to_string(), addr.port().to_string()), - trace = %e.print_span_trace(), - err = format!("{}", e.context), - "Client disconnected" - ), - _ => { - tracing::error!( - // addr = format!("{}:{}", addr.ip().to_string(), addr.port().to_string()), - trace = %e.print_span_trace(), - err = format!("{}", e.context), - actual_level = ?e.level, - "Client disconnected (bad level)" - ) - } - } + tracing::error!( + // addr = format!("{}:{}", addr.ip().to_string(), addr.port().to_string()), + trace = format!("{}", e.get_span_trace()), + err = format!("{}", e.context), + "Client disconnected" + ); } else { tracing::debug!( addr = format!("{}:{}", addr.ip().to_string(), addr.port().to_string()), @@ -97,55 +74,42 @@ async fn main() { } } +#[tracing::instrument(level = "info", skip(api, client_stream, config))] async fn process_connection( mut client_stream: TcpStream, addr: SocketAddr, api: impl MinecraftAPI, config: Config, ) -> Result<(), OpaqueError> { - // this is wrapper so that async doesnt mess up the span, and - // to make sure this doesn't propagate to later `handle_*` - #[tracing::instrument(level = "info", skip(client_stream, config))] - async fn first_packet( - client_stream: &mut TcpStream, - config: Config, - ) -> Result, OpaqueError> { - let client_packet = Packet::parse(client_stream).await?; + let client_packet = Packet::parse(&mut client_stream).await?; - // --- Handshake --- - let handshake; - let packet_id = client_packet.id.get_int(); - if packet_id != 0 { - return Err(OpaqueError::create(&format!( - "Client HANDSHAKE -> bad packet; id={packet_id} Disconnecting..." - ))); - } - handshake = packets::serverbound::handshake::Handshake::parse(client_packet) - .await - .ok_or_else(|| "Client HANDSHAKE -> malformed packet; Disconnecting...".to_string())?; - - let filter = eval_boolean(&format!( - "addr=\"{}\";{}", - handshake.get_server_address(), - config.filter_conn - )) - .map_err(|e| format!("filter error! err={:?}", e))?; - if filter { - // TODO: if the server just returns here, the client does not know it - // and sends a packet with the 122 WeirdID - tracing::trace!("filtered out the connection"); - return Ok(None); - } - - Ok(Some(handshake)) + // --- Handshake --- + let handshake; + let next_server_state; + let packet_id = client_packet.id.get_int(); + if packet_id != 0 { + return Err(OpaqueError::create(&format!( + "Client HANDSHAKE -> bad packet; id={packet_id} Disconnecting..." + ))); } - let handshake = match first_packet(&mut client_stream, config).await? { - Some(x) => x, - // this is needed because of the filter - None => return Ok(()), - }; + handshake = packets::serverbound::handshake::Handshake::parse(client_packet) + .await + .ok_or_else(|| "Client HANDSHAKE -> malformed packet; Disconnecting...".to_string())?; + + let filter = eval_boolean(&format!( + "addr=\"{}\";{}", + handshake.get_server_address(), + config.filter_conn + )) + .map_err(|e| format!("filter error! err={:?}", e))?; + if filter { + // TODO: if the server just returns here, the client does not know it + // and sends a packet with the 122 WeirdID + return Ok(()); + } + + next_server_state = handshake.get_next_state(); - let next_server_state = handshake.get_next_state(); match next_server_state { packets::ProtocolState::Status => { handle_status(&mut client_stream, &handshake, api).await?; @@ -195,6 +159,7 @@ async fn handle_status( }; let server_addr = handshake.get_server_address(); + let commit_hash: &'static str = env!("COMMIT_HASH"); let mut status_struct = StatusStructNew::create(); status_struct.version.protocol = handshake.protocol_version.get_int(); @@ -207,7 +172,7 @@ async fn handle_status( { Ok(x) => x, Err(e) => { - let span = tracing::span!(tracing::Level::INFO, "unavailable", err = e.get_kind()); + let span = tracing::span!(tracing::Level::WARN, "not_found", err = e.context); status_struct.players.max = 0; status_struct.players.online = 0; status_struct.description.text = format!( @@ -219,25 +184,22 @@ async fn handle_status( .await?; // Recieve the ping packet, so the client does not send it again - let _ping = Packet::parse(client_stream) - .instrument(span.clone()) - .await - .map_err(|err| { - tracing::debug!( - err = OpaqueError::from(err).context, - "failed to parse ping packet" - ) - }); + let _ping = Packet::parse(client_stream).instrument(span.clone()).await; // Send a bad ping packet back, so the client shows *searching* icon let _pong = Packet::new(9, vec![0; 8]) .ok_or("failed to create empty pong packet?")? .send_packet(client_stream) .instrument(span.clone()) .await - .map_err(|_| tracing::debug!("failed to send pong packet")); + .map_err(|_| "failed to send pong packet")?; + let _guard = span.enter(); - let status = ServerDeploymentStatus::Unavailable(e.get_kind().to_string()); - tracing::info!(status = ?status, "status request"); + match _ping { + Ok(_) => tracing::info!("sent status with error"), + Err(err) => { + tracing::error!(err = OpaqueError::from(err).context) + } + }; return Ok(()); } }; @@ -247,6 +209,7 @@ async fn handle_status( .get_motd() .unwrap_or("A minecraft server (proxy motd)".to_string()); + tracing::trace!(motd); match status { ServerDeploymentStatus::Connectable(mut server_stream) => { return server @@ -264,7 +227,6 @@ async fn handle_status( status_struct.description.text = format!("{motd}\n§4Offline§r §oJoin to start!§r - {BYE_MESSAGE}"); } - ServerDeploymentStatus::Unavailable(_) => unreachable!(), }; mc_server::complete_status_request(client_stream, status_struct).await?; @@ -283,8 +245,7 @@ async fn handle_login( &handshake.get_server_address(), &handshake.server_port.get_value().to_string(), ) - .await - .map_err(|e| e.set_level(tracing::Level::WARN))?; + .await?; let status = server.query_status().await?; tracing::debug!(msg = "server status", status = ?status); @@ -320,20 +281,12 @@ async fn handle_login( .execute(client_stream, &mut server_stream) .await; - match traffic.error { - Some(e) => { - tracing::warn!( - tx = traffic.tx, - rx = traffic.rx, - err = ?e, - "connection splicing ended with error", - ) - } - None => tracing::info!( - tx = traffic.tx, - rx = traffic.rx, - "connection splicing ended", - ), + tracing::debug!("data exchanged: tx: {} rx: {}", traffic.tx, traffic.rx); + if let Some(e) = traffic.error { + return Err(OpaqueError::create(&format!( + "failed to splice; err = {}", + e + ))); } } ServerDeploymentStatus::PodOk | ServerDeploymentStatus::Starting => { @@ -345,7 +298,6 @@ async fn handle_login( .await?; mc_server::send_disconnect(client_stream, format!("[\"\",{{\"text\":\"Okayy, §2starting§r the server!\n\n\"}},{{\"text\":\"{BYE_MESSAGE}\"}}]").as_str()).await?; } - ServerDeploymentStatus::Unavailable(_) => unreachable!(), } Ok(()) } diff --git a/src/mc_server.rs b/src/mc_server.rs index 03b6a9d..069e27a 100644 --- a/src/mc_server.rs +++ b/src/mc_server.rs @@ -139,7 +139,6 @@ pub enum ServerDeploymentStatus { Starting, PodOk, Offline, - Unavailable(String), } pub fn sanitize_addr(addr: &str) -> &str { diff --git a/src/opaque_error.rs b/src/opaque_error.rs index 07c65d7..ad70182 100644 --- a/src/opaque_error.rs +++ b/src/opaque_error.rs @@ -1,16 +1,10 @@ -use std::{ - error::Error, - fmt::{self, Debug}, -}; -use tracing::Level; +use std::{error::Error, fmt}; use tracing_error::SpanTrace; #[derive(Debug)] pub struct OpaqueError { span_trace: SpanTrace, pub context: String, - pub level: Level, - kind: Option, } impl fmt::Display for OpaqueError { @@ -37,23 +31,13 @@ impl fmt::Display for OpaqueError { } impl Error for OpaqueError {} impl OpaqueError { - pub fn create(context: &str) -> OpaqueError { + pub fn create(str: &str) -> OpaqueError { Self { span_trace: SpanTrace::capture(), - context: context.to_string(), - level: Level::ERROR, - kind: None, + context: str.to_string(), } } - pub fn create_with_kind(context: &str, kind: &str) -> OpaqueError { - Self { - span_trace: SpanTrace::capture(), - context: context.to_string(), - level: Level::ERROR, - kind: Some(kind.to_string()), - } - } - pub fn print_span_trace(&self) -> FancyTrace { + pub fn get_span_trace(&self) -> String { let mut vec: Vec<(&str, String)> = Vec::new(); self.span_trace.with_spans(|metadata, _fields| { @@ -61,50 +45,30 @@ impl OpaqueError { true }); let str = vec.iter().rfold(String::new(), |mut acc, x| { - let first = acc.len() == 0; - if !first { - // TODO: should this code be hardcoded? - acc.push_str("\x1b[2m:\x1b[0m"); + let first = acc.len() != 0; + if first { + acc.push_str(":"); } acc.push_str(x.0); - if !x.1.is_empty() { - acc.push_str("{"); - acc.push_str(&x.1); - acc.push_str("}"); - } + acc.push_str("{"); + acc.push_str(&x.1); + acc.push_str("}"); + acc }); - - FancyTrace { str } - } - pub fn set_level(mut self, lvl: Level) -> Self { - self.level = lvl; - self - } - pub fn get_kind(&self) -> &str { - match self.kind.as_ref() { - Some(x) => &x, - None => &self.context, + match String::from_utf8(strip_ansi_escapes::strip(str.clone())) { + Ok(x) => x, + Err(_) => str, } } } -pub struct FancyTrace { - str: String, -} -impl fmt::Display for FancyTrace { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - write!(f, "\x1b[2m{{{{\x1b[0m {} \x1b[2m}}}}\x1b[0m", self.str) - } -} impl From for OpaqueError { fn from(value: String) -> Self { Self { span_trace: SpanTrace::capture(), context: value, - level: Level::ERROR, - kind: None, } } } @@ -114,8 +78,6 @@ impl From<&str> for OpaqueError { Self { span_trace: SpanTrace::capture(), context: value.to_string(), - level: Level::ERROR, - kind: None, } } } @@ -125,8 +87,6 @@ impl From for OpaqueError { Self { span_trace: value.context, context: format!("{:?}", value.inner), - level: Level::ERROR, - kind: None, } } } diff --git a/src/packets/mod.rs b/src/packets/mod.rs index 9a20335..28c6a04 100644 --- a/src/packets/mod.rs +++ b/src/packets/mod.rs @@ -61,7 +61,7 @@ impl Packet { pub async fn parse(stream: &mut TcpStream) -> Result { let length = VarInt::parse(stream) .await - .ok_or(ParseError::LengthParseError)?; + .ok_or(ParseError::IDParseError)?; tracing::trace!(length = length.get_int()); let id = match VarInt::parse(stream).await { @@ -150,7 +150,6 @@ impl From for ParseErrorTrace { } pub enum ParseError { - LengthParseError, IDParseError, WeirdID, LengthIsTooBig(i32), @@ -163,10 +162,7 @@ pub enum ParseError { impl fmt::Debug for ParseError { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { match self { - Self::LengthParseError => { - write!(f, "LengthParseError: could not parse packet length VarInt") - } - Self::IDParseError => write!(f, "IDParseError: could not parse packet id VarInt"), + Self::IDParseError => write!(f, "IDParseError: could not parse packet id"), Self::WeirdID => write!(f, "WeirdID: weird packet id encountered: 122"), Self::LengthIsTooBig(x) => { write!(f, "LengthIsTooBig: packet length is too big; len={x}")