nitro_core 0.30.0

Core functionality for launching Minecraft
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

use anyhow::anyhow;
use directories::ProjectDirs;
use nitro_shared::io::config::IO_CONFIG;

use std::path::PathBuf;

/// Store for all of the paths that are used throughout the application
#[derive(Debug, Clone)]
pub struct Paths {
	/// Config directory
	pub config: PathBuf,
	/// Holds data
	pub data: PathBuf,
	/// Holds internal data
	pub internal: PathBuf,
	/// Holds game assets
	pub assets: PathBuf,
	/// Holds game libraries
	pub libraries: PathBuf,
	/// Holds Java installations
	pub java: PathBuf,
	/// Holds game jar files
	pub jars: PathBuf,
	/// Holds authentication data
	pub auth: PathBuf,
	/// Holds log files
	pub logs: PathBuf,
	/// Holds launch log files
	pub launch_logs: PathBuf,
	/// Used for runtime info like PIDs
	pub run: PathBuf,
	/// Used for temporary stdio files for instances
	pub stdio: PathBuf,
}

impl Paths {
	/// Create a new Paths object. This will create all of the directories
	/// referenced in the paths if they do not already exist.
	pub fn new() -> anyhow::Result<Paths> {
		let out = Self::new_no_create()?;
		out.create_dirs()?;

		Ok(out)
	}

	/// Create the directories on an existing set of paths
	pub fn create_dirs(&self) -> anyhow::Result<()> {
		let _ = std::fs::create_dir_all(&self.config);
		let _ = std::fs::create_dir_all(&self.data);
		let _ = std::fs::create_dir_all(&self.internal);
		let _ = std::fs::create_dir_all(&self.assets);
		let _ = std::fs::create_dir_all(&self.java);
		let _ = std::fs::create_dir_all(&self.jars);
		let _ = std::fs::create_dir_all(&self.auth);
		let _ = std::fs::create_dir_all(&self.logs);
		let _ = std::fs::create_dir_all(&self.launch_logs);
		let _ = std::fs::create_dir_all(&self.run);
		let _ = std::fs::create_dir_all(&self.stdio);

		Ok(())
	}

	/// Create the paths without creating any directories
	pub fn new_no_create() -> anyhow::Result<Self> {
		let project = ProjectDirs::from("", "nitro", "nitro")
			.ok_or(anyhow!("Failed to create project directories"))?;

		let config = if let Some(dir) = IO_CONFIG.get_string("config_path") {
			PathBuf::from(dir)
		} else {
			project.config_dir().to_owned()
		};
		let data = if let Some(dir) = IO_CONFIG.get_string("data_path") {
			PathBuf::from(dir)
		} else {
			project.data_dir().to_owned()
		};

		let internal = data.join("internal");
		let assets = internal.join("assets");
		let libraries = internal.join("libraries");
		let java = internal.join("java");
		let jars = internal.join("jars");
		let auth = internal.join("auth");
		let logs = data.join("logs");
		let launch_logs = logs.join("launch");
		let run = project
			.runtime_dir()
			.map(|x| x.to_path_buf())
			.unwrap_or(internal.join("run"));
		let stdio = internal.join("stdio");

		Ok(Paths {
			config,
			data,
			internal,
			assets,
			libraries,
			java,
			jars,
			auth,
			logs,
			launch_logs,
			run,
			stdio,
		})
	}
}