lighty-launch 26.5.2

Minecraft launch logic for Lighty Launcher
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

#[cfg(feature = "events")]
use tokio::io::{AsyncBufReadExt, BufReader};
use tokio::process::Child;

#[cfg(feature = "events")]
use lighty_event::EventBus;

/// Spawns tasks that stream stdout/stderr from the child, emit console
/// events, and unregister the instance when the process exits.
pub(crate) async fn handle_console_streams(
    pid: u32,
    instance_name: String,
    mut child: Child,
    #[cfg(feature = "events")] event_bus: Option<EventBus>,
) {
    // Without the events feature there is no consumer for stdout/stderr,
    // so don't bother spawning the reader tasks.
    #[cfg(feature = "events")]
    {
        let stdout = child.stdout.take();
        let stderr = child.stderr.take();

        if let Some(stdout) = stdout {
            let instance_name = instance_name.clone();
            let event_bus_clone = event_bus.clone();

            tokio::spawn(async move {
                let reader = BufReader::new(stdout);
                let mut lines = reader.lines();

                while let Ok(Some(line)) = lines.next_line().await {
                    use lighty_event::{ConsoleOutputEvent, ConsoleStream, Event};
                    use std::time::SystemTime;

                    if let Some(ref bus) = event_bus_clone {
                        bus.emit(Event::ConsoleOutput(ConsoleOutputEvent {
                            pid,
                            instance_name: instance_name.clone(),
                            stream: ConsoleStream::Stdout,
                            line,
                            timestamp: SystemTime::now(),
                        }));
                    }
                }
            });
        }

        if let Some(stderr) = stderr {
            let instance_name = instance_name.clone();
            let event_bus_clone = event_bus.clone();

            tokio::spawn(async move {
                let reader = BufReader::new(stderr);
                let mut lines = reader.lines();

                while let Ok(Some(line)) = lines.next_line().await {
                    use lighty_event::{ConsoleOutputEvent, ConsoleStream, Event};
                    use std::time::SystemTime;

                    if let Some(ref bus) = event_bus_clone {
                        bus.emit(Event::ConsoleOutput(ConsoleOutputEvent {
                            pid,
                            instance_name: instance_name.clone(),
                            stream: ConsoleStream::Stderr,
                            line,
                            timestamp: SystemTime::now(),
                        }));
                    }
                }
            });
        }
    }

    match child.wait().await {
        Ok(status) => {
            #[cfg(feature = "events")]
            {
                use lighty_event::{Event, InstanceExitedEvent};
                use std::time::SystemTime;

                if let Some(ref bus) = event_bus {
                    bus.emit(Event::InstanceExited(InstanceExitedEvent {
                        pid,
                        instance_name: instance_name.clone(),
                        exit_code: status.code(),
                        timestamp: SystemTime::now(),
                    }));
                }
            }

            lighty_core::trace_info!(
                pid = pid,
                instance = %instance_name,
                exit_code = ?status.code(),
                "Instance exited"
            );
        }
        Err(e) => {
            lighty_core::trace_error!(
                pid = pid,
                instance = %instance_name,
                error = %e,
                "Error waiting for instance"
            );
        }
    }

    use super::INSTANCE_MANAGER;
    let _ = INSTANCE_MANAGER.unregister_instance(pid).await;
}