tom/dockermcmgr
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

nix disable check phase, fix incomplete/failed write in proxy mode, add FML support, rename executable to dmm, image tag specific to servers, config folder from env,

Browse Source
This commit is contained in:
tomoron
2026-06-11 15:22:29 +02:00
parent 3f840ea284
commit 887a228cf2
11 changed files with 114 additions and 36 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
Cargo.lock generated
View File

@ -607,7 +607,7 @@ dependencies = [
[[package]]
name = "dockermcmgr"
version = "0.0.2"
version = "0.0.3"
dependencies = [
"async-std",
"bollard",

8
Cargo.toml
View File

@ -1,11 +1,11 @@
[package]
name = "dockermcmgr"
version = "0.0.2"
version = "0.0.3"
edition = "2024"
#[[bin]]
#name = "dmm"
#path = "src/main.rs"
[[bin]]
name = "dmm"
path = "src/main.rs"
[dependencies]
async-std = "1.13.2"

7
flake.nix
View File

@ -37,16 +37,19 @@
in
final:
{
pname = "dockermcmgr";
version = "0.0.2";
pname = "dmm";
version = "0.0.3";
inherit src;
cargoLock.lockFile = src + "/Cargo.lock";
nativeBuildInputs = tools;
doCheck = false;
buildInputs =
with pkgs; [ sqlite ];
}
// specialArgs
);
in

5
src/cli/env_settings.rs
View File

@ -2,7 +2,7 @@ use std::collections::HashMap;
use clap::{ Arg, ArgMatches, parser::ValueSource};
pub fn get_args() -> [Arg; 21] {
pub fn get_args() -> [Arg; 22] {
[
Arg::new("VERSION").short('v').long("version").help("Minecraft version of the server").default_value("LATEST"),
Arg::new("MEMORY").short('m').long("memory").help("How much ram does this server have").default_value("4G"),
@ -26,12 +26,13 @@ pub fn get_args() -> [Arg; 21] {
Arg::new("SPAWN_ANIMALS").long("spawn-animals").help("spawn animals").default_value("true"),
Arg::new("SPAWN_MONSTERS").long("spawn-monsters").help("spawn monsters").default_value("true"),
Arg::new("SPAWN_NPCS").long("spawn-npcs").help("spawn npcs").default_value("true"),
Arg::new("IMAGE_TAG").long("image-tag").help("set the tag of the docker image").default_value("latest")
]
}
pub fn args_to_settings(arguments: &ArgMatches, default: bool) -> Vec<(String, String)> {
let default_handle = vec!["VERSION", "MEMORY", "MAX_PLAYERS", "SPAWN_PROTECTION", "ONLINE_MODE", "TYPE", "MOTD", "DIFFICULTY", "OPS", "MODE", "ALLOW_FLIGHT",
"ALLOW_NETHER", "HARDCORE", "MAX_TICK_TIME", "PAUSE_WHEN_EMPTY_SECONDS", "PVP", "SPAWN_ANIMALS", "SPAWN_MONSTERS", "SPAWN_NPCS"];
"ALLOW_NETHER", "HARDCORE", "MAX_TICK_TIME", "PAUSE_WHEN_EMPTY_SECONDS", "PVP", "SPAWN_ANIMALS", "SPAWN_MONSTERS", "SPAWN_NPCS", "IMAGE_TAG"];
let mut res = vec![
("EULA".to_string(), "TRUE".to_string()),

6
src/config.rs
View File

@ -1,3 +1,5 @@
use std::env;
pub struct Config {
pub config_path: String,
pub docker_image: String,
@ -6,8 +8,8 @@ pub struct Config {
impl Config {
pub fn load() -> Self {
Self {
config_path: "/home/tom/desktop/rust/yo_mama/servers".to_string(), // that's my program I do what I want
docker_image: "itzg/minecraft-server".to_string()
config_path: env::var("DMM_CONFIG_PATH").unwrap_or_else(|_| "/raid/mc_servers".to_string()),
docker_image: "itzg/minecraft-server".to_string(),
}
}
}

14
src/dockermgr/start.rs
View File

@ -1,12 +1,11 @@
use bollard::{Docker, plugin::{ContainerCreateBody, HostConfig, Mount, MountType}, query_parameters::CreateContainerOptionsBuilder};
use diesel::{prelude::*, result::Error::NotFound};
use crate::{schema, models, status::ServerStatus};
use crate::{dockermgr::utils::get_image_tag, models, schema, status::ServerStatus};
use crate::{DbPool, dockermgr::utils::{self, get_container_ip}};
async fn start_docker_container(docker: &Docker, name: &String) -> Result<String, String> {
utils::check_image(&docker).await?;
let container_name = format!("minecraft-{}", name);
@ -20,6 +19,13 @@ async fn start_docker_container(docker: &Docker, name: &String) -> Result<String
let env = env_file.split("\n").filter_map(|x| if x.len() == 0 { None } else { Some(x.to_string()) } ).collect();
let image_tag = match get_image_tag(&env).await {
Some(tag) => {tag},
None => { return Err("env missing IMAGE_TAG".to_string()); }
};
utils::check_image(&docker, &image_tag).await?;
let mut mount = Mount::default();
mount.typ = Some(MountType::BIND);
mount.target = Some("/data".to_string());
@ -30,13 +36,15 @@ async fn start_docker_container(docker: &Docker, name: &String) -> Result<String
host_config.mounts = Some(vec![mount]);
host_config.auto_remove = Some(true);
let config = crate::Config::load();
let mut create_config = ContainerCreateBody::default();
create_config.tty = Some(true);
create_config.open_stdin = Some(true);
create_config.user = Some("1000:100".to_string());
create_config.stop_timeout = Some(60);
create_config.host_config = Some(host_config);
create_config.image = Some(crate::Config::load().docker_image + ":latest");
create_config.image = Some(config.docker_image + ":" + &image_tag);
create_config.env = Some(env);
let options = CreateContainerOptionsBuilder::default()

36
src/dockermgr/utils.rs
View File

@ -8,9 +8,10 @@ use bollard::{
use futures_util::stream::StreamExt;
pub async fn check_image(docker: &Docker) -> Result<(), String> {
pub async fn check_image(docker: &Docker, tag: &String) -> Result<(), String> {
let mut filters = HashMap::new();
let container_name = crate::Config::load().docker_image;
let config = crate::Config::load();
let container_name = config.docker_image + ":" + tag;
filters.insert("reference", vec![&container_name]);
let options = ListImagesOptionsBuilder::default()
.all(true)
@ -23,9 +24,10 @@ pub async fn check_image(docker: &Docker) -> Result<(), String> {
return Ok(());
}
let options = CreateImageOptionsBuilder::default()
.from_image(&container_name)
.tag("latest")
.tag(tag)
.build();
@ -69,3 +71,31 @@ pub async fn get_container_ip(docker: &Docker, name: &String) -> Result<String,
}
Ok("can't get container ip".to_string())
}
pub async fn get_image_tag(env: &Vec<String>) -> Option<String> {
for var in env {
match var.split_once("=") {
Some(split) => { if split.0 == "IMAGE_TAG" { return Some(split.1.to_string()); }},
None => { },
}
}
None
}

48
src/minecraft/client/buffer.rs
View File

@ -1,18 +1,24 @@
use tokio::net::TcpStream;
use crate::minecraft::client::client::Client;
use crate::minecraft::varint::varint_read;
use std::collections::VecDeque;
use std::io;
use tokio::io::AsyncWriteExt;
impl Client {
pub async fn in_read(&mut self) -> Result<u8, String> {
loop
{
match self.in_stream.try_read(&mut self.read_buf) {
Ok(n) => {
if let Some(out_stream) = &self.out_stream {
let _ = out_stream.writable().await;
let _ = out_stream.try_write(&self.read_buf[..n]);
if let Some(out_stream) = &mut self.out_stream {
out_stream.write_all(&self.read_buf[..n]).await.map_err(|e| format!("Failed to write to server stream :{}", e))?;
} else {
self.buffer_append((&self.read_buf[..n]).to_vec()).await?;
}
@ -23,8 +29,8 @@ impl Client {
Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {
return Ok(1);
}
Err(_e) => {
return Err("read failed".to_string())
Err(e) => {
return Err(format!("in read failed: {}", e))
}
}
}
@ -46,8 +52,7 @@ impl Client {
match self.out_stream.as_mut().unwrap().try_read(&mut self.read_buf) {
Ok(n) => {
let _ = self.in_stream.writable().await;
let _ = self.in_stream.try_write(&self.read_buf[..n]);
self.in_stream.write_all(&self.read_buf[..n]).await.map_err(|e| format!("Failed to write to client stream :{}", e))?;
if n == 0 { Ok(0) } else { Ok(1) }
}
Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {
@ -60,11 +65,14 @@ impl Client {
}
}
pub async fn buffer_append(&mut self, data: Vec<u8>) -> Result<(),String> {
if data.len() == 0 {
return Ok(());
}
println!("[{}] adding {} bytes to the buffer",self, data.len());
if self.buffer.len() + data.len() > 65536 {
return Err("buffer full".to_string());
@ -72,20 +80,34 @@ impl Client {
let _ = self.buffer.extend(data);
while self.buffer.len() != 0 && self.buffer.len() - 1 >= self.buffer[0] as usize {
let mut varint_buffer: VecDeque<u8> = self.buffer[..5].to_vec().into();
println!("varint_buffer : {:?}", varint_buffer);
let expected_len = varint_read(&mut varint_buffer)?;
let varint_len = 5 - varint_buffer.len();
println!("expected len : {}, current len : {}", expected_len as usize, self.buffer.len());
println!("buffer : {:?}", self.buffer);
while self.buffer.len() != 0 && self.buffer.len() - 1 >= expected_len as usize {
if self.buffer[0] == 0 {
return Err("invalid packet".to_string());
}
println!("valid packet found, handling");
println!("varint len : {}", varint_len);
println!("len : {}", expected_len);
let len = varint_read(&mut self.buffer.clone().into())? as usize;
self.handle_packet(self.buffer[1..=len].to_vec().into()).await?;
self.buffer.drain(..len + 1);
self.handle_packet(self.buffer[varint_len..=(expected_len as usize)].to_vec().into()).await?;
self.buffer.drain(..(expected_len as usize + varint_len));
println!("buffer after handle : {:?}", self.buffer);
if let Some(out_stream) = &self.out_stream {
println!("out stream present , sending the {} remaining bytes", self.buffer.len());
if self.buffer.len() != 0 {
let _ = out_stream.writable().await;
let _ = out_stream.try_write(self.buffer.as_slice());
let _ = out_stream.writable().await.map_err(|e| format!("out stream writable call failed : {}", e))?;
let _ = out_stream.try_write(self.buffer.as_slice()).map_err(|e| format!("Failed to send remaining buffer to out stream : {}", e))?;
self.buffer.drain(..);
}
}

6
src/minecraft/client/client.rs
View File

@ -6,7 +6,7 @@
/* By: tomoron <tomoron@student.42angouleme.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2026/05/07 17:23:09 by tomoron #+# #+# */
/* Updated: 2026/06/10 12:29:08 by tomoron ### ########.fr */
/* Updated: 2026/06/11 12:21:51 by tomoron ### ########.fr */
/* */
/* ************************************************************************** */
@ -72,10 +72,12 @@ impl Client {
let conn = &mut self.db_pool.get().unwrap();
let reg = Regex::new(r"^(?:([a-zA-Z-_]*)\.)?mc\.tmoron\.fr$").unwrap();
let reg = Regex::new(r"^(?:([a-zA-Z-_]*)\.)?mc\.tmoron\.fr").unwrap();
let mut found: Option<String> = None;
if let Some(capture) = reg.captures(&self.handshake.as_ref().unwrap().server_address) {
println!("capture : {:?}", capture);
if let Some(captured_str) = capture.get(1) {
println!("found valid capture : {}", captured_str.as_str());
found = Some(captured_str.as_str().to_string());
}
}

13
src/minecraft/client/packet.rs
View File

@ -9,6 +9,7 @@ use tokio::net::TcpStream;
impl Client {
pub async fn handle_packet(&mut self, mut packet: VecDeque<u8>) -> Result<(), String> {
println!("packet len : {}", packet.len());
let packet_id = varint_read(&mut packet)?;
@ -56,7 +57,8 @@ impl Client {
async fn proxy_start(&mut self) -> Result<(),String> {
println!("[{}] starting proxy mode", self);
let redirect_ip = &self.server.as_ref().unwrap().as_ref().unwrap().redirect_ip.as_ref().unwrap();
let server = &self.server.as_ref().unwrap().as_ref().unwrap();
let redirect_ip = server.redirect_ip.as_ref().unwrap();
let split_ip = redirect_ip.split_once(":");
let domain : String = split_ip.unwrap_or_else(|| (redirect_ip, "")).0.to_string();
let port : u16 = split_ip.unwrap_or_else(|| ("", "25565")).1.parse().map_err(|e| format!("Failed to parse redirect_ip : {}", e))?;
@ -64,7 +66,12 @@ impl Client {
.map_err(|_| "failed to connect to remote host".to_string())?;
let mut new_handshake = self.handshake.as_ref().unwrap().clone();
if server.simple_redirect {
new_handshake.server_address = domain;
} else {
new_handshake.server_address = self.handshake.as_ref().unwrap().server_address.clone();
}
new_handshake.server_port = port;
let handshake_packet = new_handshake.to_packet();
@ -76,8 +83,10 @@ impl Client {
let _ = self.out_stream.as_ref().unwrap().writable().await;
let _ = self.out_stream.as_ref().unwrap().try_write(packet.as_slice());
println!("[{}] sent handshake to server", self);
println!("proxy mode started, buffer len : {}", self.buffer.len());
Ok(())
}
}

3
src/models.rs
View File

@ -14,7 +14,8 @@ pub struct Servers {
pub name: String,
pub last_login: Option<NaiveDateTime>,
pub status: ServerStatus,
pub redirect_ip: Option<String>
pub redirect_ip: Option<String>,
pub simple_redirect: bool,
}