linux-kernel-manager 0.1.2__py3-none-any.whl

lkm/core/backends/nix.py

@@ -0,0 +1,195 @@
+"""
+nix backend — NixOS.
+
+NixOS manages kernels declaratively via /etc/nixos/configuration.nix (channels)
+or a flake.nix (flakes).  This backend:
+
+  - Detects whether the system uses channels or flakes.
+  - Patches boot.kernelPackages in the appropriate config file.
+  - Runs nixos-rebuild switch to apply the change.
+  - Hold/unhold explains flake input pinning rather than silently failing.
+"""
+from __future__ import annotations
+
+import os
+import re
+import shutil
+import tempfile
+from collections.abc import Iterator
+from pathlib import Path
+
+from lkm.core.backends.base import PackageBackend
+from lkm.core.system import privilege_escalation_cmd
+
+_NIXPKGS_KERNEL_ATTRS = {
+    "linuxPackages", "linuxPackages_latest", "linuxPackages_6_6",
+    "linuxPackages_6_1", "linuxPackages_5_15", "linuxPackages_rt",
+    "linuxPackages_hardened", "linuxPackages_zen",
+    "linuxPackages_xanmod", "linuxPackages_xanmod_latest",
+}
+
+_NIXOS_CONFIG = Path("/etc/nixos/configuration.nix")
+_NIXOS_FLAKE  = Path("/etc/nixos/flake.nix")
+
+_KERNEL_PKG_RE = re.compile(
+    r"(boot\.kernelPackages\s*=\s*)([^;]+)(;)",
+    re.MULTILINE,
+)
+
+
+def _is_flake_system() -> bool:
+    return _NIXOS_FLAKE.exists()
+
+
+def _config_path() -> Path:
+    return _NIXOS_FLAKE if _is_flake_system() else _NIXOS_CONFIG
+
+
+def _read_config(path: Path) -> str:
+    try:
+        return path.read_text()
+    except OSError:
+        return ""
+
+
+def _write_config(path: Path, text: str) -> tuple[int, str, str]:
+    priv = privilege_escalation_cmd()
+    with tempfile.NamedTemporaryFile("w", suffix=".nix", delete=False) as f:
+        f.write(text)
+        tmp = f.name
+    import subprocess
+    result = subprocess.run(priv + ["cp", tmp, str(path)], capture_output=True, text=True)
+    os.unlink(tmp)
+    return result.returncode, result.stdout, result.stderr
+
+
+def _patch_kernel_attr(text: str, new_attr: str) -> tuple[str, bool]:
+    """Replace boot.kernelPackages = <old>; or insert it if absent."""
+    if _KERNEL_PKG_RE.search(text):
+        patched = _KERNEL_PKG_RE.sub(lambda m: m.group(1) + new_attr + m.group(3), text)
+        return patched, patched != text
+    insert = f"\n  boot.kernelPackages = {new_attr};\n"
+    idx = text.rfind("}")
+    if idx == -1:
+        return text + insert, True
+    return text[:idx] + insert + text[idx:], True
+
+
+def _nixpkgs_attr_for(package_name: str) -> str:
+    """Convert a package name / version string to a pkgs.linuxPackages_* expression."""
+    if package_name.startswith("pkgs."):
+        return package_name
+    if package_name in _NIXPKGS_KERNEL_ATTRS:
+        return f"pkgs.{package_name}"
+    m = re.match(r"^(\d+)\.(\d+)", package_name)
+    if m:
+        return f"pkgs.linuxPackages_{m.group(1)}_{m.group(2)}"
+    return f"pkgs.{package_name}"
+
+
+class NixBackend(PackageBackend):
+
+    @property
+    def name(self) -> str:
+        return "nix"
+
+    @staticmethod
+    def available() -> bool:
+        return bool(shutil.which("nixos-rebuild") or shutil.which("nix-env"))
+
+    @staticmethod
+    def is_nixos() -> bool:
+        try:
+            return "nixos" in open("/etc/os-release").read().lower()
+        except OSError:
+            return False
+
+    @staticmethod
+    def is_flake() -> bool:
+        return _is_flake_system()
+
+    def install_packages(self, packages: list[str]) -> Iterator[str]:
+        if not packages:
+            return
+        attr  = _nixpkgs_attr_for(packages[0])
+        cfg   = _config_path()
+        text  = _read_config(cfg)
+        if not text:
+            yield f"Cannot read {cfg} — is this NixOS?\n"
+            yield f"  boot.kernelPackages = {attr};\n"
+            return
+        patched, changed = _patch_kernel_attr(text, attr)
+        if not changed:
+            yield f"boot.kernelPackages already set to {attr} in {cfg}\n"
+        else:
+            yield f"Patching {cfg}: boot.kernelPackages = {attr}\n"
+            rc, _, err = _write_config(cfg, patched)
+            if rc != 0:
+                yield f"Failed to write {cfg}: {err}\n"
+                yield f"Apply manually: boot.kernelPackages = {attr};\n"
+                return
+            yield f"Written {cfg}\n"
+        yield from self._rebuild()
+
+    def install_local(self, path: str) -> Iterator[str]:
+        yield f"Adding {path} to the Nix store...\n"
+        if shutil.which("nix-store"):
+            priv = privilege_escalation_cmd()
+            yield from self._run_streaming(priv + ["nix-store", "--add-fixed", "sha256", path])
+        yield f"Add the store path to boot.kernelPackages in {_config_path()}\n"
+        yield "Then run: sudo nixos-rebuild switch\n"
+
+    def remove_packages(self, packages: list[str], purge: bool = False) -> Iterator[str]:
+        yield f"Reverting boot.kernelPackages to pkgs.linuxPackages in {_config_path()}\n"
+        yield from self.install_packages(["linuxPackages"])
+
+    def hold(self, packages: list[str]) -> tuple[int, str, str]:
+        if _is_flake_system():
+            msg = (
+                "NixOS (flakes): pin nixpkgs to a specific revision in flake.lock:\n"
+                "  nix flake lock --update-input nixpkgs "
+                "--override-input nixpkgs github:NixOS/nixpkgs/<commit>\n"
+            )
+        else:
+            msg = (
+                "NixOS (channels): pin to a fixed channel URL:\n"
+                "  sudo nix-channel --add "
+                "https://releases.nixos.org/nixos/<version>/nixos-<version> nixos\n"
+                "  sudo nix-channel --update\n"
+            )
+        return 0, msg, ""
+
+    def unhold(self, packages: list[str]) -> tuple[int, str, str]:
+        if _is_flake_system():
+            msg = "NixOS (flakes): unpin by running: nix flake update\n"
+        else:
+            msg = (
+                "NixOS (channels): unpin by switching back to the rolling channel:\n"
+                "  sudo nix-channel --add https://nixos.org/channels/nixos-unstable nixos\n"
+                "  sudo nix-channel --update\n"
+            )
+        return 0, msg, ""
+
+    def is_installed(self, package: str) -> bool:
+        attr    = _nixpkgs_attr_for(package).replace("pkgs.", "")
+        current = self.current_kernel_attr()
+        return bool(current) and attr in current
+
+    def current_kernel_attr(self) -> str:
+        text = _read_config(_config_path())
+        m = _KERNEL_PKG_RE.search(text)
+        return m.group(2).strip() if m else ""
+
+    def list_available_kernels(self) -> list[str]:
+        rc, out, _ = self._run(["nix-env", "-qaP", "--no-name", "linuxPackages"])
+        if rc != 0:
+            return list(_NIXPKGS_KERNEL_ATTRS)
+        return [line.strip() for line in out.splitlines() if "linuxPackages" in line]
+
+    def _rebuild(self) -> Iterator[str]:
+        if not shutil.which("nixos-rebuild"):
+            yield "nixos-rebuild not found — run: sudo nixos-rebuild switch\n"
+            return
+        priv = privilege_escalation_cmd()
+        yield "Running nixos-rebuild switch...\n"
+        yield from self._run_streaming(priv + ["nixos-rebuild", "switch"])

