levistone 0.6.2.dev58__1-cp39-cp39-win_amd64.whl → 0.9.3__1-cp39-cp39-win_amd64.whl

endstone/__init__.py

@@ -1,14 +1,28 @@
-from endstone._internal.endstone_python import ColorFormat, GameMode, Logger, OfflinePlayer, Player, Server, Skin
+from endstone._internal.endstone_python import (
+    ColorFormat,
+    EnchantmentRegistry,
+    GameMode,
+    ItemRegistry,
+    Logger,
+    NamespacedKey,
+    OfflinePlayer,
+    Player,
+    Server,
+    Skin,
+)
 from endstone._internal.version import __version__
 
-__minecraft_version__ = "1.21.60"
+__minecraft_version__ = "1.21.93"
 
 __all__ = [
     "__version__",
     "__minecraft_version__",
     "ColorFormat",
+    "EnchantmentRegistry",
     "GameMode",
+    "ItemRegistry",
     "Logger",
+    "NamespacedKey",
     "OfflinePlayer",
     "Player",
     "Server",

endstone/_internal/bootstrap/__init__.py

@@ -2,6 +2,7 @@ import functools
 import logging
 import platform
 import sys
+import time
 
 import click
 
@@ -50,7 +51,7 @@ def catch_exceptions(func):
 @click.option(
     "-r",
     "--remote",
-    default="https://raw.githubusercontent.com/EndstoneMC/bedrock-server-data/main/bedrock_server_data.json",
+    default="https://raw.githubusercontent.com/EndstoneMC/bedrock-server-data/v2",
     help="The remote URL to retrieve bedrock server data from.",
 )
 @click.version_option(__version__)
@@ -71,4 +72,8 @@ def cli(server_folder: str, no_confirm: bool, remote: str) -> None:
 
     bootstrap = cls(server_folder=server_folder, no_confirm=no_confirm, remote=remote)
     exit_code = bootstrap.run()
+    if exit_code != 0:
+        logger.error(f"Server exited with non-zero code {exit_code}.")
+        time.sleep(2)
+
     sys.exit(exit_code)

endstone/_internal/bootstrap/base.py

@@ -1,4 +1,5 @@
 import errno
+import fnmatch
 import hashlib
 import logging
 import os
@@ -12,13 +13,13 @@ from pathlib import Path
 from typing import Union
 
 import click
+import importlib_resources
 import requests
 import sentry_crashpad
 from packaging.version import Version
 from rich.progress import BarColumn, DownloadColumn, Progress, TextColumn, TimeRemainingColumn
 
 from endstone import __minecraft_version__ as minecraft_version
-from endstone import __version__ as endstone_version
 
 
 class Bootstrap:
@@ -49,13 +50,17 @@ class Bootstrap:
     def executable_path(self) -> Path:
         return self.server_path / self.executable_filename
 
+    @property
+    def config_path(self) -> Path:
+        return self.server_path / "endstone.toml"
+
     @property
     def plugin_path(self) -> Path:
         return self.server_path / "plugins"
 
     @property
     def user_agent(self) -> str:
-        return f"Endstone/{endstone_version} (Minecraft/{minecraft_version})"
+        return "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/80.0.3987.149 Safari/537.36"
 
     def _validate(self) -> None:
         if platform.system().lower() != self.target_system:
@@ -69,22 +74,23 @@ class Bootstrap:
         dst = Path(dst)
 
         self._logger.info("Loading index from the remote server...")
-        response = requests.get(self._remote)
+        channel = "preview" if Version(minecraft_version).is_prerelease else "release"
+        metadata_url = "/".join([self._remote, channel, minecraft_version, "metadata.json"])
+        response = requests.get(metadata_url, timeout=10)
         response.raise_for_status()
-        server_data = response.json()
+        metadata = response.json()
 
-        if minecraft_version not in server_data["binary"]:
-            raise ValueError(f"Version v{minecraft_version} is not found in the remote server.")
+        if minecraft_version != metadata["version"]:
+            raise ValueError(f"Version mismatch, expect: {minecraft_version}, actual: {metadata['version']}")
 
         should_modify_server_properties = True
 
         with tempfile.TemporaryFile(dir=dst) as f:
-            metadata = server_data["binary"][minecraft_version][self.target_system.lower()]
-            url = metadata["url"]
+            url = metadata["binary"][self.target_system.lower()]["url"]
+            self._logger.info(f"Downloading server from {url}...")
             response = requests.get(url, stream=True, headers={"User-Agent": self.user_agent})
             response.raise_for_status()
             total_size = int(response.headers.get("Content-Length", 0))
-            self._logger.info(f"Downloading server from {url}...")
             m = hashlib.sha256()
 
             with Progress(
@@ -100,17 +106,28 @@ class Bootstrap:
                     m.update(data)
 
             self._logger.info("Download complete. Verifying integrity...")
-            if m.hexdigest() != metadata["sha256"]:
+            if m.hexdigest() != metadata["binary"][self.target_system.lower()]["sha256"]:
                 raise ValueError("SHA256 mismatch: the downloaded file may be corrupted or tampered with.")
 
             self._logger.info(f"Integrity check passed. Extracting to {dst}...")
             dst.mkdir(parents=True, exist_ok=True)
+            override_patterns = [
+                self.executable_filename,
+                "behavior_packs/*",
+                "definitions/*",
+                "resource_packs/*",
+                "bedrock_server_how_to.html",
+                "profanity_filter.wlist",
+                "release-notes.txt",
+            ]
             with zipfile.ZipFile(f) as zip_ref:
                 for file in zip_ref.namelist():
-                    if file in ["allowlist.json", "permissions.json", "server.properties"] and (dst / file).exists():
-                        self._logger.info(f"{file} already exists, skipping.")
-                        should_modify_server_properties = False
-                        continue
+                    dest_path = dst / file
+                    if dest_path.exists():
+                        if not any(fnmatch.fnmatch(file, pattern) for pattern in override_patterns):
+                            should_modify_server_properties = False
+                            self._logger.info(f"{dest_path} already exists, skipping.")
+                            continue
 
                     zip_ref.extract(file, dst)
 
@@ -140,6 +157,10 @@ class Bootstrap:
         shutil.copytree(
             Path(sentry_crashpad._get_executable("crashpad_handler")).parent, self.server_path, dirs_exist_ok=True
         )
+        if not self.config_path.exists():
+            ref = importlib_resources.files("endstone") / "config" / "endstone.toml"
+            with importlib_resources.as_file(ref) as path:
+                shutil.copy(path, self.config_path)
 
     def _install(self) -> None:
         """
@@ -204,8 +225,7 @@ class Bootstrap:
         self._install()
         self._validate()
         self._prepare()
-        self._create_process()
-        return self._wait_for_server()
+        return self._run()
 
     @property
     def _endstone_runtime_filename(self) -> str:
@@ -216,48 +236,27 @@ class Bootstrap:
         p = Path(__file__).parent.parent / self._endstone_runtime_filename
         return p.resolve().absolute()
 
-    def _create_process(self, *args, **kwargs) -> None:
-        """
-        Creates a subprocess for running the server.
-
-        This method initializes a subprocess.Popen object for the server executable. It sets up the necessary
-        buffers and encodings for the process and specifies the working directory.
-
-        Args:
-            *args: Variable length argument list.
-            **kwargs: Arbitrary keyword arguments.
-
-        """
-        env = kwargs.pop("env", os.environ.copy())
+    @property
+    def _endstone_runtime_env(self) -> dict[str, str]:
+        env = os.environ.copy()
         env["PATH"] = os.pathsep.join(sys.path)
         env["PYTHONPATH"] = os.pathsep.join(sys.path)
         env["PYTHONIOENCODING"] = "UTF-8"
-        self._process = subprocess.Popen(
-            [str(self.executable_path.absolute())],
-            stdin=sys.stdin,
-            stdout=sys.stdout,
-            stderr=subprocess.STDOUT,
-            text=True,
-            encoding="utf-8",
-            cwd=str(self.server_path.absolute()),
-            env=env,
-            *args,
-            **kwargs,
-        )
+        env["ENDSTONE_PYTHON_EXECUTABLE"] = sys.executable
+        return env
 
-    def _wait_for_server(self) -> int:
+    def _run(self, *args, **kwargs) -> int:
         """
-        Waits for the server process to terminate and returns its exit code.
+        Runs the server and returns its exit code.
 
-        This method blocks until the server process created by _create_process terminates. It returns the
-        exit code of the process, which can be used to determine if the server shut down successfully or if
-        there were errors.
+        This method blocks until the server process terminates. It returns the exit code of the process, which can be
+        used to determine if the server shut down successfully or if there were errors.
+
+        Args:
+            *args: Variable length argument list.
+            **kwargs: Arbitrary keyword arguments.
 
         Returns:
-            int: The exit code of the server process. Returns -1 if the process is not created or still running.
+            int: The exit code of the server process.
         """
-
-        if self._process is None:
-            return -1
-
-        return self._process.wait()
+        raise NotImplementedError

endstone/_internal/bootstrap/linux.py

@@ -1,6 +1,8 @@
 import ctypes.util
 import os
 import stat
+import subprocess
+import sys
 from pathlib import Path
 
 from endstone._internal.bootstrap.base import Bootstrap
@@ -23,17 +25,33 @@ class LinuxBootstrap(Bootstrap):
     def _endstone_runtime_filename(self) -> str:
         return "libendstone_runtime.so"
 
+    @property
+    def _endstone_runtime_env(self) -> dict[str, str]:
+        env = super()._endstone_runtime_env
+        env["LD_PRELOAD"] = str(self._endstone_runtime_path.absolute())
+        env["LD_LIBRARY_PATH"] = str(self._linked_libpython_path.parent.absolute())
+        return env
+
     def _prepare(self) -> None:
         super()._prepare()
         st = os.stat(self.executable_path)
         os.chmod(self.executable_path, st.st_mode | stat.S_IEXEC)
         os.chmod(self.server_path / "crashpad_handler", st.st_mode | stat.S_IEXEC)
 
-    def _create_process(self, *args, **kwargs) -> None:
-        env = os.environ.copy()
-        env["LD_PRELOAD"] = str(self._endstone_runtime_path.absolute())
-        env["LD_LIBRARY_PATH"] = str(self._linked_libpython_path.parent.absolute())
-        super()._create_process(env=env)
+    def _run(self, *args, **kwargs) -> int:
+        process = subprocess.Popen(
+            [str(self.executable_path.absolute())],
+            stdin=sys.stdin,
+            stdout=sys.stdout,
+            stderr=subprocess.STDOUT,
+            text=True,
+            encoding="utf-8",
+            cwd=str(self.server_path.absolute()),
+            env=self._endstone_runtime_env,
+            *args,
+            **kwargs,
+        )
+        return process.wait()
 
     @property
     def _linked_libpython_path(self) -> Path:

endstone/_internal/bootstrap/windows.py

@@ -1,86 +1,9 @@
 import ctypes
 import os
 import subprocess
-from ctypes import get_last_error
-from ctypes.wintypes import (
-    BOOL,
-    DWORD,
-    HANDLE,
-    HMODULE,
-    LPCSTR,
-    LPCVOID,
-    LPCWSTR,
-    LPDWORD,
-    LPVOID,
-)
 
 from endstone._internal.bootstrap.base import Bootstrap
-
-SIZE_T = ctypes.c_size_t
-PSIZE_T = ctypes.POINTER(SIZE_T)
-
-
-class THREADENTRY32(ctypes.Structure):
-    _fields_ = [
-        ("dwSize", DWORD),
-        ("cntUsage", DWORD),
-        ("th32ThreadID", DWORD),
-        ("th32OwnerProcessID", DWORD),
-        ("tpBasePri", DWORD),
-        ("tpDeltaPri", DWORD),
-        ("dwFlags", DWORD),
-    ]
-
-
-# Kernel32 Functions
-kernel32 = ctypes.WinDLL("kernel32", use_last_error=True)
-
-# Constants
-CREATE_SUSPENDED = 0x00000004  # https://learn.microsoft.com/en-us/windows/win32/procthread/process-creation-flags
-MAX_PATH = 260  # https://learn.microsoft.com/en-us/windows/win32/fileio/maximum-file-path-limitation
-MEM_COMMIT = 0x00001000  # https://learn.microsoft.com/en-us/windows/win32/api/memoryapi/nf-memoryapi-virtualalloc
-MEM_RESERVE = 0x00002000  # https://learn.microsoft.com/en-us/windows/win32/api/memoryapi/nf-memoryapi-virtualalloc
-PAGE_READWRITE = 0x04  # https://learn.microsoft.com/en-us/windows/win32/memory/memory-protection-constants
-INFINITE = 0xFFFFFFFF
-TH32CS_SNAPTHREAD = 0x00000004
-THREAD_ALL_ACCESS = 0x000F0000 | 0x00100000 | 0xFFFF
-INVALID_HANDLE_VALUE = ctypes.c_void_p(-1).value
-DONT_RESOLVE_DLL_REFERENCES = 0x00000001
-
-# https://learn.microsoft.com/en-us/windows/win32/api/memoryapi/nf-memoryapi-virtualallocex
-VirtualAllocEx = kernel32.VirtualAllocEx
-VirtualAllocEx.restype = LPVOID
-VirtualAllocEx.argtypes = (HANDLE, LPVOID, SIZE_T, DWORD, DWORD)
-
-# https://learn.microsoft.com/en-us/windows/win32/api/memoryapi/nf-memoryapi-writeprocessmemory
-WriteProcessMemory = kernel32.WriteProcessMemory
-WriteProcessMemory.restype = BOOL
-WriteProcessMemory.argtypes = (HANDLE, LPVOID, LPCVOID, SIZE_T, PSIZE_T)
-
-# https://learn.microsoft.com/en-us/windows/win32/api/processthreadsapi/nf-processthreadsapi-createremotethread
-CreateRemoteThread = kernel32.CreateRemoteThread
-CreateRemoteThread.restype = HANDLE
-CreateRemoteThread.argtypes = (HANDLE, LPVOID, SIZE_T, LPVOID, LPVOID, DWORD, LPDWORD)
-
-# https://learn.microsoft.com/en-us/windows/win32/api/processthreadsapi/nf-processthreadsapi-getexitcodethread
-GetExitCodeThread = kernel32.GetExitCodeThread
-GetExitCodeThread.restype = BOOL
-GetExitCodeThread.argtypes = (HANDLE, LPDWORD)
-
-# https://learn.microsoft.com/en-us/windows/win32/api/libloaderapi/nf-libloaderapi-getmodulehandlew
-GetModuleHandle = kernel32.GetModuleHandleW
-GetModuleHandle.restype = HMODULE
-GetModuleHandle.argtypes = (LPCWSTR,)
-
-# https://learn.microsoft.com/en-us/windows/win32/api/libloaderapi/nf-libloaderapi-getprocaddress
-GetProcAddress = kernel32.GetProcAddress
-GetProcAddress.restype = LPVOID
-GetProcAddress.argtypes = (HMODULE, LPCSTR)
-
-# https://learn.microsoft.com/en-us/windows/win32/api/libloaderapi/nf-libloaderapi-loadlibraryexw
-LoadLibraryExW = kernel32.LoadLibraryExW
-LoadLibraryExW.restype = HMODULE
-LoadLibraryExW.argtypes = (LPCWSTR, HANDLE, DWORD)
+from endstone._internal.winext import start_process_with_dll
 
 
 class WindowsBootstrap(Bootstrap):
@@ -100,6 +23,18 @@ class WindowsBootstrap(Bootstrap):
     def _endstone_runtime_filename(self) -> str:
         return "endstone_runtime_loader.dll"
 
+    @property
+    def _endstone_runtime_env(self) -> dict[str, str]:
+        env = super()._endstone_runtime_env
+        symbol_path = env.get("_NT_SYMBOL_PATH", "")
+        symbol_path_list = symbol_path.split(os.pathsep)
+        symbol_path_list = [
+            str(self._endstone_runtime_path.parent.absolute()),
+            str(self.plugin_path.absolute()),
+        ] + symbol_path_list
+        env["_NT_SYMBOL_PATH"] = os.pathsep.join(symbol_path_list)
+        return env
+
     def _add_loopback_exemption(self) -> bool:
         sid = "S-1-15-2-1958404141-86561845-1752920682-3514627264-368642714-62675701-733520436"
         ret = subprocess.run(
@@ -113,95 +48,12 @@ class WindowsBootstrap(Bootstrap):
         else:
             return True
 
-    def _create_process(self, *args, **kwargs) -> None:
+    def _run(self, *args, **kwargs) -> int:
         self._add_loopback_exemption()
 
-        # Add paths for symbol lookup
-        env = os.environ.copy()
-        symbol_path = env.get("_NT_SYMBOL_PATH", "")
-        symbol_path_list = symbol_path.split(os.pathsep)
-        symbol_path_list = [
-            str(self._endstone_runtime_path.parent.absolute()),
-            str(self.plugin_path.absolute()),
-        ] + symbol_path_list
-        env["_NT_SYMBOL_PATH"] = os.pathsep.join(symbol_path_list)
-
-        # Create the process is a suspended state
-        super()._create_process(creationflags=CREATE_SUSPENDED, env=env)
-        handle_proc = int(self._process._handle)
-        lib_path = str(self._endstone_runtime_path.absolute())
-
-        # Validate dll
-        dll = kernel32.LoadLibraryExW(lib_path, None, DONT_RESOLVE_DLL_REFERENCES)
-        if not dll:
-            raise ValueError(f"LoadLibraryExW failed with error {get_last_error()}.")
-
-        # Allocate memory for lib_path
-        address = kernel32.VirtualAllocEx(
-            handle_proc,  # hProcess
-            0,  # lpAddress
-            MAX_PATH * 2 + 1,  # dwSize
-            DWORD(MEM_COMMIT | MEM_RESERVE),  # flAllocationType
-            DWORD(PAGE_READWRITE),  # flProtect
-        )
-        if not address:
-            raise ValueError(f"VirtualAllocEx failed with error {get_last_error()}.")
-
-        # Write lib_path into the allocated memory
-        size_written = SIZE_T(0)
-        result = kernel32.WriteProcessMemory(
-            handle_proc, address, lib_path, len(lib_path) * 2 + 1, ctypes.byref(size_written)
+        return start_process_with_dll(
+            str(self.executable_path.absolute()),
+            str(self._endstone_runtime_path.absolute()),
+            cwd=str(self.server_path.absolute()),
+            env=self._endstone_runtime_env,
         )
-        if not result:
-            raise ValueError(f"WriteProcessMemory failed with error {get_last_error()}.")
-
-        # Get module handle of kernel32
-        handle_kernel32 = kernel32.GetModuleHandleW("kernel32.dll")
-        if not handle_kernel32:
-            raise ValueError(f"GetModuleHandleW failed with error {get_last_error()}.")
-
-        # Get address of LoadLibraryW
-        load_library = kernel32.GetProcAddress(handle_kernel32, b"LoadLibraryW")
-        if not load_library:
-            raise ValueError(f"GetProcAddress failed with error {get_last_error()}.")
-
-        # Start a new thread in the process, starting at LoadLibraryW with address as argument
-        remote_thread = kernel32.CreateRemoteThread(handle_proc, None, 0, load_library, address, 0, None)
-        if not remote_thread:
-            raise ValueError(f"CreateRemoteThread failed with error {get_last_error()}.")
-
-        # Wait for the remote thread to finish
-        if kernel32.WaitForSingleObject(remote_thread, INFINITE) == 0xFFFFFFFF:
-            raise ValueError(f"WaitForSingleObject failed with error {get_last_error()}.")
-
-        # Check dll load result
-        exit_code = DWORD()
-        result = kernel32.GetExitCodeThread(remote_thread, ctypes.byref(exit_code))
-        if result == 0:
-            raise ValueError(f"LoadLibrary failed with thread exit code: {exit_code.value}")
-
-        # Reopen the handle to process thread (which was closed by subprocess.Popen)
-        snapshot = kernel32.CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, 0)
-        if snapshot == INVALID_HANDLE_VALUE:
-            raise ValueError(f"CreateToolhelp32Snapshot failed with error {get_last_error()}.")
-
-        thread_entry = THREADENTRY32()
-        thread_entry.dwSize = ctypes.sizeof(thread_entry)
-        success = kernel32.Thread32First(snapshot, ctypes.byref(thread_entry))
-        if not success:
-            raise ValueError(f"Thread32First failed with error {get_last_error()}.")
-
-        handle_thread = None
-        while success:
-            if thread_entry.th32OwnerProcessID == self._process.pid:
-                handle_thread = kernel32.OpenThread(THREAD_ALL_ACCESS, None, thread_entry.th32ThreadID)
-                break
-
-            success = kernel32.Thread32Next(snapshot, ctypes.byref(thread_entry))
-
-        if handle_thread is None:
-            raise ValueError(f"OpenThread failed with error {get_last_error()}.")
-
-        # Resume main thread execution
-        kernel32.ResumeThread(handle_thread)
-        kernel32.CloseHandle(handle_thread)