levistone 0.6.1__1-cp311-cp311-win_amd64.whl

endstone/__init__.py

@@ -0,0 +1,16 @@
+from endstone._internal.endstone_python import ColorFormat, GameMode, Logger, OfflinePlayer, Player, Server, Skin
+from endstone._internal.version import __version__
+
+__minecraft_version__ = "1.21.60"
+
+__all__ = [
+    "__version__",
+    "__minecraft_version__",
+    "ColorFormat",
+    "GameMode",
+    "Logger",
+    "OfflinePlayer",
+    "Player",
+    "Server",
+    "Skin",
+]

endstone/__main__.py

@@ -0,0 +1,4 @@
+from endstone._internal.bootstrap import cli
+
+if __name__ == "__main__":
+    cli()

endstone/_internal/bootstrap/__init__.py

@@ -0,0 +1,74 @@
+import functools
+import logging
+import platform
+import sys
+
+import click
+
+from endstone._internal.version import __version__
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="[%(asctime)s.%(msecs)03d %(levelname)s] [%(name)s] %(message)s",
+    datefmt="%Y-%m-%d %H:%M:%S",
+)
+logger = logging.getLogger(__name__)
+
+__all__ = ["cli"]
+
+
+def catch_exceptions(func):
+    """Decorator to catch and log exceptions."""
+
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        try:
+            return func(*args, **kwargs)
+        except Exception as e:
+            logger.exception(e)
+            sys.exit(-1)
+
+    return wrapper
+
+
+@click.command(help="Starts an endstone server.")
+@click.option(
+    "-s",
+    "--server-folder",
+    default="bedrock_server",
+    help="Specify the folder for the bedrock server. Defaults to 'bedrock_server'.",
+)
+@click.option(
+    "-y",
+    "--no-confirm",
+    "--yes",
+    default=False,
+    is_flag=True,
+    show_default=True,
+    help="Assume yes as answer to all prompts",
+)
+@click.option(
+    "-r",
+    "--remote",
+    default="https://raw.githubusercontent.com/EndstoneMC/bedrock-server-data/main/bedrock_server_data.json",
+    help="The remote URL to retrieve bedrock server data from.",
+)
+@click.version_option(__version__)
+@catch_exceptions
+def cli(server_folder: str, no_confirm: bool, remote: str) -> None:
+    system = platform.system()
+    if system == "Windows":
+        from endstone._internal.bootstrap.windows import WindowsBootstrap
+
+        cls = WindowsBootstrap
+
+    elif system == "Linux":
+        from endstone._internal.bootstrap.linux import LinuxBootstrap
+
+        cls = LinuxBootstrap
+    else:
+        raise NotImplementedError(f"{system} is not supported.")
+
+    bootstrap = cls(server_folder=server_folder, no_confirm=no_confirm, remote=remote)
+    exit_code = bootstrap.run()
+    sys.exit(exit_code)

endstone/_internal/bootstrap/base.py

