ndev-stack 0.1.0__py3-none-any.whl

ndev/linux/php/extensions.py

@@ -0,0 +1,146 @@
+import shutil
+import tarfile
+import subprocess
+import httpx
+from pathlib import Path
+from ndev.common.constants import PHP_DIR, DOWNLOADS_DIR, BUILDS_DIR
+from ndev.linux.chroot.manager import SandboxManager
+from ndev.common.logger import logger
+from ndev.common.utils import run_command
+
+def get_php_binaries(version: str) -> tuple[Path, Path, Path]:
+    """Get the path to php, phpize, and php-config binaries for a version."""
+    prefix = PHP_DIR / version
+    php_bin = prefix / "bin" / "php"
+    phpize_bin = prefix / "bin" / "phpize"
+    php_config_bin = prefix / "bin" / "php-config"
+    return php_bin, phpize_bin, php_config_bin
+
+def list_extensions(version: str) -> list[str]:
+    """List loaded PHP extensions by running php -m."""
+    php_bin, _, _ = get_php_binaries(version)
+    if not php_bin.exists():
+        raise ValueError(f"PHP version {version} is not installed.")
+        
+    res = subprocess.run([str(php_bin), "-m"], capture_output=True, text=True)
+    if res.returncode != 0:
+        raise ValueError(f"Failed to list extensions: {res.stderr}")
+        
+    lines = res.stdout.splitlines()
+    extensions = []
+    for line in lines:
+        line = line.strip()
+        if line and not line.startswith("["):
+            extensions.append(line)
+    return sorted(extensions)
+
+def enable_extension(version: str, ext_name: str):
+    """Enable an extension by creating its ini file in etc/conf.d/."""
+    prefix = PHP_DIR / version
+    conf_d = prefix / "etc" / "conf.d"
+    conf_d.mkdir(parents=True, exist_ok=True)
+    
+    ini_file = conf_d / f"{ext_name}.ini"
+    
+    # OPcache and Xdebug require zend_extension, others require extension
+    if ext_name.lower() in ["opcache", "xdebug"]:
+        ini_file.write_text(f"zend_extension={ext_name}\n")
+    else:
+        ini_file.write_text(f"extension={ext_name}\n")
+        
+    logger.info(f"Extension '{ext_name}' enabled for PHP {version} (ini file created at {ini_file}).")
+
+def disable_extension(version: str, ext_name: str):
+    """Disable an extension by removing its ini file in etc/conf.d/."""
+    prefix = PHP_DIR / version
+    ini_file = prefix / "etc" / "conf.d" / f"{ext_name}.ini"
+    if ini_file.exists():
+        ini_file.unlink()
+        logger.info(f"Extension '{ext_name}' disabled for PHP {version} (ini file removed).")
+    else:
+        logger.warning(f"Extension '{ext_name}' was not enabled (ini file {ini_file} does not exist).")
+
+def install_extension(version: str, ext_name: str, show_logs: bool = False):
+    """Download, compile, and install a PECL extension inside the sandbox."""
+    php_bin, phpize_bin, php_config_bin = get_php_binaries(version)
+    if not php_bin.exists():
+        raise ValueError(f"PHP version {version} is not installed.")
+    if not phpize_bin.exists():
+        raise ValueError(f"phpize binary not found for version {version}. Development headers may be missing.")
+
+    # 1. Download extension archive on host
+    DOWNLOADS_DIR.mkdir(parents=True, exist_ok=True)
+    archive_path = DOWNLOADS_DIR / f"{ext_name}.tgz"
+    url = f"https://pecl.php.net/get/{ext_name}"
+    
+    logger.info(f"Downloading extension '{ext_name}' from {url}...")
+    with httpx.Client(follow_redirects=True) as client:
+        res = client.get(url)
+        if res.status_code != 200:
+            raise ValueError(f"Failed to download extension '{ext_name}' from PECL (HTTP status {res.status_code}).")
+        archive_path.write_bytes(res.content)
+
+    # 2. Extract extension archive
+    BUILDS_DIR.mkdir(parents=True, exist_ok=True)
+    build_dir = BUILDS_DIR / f"ext-{ext_name}"
+    if build_dir.exists():
+        if build_dir.is_dir():
+            shutil.rmtree(build_dir)
+        else:
+            build_dir.unlink()
+        
+    logger.info(f"Extracting extension archive to {build_dir}...")
+    with tarfile.open(archive_path) as tar:
+        root_dir_name = None
+        for member in tar.getmembers():
+            if member.name.endswith("config.m4"):
+                parts = Path(member.name).parts
+                if len(parts) > 1:
+                    root_dir_name = parts[0]
+                    break
+        if not root_dir_name:
+            for member in tar.getmembers():
+                parts = Path(member.name).parts
+                if len(parts) > 1 and parts[0] != ".":
+                    root_dir_name = parts[0]
+                    break
+        if not root_dir_name:
+            raise ValueError("Could not find a valid root directory in extension archive.")
+        tar.extractall(path=BUILDS_DIR)
+        
+    extracted_path = BUILDS_DIR / root_dir_name
+    if extracted_path.resolve() != build_dir.resolve():
+        shutil.move(str(extracted_path), str(build_dir))
+
+    # 3. Configure and compile inside sandbox
+    if not show_logs:
+        logger.info(f"[yellow]Compiling extension '{ext_name}'...[/yellow]")
+    else:
+        logger.info(f"Compiling extension '{ext_name}' inside the sandbox...")
+    sandbox = SandboxManager()
+    
+    # Run phpize
+    sandbox.run([str(phpize_bin)], cwd=build_dir, show_logs=show_logs)
+    
+    # Run configure
+    sandbox.run(["./configure", f"--with-php-config={php_config_bin}"], cwd=build_dir, show_logs=show_logs)
+    
+    # Run make
+    sandbox.run(["make", "-j4"], cwd=build_dir, show_logs=show_logs)
+    
+    if not show_logs:
+        logger.info(f"[green]Compiled extension '{ext_name}'[/green]")
+        logger.info(f"[yellow]Installing extension '{ext_name}'...[/yellow]")
+    else:
+        logger.info("Installing extension...")
+    sandbox.run(["make", "install"], cwd=build_dir, show_logs=show_logs)
+    
+    if not show_logs:
+        logger.info(f"[green]Installed extension '{ext_name}'[/green]")
+    
+    # 4. Enable extension (strip version suffix if present: e.g. xdebug-3.1.6 -> xdebug)
+    base_ext_name = ext_name.split("-")[0]
+    enable_extension(version, base_ext_name)
+    
+    # Clean up build dir
+    shutil.rmtree(build_dir, ignore_errors=True)