lkm/core/backends/pacman.py

@@ -0,0 +1,78 @@
+"""pacman backend — Arch, Manjaro, EndeavourOS, CachyOS, and derivatives."""
+from __future__ import annotations
+
+from collections.abc import Iterator
+
+from lkm.core.backends.base import PackageBackend
+from lkm.core.system import privilege_escalation_cmd
+
+
+class PacmanBackend(PackageBackend):
+
+    @property
+    def name(self) -> str:
+        return "pacman"
+
+    def install_packages(self, packages: list[str]) -> Iterator[str]:
+        priv = privilege_escalation_cmd()
+        yield from self._run_streaming(
+            priv + ["pacman", "-S", "--noconfirm", "--needed"] + packages
+        )
+
+    def install_local(self, path: str) -> Iterator[str]:
+        priv = privilege_escalation_cmd()
+        yield from self._run_streaming(
+            priv + ["pacman", "-U", "--noconfirm", path]
+        )
+
+    def remove_packages(self, packages: list[str], purge: bool = False) -> Iterator[str]:
+        priv = privilege_escalation_cmd()
+        flags = ["-Rns"] if purge else ["-R"]
+        yield from self._run_streaming(
+            priv + ["pacman"] + flags + ["--noconfirm"] + packages
+        )
+
+    def hold(self, packages: list[str]) -> tuple[int, str, str]:
+        # pacman uses IgnorePkg in /etc/pacman.conf; we append to it
+        import re
+        priv = privilege_escalation_cmd()
+        conf = "/etc/pacman.conf"
+        try:
+            text = open(conf).read()
+        except OSError as e:
+            return 1, "", str(e)
+        pkg_str = " ".join(packages)
+        if "IgnorePkg" in text:
+            text = re.sub(
+                r"(IgnorePkg\s*=\s*)(.*)",
+                lambda m: m.group(1) + (m.group(2) + " " + pkg_str).strip(),
+                text,
+            )
+        else:
+            text = text.replace("[options]", f"[options]\nIgnorePkg = {pkg_str}", 1)
+        import tempfile
+        with tempfile.NamedTemporaryFile("w", suffix=".conf", delete=False) as f:
+            f.write(text)
+            tmp = f.name
+        rc, out, err = self._run(priv + ["cp", tmp, conf])
+        return rc, out, err
+
+    def unhold(self, packages: list[str]) -> tuple[int, str, str]:
+        import re
+        priv = privilege_escalation_cmd()
+        conf = "/etc/pacman.conf"
+        try:
+            text = open(conf).read()
+        except OSError as e:
+            return 1, "", str(e)
+        for pkg in packages:
+            text = re.sub(rf"\b{re.escape(pkg)}\b\s*", "", text)
+        import tempfile
+        with tempfile.NamedTemporaryFile("w", suffix=".conf", delete=False) as f:
+            f.write(text)
+            tmp = f.name
+        return self._run(priv + ["cp", tmp, conf])
+
+    def is_installed(self, package: str) -> bool:
+        rc, _, _ = self._run(["pacman", "-Q", package])
+        return rc == 0