@@ -0,0 +1,258 @@
+import errno
+import hashlib
+import logging
+import os
+import platform
+import subprocess
+import sys
+import tempfile
+import zipfile
+from pathlib import Path
+from typing import Union
+
+import click
+import requests
+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:
+    def __init__(self, server_folder: str, no_confirm: bool, remote: str) -> None:
+        self._server_path = Path(server_folder).absolute()
+        self._no_confirm = no_confirm
+        self._remote = remote
+        self._logger = logging.getLogger(self.name)
+        self._process: subprocess.Popen
+
+    @property
+    def name(self) -> str:
+        return __name__
+
+    @property
+    def target_system(self) -> str:
+        raise NotImplementedError
+
+    @property
+    def executable_filename(self) -> str:
+        raise NotImplementedError
+
+    @property
+    def server_path(self) -> Path:
+        return self._server_path
+
+    @property
+    def executable_path(self) -> Path:
+        return self.server_path / self.executable_filename
+
+    @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})"
+
+    def _validate(self) -> None:
+        if platform.system().lower() != self.target_system:
+            raise NotImplementedError(f"{platform.system()} is not supported by this bootstrap.")
+        if not self.executable_path.exists():
+            raise FileNotFoundError(errno.ENOENT, os.strerror(errno.ENOENT), str(self.executable_path))
+        if not self._endstone_runtime_path.exists():
+            raise FileNotFoundError(errno.ENOENT, os.strerror(errno.ENOENT), str(self._endstone_runtime_path))
+
+    def _download(self, dst: Union[str, os.PathLike]) -> None:
+        dst = Path(dst)
+
+        self._logger.info("Loading index from the remote server...")
+        response = requests.get(self._remote)
+        response.raise_for_status()
+        server_data = response.json()
+
+        if minecraft_version not in server_data["binary"]:
+            raise ValueError(f"Version v{minecraft_version} is not found in the remote server.")
+
+        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"]
+            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(
+                TextColumn("[progress.description]{task.description}"),
+                BarColumn(),
+                DownloadColumn(),
+                TimeRemainingColumn(),
+            ) as progress:
+                task = progress.add_task("[bold blue]Downloading...", total=total_size)
+                for data in response.iter_content(chunk_size=1024):
+                    progress.update(task, advance=len(data))
+                    f.write(data)
+                    m.update(data)
+
+            self._logger.info("Download complete. Verifying integrity...")
+            if m.hexdigest() != metadata["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)
+            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
+
+                    zip_ref.extract(file, dst)
+
+        if should_modify_server_properties:
+            properties = dst / "server.properties"
+            with properties.open("r", encoding="utf-8") as file:
+                in_lines = file.readlines()
+
+            out_lines = []
+            for line in in_lines:
+                if line.strip() == "server-name=Dedicated Server":
+                    out_lines.append("server-name=Endstone Server\n")
+                elif line.strip() == "client-side-chunk-generation-enabled=true":
+                    out_lines.append("client-side-chunk-generation-enabled=false\n")
+                else:
+                    out_lines.append(line)
+
+            with properties.open("w", encoding="utf-8") as file:
+                file.writelines(out_lines)
+
+        version_file = dst / "version.txt"
+        with version_file.open("w", encoding="utf-8") as file:
+            file.writelines(minecraft_version)
+
+    def _prepare(self) -> None:
+        self.plugin_path.mkdir(parents=True, exist_ok=True)
+
+    def _install(self) -> None:
+        """
+        Installs the server if not already installed.
+        """
+
+        if self.executable_path.exists():
+            self._update()
+            return
+
+        if not self._no_confirm:
+            download = click.confirm(
+                f"Bedrock Dedicated Server (v{minecraft_version}) "
+                f"is not found in {str(self.executable_path.parent)}. "
+                f"Would you like to download it now?",
+                default=True,
+            )
+        else:
+            download = True
+
+        if not download:
+            sys.exit(1)
+
+        self.server_path.mkdir(parents=True, exist_ok=True)
+        self._download(self.server_path)
+
+    def _update(self) -> None:
+        current_version = Version("0.0.0")
+        supported_version = Version(minecraft_version)
+
+        version_file = self.server_path / "version.txt"
+        if version_file.exists():
+            with version_file.open("r", encoding="utf-8") as file:
+                current_version = Version(file.readline())
+
+        if current_version == supported_version:
+            return
+
+        if current_version > supported_version:
+            raise RuntimeError(
+                f"A newer version of Bedrock Dedicated Server (v{current_version}) "
+                f"is found in {str(self.executable_path.parent)}. Please update your Endstone server."
+            )
+
+        if not self._no_confirm:
+            update = click.confirm(
+                f"An older version of Bedrock Dedicated Server (v{current_version}) "
+                f"is found in {str(self.executable_path.parent)}. "
+                f"Would you like to update to v{minecraft_version} now?",
+                default=True,
+            )
+        else:
+            update = True
+
+        if not update:
+            sys.exit(1)
+
+        self._logger.info(f"Updating server from v{current_version} to v{minecraft_version}...")
+        self._download(self.server_path)
+
+    def run(self) -> int:
+        self._install()
+        self._validate()
+        self._prepare()
+        self._create_process()
+        return self._wait_for_server()
+
+    @property
+    def _endstone_runtime_filename(self) -> str:
+        raise NotImplementedError
+
+    @property
+    def _endstone_runtime_path(self) -> Path:
+        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())
+        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,
+        )
+
+    def _wait_for_server(self) -> int:
+        """
+        Waits for the server process to terminate 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.
+
+        Returns:
+            int: The exit code of the server process. Returns -1 if the process is not created or still running.
+        """
+
+        if self._process is None:
+            return -1
+
+        return self._process.wait()

