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.
- mcsc/__init__.py +4 -0
- mcsc/__main__.py +7 -0
- mcsc/config/settings.py +45 -0
- mcsc/config/update_files.py +24 -0
- mcsc/localization/it.py +80 -0
- mcsc/main.py +102 -0
- mcsc/modules/classes.py +115 -0
- mcsc/modules/logger.py +107 -0
- mcsc/modules/pages.py +379 -0
- mcsc/modules/servers/forge.py +175 -0
- mcsc/modules/servers/java.py +13 -0
- mcsc/modules/servers/models.py +430 -0
- mcsc/modules/servers/paper.py +109 -0
- mcsc/modules/servers/utils.py +136 -0
- mcsc/modules/translations.py +47 -0
- mcsc/modules/user_settings.py +144 -0
- mcsc/modules/utils.py +735 -0
- mcsc/static/logo.png +0 -0
- mcsc/static/style.css +249 -0
- mcsc/tasks.py +152 -0
- mcsc/telemetry.py +99 -0
- mcsc/update.py +87 -0
- mcsc/utils.py +30 -0
- minecraft_server_creator-2.0.0.dist-info/METADATA +46 -0
- minecraft_server_creator-2.0.0.dist-info/RECORD +29 -0
- minecraft_server_creator-2.0.0.dist-info/WHEEL +5 -0
- minecraft_server_creator-2.0.0.dist-info/entry_points.txt +2 -0
- minecraft_server_creator-2.0.0.dist-info/licenses/LICENSE +2 -0
- minecraft_server_creator-2.0.0.dist-info/top_level.txt +1 -0
|
@@ -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
|