lkm/core/backends/portage.py

@@ -0,0 +1,107 @@
+"""portage backend — Gentoo."""
+from __future__ import annotations
+
+import os
+import shutil
+from collections.abc import Iterator
+from pathlib import Path
+
+from lkm.core.backends.base import PackageBackend
+from lkm.core.system import privilege_escalation_cmd
+
+_KERNEL_SOURCES_DIR = Path("/usr/src")
+
+
+class PortageBackend(PackageBackend):
+
+    @property
+    def name(self) -> str:
+        return "portage"
+
+    def install_packages(self, packages: list[str]) -> Iterator[str]:
+        priv = privilege_escalation_cmd()
+        yield from self._run_streaming(
+            priv + ["emerge", "--ask=n", "--quiet-build"] + packages
+        )
+
+    def install_local(self, path: str) -> Iterator[str]:
+        # Portage doesn't install arbitrary binary packages; delegate to
+        # a manual unpack with a clear message.
+        yield f"Portage does not support binary package install from {path}.\n"
+        yield "Use 'lkm build' to compile from source on Gentoo.\n"
+
+    def remove_packages(self, packages: list[str], purge: bool = False) -> Iterator[str]:
+        priv = privilege_escalation_cmd()
+        flags = ["--depclean"] if purge else ["--unmerge"]
+        yield from self._run_streaming(
+            priv + ["emerge"] + flags + packages
+        )
+
+    def hold(self, packages: list[str]) -> tuple[int, str, str]:
+        # Write package.mask entries
+        priv = privilege_escalation_cmd()
+        mask_dir = Path("/etc/portage/package.mask")
+        mask_dir.mkdir(parents=True, exist_ok=True)
+        mask_file = mask_dir / "lkm-held"
+        existing = mask_file.read_text() if mask_file.exists() else ""
+        new_entries = "\n".join(f"={p}" for p in packages if f"={p}" not in existing)
+        if new_entries:
+            return self._run(
+                priv + ["tee", "-a", str(mask_file)],
+                input=new_entries + "\n",
+            )
+        return 0, "", ""
+
+    def unhold(self, packages: list[str]) -> tuple[int, str, str]:
+        import re
+        mask_file = Path("/etc/portage/package.mask/lkm-held")
+        if not mask_file.exists():
+            return 0, "", ""
+        text = mask_file.read_text()
+        for pkg in packages:
+            text = re.sub(rf"^={re.escape(pkg)}\n?", "", text, flags=re.MULTILINE)
+        priv = privilege_escalation_cmd()
+        return self._run(priv + ["tee", str(mask_file)], input=text)
+
+    def is_installed(self, package: str) -> bool:
+        rc, _, _ = self._run(["qlist", "-I", package])
+        return rc == 0
+
+    # ------------------------------------------------------------------
+    # Gentoo-specific helpers used by the Gentoo provider
+    # ------------------------------------------------------------------
+
+    def list_kernel_sources(self) -> list[str]:
+        """Return paths to installed kernel source trees under /usr/src."""
+        if not _KERNEL_SOURCES_DIR.exists():
+            return []
+        return sorted(
+            str(p) for p in _KERNEL_SOURCES_DIR.iterdir()
+            if p.is_dir() and p.name.startswith("linux-")
+        )
+
+    def has_genkernel(self) -> bool:
+        return bool(shutil.which("genkernel"))
+
+    def compile(self, src: str, use_genkernel: bool, jobs: int) -> Iterator[str]:
+        """Stream kernel compilation output."""
+        priv = privilege_escalation_cmd()
+        if use_genkernel:
+            yield from self._run_streaming(
+                priv + ["genkernel", "--kernel-config=/proc/config.gz", "all"],
+                cwd=src,
+            )
+        else:
+            j = jobs if jobs > 0 else os.cpu_count() or 1
+            yield from self._run_streaming(
+                priv + ["make", f"-j{j}"],
+                cwd=src,
+            )
+            yield from self._run_streaming(
+                priv + ["make", "modules_install"],
+                cwd=src,
+            )
+            yield from self._run_streaming(
+                priv + ["make", "install"],
+                cwd=src,
+            )