endstone/_internal/bootstrap/linux.py

@@ -0,0 +1,67 @@
+import ctypes.util
+import os
+import stat
+from pathlib import Path
+
+from endstone._internal.bootstrap.base import Bootstrap
+
+
+class LinuxBootstrap(Bootstrap):
+    @property
+    def name(self) -> str:
+        return "LinuxBootstrap"
+
+    @property
+    def target_system(self) -> str:
+        return "linux"
+
+    @property
+    def executable_filename(self) -> str:
+        return "bedrock_server"
+
+    @property
+    def _endstone_runtime_filename(self) -> str:
+        return "libendstone_runtime.so"
+
+    def _prepare(self) -> None:
+        super()._prepare()
+        st = os.stat(self.executable_path)
+        os.chmod(self.executable_path, 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)
+
+    @property
+    def _linked_libpython_path(self) -> Path:
+        """
+        Find the path of the linked libpython on Unix systems.
+
+        From https://gist.github.com/tkf/d980eee120611604c0b9b5fef5b8dae6
+
+        Returns:
+            (Path): Path object representing the path of the linked libpython.
+        """
+
+        class DlInfo(ctypes.Structure):
+            # https://www.man7.org/linux/man-pages/man3/dladdr.3.html
+            _fields_ = [
+                ("dli_fname", ctypes.c_char_p),
+                ("dli_fbase", ctypes.c_void_p),
+                ("dli_sname", ctypes.c_char_p),
+                ("dli_saddr", ctypes.c_void_p),
+            ]
+
+        libdl = ctypes.CDLL(ctypes.util.find_library("dl"))
+        libdl.dladdr.argtypes = [ctypes.c_void_p, ctypes.POINTER(DlInfo)]
+        libdl.dladdr.restype = ctypes.c_int
+
+        dlinfo = DlInfo()
+        retcode = libdl.dladdr(ctypes.cast(ctypes.pythonapi.Py_GetVersion, ctypes.c_void_p), ctypes.pointer(dlinfo))
+        if retcode == 0:
+            raise ValueError("dladdr cannot match the address of ctypes.pythonapi.Py_GetVersion to a shared object")
+
+        path = Path(dlinfo.dli_fname.decode()).resolve()
+        return path

endstone/_internal/bootstrap/windows.py

@@ -0,0 +1,207 @@
+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)
+
+
+class WindowsBootstrap(Bootstrap):
+    @property
+    def name(self) -> str:
+        return "WindowsBootstrap"
+
+    @property
+    def target_system(self) -> str:
+        return "windows"
+
+    @property
+    def executable_filename(self) -> str:
+        return "bedrock_server.exe"
+
+    @property
+    def _endstone_runtime_filename(self) -> str:
+        return "endstone_runtime_loader.dll"
+
+    def _add_loopback_exemption(self) -> bool:
+        sid = "S-1-15-2-1958404141-86561845-1752920682-3514627264-368642714-62675701-733520436"
+        ret = subprocess.run(
+            ["CheckNetIsolation", "LoopbackExempt", "-s", f"-p={sid}"], check=True, capture_output=True
+        )
+        if sid not in str(ret.stdout):
+            ret = ctypes.windll.shell32.ShellExecuteW(
+                None, "runas", "CheckNetIsolation", " ".join(["LoopbackExempt", "-a", f"-p={sid}"]), None, 1
+            )
+            return ret > 32
+        else:
+            return True
+
+    def _create_process(self, *args, **kwargs) -> None:
+        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)
+        )
+        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)