build(nix): a NixOS module for komorebi

On NixOS, running komorebi should take one flake input and one module line. The
flake exports `services.komorebi` as nixosModules.default (and .komorebi). It
adds the flake's overlay, which gains komorebi-full, installs komorebi and
komorebic, and runs the daemon in every Plasma session as a systemd user unit,
wanted by plasma-workspace.target and ordered after plasma-core.target, which
Plasma orders after KWin. systemd starts a daemon that fails again; the exit
status of a SIGTERM (130) counts as success, so a stopped unit is not failed.
The unit's PATH is the one a terminal in the session has, instead of the few
store paths NixOS gives a unit.

The options are enable, package, logLevel and a read-only execStart, the command
line the unit runs. There is no configFile: the daemon reads no configuration
file yet, and an option that linked one would do nothing.

nixos-module-eval evaluates seven scenarios as real NixOS systems and checks
their assertions, the unit and execStart, with builtins.tryEval for the two that
must not evaluate. Nothing in it builds a Linux package, so it runs on a Mac as
well.

The VM nodes import the module, so every suite runs komorebi as the module
installs it. The headless node's komorebi@NAME runs execStart, which has
--log-level, so the nodes set logLevel to debug and the suites stop passing it;
latency, which times the daemon, keeps the default level. The session node
starts the module's unit at login; render-smoke turns it off, since a tiled
terminal would cover the desktop it looks at. A new fast suite, vm-module, logs
in to Plasma and checks that the unit runs the daemon with the module's log
level and PATH, that a window opened in the session is tiled, that a killed
daemon is started again, and that a stop is not a failure.

docs/installation.md covers NixOS first, and building from source on other
distributions. There is no binary cache: the Komorebi license does not allow
third parties to redistribute binaries.
This commit is contained in:
LGUG2Z committed 2026-10-28 07:20:37 -07:00
1 parent e2d757bbb0
commit a86e2bdc63
26 files changed
+840 -71

No files matched your search