ndev/linux/php/installer.py

@@ -0,0 +1,42 @@
+from pathlib import Path
+from ndev.linux.php.resolver import resolve_version
+from ndev.linux.php.downloader import download_php_source
+from ndev.linux.php.builder import build_php
+from ndev.linux.php.templates import write_default_configs
+from ndev.linux.chroot.packages import install_host_packages
+from ndev.common.logger import logger
+
+def install_version(version_input: str, show_logs: bool = False) -> str:
+    """Resolve, download, build and configure a PHP version."""
+    resolved_version, filename, sha256, download_url = resolve_version(version_input)
+    
+    archive_path = download_php_source(filename, sha256, download_url)
+    
+    # Pre-install development dependencies inside sandbox
+    install_host_packages([
+        "libsqlite3-dev",
+        "libonig-dev",
+        "libcrypt-dev",
+        "libcurl4-openssl-dev",
+        "libxml2-dev",
+        "libssl-dev",
+        "libzip-dev",
+        "libicu-dev",
+        "libsodium-dev",
+        "libpng-dev",
+        "libjpeg-dev",
+        "libwebp-dev",
+        "libwebpdecoder3",
+        "libfreetype-dev",
+        "libbz2-dev",
+        "libgmp-dev",
+        "libreadline-dev",
+        "zlib1g-dev"
+    ], show_logs=show_logs)
+    
+    install_prefix = build_php(resolved_version, archive_path, show_logs=show_logs)
+    
+    write_default_configs(install_prefix, resolved_version)
+    
+    logger.info(f"Successfully finished installation of PHP version {resolved_version}")
+    return resolved_version

ndev/linux/php/resolver.py

@@ -0,0 +1,59 @@
+import httpx
+from packaging.version import parse as parse_version
+from ndev.common.github import fetch_releases
+from ndev.common.logger import logger
+
+def resolve_version(version_input: str) -> tuple[str, str, str, str]:
+    """
+    Resolve version input (e.g. '8.4', '8.5.8') to:
+    (exact_version, filename, sha256, download_url)
+    """
+    version_input = version_input.strip().lower()
+    if version_input.startswith("php-"):
+        version_input = version_input[4:]
+        
+    parts = version_input.split(".")
+    try:
+        major = int(parts[0])
+    except ValueError:
+        raise ValueError(f"Invalid version format: '{version_input}'")
+        
+    logger.info(f"Resolving version prefix '{version_input}'...")
+    releases = fetch_releases(major)
+    if not releases:
+        raise ValueError(f"No releases found or network error for PHP version {major}")
+        
+    matching_versions = []
+    for v in releases.keys():
+        if v.startswith(version_input):
+            matching_versions.append(v)
+            
+    if not matching_versions:
+        raise ValueError(f"Could not resolve version prefix '{version_input}' to any active release.")
+        
+    resolved_version = max(matching_versions, key=parse_version)
+    logger.info(f"Resolved to version: {resolved_version}")
+    
+    release_data = releases[resolved_version]
+    sources = release_data.get("source", [])
+    
+    chosen_source = None
+    for ext in [".tar.xz", ".tar.gz", ".tar.bz2"]:
+        for src in sources:
+            if src.get("filename", "").endswith(ext):
+                chosen_source = src
+                break
+        if chosen_source:
+            break
+            
+    if not chosen_source:
+        if sources:
+            chosen_source = sources[0]
+        else:
+            raise ValueError(f"No source downloads available for resolved version {resolved_version}")
+            
+    filename = chosen_source["filename"]
+    sha256 = chosen_source.get("sha256", "")
+    download_url = f"https://www.php.net/distributions/{filename}"
+    
+    return resolved_version, filename, sha256, download_url

