login to start

src/minecraft/client/client.rs

@@ -6,16 +6,26 @@
 /*   By: tomoron <tomoron@student.42angouleme.fr>   +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2026/05/07 17:23:09 by tomoron           #+#    #+#             */
-/*   Updated: 2026/06/05 12:36:46 by tomoron          ###   ########.fr       */
+/*   Updated: 2026/06/10 12:29:08 by tomoron          ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
+use bollard::Docker;
 use tokio::net::TcpStream;
 use crate::minecraft::handshake::Handshake;
 use std::fmt;
 
 use crate::models::Servers;
 
+use crate::DbPool;
+
+use crate::schema;
+use crate::models;
+use diesel::prelude::*;
+
+use regex::Regex;
+
+
 pub struct Client {
     pub in_stream: TcpStream,
 
@@ -28,19 +38,12 @@ pub struct Client {
 
     pub server: Option<Result<Servers,diesel::result::Error>>,
 
-    pub db_pool: DbPool
+    pub db_pool: DbPool,
+    pub docker: Docker
 }
 
-use crate::DbPool;
-
-use crate::schema;
-use crate::models;
-use diesel::prelude::*;
-
-use regex::Regex;
-
 impl Client {
-    pub fn create(stream: TcpStream, pool: DbPool) -> Self {
+    pub fn create(stream: TcpStream, pool: DbPool, docker: Docker) -> Self {
         Self {
             in_stream: stream,
 
@@ -53,7 +56,9 @@ impl Client {
 
             server: None,
 
-            db_pool: pool
+            db_pool: pool,
+
+            docker: docker
         }
     }
 

src/minecraft/client/login.rs

@@ -1,16 +1,44 @@
 use crate::minecraft::client::client::Client;
 
+use diesel::result::Error::NotFound;
 use json::object;
 use crate::minecraft::varint::varint_write;
 use std::collections::VecDeque;
 
+use crate::dockermgr;
+
 impl Client {
     pub async fn login_intent_handle(&mut self, mut _packet: &mut VecDeque<u8>, _packet_id: i32) -> Result<(),String> {
+        match self.login_start_server().await {
+            Ok(_) => {
+                self.login_send_disconnect(&"Start request successful, the server will start soon".to_string(), &"green".to_string()).await?;
+                return Ok(());
+            }
+            Err(e) => {
+                self.login_send_disconnect(&e, &"red".to_string()).await?;
+                return Err(e);
+            },
+        }
+    }
+
+    async fn login_start_server(&mut self) -> Result<(), String> {
+        let server = match self.server.as_ref().unwrap().as_ref() {
+            Ok(server) => { server },
+            Err(NotFound) => { return Err("This server was not found".to_string()); },
+            Err(e) => { return Err(format!("db fetch error : {}", e)); }
+        };
+
+        dockermgr::start_server(&self.docker, &self.db_pool, &server.name).await?;
+        Ok(())
+    }
+
+    async fn login_send_disconnect(&mut self, message: &String, color: &String) -> Result<(), String> {
         let reason_json = object! {
             "type": "text",
-            "text": "login to start not implemented yet",
-            "color": "red"
+            "text": *message.clone(),
+            "color": *color.clone()
         };
+
         let mut response: Vec<u8> = vec![];
         let response_json = json::stringify(reason_json);   
         let mut response_json_len = varint_write(response_json.len() as i32);

src/minecraft/socket.rs

@@ -1,4 +1,5 @@
 use crate::minecraft::client::client::Client;
+use bollard::Docker;
 use tokio::net::TcpStream;
 
 use crate::DbPool;
@@ -7,13 +8,15 @@ use tokio::net::TcpListener;
 
 use std::io;
 
-pub async fn mc_socket_listen(pool: DbPool) -> io::Result<()> {
+pub async fn mc_socket_listen(pool: DbPool, docker: Docker) -> io::Result<()> {
     let mc_listener = TcpListener::bind("0.0.0.0:25565").await?;
     loop {
         if let Ok((socket, _)) = mc_listener.accept().await {
-            let cloned = pool.clone();
+            let cloned_pool = pool.clone();
+            let cloned_docker = docker.clone();
+            
             tokio::spawn(async move {
-                if let Err(e) = process_mc_socket(socket, cloned).await {
+                if let Err(e) = process_mc_socket(socket, cloned_pool, cloned_docker).await {
                     eprintln!("mc error: {:?}", e);
                 }
             });
@@ -21,10 +24,10 @@ pub async fn mc_socket_listen(pool: DbPool) -> io::Result<()> {
     }
 }
 
-async fn process_mc_socket(stream: TcpStream, pool: DbPool) -> Result<(), String> {
+async fn process_mc_socket(stream: TcpStream, pool: DbPool, docker: Docker) -> Result<(), String> {
     println!("new client {:?}", stream);
 
-    let mut client = Client::create(stream, pool);
+    let mut client = Client::create(stream, pool, docker);
 
     loop {
         tokio::select! {