lkm/core/backends/xbps.py

@@ -0,0 +1,139 @@
+"""
+xbps backend — Void Linux.
+
+Void ships its own kernel packages (linux, linux-lts, linux-mainline) via the
+official xbps repository.  This backend handles install/remove/hold for those
+packages and for locally built .xbps archives produced by lkf.
+
+Hold/unhold is implemented via xbps-pkgdb -m hold/unhold, which is the
+official Void mechanism for pinning packages.
+"""
+from __future__ import annotations
+
+import re
+import shutil
+from collections.abc import Iterator
+
+from lkm.core.backends.base import PackageBackend
+from lkm.core.system import privilege_escalation_cmd
+
+
+class XbpsBackend(PackageBackend):
+
+    @property
+    def name(self) -> str:
+        return "xbps"
+
+    # ------------------------------------------------------------------
+    # Availability guard
+    # ------------------------------------------------------------------
+
+    @staticmethod
+    def available() -> bool:
+        return bool(shutil.which("xbps-install"))
+
+    # ------------------------------------------------------------------
+    # Core operations
+    # ------------------------------------------------------------------
+
+    def install_packages(self, packages: list[str]) -> Iterator[str]:
+        priv = privilege_escalation_cmd()
+        # -y: assume yes; -S: sync repos first
+        yield from self._run_streaming(
+            priv + ["xbps-install", "-Sy"] + packages
+        )
+
+    def install_local(self, path: str) -> Iterator[str]:
+        """
+        Install a locally built .xbps package.
+
+        xbps-install can install from a local repository directory.  We point
+        it at the directory containing the package file and install by name.
+        """
+        import os
+        priv = privilege_escalation_cmd()
+        pkg_dir = os.path.dirname(os.path.abspath(path))
+        # xbps-install -R <repodir> -y <pkgname>
+        # The package name is the filename without the arch+suffix.
+        pkg_name = os.path.basename(path).split("-")[0]
+        yield from self._run_streaming(
+            priv + ["xbps-install", "-R", pkg_dir, "-y", pkg_name]
+        )
+
+    def remove_packages(self, packages: list[str], purge: bool = False) -> Iterator[str]:
+        priv = privilege_escalation_cmd()
+        # -R: remove recursively (orphaned deps); -y: assume yes
+        flags = ["-Ry"] if purge else ["-y"]
+        yield from self._run_streaming(
+            priv + ["xbps-remove"] + flags + packages
+        )
+
+    def hold(self, packages: list[str]) -> tuple[int, str, str]:
+        """
+        Pin packages with xbps-pkgdb -m hold.
+
+        A held package is excluded from xbps-install -u (system upgrades)
+        but can still be explicitly upgraded.
+        """
+        priv = privilege_escalation_cmd()
+        rc, out, err = 0, "", ""
+        for pkg in packages:
+            r, o, e = self._run(priv + ["xbps-pkgdb", "-m", "hold", pkg])
+            rc = rc or r
+            out += o
+            err += e
+        return rc, out, err
+
+    def unhold(self, packages: list[str]) -> tuple[int, str, str]:
+        priv = privilege_escalation_cmd()
+        rc, out, err = 0, "", ""
+        for pkg in packages:
+            r, o, e = self._run(priv + ["xbps-pkgdb", "-m", "unhold", pkg])
+            rc = rc or r
+            out += o
+            err += e
+        return rc, out, err
+
+    def is_installed(self, package: str) -> bool:
+        rc, out, _ = self._run(["xbps-query", package])
+        return rc == 0 and "state: installed" in out.lower()
+
+    # ------------------------------------------------------------------
+    # Void-specific helpers
+    # ------------------------------------------------------------------
+
+    def list_available_kernels(self) -> list[str]:
+        """
+        Return kernel package names available in the xbps repos.
+
+        xbps-query -Rs output format (varies by version):
+          [-] linux-6.6.30_1  The Linux kernel and modules
+          [*] linux-6.6.30_1  The Linux kernel and modules  (installed)
+
+        We accept both the flag-prefixed form and bare pkgver strings.
+        Only packages whose name starts with "linux" and whose name does
+        NOT contain "-headers" or "-dbg" are returned.
+        """
+        rc, out, _ = self._run(["xbps-query", "-Rs", "linux"])
+        if rc != 0:
+            return []
+
+        names: list[str] = []
+        # Match: optional [x] prefix, then pkgver like linux-6.6.30_1
+        _LINE_RE = re.compile(r"(?:\[.\]\s+)?(linux[a-zA-Z0-9._+-]+?)(?:_\d+)?\s")
+        for line in out.splitlines():
+            m = _LINE_RE.search(line)
+            if not m:
+                continue
+            name = m.group(1)
+            # Skip sub-packages
+            if any(x in name for x in ("-headers", "-dbg", "-doc", "-devel")):
+                continue
+            if name not in names:
+                names.append(name)
+        return names
+
+    def sync(self) -> Iterator[str]:
+        """Sync xbps repository index."""
+        priv = privilege_escalation_cmd()
+        yield from self._run_streaming(priv + ["xbps-install", "-S"])