ndev/linux/php/templates.py

@@ -0,0 +1,128 @@
+import os
+import getpass
+from pathlib import Path
+from jinja2 import Template
+from ndev.common.constants import RUN_DIR, LOGS_DIR
+from ndev.common.logger import logger
+
+PHP_INI_TEMPLATE = """[PHP]
+engine = On
+short_open_tag = Off
+precision = 14
+output_buffering = 4096
+zlib.output_compression = Off
+implicit_flush = Off
+unserialize_callback_func =
+serialize_precision = -1
+disable_functions =
+disable_classes =
+zend.enable_gc = On
+expose_php = On
+max_execution_time = 30
+max_input_time = 60
+memory_limit = 128M
+error_reporting = E_ALL & ~E_DEPRECATED & ~E_STRICT
+display_errors = On
+display_startup_errors = On
+log_errors = On
+log_errors_max_len = 1024
+ignore_repeated_errors = Off
+ignore_repeated_source = Off
+report_memleaks = On
+html_errors = On
+variables_order = "GPCS"
+request_order = "GP"
+register_argc_argv = Off
+auto_globals_jit = On
+post_max_size = 8M
+default_mimetype = "text/html"
+default_charset = "UTF-8"
+doc_root =
+user_dir =
+enable_dl = Off
+file_uploads = On
+upload_max_filesize = 2M
+max_file_uploads = 20
+allow_url_fopen = On
+allow_url_include = Off
+default_socket_timeout = 60
+
+[CLI Server]
+cli_server.color = On
+
+[Date]
+date.timezone = UTC
+"""
+
+PHP_FPM_CONF_TEMPLATE = """[global]
+pid = {{ run_dir }}/php-fpm-{{ major_minor }}.pid
+error_log = {{ logs_dir }}/php-fpm-{{ major_minor }}.log
+log_level = notice
+include = {{ prefix }}/etc/php-fpm.d/*.conf
+"""
+
+WWW_CONF_TEMPLATE = """[www]
+user = {{ user }}
+group = {{ group }}
+listen = {{ run_dir }}/php{{ major_minor }}.sock
+listen.owner = {{ user }}
+listen.group = {{ group }}
+listen.mode = 0666
+
+pm = dynamic
+pm.max_children = 5
+pm.start_servers = 2
+pm.min_spare_servers = 1
+pm.max_spare_servers = 3
+"""
+
+def get_major_minor(version: str) -> str:
+    parts = version.split(".")
+    return f"{parts[0]}{parts[1]}"
+
+def write_default_configs(prefix: Path, version: str):
+    """Generate and write default configs to the installed PHP prefix."""
+    etc_dir = prefix / "etc"
+    fpm_d = etc_dir / "php-fpm.d"
+    conf_d = etc_dir / "conf.d"
+    
+    # Create directories
+    etc_dir.mkdir(parents=True, exist_ok=True)
+    fpm_d.mkdir(parents=True, exist_ok=True)
+    conf_d.mkdir(parents=True, exist_ok=True)
+    
+    # Get current user details
+    user = getpass.getuser()
+    # On some systems, group matches user
+    group = user
+    
+    major_minor = get_major_minor(version)
+    
+    context = {
+        "prefix": str(prefix),
+        "run_dir": str(RUN_DIR),
+        "logs_dir": str(LOGS_DIR),
+        "major_minor": major_minor,
+        "user": user,
+        "group": group
+    }
+    
+    # 1. php.ini
+    php_ini_path = etc_dir / "php.ini"
+    if not php_ini_path.exists():
+        php_ini_path.write_text(PHP_INI_TEMPLATE)
+        logger.info(f"Generated default php.ini at {php_ini_path}")
+        
+    # 2. php-fpm.conf
+    php_fpm_conf_path = etc_dir / "php-fpm.conf"
+    if not php_fpm_conf_path.exists():
+        rendered = Template(PHP_FPM_CONF_TEMPLATE).render(context)
+        php_fpm_conf_path.write_text(rendered)
+        logger.info(f"Generated default php-fpm.conf at {php_fpm_conf_path}")
+        
+    # 3. www.conf
+    www_conf_path = fpm_d / "www.conf"
+    if not www_conf_path.exists():
+        rendered = Template(WWW_CONF_TEMPLATE).render(context)
+        www_conf_path.write_text(rendered)
+        logger.info(f"Generated default www.conf at {www_conf_path}")

