minecraft-server-creator 2.0.0__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -0,0 +1,430 @@
1
+ """
2
+ Minecraft Server Module
3
+ """
4
+
5
+ import asyncio
6
+ import json
7
+ import os
8
+ import shutil
9
+ from uuid import uuid4
10
+ import numpy as np
11
+ import requests
12
+ from nicegui import binding, ui
13
+
14
+ from mcsc.config import settings as mcssettings
15
+ from mcsc.modules.translations import translate as _
16
+ from mcsc.modules.classes import ProcessMonitor
17
+ from mcsc.modules.logger import RotatingLogger
18
+ from mcsc.telemetry import TelemetryClient
19
+
20
+ telemetry_client = TelemetryClient()
21
+
22
+
23
+ server_list = []
24
+ global_settings = {}
25
+ logger = RotatingLogger()
26
+
27
+
28
+ class MinecraftServer:
29
+ """
30
+ Base Minecraft Server class
31
+ This acts as a model for each type of server
32
+ """
33
+
34
+ name = binding.BindableProperty()
35
+ settings = binding.BindableProperty()
36
+
37
+ def __init__(self, settings: dict, uuid: str = ""):
38
+ # Setup attributes
39
+ logger.info("Initializing Minecraft Server...")
40
+ self.name = settings.get("name")
41
+ self.settings = settings.copy() or {}
42
+ self.running = False
43
+ self.starting = False
44
+ self.stopping = False
45
+ self.process = None
46
+ self.log = None
47
+ self.server_properties = {}
48
+ self.monitor = ProcessMonitor()
49
+
50
+ if not uuid:
51
+ self._create_server()
52
+
53
+ # Add to server list
54
+ server_list.append(self)
55
+ logger.info(f"Server {self.uuid} initialized")
56
+
57
+ def __repr__(self):
58
+ if self.jar_type == 0:
59
+ return f"<JavaServer: {self.name!r} addr={self.socket_address}>"
60
+ if self.jar_type == 1:
61
+ return f"<PaperServer: {self.name!r} addr={self.socket_address}>"
62
+ if self.jar_type == 2:
63
+ return f"<ForgeServer: {self.name!r} addr={self.socket_address}>"
64
+ return f"<MinecraftServer: {self.name!r} addr={self.socket_address}>"
65
+
66
+ def __str__(self):
67
+ return self.name
68
+
69
+ @property
70
+ def status(self):
71
+ """Display-friendly status of the server"""
72
+ if any([self.starting, self.stopping]):
73
+ if self.starting and self.running is False:
74
+ return _("Starting")
75
+ if self.stopping and self.running is True:
76
+ return _("Stopping")
77
+
78
+ return _("Running") if self.running else _("Stopped")
79
+
80
+ @property
81
+ def address(self) -> str:
82
+ """ip address"""
83
+ return self.settings.get("address", "undefined")
84
+
85
+ @property
86
+ def port(self) -> int:
87
+ """port number"""
88
+ return self.settings.get("port", np.nan)
89
+
90
+ @property
91
+ def socket_address(self) -> str:
92
+ """display friendly socked addres"""
93
+ return f"{self.address}:{self.port}"
94
+
95
+ @property
96
+ def version(self) -> str:
97
+ """display friendly server version"""
98
+ return self.settings["version"] or global_settings[self.uuid].get("version")
99
+
100
+ @property
101
+ def jar_type(self) -> int:
102
+ """display friendly jar type"""
103
+ return self.settings["jar_type"]
104
+
105
+ @property
106
+ def uuid(self) -> str:
107
+ """return uuid"""
108
+ return self.settings["uuid"]
109
+
110
+ @property
111
+ def jar_path(self) -> str:
112
+ """server's jar path"""
113
+ return os.path.join(self.server_path, "server.jar")
114
+
115
+ @property
116
+ def server_path(self) -> str:
117
+ """server's jar path"""
118
+ return self.settings["folder_path"]
119
+
120
+ @property
121
+ def has_server_properties(self) -> bool:
122
+ """Returns true if server.properties is in server dir"""
123
+ return os.path.exists(os.path.join(self.server_path, "server.properties"))
124
+
125
+ def accept_eula(self):
126
+ """Accepts eula"""
127
+ eula_path = os.path.join(self.server_path, "eula.txt")
128
+
129
+ with open(eula_path, mode="w", encoding="utf-8") as eula:
130
+ eula.write("eula=true")
131
+
132
+ def _create_server_folder(self):
133
+ """
134
+ Creates the server folder
135
+ """
136
+ self.settings["uuid"] = str(uuid4())
137
+ self.settings["folder_path"] = os.path.join(
138
+ mcssettings.SERVER_DIR_PATH, self.settings["uuid"], ""
139
+ )
140
+ # create server folder
141
+ os.mkdir(self.settings["folder_path"])
142
+ assert os.path.exists(self.settings["folder_path"])
143
+ logger.info(f"Created folder for server {self.uuid}")
144
+
145
+ def _create_server(self):
146
+ """
147
+ Actually creates the server on the device
148
+ Order of actions:
149
+ - create server folder
150
+ - download jar and place it inside folder
151
+ - eula
152
+ - create start.bat (maybe not?)
153
+ """
154
+ logger.info("Initializing server creation...")
155
+ self._create_server_folder()
156
+ # download jar
157
+ self._download_jar()
158
+ # accept eula
159
+ self.accept_eula()
160
+ # save into server.json
161
+ self.save()
162
+
163
+ def _download_jar(self):
164
+ """downloads jar"""
165
+ # get jar link
166
+ from mcsc.modules.utils import urls # pylint: disable=import-outside-toplevel
167
+
168
+ url = urls.get_url(self.version, self.jar_type)
169
+ file_path = os.path.join(self.settings["folder_path"], "server.jar")
170
+ try:
171
+ response = requests.get(url, stream=True) # pylint: disable=missing-timeout
172
+ response.raise_for_status()
173
+ with open(file_path, "wb") as file:
174
+ for chunk in response.iter_content(chunk_size=8192):
175
+ file.write(chunk)
176
+ logger.info(f"Downloaded {url} for server {self.uuid}")
177
+
178
+ except requests.exceptions.RequestException as e:
179
+ logger.error(f"Error downloading the file: {e}")
180
+ raise
181
+
182
+ except Exception as e:
183
+ logger.error(f"{e}")
184
+ raise
185
+
186
+ def _save_settings(self):
187
+ """saves global settings to servers.json"""
188
+ with open(mcssettings.SERVERS_JSON_PATH, "w", encoding="utf-8") as file:
189
+ # save global_settings
190
+ json.dump(global_settings, file, indent=4)
191
+ logger.info("Global server settings saved")
192
+
193
+ def save(self):
194
+ """Saves instance settings into servers.json file"""
195
+ try:
196
+ # update global_settings
197
+ global_settings[self.uuid] = self.settings
198
+ # save global_settings
199
+ self._save_settings()
200
+ # update name
201
+ self.name = self.settings.get("name")
202
+
203
+ except Exception as e:
204
+ logger.error(f"Can't save servers: {e}")
205
+ raise
206
+
207
+ logger.info(f"Server {self.uuid} saved!")
208
+
209
+ async def start(self):
210
+ """Starts the server"""
211
+ self.starting = True
212
+ logger.info(f"Starting server {self.uuid}...")
213
+ try:
214
+ cmd = [
215
+ "java",
216
+ # f"-d{mcssettings.JAVA_BIT_MODEL}",
217
+ f"-Xmx{self.settings['dedicated_ram']}G",
218
+ f"-Xms{self.settings['dedicated_ram']}G",
219
+ "-jar",
220
+ self.jar_path,
221
+ "nogui" if mcssettings.NOGUI else "",
222
+ ]
223
+
224
+ # Start the subprocess
225
+ self.process = await asyncio.create_subprocess_exec(
226
+ *cmd,
227
+ cwd=self.server_path,
228
+ stdin=asyncio.subprocess.PIPE,
229
+ stdout=asyncio.subprocess.PIPE,
230
+ stderr=asyncio.subprocess.STDOUT,
231
+ )
232
+
233
+ # Start monitoring the process
234
+ self.monitor.process = self.process
235
+ monitor_task = asyncio.create_task(self.monitor.run())
236
+
237
+ # Start tasks for reading output and taking input
238
+ output_task = asyncio.create_task(self._console_reader())
239
+ # input_task = asyncio.create_task(self.console_writer())
240
+
241
+ telemetry_client.send_event("server_start", details=self.settings)
242
+ # Wait for the server process to finish
243
+ await self.process.wait()
244
+
245
+ self.running = False
246
+
247
+ # Cancel input and output tasks once the server stops
248
+ await asyncio.gather(output_task, return_exceptions=True)
249
+ await asyncio.gather(monitor_task, return_exceptions=True)
250
+
251
+ except FileNotFoundError as e:
252
+ logger.error(f"Error: {e}")
253
+
254
+ except Exception as e:
255
+ logger.error(f"An error occurred: {e}")
256
+
257
+ finally:
258
+ self.starting = False
259
+ self.running = False
260
+
261
+ async def stop(self):
262
+ """Stops the server"""
263
+ if self.process and self.running:
264
+ logger.info(f"Stopping server {self.uuid}...")
265
+ self.running = False
266
+ self.stopping = True
267
+ try:
268
+ # Send the 'stop' command to the server
269
+ if self.process.stdin:
270
+ self.process.stdin.write(b"stop\n")
271
+ await self.process.stdin.drain()
272
+
273
+ # Wait for the process to terminate gracefully
274
+ await self.process.wait()
275
+ telemetry_client.send_event("server_stop", details=self.settings)
276
+ logger.info(f"Server {self.uuid} stopped.")
277
+ except Exception as e:
278
+ logger.info(f"Error while stopping the server: {e}")
279
+ finally:
280
+ # Ensure process cleanup
281
+ self.process = None
282
+ self.running = False
283
+ self.stopping = False
284
+ self.monitor.stop()
285
+ else:
286
+ logger.warning("Server is not running.")
287
+
288
+ async def console_writer(self, command: str):
289
+ """Reads user input and sends it to the server."""
290
+ try:
291
+ if self.running:
292
+ # command = await asyncio.to_thread(input)
293
+ if self.process and self.process.stdin and command == "stop":
294
+ await self.stop()
295
+
296
+ elif self.process and self.process.stdin:
297
+ self.process.stdin.write((command + "\n").encode())
298
+ await self.process.stdin.drain()
299
+ except Exception as e:
300
+ logger.error(f"Writer error: {e}")
301
+
302
+ async def _console_reader(self) -> str:
303
+ """reads and prints console output"""
304
+ try:
305
+ line = await self.process.stdout.readline()
306
+ self.starting = False
307
+ self.running = True
308
+ while self.running or self.stopping:
309
+ line = await self.process.stdout.readline()
310
+ if self.log and line:
311
+ self.log.push(line.decode().strip())
312
+ elif not line:
313
+ break
314
+ except Exception as e:
315
+ logger.error(f"Reader error: {e}")
316
+
317
+ def delete(self, delete_dir: bool = False):
318
+ """Deletes the server from servers.json"""
319
+ # Don't use self.server_path here
320
+ if not self.running and not self.process:
321
+ logger.info(f"Deleting server {self.uuid}... delete_dir: {delete_dir}")
322
+ if delete_dir:
323
+ for item in os.listdir(self.settings["folder_path"]):
324
+ item_path = os.path.join(self.settings["folder_path"], item)
325
+ try:
326
+ if os.path.isfile(item_path) or os.path.islink(item_path):
327
+ os.unlink(item_path)
328
+ elif os.path.isdir(item_path):
329
+ shutil.rmtree(item_path)
330
+ except Exception as e:
331
+ logger.error(f"Failed to delete {item_path}: {e}")
332
+ # remove server dir
333
+ shutil.rmtree(self.settings["folder_path"])
334
+
335
+ # remove from server_list
336
+ assert self in server_list, _("Invalid server")
337
+ server_list.remove(self)
338
+
339
+ # remove from global_settings
340
+ assert global_settings[self.uuid], _("Invalid server")
341
+ del global_settings[self.uuid]
342
+
343
+ # update settings
344
+ try:
345
+ self._save_settings()
346
+
347
+ except Exception as e:
348
+ logger.error(f"Can't delete server: {e}")
349
+ raise
350
+
351
+ logger.info(f"Deleted server {self.uuid}")
352
+
353
+ else:
354
+ raise Exception("Can't delete the server while it's running.")
355
+
356
+ def load_server_properties(self):
357
+ """Loads server.properties file"""
358
+ if self.has_server_properties:
359
+ with open(
360
+ os.path.join(self.server_path, "server.properties"),
361
+ mode="r",
362
+ encoding="utf-8",
363
+ ) as properties:
364
+ for line in properties:
365
+ if line.strip() and not line.startswith("#"):
366
+ key, value = line.strip().split("=", 1)
367
+ self.server_properties[key] = value
368
+ logger.info(f"{self.uuid} properties loaded")
369
+
370
+ def save_server_properties(self, editor: ui.editor) -> bool:
371
+ """
372
+ Saves server.properties file
373
+ Returns True if saved otherwise False
374
+ """
375
+ if self.has_server_properties and editor.content.get("json"):
376
+ self.server_properties = editor.content.get("json")
377
+
378
+ # Actually save server.properties file
379
+ # It's not a json, rows are NAME=VALUE
380
+ with open(
381
+ os.path.join(self.server_path, "server.properties"),
382
+ mode="w",
383
+ encoding="utf-8",
384
+ ) as properties:
385
+ for setting, value in self.server_properties.items():
386
+ properties.write(f"{setting}={value}\n")
387
+
388
+ properties.flush()
389
+ properties.close()
390
+
391
+ logger.info(f"{self.uuid} properties saved")
392
+ return True
393
+
394
+ elif self.has_server_properties and editor.content.get("text"):
395
+ raise NotImplementedError("Editing in 'text' mode is currently disabled")
396
+ # The ugly
397
+ # editor.content.get("text").replace("\n", "").replace('"', "").replace(
398
+ # "{", ""
399
+ # ).replace("}", "").split(",")[0].strip().split(": ")
400
+
401
+ return False
402
+
403
+
404
+ # Some functions
405
+ def get_server_list() -> list[MinecraftServer]:
406
+ """Returns server list"""
407
+ return server_list
408
+
409
+
410
+ def set_server_list(servers: list[MinecraftServer]):
411
+ """Sets server list"""
412
+ global server_list # pylint: disable=global-statement
413
+ server_list = servers
414
+
415
+
416
+ def add_server_to_list(server: MinecraftServer):
417
+ """Adds server to server list"""
418
+ if server not in server_list:
419
+ server_list.append(server)
420
+
421
+
422
+ def get_global_settings() -> dict:
423
+ """Returns global settings"""
424
+ return global_settings
425
+
426
+
427
+ def set_global_settings(settings: dict):
428
+ """Sets global settings"""
429
+ global global_settings # pylint: disable=global-statement
430
+ global_settings = settings
@@ -0,0 +1,109 @@
1
+ """
2
+ Paper server module
3
+ """
4
+
5
+ import os
6
+ import yaml
7
+
8
+ from mcsc.modules.translations import translate as _
9
+
10
+ from mcsc.modules.servers.models import MinecraftServer
11
+ from mcsc.modules.logger import RotatingLogger
12
+
13
+
14
+ logger = RotatingLogger()
15
+
16
+ FILE_TO_ATTR = {
17
+ "spigot.yml": "spigot_properties",
18
+ "paper.yml": "paper_properties",
19
+ }
20
+
21
+
22
+ class PaperServer(MinecraftServer):
23
+ """
24
+ Paper Server Model
25
+ """
26
+
27
+ def __init__(self, settings, uuid=""):
28
+ self.spigot_properties = {}
29
+ self.paper_properties = {}
30
+ super().__init__(settings, uuid)
31
+
32
+ @property
33
+ def has_spigot_yml(self):
34
+ """
35
+ Check if the server has a spigot.yml file
36
+ """
37
+ return os.path.exists(os.path.join(self.server_path, "spigot.yml"))
38
+
39
+ @property
40
+ def has_paper_yml(self):
41
+ """
42
+ Check if the server has a spigot.yml file
43
+ """
44
+ return os.path.exists(os.path.join(self.server_path, "paper.yml"))
45
+
46
+ def load_yml(self, filename: str) -> dict:
47
+ """
48
+ Load a file in server directory. This could easily be
49
+ a method in the MinecraftServer class as a generic load_file
50
+ method, but that will be done in the future.
51
+
52
+ Args:
53
+ filename (str): filename to load
54
+
55
+ Returns:
56
+ loaded file as a dict
57
+ """
58
+ if not os.path.exists(os.path.join(self.server_path, filename)):
59
+ logger.error(_("File not found"))
60
+ return {}
61
+
62
+ with open(
63
+ os.path.join(self.server_path, filename), "r", encoding="utf-8"
64
+ ) as file:
65
+ data = yaml.safe_load(file)
66
+
67
+ logger.info(f"Loaded {filename} for server {self.uuid}")
68
+ return data
69
+
70
+ def save_yml(self, filename: str, editor: dict):
71
+ """
72
+ Save a file in server directory. This could easily be
73
+ a method in the MinecraftServer class as a generic save_file
74
+ method, but that will be done in the future.
75
+
76
+ Args:
77
+ filename (str): filename to save
78
+ editor (nicegui editor): editor with content
79
+ """
80
+ if editor.content.get("json"):
81
+ data = editor.content.get("json")
82
+ try:
83
+ with open(
84
+ os.path.join(self.server_path, filename), "w", encoding="utf-8"
85
+ ) as file:
86
+ yaml.dump(data, file)
87
+
88
+ setattr(self, FILE_TO_ATTR[filename], data)
89
+
90
+ except Exception as e:
91
+ logger.error(f"Error saving file: {e}")
92
+ return False
93
+
94
+ logger.info(f"Saved {filename} for server {self.uuid}")
95
+ return True
96
+
97
+ def load_paper_yml(self) -> dict:
98
+ """
99
+ Get paper.yml file as a dict
100
+ """
101
+ if self.has_paper_yml:
102
+ self.paper_properties = self.load_yml("paper.yml")
103
+
104
+ def load_spigot_yml(self) -> dict:
105
+ """
106
+ Get spigot.yml file as a dict
107
+ """
108
+ if self.has_spigot_yml:
109
+ self.spigot_properties = self.load_yml("spigot.yml")
@@ -0,0 +1,136 @@
1
+ """
2
+ Server related utility functions and classes
3
+ """
4
+
5
+ import json
6
+ import os
7
+ import requests
8
+
9
+ from mcsc.config import settings as mcssettings
10
+ from mcsc.modules.translations import translate as _
11
+ from mcsc.modules.servers.models import (
12
+ MinecraftServer,
13
+ get_server_list,
14
+ set_global_settings,
15
+ )
16
+ from mcsc.modules.servers.forge import ForgeServer
17
+ from mcsc.modules.servers.java import JavaServer
18
+ from mcsc.modules.servers.paper import PaperServer
19
+ from mcsc.modules.logger import RotatingLogger
20
+ from mcsc.telemetry import TelemetryClient
21
+
22
+ telemetry_client = TelemetryClient()
23
+ logger = RotatingLogger()
24
+
25
+ TYPE_TO_CLASS: dict[str, MinecraftServer] = {
26
+ 0: JavaServer,
27
+ 1: PaperServer,
28
+ 2: ForgeServer,
29
+ }
30
+
31
+ FILE_TO_ATTR = {
32
+ "server.properties": "server_properties",
33
+ "spigot.yml": "spigot_properties",
34
+ "paper.yml": "paper_properties",
35
+ }
36
+
37
+
38
+ def create_server(settings: dict):
39
+ """
40
+ Use this function to successfully create a server on MCSC.
41
+ This function handles all the necessary steps to create a server.
42
+ Its higly recommended to use this function to create a server.
43
+ """
44
+ logger.info("Creating server...")
45
+ instance = TYPE_TO_CLASS[settings["jar_type"]](settings=settings)
46
+ logger.info(f"Created server with uuid {instance.uuid}")
47
+ telemetry_client.send_event(event_name="server_create",details=settings)
48
+
49
+
50
+ def load_servers():
51
+ """
52
+ Function to load server as a MinecraftServer class instance
53
+ """
54
+ logger.info("Loading servers...")
55
+ if not os.path.exists(mcssettings.SERVERS_JSON_PATH):
56
+ with open(mcssettings.SERVERS_JSON_PATH, "w", encoding="utf-8") as file:
57
+ file.write("{}")
58
+ file.flush()
59
+
60
+ os.makedirs(mcssettings.SERVER_DIR_PATH, exist_ok=True)
61
+ return
62
+
63
+ with open(mcssettings.SERVERS_JSON_PATH, "r", encoding="utf-8") as file:
64
+ servers = json.load(file)
65
+
66
+ # Set global settings
67
+ set_global_settings(servers)
68
+
69
+ for server_uuid, settings in servers.items():
70
+ logger.info(f"Loading {server_uuid}...")
71
+ TYPE_TO_CLASS[settings["jar_type"]](settings=settings, uuid=server_uuid)
72
+
73
+
74
+ def get_server_by_name(server_name: str) -> MinecraftServer | None:
75
+ """
76
+ Returns server instance found by name.
77
+ Probably not gonna be used
78
+ """
79
+ for server in get_server_list():
80
+ if server.name == server_name:
81
+ return server
82
+ return None
83
+
84
+
85
+ def get_server_by_uuid(
86
+ uuid: str
87
+ ) -> MinecraftServer | ForgeServer | PaperServer | None:
88
+ """
89
+ Returns server instance by by uuid.
90
+ """
91
+ for server in get_server_list():
92
+ if server.uuid == uuid:
93
+ return server
94
+ return None
95
+
96
+
97
+ async def full_stop():
98
+ """Ensures all servers are stopped"""
99
+ logger.info("Stopping all servers...")
100
+ for server in get_server_list():
101
+ if server.running and server.process:
102
+ await server.stop()
103
+
104
+
105
+ def load_vanilla_versions() -> dict:
106
+ """Loads vanilla versions"""
107
+ response = requests.get(mcssettings.VANILLA_VERSION_LIST_URL, timeout=10)
108
+ response.raise_for_status()
109
+ vanilla_dict = response.json()
110
+ return vanilla_dict
111
+
112
+
113
+ def load_paper_versions() -> dict:
114
+ """Loads paper versions"""
115
+ response = requests.get(mcssettings.PAPER_VERSION_LIST_URL, timeout=10)
116
+ response.raise_for_status()
117
+ paper_dict = response.json()
118
+ return paper_dict
119
+
120
+
121
+ def load_forge_versions() -> dict:
122
+ """Loads forge versions"""
123
+ response = requests.get(mcssettings.FORGE_VERSION_LIST_URL, timeout=10)
124
+ response.raise_for_status()
125
+ forge_dict = response.json()
126
+
127
+ # atm mcsc works only with forge version from 1.17.0
128
+ # so we need to remove the previous versions
129
+ filtered_dict = {}
130
+ for version in forge_dict.keys():
131
+ text_version = version.split("-")[0].replace(".", "").strip("0")
132
+ if text_version.isnumeric():
133
+ version_number = int(text_version)
134
+ if version_number >= 1170:
135
+ filtered_dict[version] = forge_dict[version]
136
+ return filtered_dict