lkm/core/backends/zypper.py

@@ -0,0 +1,44 @@
+"""zypper backend — openSUSE Leap, Tumbleweed, SLES, Regata."""
+from __future__ import annotations
+
+from collections.abc import Iterator
+
+from lkm.core.backends.base import PackageBackend
+from lkm.core.system import privilege_escalation_cmd
+
+
+class ZypperBackend(PackageBackend):
+
+    @property
+    def name(self) -> str:
+        return "zypper"
+
+    def install_packages(self, packages: list[str]) -> Iterator[str]:
+        priv = privilege_escalation_cmd()
+        yield from self._run_streaming(
+            priv + ["zypper", "--non-interactive", "install"] + packages
+        )
+
+    def install_local(self, path: str) -> Iterator[str]:
+        priv = privilege_escalation_cmd()
+        yield from self._run_streaming(
+            priv + ["zypper", "--non-interactive", "install", path]
+        )
+
+    def remove_packages(self, packages: list[str], purge: bool = False) -> Iterator[str]:
+        priv = privilege_escalation_cmd()
+        yield from self._run_streaming(
+            priv + ["zypper", "--non-interactive", "remove"] + packages
+        )
+
+    def hold(self, packages: list[str]) -> tuple[int, str, str]:
+        priv = privilege_escalation_cmd()
+        return self._run(priv + ["zypper", "addlock"] + packages)
+
+    def unhold(self, packages: list[str]) -> tuple[int, str, str]:
+        priv = privilege_escalation_cmd()
+        return self._run(priv + ["zypper", "removelock"] + packages)
+
+    def is_installed(self, package: str) -> bool:
+        rc, _, _ = self._run(["rpm", "-q", package])
+        return rc == 0