ndev/linux/runtime/fpm.py

@@ -0,0 +1,117 @@
+import time
+import signal
+from pathlib import Path
+import subprocess
+from ndev.common.constants import PHP_DIR
+from ndev.common.logger import logger
+from ndev.linux.runtime.process import is_pid_running, read_pid_file, kill_process
+from ndev.linux.runtime.sockets import get_pid_path, get_socket_path
+
+def get_fpm_binary(version: str) -> Path:
+    """Get the path to php-fpm binary for a version."""
+    prefix = PHP_DIR / version
+    return prefix / "sbin" / "php-fpm"
+
+def start_fpm(version: str):
+    """Start PHP-FPM daemon for a version."""
+    pid_file = get_pid_path(version)
+    pid = read_pid_file(pid_file)
+    
+    if pid and is_pid_running(pid):
+        logger.info(f"PHP-FPM {version} is already running with PID {pid}.")
+        return
+        
+    fpm_bin = get_fpm_binary(version)
+    if not fpm_bin.exists():
+        raise FileNotFoundError(f"PHP-FPM binary not found at {fpm_bin} for version {version}")
+        
+    prefix = PHP_DIR / version
+    conf_file = prefix / "etc" / "php-fpm.conf"
+    ini_file = prefix / "etc" / "php.ini"
+    
+    cmd = [
+        str(fpm_bin),
+        "-y", str(conf_file),
+        "-c", str(ini_file)
+    ]
+    
+    logger.info(f"Starting PHP-FPM {version}...")
+    res = subprocess.run(cmd, capture_output=True, text=True)
+    if res.returncode != 0:
+        raise RuntimeError(f"Failed to start PHP-FPM {version}: {res.stderr or res.stdout}")
+        
+    for _ in range(10):
+        time.sleep(0.2)
+        pid = read_pid_file(pid_file)
+        if pid and is_pid_running(pid):
+            logger.info(f"PHP-FPM {version} started successfully (PID {pid}).")
+            return
+            
+    logger.warning(f"PHP-FPM {version} launched, but PID file could not be verified.")
+
+def stop_fpm(version: str):
+    """Stop PHP-FPM daemon for a version."""
+    pid_file = get_pid_path(version)
+    pid = read_pid_file(pid_file)
+    
+    if not pid or not is_pid_running(pid):
+        logger.info(f"PHP-FPM {version} is not running.")
+        if pid_file.exists():
+            pid_file.unlink()
+        return
+        
+    logger.info(f"Stopping PHP-FPM {version} (PID {pid})...")
+    kill_process(pid, signal.SIGTERM)
+    
+    for _ in range(20):
+        time.sleep(0.2)
+        if not is_pid_running(pid):
+            logger.info(f"PHP-FPM {version} stopped.")
+            if pid_file.exists():
+                pid_file.unlink()
+            sock_file = get_socket_path(version)
+            if sock_file.exists():
+                sock_file.unlink()
+            return
+            
+    logger.warning("FPM process did not exit. Force killing...")
+    kill_process(pid, signal.SIGKILL)
+    if pid_file.exists():
+        pid_file.unlink()
+    sock_file = get_socket_path(version)
+    if sock_file.exists():
+        sock_file.unlink()
+
+def reload_fpm(version: str):
+    """Gracefully reload PHP-FPM daemon (SIGUSR2)."""
+    pid_file = get_pid_path(version)
+    pid = read_pid_file(pid_file)
+    
+    if not pid or not is_pid_running(pid):
+        logger.warning(f"PHP-FPM {version} is not running. Starting it instead...")
+        start_fpm(version)
+        return
+        
+    logger.info(f"Reloading PHP-FPM {version} (PID {pid})...")
+    kill_process(pid, signal.SIGUSR2)
+    logger.info("SIGUSR2 reload signal sent.")
+
+def restart_fpm(version: str):
+    """Restart PHP-FPM daemon."""
+    stop_fpm(version)
+    start_fpm(version)
+
+def get_fpm_status(version: str) -> dict:
+    """Get the status of PHP-FPM for a version."""
+    pid_file = get_pid_path(version)
+    pid = read_pid_file(pid_file)
+    running = is_pid_running(pid) if pid else False
+    socket_path = get_socket_path(version)
+    
+    return {
+        "version": version,
+        "pid": pid if running else None,
+        "running": running,
+        "socket": str(socket_path) if socket_path.exists() else str(socket_path),
+        "socket_exists": socket_path.exists()
+    }