+13
View File
@@ -59,6 +59,19 @@ The messages between the bridge and the daemon are in
both sides read. A change to a message changes the fixture, the bridge and the
daemon in the same commit.
## The NixOS module
[`nix/nixos-module.nix`](nix/nixos-module.nix) is `services.komorebi`, which the
flake exports as `nixosModules.default` with its overlay. A change to it comes
with a scenario in [`nix/tests/nixos-module.nix`](nix/tests/nixos-module.nix),
the `nixos-module-eval` check: each scenario is a real NixOS system that is
evaluated and never built, and its checks read the assertions, the unit and
the options it evaluates to. It runs on a Mac too, with `nix build
.#checks.aarch64-darwin.nixos-module-eval`. A change to what the unit does in a
session also changes the VM suite `module`, which logs in to Plasma on a machine
with the module and checks the daemon the unit runs. Every other VM suite runs
on machines built with the module too.
## VM tests
A change that needs a real KWin to be checked comes with a VM test, next to
+25 -9
View File
@@ -6,6 +6,15 @@ A tiling window manager for KDE Plasma on Wayland, in the family of
decides where each window goes, and KWin, the window manager of Plasma, does the
moving and the drawing.
## Installing it
On NixOS, the flake's module, `services.komorebi`, installs `komorebi` and
`komorebic` and starts komorebi with every Plasma session: one flake input,
one module line and `services.komorebi.enable = true`. Elsewhere, both are
built from source. [`docs/installation.md`](docs/installation.md) has both
ways. There are no prebuilt binaries: the Komorebi license does not allow third
parties to redistribute them.
## Running it locally
```sh
@@ -83,14 +92,16 @@ a git dependency at the revision `Cargo.toml` pins.
rustdoc with warnings denied, and the type check and tests of the bridge (no
package.json: `tsc` and `node` come from the dev shell), inside `nix develop`.
`nix flake check` runs the same checks as derivations, plus `cargo deny`, the
TOML and Nix formatting, and the tests under `cargo nextest`, on Linux and on an
Apple silicon Mac. On Linux it also boots every VM test, which needs KVM. A Mac
runs the tests against the fake desktop, since KWin only exists on Linux.
`nix fmt` formats every file the checks look at.
TOML and Nix formatting, the tests under `cargo nextest`, and
`nixos-module-eval`, which evaluates the NixOS module in real NixOS systems, on
Linux and on an Apple silicon Mac. On Linux it also boots every VM test, which
needs KVM. A Mac runs the tests against the fake desktop, since KWin only exists
on Linux. `nix fmt` formats every file the checks look at.
The VM tests boot NixOS with Plasma and run a real KWin. `just vm NAME` runs
one; [`docs/dev/vm-tests.md`](docs/dev/vm-tests.md) has the details, including
how to run them on a Mac.
The VM tests boot NixOS with Plasma and run a real KWin, on machines configured
with the NixOS module, so every one of them runs komorebi as the module installs
it. `just vm NAME` runs one; [`docs/dev/vm-tests.md`](docs/dev/vm-tests.md) has
the details, including how to run them on a Mac.
## How it fits together
@@ -125,10 +136,15 @@ listens on a socket of its own, and after each event and each message, the
daemon connects to it and writes the event or the message with the state of
the window manager.
On NixOS, the module [`nix/nixos-module.nix`](nix/nixos-module.nix) runs the
daemon as a systemd user unit that the Plasma session starts, and systemd
starts it again if it fails.
## Documentation
The user guide starts at [`docs/index.md`](docs/index.md), and
[`docs/cli`](docs/cli) has a page for every `komorebic` subcommand, which
The user guide starts at [`docs/index.md`](docs/index.md),
[`docs/installation.md`](docs/installation.md) says how to install komorebi,
and [`docs/cli`](docs/cli) has a page for every `komorebic` subcommand, which
`just docgen` writes from the subcommands' help.
`cargo doc --workspace --no-deps --open` builds the API documentation.
[`CONTRIBUTING.md`](CONTRIBUTING.md) says how to work on the code.
+47 -2
View File
@@ -8,8 +8,8 @@ tested, without one.
This page describes that trait, who implements and calls it, where each of its rules is
enforced, the model of the desktop the window manager tiles, the backend that reaches KWin,
how an event about a window becomes a tile, how a message on the daemon's socket is
answered, and how subscribers are notified of both. It grows with the code: each part of the
daemon that is added has its place here.
answered, how subscribers are notified of both, and how the NixOS module runs the daemon. It
grows with the code: each part of the daemon that is added has its place here.
## Vocabulary
@@ -45,6 +45,9 @@ daemon that is added has its place here.
keep up to date and the queries are answered from.
- **Held call**: the `Poll` call the bridge always has open, which the daemon answers when it
has commands for the bridge, or after 10 seconds with none.
- **Module**: `services.komorebi`, the NixOS module ([`nixos-module.nix`]), which installs
komorebi and runs the daemon in every Plasma session as the systemd user unit
`komorebi.service`.
## Design
@@ -227,6 +230,41 @@ channel of [`window_manager_event_listener`], and past 20 the backend drops them
When the daemon stops ([`WindowManager::stop`], or `SIGINT` and `SIGTERM` in `main.rs`), it
connects to each subscriber and shuts the connection down without writing anything.
## The NixOS module
The flake exports one module under two names, `nixosModules.default` and
`nixosModules.komorebi`: [`nixos-module.nix`] and the flake's overlay, which builds
`komorebi-full` (both programs) with the flake's nixpkgs and Rust toolchain. Its options are
`enable`, `package` (by default `pkgs.komorebi-full`, from the overlay), `logLevel`, and
`execStart`, which is read-only: the module sets it to `bin/komorebi` of the package with
`--log-level`. With `services.komorebi.enable`, the module:
- installs the package in the system profile;
- defines the user unit `komorebi.service`, which every user of the machine has. Plasma's
`plasma-workspace.target` wants it, so a Plasma session starts it at login, and it is ordered
after `plasma-core.target`, which Plasma orders after KWin's service, `plasma-kwin_wayland`;
- runs `execStart` in it, with `Restart=on-failure`, the exit status of a `SIGTERM` (130)
counted as success, and a `PATH` of `/run/wrappers/bin`, `/etc/profiles/per-user/%u/bin` and
`/run/current-system/sw/bin` instead of the store paths NixOS gives a unit;
- asserts that Plasma 6 is enabled.
The VM tests run on machines built with it ([vm-tests.md](vm-tests.md)). Their headless node
runs the daemon in test sessions, with a template unit, `komorebi@NAME`, that runs the module's
`execStart` on the session's private bus. The session node logs in to Plasma, which starts the
module's unit.
| Rule | Enforced by | Proof | Escape hatch |
|---|---|---|---|
| komorebi is enabled only on a machine with Plasma 6 | evaluation error: an assertion of the module | `nixos-module-eval` ("without Plasma 6, an assertion fails") | none |
| The log level is one the daemon accepts | evaluation error: `logLevel` is an enum of the daemon's `--log-level` values | `nixos-module-eval` ("a log level the daemon does not have does not evaluate") | none |
| The unit runs `execStart`, and nothing but the module sets it | evaluation error: the option is read-only | `nixos-module-eval` ("execStart cannot be set", "the unit runs execStart") | a unit of your own |
| `komorebi` and `komorebic` are on every user's `PATH` | the module installs the package in the system profile | `nixos-module-eval`; every VM suite runs `komorebic` | none |
| Every Plasma session starts komorebi, once KWin's service has started | systemd: the user unit is wanted by `plasma-workspace.target`, after `plasma-core.target` | `nixos-module-eval`, `vm-module` | `systemctl --user mask komorebi` |
| A daemon that fails or is killed is started again | systemd: `Restart=on-failure` | `vm-module` (`SIGKILL`) | none |
| A daemon that is told to stop stays stopped, and the unit is not failed | systemd: the exit statuses of `Stop` (0) and of `SIGTERM` (130) are successes | `vm-module` | none |
| The daemon has the `PATH` of a terminal in the session | the unit's environment, with NixOS's default `PATH` turned off | `nixos-module-eval`, `vm-module` | none |
| The VM suites run komorebi as the module installs it | framework path: the test nodes import the module, and `komorebi@NAME` runs its `execStart` | every VM suite | a suite's `node` can set `services.komorebi.enable = false` (`vm-render-smoke` does) |
## The parts
- [`backend`](../../komorebi/src/backend/mod.rs): the trait, the two data types, and the
@@ -271,6 +309,8 @@ connects to each subscriber and shuts the connection down without writing anythi
fake with `--fake-backend`, makes the window manager, which binds the socket, loads and
tiles the desktop, starts the threads that listen on the socket and handle events, and
waits to be stopped.
- [`nixos-module.nix`]: the NixOS module, which installs komorebi and runs the daemon as a
systemd user unit of every Plasma session.
The handle is a process-wide singleton so that a window can be a small `Copy` value
that carries only its id, and ask the backend for what it needs. A test replaces it for
@@ -429,7 +469,12 @@ A window is shown, and ends up on a tile:
driven end to end against the fake.
- [`komorebi/tests/socket.rs`](../../komorebi/tests/socket.rs): the daemon over its socket,
from its start to a `Stop`.
- [`nix/nixos-module.nix`](../../nix/nixos-module.nix): the NixOS module;
[`nix/tests/nixos-module.nix`](../../nix/tests/nixos-module.nix), its scenarios, evaluated in
real NixOS systems; and [`nix/tests/vm/suites/module`](../../nix/tests/vm/suites/module/test.py),
a Plasma session in which the module's unit runs the daemon.
[`nixos-module.nix`]: ../../nix/nixos-module.nix
[`Backend`]: ../../komorebi/src/backend/mod.rs
[`WindowInfo`]: ../../komorebi/src/backend/mod.rs
[`MonitorInfo`]: ../../komorebi/src/backend/mod.rs
+28
View File
@@ -182,3 +182,31 @@ and komorebi for Mac sends the same notifications to Unix sockets, which is also
([its README](https://github.com/LGUG2Z/komorebi-for-mac#window-manager-event-subscriptions)).
A subscriber here is a Unix socket, as on macOS. The named pipes that komorebi on Windows
sends notifications to are not ported, since the socket subscribers do the same.
## Why does the flake have a NixOS module?
So that komorebi runs on NixOS with one flake input and one module line. The module installs
komorebi and starts it with every Plasma session, and it adds the flake's overlay to nixpkgs
itself, so a configuration needs nothing else to find the package. Its options follow those of
the nix-darwin module of komorebi for Mac: `enable`, `package` and `logLevel`.
## Why does komorebi run as a systemd user unit?
Because a user unit covers every user: it is defined once for the machine and runs for each
user who logs in. It is wanted by `plasma-workspace.target`, so it runs in Plasma sessions and
nowhere else, and it is ordered after `plasma-core.target`, which Plasma orders after KWin's
service: the daemon exits when KWin is not on the session bus. systemd starts a daemon that fails
again.
## Why is there no binary cache?
The Komorebi license does not allow third parties to redistribute binaries. There is no public
binary cache for komorebi, and every installation builds it from source.
## Why do the VM tests run on machines built with the module?
So that the tests exercise the module. Every VM suite boots a machine that imports
`nixosModules.default` and installs komorebi through it. The headless node runs the daemon with
the module's read-only `execStart`, and the session node runs the module's unit itself. A change
to the module that breaks how komorebi is installed or started fails the VM suites, and not only
`nixos-module-eval`.
+6
View File
@@ -59,6 +59,12 @@ The same questions, for each place the daemon can be started:
Through the session bus. When the daemon is started from the session (a terminal, an
autostart entry, a user unit of the session), the bus is already in its environment.
On NixOS, the module's user unit, `komorebi.service`, is wanted by `plasma-workspace.target`
and ordered after `plasma-core.target`, which Plasma orders after KWin's service,
`plasma-kwin_wayland.service`: the session starts the daemon once KWin's service has started
([installation.md](../installation.md)). The unit's `PATH` is `/run/wrappers/bin`,
`/etc/profiles/per-user/<user>/bin` and `/run/current-system/sw/bin`.
#### What komorebi does
It connects to the session bus as `org.komorebi.Bridge`, writes the bridge to
+32 -12
View File
@@ -37,7 +37,8 @@ A suite has two files:
- `default.nix` sets `tier` (`"fast"` or `"slow"`), `kind` (the node it runs on)
and `timeoutMinutes`, and may set `node`, a NixOS module that adds to the node
for this suite alone (more memory, the clients it starts).
for this suite alone (more memory, the clients it starts, the options of
`services.komorebi`).
- `test.py` is the test, a Python script for the NixOS test driver. It is
prefixed with `SCALE = <number>`, how many times slower than KVM the machine
is.
@@ -47,23 +48,38 @@ A suite has two files:
`kind` picks a file under
[`nix/tests/vm/nodes`](../../nix/tests/vm/nodes).
Both nodes are built with the NixOS module, as a user's machine is: they import
`nixosModules.default`, which the generator passes to them, and enable
`services.komorebi`, which installs `komorebi` and `komorebic`, built from the
commit under test. `services.komorebi.logLevel` is `"debug"`, because the tests
read the daemon's debug log. A suite can change either option in its `node`:
`latency`, which times the daemon, runs it at `"info"`.
The checks of the module that need no machine are `nixos-module-eval`
([`nix/tests/nixos-module.nix`](../../nix/tests/nixos-module.nix)), and the
suite `module` checks its unit in a Plasma session.
`headless` is a machine with Plasma installed and no login. Each KWin a test
starts is a pair of user units of the test user, `session-bus@NAME` (a private
D-Bus session bus) and `kwin-virtual@NAME` (`kwin_wayland --virtual` with its
own Wayland socket), so a test can run several sessions side by side and none
touches another. A virtual KWin has no real output, so it cannot draw: it can
place windows and answer questions about them, but it cannot take a screenshot.
A third unit, `komorebi@NAME`, runs the daemon in a session, built from the
commit under test and installed on the node with `komorebic`; it is not bound to
KWin's unit, so a test can restart KWin under a running daemon.
A third unit, `komorebi@NAME`, runs the daemon in a session: it is the module's
unit, `komorebi.service`, moved to the session's bus and Wayland socket, and runs
the module's `execStart` followed by the arguments the test gives. It is not
bound to KWin's unit, so a test can restart KWin under a running daemon. The
module's unit itself starts with a Plasma session, which this node does not
have.
KWin wants a DRM render node, which needs a GPU. The test driver gives every aarch64 guest one
`virtio-gpu-pci`; on x86_64 the node adds it, unless `komorebi.vm.renderNode` is false.
`session` is the headless node plus a login: plasma-login-manager logs the test
user in by itself, as in nixpkgs' own `plasma6` test, and Plasma draws on the
machine's display device. It is the node for anything that needs pixels. The
choice of login manager is made in
machine's display device. The login starts the module's unit, so komorebi runs
in the session from the start, as on a user's machine; `render-smoke`, which
checks that the session draws, turns it off. It is the node for anything that
needs pixels. The choice of login manager is made in
[`nodes/session.nix`](../../nix/tests/vm/nodes/session.nix) and nowhere else;
the file says how to switch to sddm, the other one that has been seen to work.
Its display is 1280x800, because screenshots are taken of the machine's one
@@ -100,9 +116,11 @@ the run.
user would, and `wid_by_class` finds a window by its app id or X11 class.
`Kde.headless(..., xwayland=True)` gives the session XWayland, for X11
clients.
- `start_komorebi(*args)` starts the daemon in the session, `stop_komorebi()`
stops it with `SIGTERM`, `komorebi_log()` returns its log since it was last
started, and `script_loaded()` asks KWin whether it runs the bridge.
- `start_komorebi(*args)` starts the daemon in the session, with the module's
`execStart` and `args` after it (not `--log-level`, which `execStart` has),
`stop_komorebi()` stops it with `SIGTERM`, `komorebi_log()` returns its log
since it was last started, and `script_loaded()` asks KWin whether it runs
the bridge.
`restart_kwin()` stops the session's KWin and starts a new one on the same
bus, as when the compositor of a running session crashes, and waits for it.
- `komorebic(*args)` runs `komorebic` in the session and returns what it
@@ -110,8 +128,8 @@ the run.
`komorebic state` prints it, `managed(workspace)` the number of windows the
daemon has on a workspace of the first monitor, and `focused_title(workspace)`
the title of the window it has focused there.
- `daemon` reads the daemon's view of the desktop from that log, started with
`--log-level debug`: `daemon.events(log)` lists the window events it handled,
- `daemon` reads the daemon's view of the desktop from that log, at the debug
level the nodes set: `daemon.events(log)` lists the window events it handled,
in order, `daemon.window_ids(log)` maps a window's title to the daemon's id
for it, and `daemon.requests(log)` returns the frame the daemon last asked KWin
for, for each window.
@@ -179,4 +197,6 @@ build `driverInteractive` instead of `driver`, run it, and call `start_all()`
and `machine.shell_interact()` at its prompt. In the guest, KWin's own log is
`journalctl --user -u kwin-virtual@NAME` as the test user, and a KWin script's
`print()` goes to the same journal. The daemon's log is
`/run/user/1000/komorebi-NAME.log`.
`/run/user/1000/komorebi-NAME.log`. On the session node, the daemon of the
module's unit logs to `journalctl --user -u komorebi`, with colors, and to
`~/.local/share/komorebi/komorebi_plaintext.log.DATE`, without.
+4 -2
View File
@@ -28,8 +28,10 @@ key bindings --------> komorebic <------> komorebi
## Getting started
[Running komorebi](usage/running-komorebi.md) explains how to get the two programs, start and
stop the daemon, ask it what it is doing and read its log.
[Installing komorebi](installation.md) explains how to install the two programs: on NixOS with
the flake's module, which also starts komorebi with every Plasma session, and from source
anywhere else. [Running komorebi](usage/running-komorebi.md) explains how to start and stop the
daemon, ask it what it is doing and read its log.
[Subscribing to notifications](usage/subscribing-to-notifications.md) explains how a program
such as a status bar follows what komorebi does. The [CLI reference](cli/start.md) has a page
for every `komorebic` command, generated from its help.
+152
View File
@@ -0,0 +1,152 @@
# Installing komorebi
`komorebi` is two programs: `komorebi`, the daemon that tiles the windows, and `komorebic`, the
command line that controls it. The daemon runs in a KDE Plasma Wayland session with KWin 6.8 or
newer ([PLATFORM.md](dev/PLATFORM.md) has what it needs from the session).
On NixOS, the repository's flake has a module that installs both programs and starts komorebi
with every Plasma session. On any other distribution, build them from source.
There is no binary cache and there are no prebuilt binaries: the Komorebi license does not allow
third parties to redistribute binaries, so every installation builds komorebi from source. On
NixOS, Nix does that for you, the first time you switch to a configuration that has it.
## NixOS
### The module
Add the repository to the inputs of your system's flake, and import its module,
`nixosModules.default`, into your configuration:
```nix
{
inputs = {
nixpkgs.url = "github:NixOS/nixpkgs/nixpkgs-unstable";
komorebi.url = "github:LGUG2Z/komorebi-for-kde";
};
outputs =
{ nixpkgs, komorebi, ... }:
{
nixosConfigurations.HOSTNAME = nixpkgs.lib.nixosSystem {
modules = [
komorebi.nixosModules.default
./configuration.nix
];
};
};
}
```
Then enable it, next to Plasma, in `configuration.nix`:
```nix
{
services.desktopManager.plasma6.enable = true;
services.komorebi.enable = true;
}
```
The module adds the flake's overlay, which provides `pkgs.komorebi-full`, to your nixpkgs, so
nothing else is needed. komorebi is built with the flake's nixpkgs and the Rust toolchain that
the repository's `rust-toolchain.toml` selects, whatever nixpkgs your system uses.
### What the module does
- It installs `komorebi` and `komorebic` in the system profile, so they are on every user's
`PATH`.
- It defines a systemd user unit, `komorebi.service`, for every user of the machine. Plasma's
`plasma-workspace.target` starts it when a user logs in to a Plasma session, after
`plasma-core.target`, which Plasma orders after KWin. The unit runs the daemon with the `PATH`
of a terminal in the session.
- systemd starts the daemon again when it fails or is killed. When it is stopped (`komorebic
stop`, or `systemctl --user stop komorebi`), it stays stopped until the next login or
`systemctl --user start komorebi`.
- Without `services.desktopManager.plasma6.enable`, the configuration does not evaluate: an
assertion of the module fails, and its message names the option to set.
### Options
| Option | Default | What it does |
|---|---|---|
| `services.komorebi.enable` | `false` | Installs komorebi and starts it with every Plasma session. |
| `services.komorebi.package` | `pkgs.komorebi-full` | The package with `bin/komorebi` and `bin/komorebic`; the unit runs the first, and both are installed. |
| `services.komorebi.logLevel` | `"info"` | The daemon's `--log-level`: `"error"`, `"warn"`, `"info"`, `"debug"` or `"trace"`. |
| `services.komorebi.execStart` | read only | The command line the unit starts komorebi with, built from `package` and `logLevel`. A unit of your own that runs komorebi uses it to start komorebi the same way. |
### Running it
`plasma-workspace.target` starts komorebi when you log in. In a session that was already
running when you switched to the new configuration, start it yourself:
```sh
systemctl --user start komorebi
systemctl --user status komorebi
journalctl --user -u komorebi
```
[`komorebic stop`](cli/stop.md) stops it until you start it again or log in again.
[`komorebic start`](cli/start.md) finds the daemon the unit runs and does nothing, and a second
`komorebi` in the same session exits: the session bus gives the name komorebi needs to one
daemon. [Running komorebi](usage/running-komorebi.md) has the rest: asking komorebi what it is
doing, and its log.
### The packages without the module
The flake's packages are `komorebi`, `komorebic`, and `komorebi-full`, which has both and is the
`default`. To install them without the unit, and start komorebi yourself:
```sh
nix profile install github:LGUG2Z/komorebi-for-kde
```
On a NixOS configuration, the overlay, `overlays.default`, provides `pkgs.komorebi`,
`pkgs.komorebic` and `pkgs.komorebi-full` for `environment.systemPackages`.
## Other distributions: from source
You need a Plasma 6.8 (or newer) Wayland session, [rustup](https://rustup.rs) with the stable
toolchain, which `rust-toolchain.toml` selects, and a C compiler (`cc`): the crate that makes the
version string builds libgit2, and zlib when the system has none. Then:
```sh
git clone https://github.com/LGUG2Z/komorebi-for-kde
cd komorebi-for-kde
cargo install --locked --path komorebi
cargo install --locked --path komorebic
```
`cargo` installs both in `~/.cargo/bin`, which has to be on your `PATH`. Start komorebi from a
terminal in your Plasma session with [`komorebic start`](cli/start.md).
To start it with every Plasma session instead, write the unit the NixOS module defines, without
the NixOS paths, to `~/.config/systemd/user/komorebi.service`:
```ini
[Unit]
Description=komorebi, the tiling window manager
After=plasma-core.target
[Service]
ExecStart=%h/.cargo/bin/komorebi
Restart=on-failure
SuccessExitStatus=130
[Install]
WantedBy=plasma-workspace.target
```
and enable it with `systemctl --user enable komorebi`. At time of writing (2026-10-27), only the
module's unit has been run, on NixOS; this one has not been tried on another distribution.
## Uninstalling
Stop the daemon first, with `komorebic stop`.
- With the module, remove `services.komorebi.enable` (or the module) from your configuration and
switch to it.
- From source, remove the unit if you wrote one (`systemctl --user disable komorebi`, then the
file), and the programs, with `cargo uninstall komorebi komorebic`.
The daemon's logs are in `~/.local/share/komorebi` (`$XDG_DATA_HOME/komorebi`), which you can
delete. Its socket is in `$XDG_RUNTIME_DIR/komorebi`, which is removed when you log out.
+10 -4
View File
@@ -6,16 +6,22 @@ doing, and reading its log.
## Getting the two programs
On Linux, the flake's default package has both: in a checkout of the repository,
`nix build` leaves them in `result/bin`, and `nix profile install .` puts them on your
`PATH`. Without nix, build them with the Rust toolchain that `rust-toolchain.toml`
selects:
[Installing komorebi](../installation.md) covers NixOS, where the flake's module installs both
and starts the daemon with every Plasma session, and building them from source. In a checkout of
the repository, on Linux, `nix build` leaves them in `result/bin`, and `nix profile install .`
puts them on your `PATH`. Without nix, build them with the Rust toolchain that
`rust-toolchain.toml` selects:
```sh
cargo build --release --locked
export PATH="$PWD/target/release:$PATH"
```
With the NixOS module, the daemon is the user unit `komorebi.service`, which starts when you log
in to Plasma. `systemctl --user start komorebi` starts it again after a `komorebic stop`, and
`journalctl --user -u komorebi` shows what it wrote. Everything else on this page applies to it
as it is.
## Starting and stopping
[`komorebic start`](../cli/start.md) runs the `komorebi` on your `PATH` in the background,
+30 -10
View File
@@ -123,12 +123,12 @@
pkgs = mkPkgs system;
build = mkKomorebiPackages { inherit pkgs; };
isLinux = pkgs.stdenv.hostPlatform.isLinux;
# the daemon and komorebic each guest runs, built for the guest's system
komorebiFor = guestSystem: self.packages.${guestSystem}.komorebi-full;
# the guests install komorebi through the module, as a NixOS user does
komorebiModule = self.nixosModules.default;
# a Mac runs the guests under HVF, which is slower than KVM
vm = import ./nix/tests/vm {
hostPkgs = pkgs;
inherit komorebiFor;
inherit komorebiModule;
scale = if isLinux then 1 else 1.5;
};
nightlyRustfmt = pkgs.rust-bin.nightly.latest.rustfmt;
@@ -211,6 +211,15 @@
'';
vm-lib = vm.lib;
# The NixOS module in real NixOS systems, evaluated and never built, so a Mac checks it
# too. A VM suite, `vm-module`, runs it.
nixos-module-eval = import ./nix/tests/nixos-module.nix {
inherit pkgs;
inherit (nixpkgs.lib) nixosSystem;
module = self.nixosModules.default;
komorebiFor = guestSystem: self.packages.${guestSystem}.komorebi-full;
};
}
# The VM tests need QEMU with KVM, so only Linux checks them. A Mac runs the same tests
# through legacyPackages.<system>.vm, see docs/dev/vm-tests.md.
@@ -231,7 +240,7 @@
vmTcg =
(import ./nix/tests/vm {
hostPkgs = pkgs;
inherit komorebiFor;
inherit komorebiModule;
scale = 8;
}).suites;
};
@@ -295,13 +304,24 @@
};
flake = {
overlays.default = final: _: {
inherit ((mkKomorebiPackages { pkgs = mkPkgs final.stdenv.hostPlatform.system; }))
komorebi
komorebic
;
};
overlays.default =
final: _:
let
build = mkKomorebiPackages { pkgs = mkPkgs final.stdenv.hostPlatform.system; };
in
{
inherit (build) komorebi komorebic;
komorebi-full = build.fullBuild;
};
overlays.komorebi = self.overlays.default;
# `services.komorebi`, with the overlay that provides its package, so that a NixOS
# configuration needs this flake as an input and one module line (docs/installation.md)
nixosModules.default = {
imports = [ ./nix/nixos-module.nix ];
nixpkgs.overlays = [ self.overlays.default ];
};
nixosModules.komorebi = self.nixosModules.default;
};
};
}
+96
View File
@@ -0,0 +1,96 @@
# `services.komorebi`: komorebi in the Plasma session of every user of a NixOS machine. The flake
# exports this module as `nixosModules.default` and `nixosModules.komorebi`, together with its
# overlay, which provides `pkgs.komorebi-full` (see docs/installation.md). What the module
# guarantees, and what enforces each guarantee, is in docs/dev/ARCHITECTURE.md; its tests are
# nix/tests/nixos-module.nix and the VM suite `module`.
{
config,
lib,
pkgs,
...
}:
let
cfg = config.services.komorebi;
in
{
options.services.komorebi = {
enable = lib.mkEnableOption "komorebi, the tiling window manager, in the Plasma session of every user";
package = lib.mkPackageOption pkgs "komorebi-full" {
extraDescription = ''
It must have `bin/komorebi`, which the unit runs, and `bin/komorebic`. The module installs
both in the system profile.
'';
};
logLevel = lib.mkOption {
type = lib.types.enum [
"error"
"warn"
"info"
"debug"
"trace"
];
default = "info";
description = ''
How much the daemon logs: its `--log-level`. The log goes to the journal of the unit
(`journalctl --user -u komorebi`) and to the daemon's log files, which `komorebic log`
follows.
'';
};
execStart = lib.mkOption {
type = lib.types.str;
readOnly = true;
description = ''
The command line the unit starts komorebi with: `bin/komorebi` of `package`, with
`logLevel`. The module sets it, and setting it anywhere else is an error. A unit of your
own that runs komorebi somewhere else, as the VM tests do in their headless sessions,
starts it with this, the way the module does.
'';
};
};
config = lib.mkMerge [
{
services.komorebi.execStart = "${lib.getExe' cfg.package "komorebi"} --log-level ${cfg.logLevel}";
}
(lib.mkIf cfg.enable {
assertions = [
{
assertion = config.services.desktopManager.plasma6.enable;
message = ''
services.komorebi needs Plasma 6: komorebi runs in a Plasma Wayland session, and the
session starts it. Set services.desktopManager.plasma6.enable = true.
'';
}
];
environment.systemPackages = [ cfg.package ];
# A user unit, so it runs for every user who logs in to Plasma. plasma-workspace.target is
# the target of a Plasma session's services, and plasma-core.target, which it requires, is
# ordered after KWin's service: the daemon exits when KWin is not on the session bus.
systemd.user.services.komorebi = {
description = "komorebi, the tiling window manager";
wantedBy = [ "plasma-workspace.target" ];
after = [ "plasma-core.target" ];
# NixOS gives a unit a PATH made of a few store paths; this is the PATH a terminal in the
# user's session has
enableDefaultPath = false;
environment.PATH = lib.concatStringsSep ":" [
"/run/wrappers/bin"
"/etc/profiles/per-user/%u/bin"
"/run/current-system/sw/bin"
];
serviceConfig = {
ExecStart = cfg.execStart;
Restart = "on-failure";
# what komorebi exits with when it is stopped with SIGTERM, as systemd stops a unit
SuccessExitStatus = 130;
};
};
})
];
}
+215
View File
@@ -0,0 +1,215 @@
# `nixos-module-eval`: `services.komorebi` in real NixOS systems, evaluated and never built. Each
# scenario is a `nixosSystem` with the module, and the checks read what it evaluates to: the
# assertions, the unit the module defines, and its read-only `execStart`. A scenario that must
# not evaluate is caught with `builtins.tryEval`. Nothing here builds a Linux package (the
# derivation below gets only check names and booleans), so a Mac runs it too.
{
pkgs,
# nixpkgs' `lib.nixosSystem`
nixosSystem,
# the module, as the flake exports it, with its overlay
module,
# the flake's komorebi-full for a system, which the overlay has to provide
komorebiFor,
}:
let
inherit (pkgs) lib;
# the systems are of the host's architecture
system = "${pkgs.stdenv.hostPlatform.parsed.cpu.name}-linux";
# enough of a machine for every NixOS assertion to hold, since no scenario is ever built
machine = {
nixpkgs.hostPlatform = system;
boot.loader.grub.enable = false;
fileSystems."/" = {
device = "/dev/vda";
fsType = "ext4";
};
system.stateVersion = lib.trivial.release;
};
plasma = {
services.desktopManager.plasma6.enable = true;
};
eval =
scenario:
(nixosSystem {
modules = [
module
machine
scenario
];
}).config;
enabled = eval {
imports = [ plasma ];
services.komorebi.enable = true;
};
disabled = eval plasma;
withoutPlasma = eval { services.komorebi.enable = true; };
debug = eval {
imports = [ plasma ];
services.komorebi = {
enable = true;
logLevel = "debug";
};
};
# a package that is not the overlay's: any package will do, since nothing is built
otherPackage = eval (
{ pkgs, ... }:
{
imports = [ plasma ];
services.komorebi = {
enable = true;
package = pkgs.hello;
};
}
);
unknownLevel = eval {
imports = [ plasma ];
services.komorebi = {
enable = true;
logLevel = "verbose";
};
};
execStartSet = eval {
imports = [ plasma ];
services.komorebi = {
enable = true;
execStart = "/bin/true";
};
};
failed = config: map (a: a.message) (lib.filter (a: !a.assertion) config.assertions);
unit = config: config.systemd.user.services.komorebi;
evaluates = value: (builtins.tryEval value).success;
checks = [
{
name = "enabled with Plasma 6, every assertion holds";
ok = failed enabled == [ ];
got = failed enabled;
}
{
name = "the unit is started by plasma-workspace.target";
ok = (unit enabled).wantedBy == [ "plasma-workspace.target" ];
got = (unit enabled).wantedBy;
}
{
name = "the unit starts after plasma-core.target";
ok = lib.elem "plasma-core.target" (unit enabled).after;
got = (unit enabled).after;
}
{
name = "the unit is restarted when it fails";
ok = (unit enabled).serviceConfig.Restart == "on-failure";
}
{
name = "the unit counts the exit status of a SIGTERM (130) as success";
ok = (unit enabled).serviceConfig.SuccessExitStatus == 130;
}
{
name = "the unit runs execStart";
ok = (unit enabled).serviceConfig.ExecStart == enabled.services.komorebi.execStart;
got = (unit enabled).serviceConfig.ExecStart;
}
{
name = "execStart is bin/komorebi of the package, at the info level";
ok =
enabled.services.komorebi.execStart
== "${enabled.services.komorebi.package}/bin/komorebi --log-level info";
got = enabled.services.komorebi.execStart;
}
{
name = "the default package is the flake's komorebi-full, from the overlay";
ok = enabled.services.komorebi.package.outPath == (komorebiFor system).outPath;
}
{
name = "the unit has the PATH of the user's session";
ok =
(unit enabled).environment.PATH
== "/run/wrappers/bin:/etc/profiles/per-user/%u/bin:/run/current-system/sw/bin";
got = (unit enabled).environment.PATH;
}
{
name = "the package is installed in the system profile";
ok = lib.elem enabled.services.komorebi.package enabled.environment.systemPackages;
}
{
name = "disabled, every assertion holds";
ok = failed disabled == [ ];
got = failed disabled;
}
{
name = "disabled, there is no unit";
ok = !(disabled.systemd.user.services ? komorebi);
}
{
name = "disabled, nothing is installed";
ok = !(lib.elem disabled.services.komorebi.package disabled.environment.systemPackages);
}
{
name = "without Plasma 6, an assertion fails and names the option to set";
ok = lib.any (lib.hasInfix "services.desktopManager.plasma6.enable = true") (failed withoutPlasma);
got = failed withoutPlasma;
}
{
name = "logLevel reaches execStart and the unit";
ok =
debug.services.komorebi.execStart
== "${debug.services.komorebi.package}/bin/komorebi --log-level debug"
&& (unit debug).serviceConfig.ExecStart == debug.services.komorebi.execStart;
got = (unit debug).serviceConfig.ExecStart;
}
{
name = "another package is the one the unit runs and the one installed";
ok =
(unit otherPackage).serviceConfig.ExecStart
== "${otherPackage.services.komorebi.package}/bin/komorebi --log-level info"
&& lib.elem otherPackage.services.komorebi.package otherPackage.environment.systemPackages;
got = (unit otherPackage).serviceConfig.ExecStart;
}
{
name = "a log level the daemon does not have does not evaluate";
ok = !(evaluates unknownLevel.services.komorebi.logLevel);
}
{
name = "execStart cannot be set";
ok = !(evaluates execStartSet.services.komorebi.execStart);
}
];
failures = lib.filter (check: !check.ok) checks;
# what a failed check got, without the store paths' context: this derivation must not depend on
# a Linux package
show =
check:
check.name
+ lib.optionalString (check ? got) (
": got " + builtins.unsafeDiscardStringContext (builtins.toJSON check.got)
);
in
pkgs.runCommand "nixos-module-eval" { } (
if failures == [ ] then
''
${lib.concatMapStringsSep "\n" (check: "echo ${lib.escapeShellArg "ok: ${check.name}"}") checks}
echo "${toString (lib.length checks)} checks of services.komorebi passed"
touch $out
''
else
''
${lib.concatMapStringsSep "\n" (
check: "echo ${lib.escapeShellArg "FAILED: ${show check}"}"
) failures}
exit 1
''
)
+10 -10
View File
@@ -2,21 +2,19 @@
# (Linux) and `legacyPackages.<system>.vm.<name>` (everywhere), so a new suite needs no edit to
# the flake. See docs/dev/vm-tests.md.
#
# `hostPkgs` is the pkgs of the machine that runs QEMU; the guests are always Linux. `komorebiFor`
# returns the package of `komorebi` and `komorebic` for a system, and the guests get the one of
# their own. `scale` says how much slower than KVM that machine is (1 for KVM, 1.5 for HVF on a
# Mac, 8 for TCG), and every wait in the suites is multiplied by it.
# `hostPkgs` is the pkgs of the machine that runs QEMU; the guests are always Linux.
# `komorebiModule` is the flake's NixOS module, `services.komorebi`, which every node imports: its
# overlay builds `komorebi` and `komorebic` for the guest's system. `scale` says how much slower
# than KVM that machine is (1 for KVM, 1.5 for HVF on a Mac, 8 for TCG), and every wait in the
# suites is multiplied by it.
{
hostPkgs,
komorebiFor,
komorebiModule,
scale ? 1,
}:
let
inherit (hostPkgs) lib;
# a Linux guest of the host's architecture, which is what the test driver boots
guestSystem = "${hostPkgs.stdenv.hostPlatform.parsed.cpu.name}-linux";
# the library the suites import, built for the python of the test driver
komorebiVm =
ps:
@@ -80,8 +78,10 @@ let
globalTimeout = builtins.ceil (suite.timeoutMinutes * 60 * scale);
passthru.tier = suite.tier;
# the nodes take the daemon as an argument, `komorebi`
node.specialArgs.komorebi = komorebiFor guestSystem;
# the nodes import the module, `komorebiModule`, which adds its overlay to nixpkgs: the test
# framework's pkgs, which cannot be changed, would refuse it
node.specialArgs = { inherit komorebiModule; };
node.pkgsReadOnly = false;
nodes.machine = {
# a suite's `node`, if it has one, adds to the node of its kind
+4 -4
View File
@@ -1,10 +1,10 @@
"""What the komorebi daemon logs about the events it handles.
A test reads the daemon's view of the desktop from its log
([`Kde.komorebi_log`](komorebi_vm.kde.Kde.komorebi_log)), started with
`--log-level debug`: every event it handles is an info line, every focus
change KWin reports names the window by the daemon's id and its title, and
every frame the daemon asks KWin for is a debug line.
([`Kde.komorebi_log`](komorebi_vm.kde.Kde.komorebi_log)), at the debug level
the test nodes set (`services.komorebi.logLevel`): every event it handles is an
info line, every focus change KWin reports names the window by the daemon's id
and its title, and every frame the daemon asks KWin for is a debug line.
"""
import re
+4 -2
View File
@@ -218,8 +218,10 @@ class Kde:
def start_komorebi(self, *args: str) -> None:
"""Starts the daemon in this session, with `args`, as the user unit `komorebi@NAME`.
The unit runs the `komorebi` the node has, against this session's bus and KWin, and
writes its log to a file that [`Kde.komorebi_log`][] reads, emptied on every start.
The unit runs the NixOS module's `execStart` with `args` after it, against this
session's bus and KWin, and writes its log to a file that [`Kde.komorebi_log`][] reads,
emptied on every start. `execStart` already has `--log-level`, from the node's
`services.komorebi.logLevel` (debug), and `komorebi` refuses a second one.
"""
words = shlex.quote(" ".join(args))
self.as_user(f"echo KOMOREBI_ARGS={words} > {self.runtime}/komorebi-{self.name}.env")
+2 -2
View File
@@ -139,10 +139,10 @@ def test_shot_returns_the_screenshot_as_rgb(machine: FakeMachine) -> None:
def test_start_komorebi_writes_the_arguments_and_starts_the_unit(machine: FakeMachine) -> None:
Kde(machine, "main").start_komorebi("--log-level", "debug")
Kde(machine, "main").start_komorebi("--fake-backend")
scripts = [inner(command) for command in machine.commands if " sh -c " in command]
assert "echo KOMOREBI_ARGS='--log-level debug' > /run/user/1000/komorebi-main.env" in scripts
assert "echo KOMOREBI_ARGS=--fake-backend > /run/user/1000/komorebi-main.env" in scripts
assert "systemctl --user start komorebi@main.service" in scripts
+22 -9
View File
@@ -1,23 +1,35 @@
# A machine with Plasma installed and no login: `kwin_wayland --virtual` runs as the test user's
# own user units, once for every session a test starts, each with its own private session bus and
# Wayland socket (`session-bus@NAME`, `kwin-virtual@NAME`). A virtual KWin has no real output, so it
# cannot draw: pixel and pointer tests use the session node instead. `komorebi@NAME` runs the daemon
# in a session; `komorebi` is the package of the daemon and `komorebic`, which the test framework
# passes in.
# cannot draw: pixel and pointer tests use the session node instead.
#
# komorebi comes from the NixOS module, `komorebiModule`, which the test framework passes in: the
# node imports it and enables `services.komorebi` as a user's machine does, which installs
# `komorebi` and `komorebic`. The module's unit starts with a Plasma session, and this node has
# none; `komorebi@NAME` runs the module's `execStart` in a test session instead.
{
config,
lib,
pkgs,
komorebi,
komorebiModule,
...
}:
{
imports = [ ./options.nix ];
imports = [
./options.nix
komorebiModule
];
# KWin, its plugins and the environment a session expects
services.desktopManager.plasma6.enable = true;
hardware.graphics.enable = true;
# A suite can change either in its `node`. The tests read the daemon's debug log.
services.komorebi = {
enable = lib.mkDefault true;
logLevel = lib.mkDefault "debug";
};
users.users.komorebi = {
isNormalUser = true;
uid = 1000;
@@ -40,7 +52,6 @@
kdotool
kdePackages.libkscreen
kdePackages.qttools
komorebi
];
systemd.user.services = {
@@ -70,7 +81,8 @@
};
};
# Not bound to KWin's unit: a test restarts KWin under a running daemon
# The module's unit, moved to the test session's bus and Wayland socket. Not bound to KWin's
# unit: a test restarts KWin under a running daemon.
"komorebi@" = {
description = "komorebi in the test session %i";
requires = [ "session-bus@%i.service" ];
@@ -86,10 +98,11 @@
NO_COLOR = "1";
};
serviceConfig = {
# the library writes KOMOREBI_ARGS (the log level) before it starts the unit
# the library writes KOMOREBI_ARGS (what follows the module's command line) before it
# starts the unit
EnvironmentFile = "-%t/komorebi-%i.env";
# a log file per run, emptied on every start, which the library reads
ExecStart = "${pkgs.runtimeShell} -c 'exec ${komorebi}/bin/komorebi $${KOMOREBI_ARGS} > %t/komorebi-%i.log 2>&1'";
ExecStart = "${pkgs.runtimeShell} -c 'exec ${config.services.komorebi.execStart} $${KOMOREBI_ARGS} > %t/komorebi-%i.log 2>&1'";
# what komorebi exits with when it is told to stop
SuccessExitStatus = 130;
};
+4 -1
View File
@@ -1,5 +1,8 @@
# A real Plasma Wayland session that logs in by itself, on a machine that can draw. Everything the
# headless node has is here too, so a test can still start a virtual KWin next to it.
# headless node has is here too, so a test can still start a virtual KWin next to it. The module's
# unit, `komorebi.service`, starts komorebi in the session when the user logs in, as on a user's
# machine; a suite that wants the session without it sets `services.komorebi.enable = false` in
# its `node`.
#
# The choice of login manager is made here and nowhere else. nixpkgs' own `plasma6` test uses
# plasma-login-manager, so that is what this node follows; sddm with a Wayland greeter is the other
+1 -1
View File
@@ -32,7 +32,7 @@ machine.wait_for_unit("user@1000.service")
checks = Checks()
kde = Kde.headless(machine, "main", size=(W, H), xwayland=True, scale=SCALE)
kde.as_user("mkdir -p /tmp/firefox-profile")
kde.start_komorebi("--log-level", "debug")
kde.start_komorebi()
checks.check(
"the daemon loaded its script into KWin",
kde.wait_for(lambda: "loaded the KWin bridge script" in kde.komorebi_log(), timeout=30),
+1 -1
View File
@@ -74,7 +74,7 @@ def report(titles: list[str]) -> None:
print("== 1. start")
kde.start_komorebi("--log-level", "debug")
kde.start_komorebi()
checks.check(
"the daemon loaded its script into KWin",
kde.wait_for(lambda: "loaded the KWin bridge script" in daemon_log(), timeout=30),
+1 -1
View File
@@ -29,7 +29,7 @@ checks.check(
)
before = kde.wid("before")
kde.start_komorebi("--log-level", "debug")
kde.start_komorebi()
checks.check(
"the daemon loaded its script into KWin",
kde.wait_for(lambda: "loaded the KWin bridge script" in daemon_log(), timeout=30),
+1 -1
View File
@@ -83,7 +83,7 @@ def restart(old: list[str], loaded: int) -> None:
print("== 1. three windows are tiled")
kde.start_komorebi("--log-level", "debug")
kde.start_komorebi()
checks.check(
"the daemon loaded its script into KWin", kde.wait_for(lambda: loads() == 1, timeout=30)
)
+2
View File
@@ -6,5 +6,7 @@
{ pkgs, ... }:
{
environment.systemPackages = [ pkgs.dbus ];
# this suite times the daemon, so it runs at the default log level, as a user's does
services.komorebi.logLevel = "info";
};
}
+5
View File
@@ -0,0 +1,5 @@
{
tier = "fast";
kind = "session";
timeoutMinutes = 10;
}
+123
View File
@@ -0,0 +1,123 @@
# The NixOS module runs komorebi in a real Plasma session: nothing in this test starts the daemon.
# What only a real session can tell: that logging in starts the module's user unit through
# `plasma-workspace.target`, that the daemon it runs reaches KWin from there and tiles a window
# opened in the session, that it runs with the module's log level and the PATH of the user's
# session, that systemd starts it again when it is killed, and that a clean stop is not a failure.
# The options and the unit the module writes are checked without a machine by `nixos-module-eval`
# (`nix/tests/nixos-module.nix`).
import json
from komorebi_vm import Checks, Kde, Rect, daemon
UNIT = "komorebi.service"
# foot sizes itself to whole cells of its font, so its frame can be short of the one asked for
CELL = 24
# the daemon's log of the day, without colors, which the unit's journal has
LOG = "/home/komorebi/.local/share/komorebi/komorebi_plaintext.log.*"
start_all()
machine.wait_for_unit("multi-user.target")
checks = Checks()
kde = Kde.session(machine, scale=SCALE)
def active() -> bool:
return kde.run(f"systemctl --user is-active --quiet {UNIT}")[0] == 0
def failed() -> bool:
return kde.run(f"systemctl --user is-failed --quiet {UNIT}")[0] == 0
def main_pid() -> str:
return kde.sh(f"systemctl --user show --property MainPID --value {UNIT}").strip()
def answering() -> bool:
return kde.run("komorebic monitor-information")[0] == 0
def managed_titles() -> list[str]:
"""The titles of the windows komorebi has on the first workspace of the first monitor."""
workspace = kde.state()["monitors"]["elements"][0]["workspaces"]["elements"][0]
return [
window["details"]["title"]
for container in workspace["containers"]["elements"]
for window in container["windows"]["elements"]
]
def daemon_log() -> str:
return machine.execute(f"cat {LOG}")[1]
print("== 1. logging in starts komorebi")
checks.check("the session started the module's unit", kde.wait_for(active, timeout=60))
checks.check("its daemon answers komorebic", kde.wait_for(answering, timeout=60))
pid = main_pid()
command = kde.sh(f"tr '\\0' ' ' < /proc/{pid}/cmdline").split()
print(f" the unit runs: {' '.join(command)}")
checks.check("the unit runs bin/komorebi", command[0].endswith("/bin/komorebi"))
checks.check("... at the module's log level", command[1:] == ["--log-level", "debug"])
environment = kde.sh(f"tr '\\0' '\\n' < /proc/{pid}/environ").splitlines()
path = next((line[len("PATH=") :] for line in environment if line.startswith("PATH=")), "")
checks.check(
"... with the PATH of the user's session",
path.split(":")
== ["/run/wrappers/bin", "/etc/profiles/per-user/komorebi/bin", "/run/current-system/sw/bin"],
)
print("== 2. a window opened in the session is tiled")
width = json.loads(kde.komorebic("monitor-information"))[0]["size"]["right"]
def asked() -> Rect | None:
return daemon.asked(daemon_log(), "tiled")
def tiled() -> bool:
"""KWin has the window where komorebi asked, and that is a tile across the screen."""
want, wid = asked(), kde.wid("tiled")
if want is None or wid == "":
return False
have = kde.rect(wid)
return (
(have.x, have.y) == (want.x, want.y)
and 0 <= want.w - have.w < CELL
and 0 <= want.h - have.h < CELL
and want.w > width // 2
)
kde.spawn("foot -T tiled sleep 3000")
checks.check("the window opens", kde.wait_for(lambda: kde.wid("tiled") != "", timeout=60))
checks.check("komorebi manages it", kde.wait_for(lambda: "tiled" in managed_titles(), timeout=30))
checks.check("KWin has it on its tile", kde.wait_for(tiled, timeout=30))
print(f" asked {asked()}, has {kde.rect(kde.wid('tiled'))}")
print("== 3. systemd starts a komorebi that was killed again")
kde.systemctl("kill", "--signal=SIGKILL", UNIT)
checks.check(
"the unit runs a new daemon",
kde.wait_for(lambda: active() and main_pid() not in ("0", pid), timeout=30),
)
checks.check("... which answers komorebic", kde.wait_for(answering, timeout=60))
checks.check(
"... and manages the window again",
kde.wait_for(lambda: "tiled" in managed_titles(), timeout=30),
)
print("== 4. a stop is not a failure")
kde.systemctl("stop", UNIT)
checks.check("stopped with SIGTERM, the unit is inactive", not active())
checks.check("... and not failed", not failed())
kde.systemctl("start", UNIT)
checks.check("started again, its daemon answers", kde.wait_for(answering, timeout=60))
kde.komorebic("stop")
checks.check("komorebic stop stops the unit", kde.wait_for(lambda: not active(), timeout=30))
checks.check("... which is not failed", not failed())
checks.check("... and not started again", not kde.wait_for(active, timeout=5))
checks.finish()
@@ -2,4 +2,6 @@
tier = "slow";
kind = "session";
timeoutMinutes = 10;
# the session draws without komorebi: a tiled terminal would cover the desktop this test looks at
node.services.komorebi.enable = false;
}