lkm/core/kernel.py

@@ -0,0 +1,95 @@
+"""
+Kernel data model: KernelEntry, KernelVersion, KernelFamily, KernelStatus.
+
+Unchanged from ukm except KernelFamily gains LKF_BUILD for locally compiled
+kernels produced by the lkf build pipeline.
+"""
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+from enum import Enum
+from functools import total_ordering
+
+
+class KernelFamily(Enum):
+    MAINLINE    = "mainline"     # Ubuntu Mainline PPA
+    XANMOD      = "xanmod"
+    LIQUORIX    = "liquorix"
+    DISTRO      = "distro"       # whatever the distro ships
+    GENTOO      = "gentoo"
+    LOCAL_FILE  = "local_file"   # pre-built .deb/.rpm/.pkg.tar.* dropped in
+    LKF_BUILD   = "lkf_build"    # compiled by the lkf build pipeline
+
+
+class KernelStatus(Enum):
+    AVAILABLE   = "available"
+    INSTALLED   = "installed"
+    RUNNING     = "running"
+    HELD        = "held"
+
+
+@total_ordering
+@dataclass
+class KernelVersion:
+    """Comparable semantic kernel version, e.g. 6.12.3."""
+    major: int
+    minor: int
+    patch: int
+    extra: str = ""   # e.g. "-xanmod1", "-rt4", "-lkf"
+
+    _VERSION_RE = re.compile(
+        r"^(\d+)\.(\d+)(?:\.(\d+))?(.*)$"
+    )
+
+    @classmethod
+    def parse(cls, s: str) -> KernelVersion:
+        m = cls._VERSION_RE.match(s.strip())
+        if not m:
+            raise ValueError(f"Cannot parse kernel version: {s!r}")
+        major = int(m.group(1))
+        minor = int(m.group(2))
+        patch = int(m.group(3) or 0)
+        extra = m.group(4) or ""
+        return cls(major=major, minor=minor, patch=patch, extra=extra)
+
+    def __str__(self) -> str:
+        return f"{self.major}.{self.minor}.{self.patch}{self.extra}"
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, KernelVersion):
+            return NotImplemented
+        return (self.major, self.minor, self.patch) == (other.major, other.minor, other.patch)
+
+    def __lt__(self, other: KernelVersion) -> bool:
+        return (self.major, self.minor, self.patch) < (other.major, other.minor, other.patch)
+
+    def __hash__(self) -> int:
+        return hash((self.major, self.minor, self.patch, self.extra))
+
+
+@dataclass
+class KernelEntry:
+    """A single kernel known to lkm — may be available, installed, or running."""
+    version:     KernelVersion
+    family:      KernelFamily
+    flavor:      str          # e.g. "generic", "rt", "xanmod-edge", "lkf-tkg"
+    arch:        str          # normalised arch string
+    provider_id: str          # matches KernelProvider.id
+    status:      KernelStatus = KernelStatus.AVAILABLE
+    held:        bool         = False
+    notes:       str          = ""
+    # For LOCAL_FILE / LKF_BUILD: path to the package file
+    local_path:  str | None = field(default=None)
+
+    @property
+    def display_name(self) -> str:
+        return f"{self.version} ({self.family.value}, {self.flavor})"
+
+    @property
+    def is_installed(self) -> bool:
+        return self.status in (KernelStatus.INSTALLED, KernelStatus.RUNNING, KernelStatus.HELD)
+
+    @property
+    def is_running(self) -> bool:
+        return self.status == KernelStatus.RUNNING