tamipes/mc-ingress
1
0
Fork 0
Code Issues 3 Pull requests Projects Releases Packages Wiki Activity Actions

feat: handle login and scaling up deployments

Browse source
This commit is contained in:
Tamipes 2025-12-01 20:03:23 +01:00
parent b14d3b599d
commit 6021bb05f1
5 changed files with 222 additions and 44 deletions
Download patch file Download diff file Expand all files Collapse all files

134
src/main.rs
View file

@ -3,11 +3,13 @@
//! with labels and namespace selectors supported.
use std::{net::SocketAddr, sync::Arc};
use futures::TryFutureExt;
use tokio::io::AsyncWriteExt;
use tokio::net::{TcpListener, TcpStream};
use tokio::sync::Mutex;
use tracing_subscriber::{prelude::*, EnvFilter};
use crate::kube_cache::{KubeServer, ServerDeploymentStatus};
use crate::kube_cache::{Cache, KubeServer, ServerDeploymentStatus};
use crate::opaque_error::OpaqueError;
use crate::packets::clientbound::status::StatusStructNew;
use crate::packets::serverbound::handshake::Handshake;
@ -55,7 +57,7 @@ async fn main() {
if let Err(e) = process_connection(socket, addr, acc).await {
tracing::error!(
message = format!("Client disconnected"),
addr = format!("{}:{}", addr.ip().to_string(), addr.port().to_string()),
// addr = format!("{}:{}", addr.ip().to_string(), addr.port().to_string()),
trace = format!("{}", e.get_span_trace()),
err = format!("{}", e.context)
);
@ -85,7 +87,7 @@ async fn process_connection(
// --- Handshake ---
let handshake;
let server_state;
let next_server_state;
if client_packet.id.get_int() != 0 {
return Err(OpaqueError::create(
"Client HANDSHAKE -> bad packet; Disconnecting...",
@ -95,38 +97,41 @@ async fn process_connection(
.await
.ok_or_else(|| "Handshake request from client failed to parse".to_string())?;
server_state = handshake.get_next_state();
next_server_state = handshake.get_next_state();
match server_state {
let kube_server = KubeServer::create(cache.clone(), &handshake.get_server_address()).await?;
tracing::debug!(
"kube server status: {:?}",
kube_server.get_server_status().await?
);
match next_server_state {
packets::ProtocolState::Status => {
handle_status(
&mut client_stream,
cache,
handshake.get_server_address(),
&handshake,
)
.await?;
handle_status(&mut client_stream, &handshake, kube_server).await?;
}
packets::ProtocolState::Login => todo!(),
packets::ProtocolState::Transfer => todo!(),
_ => todo!(),
packets::ProtocolState::Login => {
handle_login(&mut client_stream, &handshake, kube_server, cache.clone()).await?
}
packets::ProtocolState::Transfer => {
return Err(OpaqueError::create("Transfer; Not yet implemented!"))
}
_ => unreachable!(),
};
Ok(())
}
#[tracing::instrument(level = "info", skip(client_stream, cache, handshake))]
#[tracing::instrument(level = "info", fields(server_addr = kube_server.get_server_addr()),skip(client_stream, handshake, kube_server))]
async fn handle_status(
client_stream: &mut TcpStream,
cache: Arc<Mutex<kube_cache::Cache>>,
server_addr: String,
handshake: &Handshake,
kube_server: KubeServer,
) -> Result<(), OpaqueError> {
tracing::debug!(handshake = ?handshake);
let client_packet = Packet::parse(client_stream)
.await
.ok_or_else(|| "Could not parse client_packet".to_string())?;
match client_packet.id.get_int() {
0 => tracing::info!("Client STATUS: {:#x} Status Request", 0),
0 => tracing::info!("status request"),
_ => {
return Err(OpaqueError::create(&format!(
"Client STATUS: {:#x} Unknown Id -> Shutdown",
@ -135,15 +140,10 @@ async fn handle_status(
}
};
let kube_server = KubeServer::create(cache, &server_addr).await?;
let status: ServerDeploymentStatus = kube_server.get_server_status().await?;
tracing::info!("kube server status: {:?}", status);
let commit_hash: &'static str = env!("COMMIT_HASH");
let mut status_struct = StatusStructNew::create();
status_struct.version.protocol = handshake.protocol_version.get_int();
match status {
match kube_server.get_server_status().await? {
ServerDeploymentStatus::Connectable => {
return kube_server
.proxy_status(handshake, &client_packet, client_stream)
@ -170,3 +170,87 @@ async fn handle_status(
Ok(())
}
#[tracing::instrument(level = "info", fields(server_addr = kube_server.get_server_addr()),skip(client_stream, handshake, kube_server,cache))]
async fn handle_login(
client_stream: &mut TcpStream,
handshake: &Handshake,
kube_server: KubeServer,
cache: Arc<Mutex<Cache>>,
) -> Result<(), OpaqueError> {
// let client_packet = Packet::parse(client_stream).await.unwrap();
tracing::info!("login request");
match kube_server.get_server_status().await? {
ServerDeploymentStatus::Connectable => {
// referenced from:
// https://github.com/hanyu-dev/tokio-splice2/blob/fc47199fffde8946b0acf867d1fa0b2222267a34/examples/proxy.rs
let io_sl2sr = tokio_splice2::context::SpliceIoCtx::prepare()
.map_err(|e| format!("tokio_splice2::context::SpliceIoCtx err={}", e.to_string()))?
.into_io();
let io_sr2sl = tokio_splice2::context::SpliceIoCtx::prepare()
.map_err(|e| format!("tokio_splice2::context::SpliceIoCtx err={}", e.to_string()))?
.into_io();
let port = kube_server
.get_port()
.ok_or_else(|| "failed to get port from service")?;
let mut server_stream = TcpStream::connect(format!("localhost:{}", port))
.await
.map_err(|_| "Failed to connect to minecraft server")?;
handshake
.send_packet(&mut server_stream)
.await
.map_err(|_| "Failed to forward handshake packet to minecraft server")?;
tracing::info!("proxying with splice");
let traffic = tokio_splice2::io::SpliceBidiIo { io_sl2sr, io_sr2sl }
.execute(client_stream, &mut server_stream)
.await;
tracing::debug!("data exchanged: tx: {} rx: {}", traffic.tx, traffic.rx);
}
ServerDeploymentStatus::PodOk | ServerDeploymentStatus::Starting => {
let _client_packet = Packet::parse(client_stream).await;
if _client_packet.is_none() {
return Err(OpaqueError::create(
"Client LOGIN START -> bad packet; Disconnecting...",
));
}
let disconnect_packet =
packets::clientbound::login::Disconnect::set_reason("Starting...§d<3§r".to_owned())
.await
.ok_or_else(|| "failed to *create* disconnect packet")?;
disconnect_packet
.send_packet(client_stream)
.await
.map_err(|_| "failed to *send* disconnect packet")?;
client_stream.flush().await.map_err(|e| e.to_string())?;
}
ServerDeploymentStatus::Offline => {
let _client_packet = Packet::parse(client_stream).await;
if _client_packet.is_none() {
return Err(OpaqueError::create(
"Client LOGIN START -> bad packet; Disconnecting...",
));
}
kube_server
.set_scale(cache, 1)
.map_err(|e| format!("Failed to set depoloyment scale: err = {:?}", e))
.await?;
let disconnect_packet = packets::clientbound::login::Disconnect::set_reason(
"Okayy_starting_it...§d<3§r".to_owned(),
)
.await
.ok_or_else(|| "failed to *create* disconnect packet")?;
disconnect_packet
.send_packet(client_stream)
.await
.map_err(|_| "failed to *send* disconnect packet")?;
client_stream.flush().await.map_err(|e| e.to_string())?;
}
}
Ok(())
}