"]
-description = "A simple tui to view & control docker containers"
-repository = "https://github.com/mrjackwills/oxker"
-homepage = "https://github.com/mrjackwills/oxker"
-license = "MIT"
-rust-version = "1.90.0"
-readme = "README.md"
-keywords = ["docker", "tui", "tokio", "terminal", "podman"]
-categories = ["command-line-utilities"]
-
-[lints.rust]
-unsafe_code = "forbid"
-
-[lints.clippy]
-expect_used = "warn"
-todo = "warn"
-unused_async = "warn"
-unwrap_used = "warn"
-module_name_repetitions = "allow"
-doc_markdown = "allow"
-similar_names = "allow"
-
-[dependencies]
-anyhow = "1.0"
-bollard = "0.20"
-cansi = "2.2"
-clap = { version = "4.5", features = ["color", "derive", "unicode"] }
-crossterm = "0.29"
-directories = "6.0"
-futures-util = "0.3"
-jiff = { version = "0.2", features = ["tzdb-bundle-always"] }
-parking_lot = { version = "0.12" }
-ratatui = "0.30"
-serde = { version = "1.0", features = ["derive"] }
-serde_json = { version = "1.0"}
-serde_jsonc = "1.0"
-tokio = { version = "1.49", features = ["full"] }
-tokio-util = "0.7"
-toml = { version = "1.0", default-features = false, features = ["parse", "serde"] }
-tracing = "0.1"
-tracing-subscriber = "0.3"
-uuid = { version = "1.21", features = ["fast-rng", "v4"] }
-
-[dev-dependencies]
-insta = "1.46"
-serde_json = { version = "1.0", features = ["preserve_order"]}
-
-[profile.release]
-lto = true
-codegen-units = 1
-panic = 'abort'
-strip = true
-debug = false
-
-
diff --git a/README.md b/README.md
index 394121f..9d4b53c 100644
--- a/README.md
+++ b/README.md
@@ -1,238 +1,47 @@
-
- 
-
-
oxker
- A simple tui to view & control docker containers
-
+# Oxker - Go Version
-
- Built in Rust, making heavy use of ratatui & Bollard
-
+A simple TUI to view & control Docker containers, built with Bubbletea.
-
-
-
- 
-
-
-
-
- link to alternative screenshot
-
-
-
+## Features
-- [Download & install](#download--install)
-- [Run](#run)
-- [Build step](#build-step)
-- [Tests](#tests)
+- View Docker containers in a table format
+- Filter containers
+- Start/Stop containers
+- Container details
-## Download & install
+## Requirements
-### Cargo
-Published on crates.io, so if you have cargo installed, simply run
+- Go 1.23+
+- Docker installed and running
+## Installation
-```shell
-cargo install oxker
+```bash
+go install github.com/oxker/oxker@latest
```
-### Docker
+## Usage
-Published on ghcr.io and Docker Hub,
-with images built for `linux/amd64`, `linux/arm64`, and `linux/arm/v6`
-
-
-**via ghcr.io**
-
-```shell
-docker run --rm -it -v /var/run/docker.sock:/var/run/docker.sock:ro --pull=always ghcr.io/mrjackwills/oxker
-```
-
-**via Docker Hub**
-```shell
-docker run --rm -it -v /var/run/docker.sock:/var/run/docker.sock:ro --pull=always mrjackwills/oxker
-```
-
-### Nix
-Using nix flakes, oxker can be ran directly with
-
-```shell
-nix run nixpkgs#oxker
-```
-
-Without flakes, you can build a shell that contains oxker using
-
-```shell
-nix-shell -p oxker
-```
-
-### AUR
-
-oxker can be installed from the [AUR](https://aur.archlinux.org/packages/oxker) with using an [AUR helper](https://wiki.archlinux.org/title/AUR_helpers):
-
-```shell
-paru -S oxker
-```
-
-### Homebrew
-
-oxker can be installed on macOS using [Homebrew](https://formulae.brew.sh/formula/oxker):
-
-```shell
-brew install oxker
-```
-
-### Pre-Built
-See the pre-built binaries
-
-or, download & install (x86_64 one liner)
-
-```shell
-wget https://www.github.com/mrjackwills/oxker/releases/latest/download/oxker_linux_x86_64.tar.gz &&
-tar xzvf oxker_linux_x86_64.tar.gz oxker &&
-install -Dm 755 oxker -t "${HOME}/.local/bin" &&
-rm oxker_linux_x86_64.tar.gz oxker
-```
-
-or, for automatic platform selection, download, and installation (to `$HOME/.local/bin`)
-
-*One should always verify script content before running in a shell*
-
-```shell
-curl https://raw.githubusercontent.com/mrjackwills/oxker/main/install.sh | bash
-```
-
-## Run
-
-```shell
+```bash
oxker
```
-In application controls, these, amongst many other settings, can be customized with the [config file](#Config-File)
-| button| result|
-|--|--|
-| ```( tab )``` or ```( shift+tab )``` | Change panel, clicking on a panel also changes the selected panel.|
-| ```( ↑ ↓ )``` or ```( j k )``` or ```( Home End )```| Scroll line in selected panel - mouse wheel will also scroll.|
-| ```( ← → )``` | Scroll horizontally across text.|
-| ```( ctrl )``` | Increase scroll speed, used in conjunction with scroll keys.|
-| ```( enter )```| Run selected docker command.|
-| ```( 1-9 )``` | Sort containers by heading, clicking on headings also sorts the selected column. |
-| ```( 0 )``` | Stop sorting.|
-| ```( F1 )``` or ```( / )``` | Enter filter mode. |
-| ```( # )``` | Enter log search mode. |
-| ```( - ) ``` or ```(=)``` | Reduce or increase the height of the logs panel.|
-| ```( \ )``` | Toggle the visibility of the logs panel.|
-| ```( e )``` | Exec into the selected container - not available on Windows.|
-| ```( i )``` | Enter container inspect mode. |
-| ```( f )``` | Force clear the screen & redraw the gui.|
-| ```( h )``` | Toggle help menu.|
-| ```( m )``` | Toggle mouse capture - if disabled, text on screen can be selected.|
-| ```( q )``` | Quit.|
-| ```( s )``` | Save logs to `$HOME/[container_name]_[timestamp].log`, or the directory set by `--save-dir`.|
-| ```( esc )``` | Close dialog.|
-Available command line arguments
+## Controls
-| argument|result|
-|--|--|
-|```-d [number > 0]```| Set the minimum update interval for docker information in milliseconds. Defaults to 1000 (1 second).|
-|```-r```| Show raw logs. By default, removes ANSI formatting (conflicts with `-c`).|
-|```-c```| Attempt to color the logs (conflicts with `-r`).|
-|```-t```| Remove timestamps from each log entry.|
-|```-s```| If running via Docker, will display the oxker container.|
-|```-g```| No TUI, essentially a debugging mode with limited functionality, for now.|
-|```--config-file [string]```| Location of a `config.toml`/`config.json`/`config.jsonc`. By default will check the users local config directory.|
-|```--host [string]```| Connect to Docker with a custom hostname. Defaults to `/var/run/docker.sock`. Will use `$DOCKER_HOST` environment variable if set.|
-|```--no-stderr```| Do not include stderr output in logs.|
-|```--save-dir [string]```| Save exported logs into a custom directory. Defaults to `$HOME`.|
-|```--timezone [string]```| Display the Docker logs timestamps in a given [timezone](https://en.wikipedia.org/wiki/List_of_tz_database_time_zones). Defaults to `Etc/UTC`.|
-|```--use-cli```| Use the Docker application when exec-ing into a container, instead of the Docker API.|
+| Key | Action |
+|-----|--------|
+| q | Quit |
+| r | Refresh containers |
+| j/k | Navigate up/down |
+| enter | View container details |
+| ctrl+c | Quit |
-### Config File
+## Building
-
-A config file enables the user to persist settings, create a custom keymap, set the color scheme used by the application, and more.
-
-
-Examples of the config file, alsong with explanations of each value, can be found in the [example_config](https://github.com/mrjackwills/oxker/tree/main/example_config) directory. `oxker` supports `.toml`,`.json`, and `.jsonc` file formats.
-
-
-If no config file is found, a `config.toml` file will be created in an `oxker` directory in the user's local config directory, as found by the [directories crate](https://docs.rs/directories/6.0.0/directories/struct.BaseDirs.html#method.config_local_dir).
-
-
-Command line arguments will take priority over values from the config file.
-
-
-If running an `oxker` container, the default config location will be `/` rather than the automatically detected platform-specific local config directory, and can be mounted as follows;
-
-```shell
-docker run --rm -it -v /var/run/docker.sock:/var/run/docker.sock:ro -v /some_location/config.toml:/config.toml:ro ghcr.io/mrjackwills/oxker
+```bash
+go build -o oxker
```
-## Build step
+## License
-### x86_64
-
-```shell
-cargo build --release
-```
-
-### Raspberry pi
-
-requires docker & cross-rs
-
-#### 64bit pi (pi 4, pi zero w 2)
-
-```shell
-cross build --target aarch64-unknown-linux-gnu --release
-```
-
-#### 32bit pi (pi zero w)
-
-Tested, and fully working on pi zero w, running Raspberry Pi OS 32 bit, the initial logs parsing can take an extended period of time if thousands of lines long, suggest running with a -d argument of 5000
-
-```shell
-cross build --target arm-unknown-linux-musleabihf --release
-```
-
-If no memory information available, try appending either ```/boot/cmdline.txt``` or ```/boot/firmware/cmdline.txt``` with
-
-```cgroup_enable=cpuset cgroup_enable=memory```
-
-see https://forums.raspberrypi.com/viewtopic.php?t=203128 and https://github.com/docker/for-linux/issues/1112
-
-
-### Untested on other platforms
-
-
-## Tests
-
-~~As of yet untested, needs work~~
-
-The work has been done, so far the tests don't effect any running containers, but this may change in the future.
-
-```shell
-cargo test
-```
-
-Run some example docker images
-
-using docker/docker-compose.yml;
-
-```shell
-docker compose -f ./docker/docker-compose.yml up -d
-```
-
-or individually
-
-```shell
-docker run --name redis -d redis:alpine3.21
-```
-
-```shell
-docker run --name postgres -e POSTGRES_PASSWORD=never_use_this_password_in_production -d postgres:alpine3.21
-```
-
-```shell
-docker run -d --hostname my-rabbit --name rabbitmq rabbitmq:3
-```
+MIT
\ No newline at end of file
diff --git a/REVIEW_FINDINGS.md b/REVIEW_FINDINGS.md
new file mode 100644
index 0000000..63de67a
--- /dev/null
+++ b/REVIEW_FINDINGS.md
@@ -0,0 +1,454 @@
+# Oxker Go Rewrite — Review Findings
+
+Systematischer Vergleich aller Original-Rust-Dateien mit der Go-Reimplementierung.
+6 parallele Review-Agenten, ~130 Findings gesamt.
+
+---
+
+## CRITICAL (App funktioniert falsch)
+
+### C1. CPU immer 0 — ContainerStatsOneShot liefert leere precpu_stats
+- **Source:** Docker Integration Review #11
+- **Rust:** `docker_data/mod.rs:136-143` — `stream: false, one_shot: false` + `.take(1)`
+- **Go:** `docker/client.go:70` — `ContainerStatsOneShot` setzt `one-shot=true`
+- **Problem:** Mit `one-shot=true` liefert Docker leere `precpu_stats`, CPU-Berechnung ergibt 0
+- **Fix:** `ContainerStats` mit `stream=false` statt `ContainerStatsOneShot` verwenden
+- **Status:** [x] FIXED
+
+### C2. uint64 Underflow bei CPU-Berechnung
+- **Source:** Docker Integration Review #6/#7
+- **Rust:** `docker_data/mod.rs:86-91` — `saturating_sub` verhindert Underflow
+- **Go:** `app.go:1120-1121` — plain uint64 Subtraktion, kann wrappen
+- **Fix:** Guard: `if TotalUsage < PreTotalUsage { return 0 }`
+- **Status:** [x] FIXED
+
+### C3. --host Flag wird ignoriert
+- **Source:** Docker Integration Review #1
+- **Rust:** `main.rs:47-57` — Config Host > DOCKER_HOST env > default socket
+- **Go:** `docker/client.go:17-22` — nur `FromEnv`, ignoriert `Config.Host`
+- **Fix:** `docker.New()` soll optionalen Host akzeptieren, `client.WithHost(host)` verwenden
+- **Status:** [x] FIXED
+
+### C4. Logs ShowStderr Config ignoriert
+- **Source:** Docker Integration Review #8
+- **Rust:** `docker_data/mod.rs:256-258` — `config.show_std_err`
+- **Go:** `app.go:1089-1091` — hardcoded `ShowStderr: true`
+- **Fix:** `ShowStderr: a.Config.ShowStdErr`
+- **Status:** [x] FIXED
+
+### C5. Bandwidth-Chart zeigt kumulative Bytes statt Rate
+- **Source:** Data Model Review #8
+- **Rust:** `container_state.rs:627-672` — `NetworkBandwidth.to_vec_f64` berechnet Deltas
+- **Go:** `app.go:1493-1508` — `fmtRate(c.RxBytes)` auf kumulative Rohwerte
+- **Fix:** Bandwidth als Differenz zwischen aufeinanderfolgenden Einträgen berechnen
+- **Status:** [x] FIXED
+
+### C6. RunningUnhealthy — fehlt pause/restart in Commands
+- **Source:** Data Model Review #2, Main UI Review #6
+- **Rust:** `container_state.rs:451` — `Running(_) => [Pause, Restart, Stop, Delete]`
+- **Go:** `app.go:1749-1750` — `RunningUnhealthy` nur `["stop", "delete"]`
+- **Fix:** Gleiche Commands wie RunningHealthy
+- **Status:** [x] FIXED
+
+### C7. Enter führt immer ersten Command aus — kein Command-Selection
+- **Source:** Input Review #6, Data Model Review #4, Main UI Review #8
+- **Rust:** `input_handler/mod.rs:267` — prüft `panel == Commands`, nutzt `selected_docker_controls()`
+- **Go:** `app.go:922` — `cmds[0]` immer, unabhängig von Panel
+- **Fix:** `CmdSelectedIdx` Feld, nur bei `ActivePanel == PanelCommands` ausführen
+- **Status:** [x] FIXED
+
+### C8. Ctrl+C quit nicht in Filter/Search-Modus
+- **Source:** Input Review #9
+- **Rust:** `input_handler/mod.rs:762-763` — Ctrl+C immer quit
+- **Go:** `app.go:360-367` — Filter/Search early return, Ctrl+C wird nie erreicht
+- **Fix:** Ctrl+C Check vor Mode-Dispatch
+- **Status:** [x] FIXED
+
+### C9. Mouse-Events nicht blockiert in Overlay-Modi
+- **Source:** Input Review #10
+- **Rust:** `input_handler/mod.rs:74-84` — blockiert Mouse in Error/Help/Filter/Search/DeleteConfirm
+- **Go:** `app.go:638` — keine Mode-Checks, Mouse immer aktiv
+- **Fix:** Mode-Checks am Anfang von `handleMouse`
+- **Status:** [x] FIXED
+
+### C10. Info-Popup Auto-Dismiss fehlt (4 Sekunden)
+- **Source:** Popups Review #9
+- **Rust:** `info.rs:52-54` — `instant.elapsed() > 4000ms`
+- **Go:** `app.go:1003-1006` — Kommentar sagt "handled by tick", aber kein Timer
+- **Fix:** `tea.Tick(4*time.Second)` → `InfoDismissMsg`
+- **Status:** [x] FIXED
+
+---
+
+## HIGH (UI sieht falsch aus)
+
+### H1. CPU-Format ohne Zero-Padding
+- **Source:** Main UI Review #2
+- **Rust:** `container_state.rs:521` — `{:05.2}%` → `00.00%`, `05.34%`
+- **Go:** `app.go:1325` — `%.2f%%` → `0.00%`, `5.34%`
+- **Fix:** `fmt.Sprintf("%05.2f%%", c.CPUPercent)`
+- **Status:** [x] FIXED
+
+### H2. Container-Spalten ohne Farben (Name/ID/Image/RX/TX)
+- **Source:** Main UI Review #10/#11
+- **Rust:** `containers.rs:26-33` — Name/ID/Image mit `containers.text` (Blue), RX/TX eigene Farben
+- **Go:** `app.go:1321-1332` — kein Styling
+- **Fix:** lipgloss.Foreground für Name/ID/Image und separate Farben für RX/TX
+- **Status:** [x] FIXED
+
+### H3. Command-Farben falsch
+- **Source:** Main UI Review #5
+- **Rust:** restart=Magenta, delete=Gray, resume=Blue, start=Green, stop=Red, pause=Yellow
+- **Go:** restart/resume/start=Green, stop/delete=Red, pause=Yellow
+- **Fix:** Jeder Command eigene Farbe
+- **Status:** [x] FIXED
+
+### H4. Layout-Proportionen falsch
+- **Source:** Main UI Review #17
+- **Rust:** `ui/mod.rs:400` — 75%/25% (oben/unten)
+- **Go:** `app.go:1664-1686` — 30% Container, 22% Charts, Rest Logs
+- **Fix:** 75%/25% Split, dann Container/Logs innerhalb der 75%
+- **Status:** [x] FIXED
+
+### H5. Ports: `::` und `0` statt leer
+- **Source:** Charts/Ports Review #15/#16
+- **Rust:** `container_state.rs:156-160` — None → leerer String
+- **Go:** `app.go:1522-1523` — `::` für leere IP, `0` für fehlenden Public Port
+- **Fix:** Leere Strings statt `::` und `0`
+- **Status:** [x] FIXED
+
+### H6. Falsches Highlight-Symbol
+- **Source:** Main UI Review #12
+- **Rust:** `mod.rs:47` — `⚪ ` (offener Kreis)
+- **Go:** `app.go:1315` — `●` (gefüllter Kreis, blau)
+- **Fix:** `⚪ ` verwenden
+- **Status:** [x] FIXED
+
+### H7. Default-Sort fehlt (nach CreatedAt)
+- **Source:** Data Model Review #13
+- **Rust:** `mod.rs:492-499` — sort by `created` + Name als Tiebreaker
+- **Go:** `app.go:829-831` — kein Sort bei `SortNone`
+- **Fix:** Bei `SortNone` nach `CreatedAt` sortieren, Name als Tiebreaker
+- **Status:** [x] FIXED
+
+### H8. Sort verliert Selection
+- **Source:** Data Model Review #6
+- **Rust:** `mod.rs:377-387` — re-selects Container by ID nach Sort
+- **Go:** `app.go:812-827` — SelectedIdx bleibt gleich, Container an Position ändert sich
+- **Fix:** Nach Sort alten Container per ID finden und SelectedIdx aktualisieren
+- **Status:** [x] FIXED
+
+### H9. Sort Tiebreaker by Name fehlt
+- **Source:** Data Model Review #15
+- **Rust:** `mod.rs:437-484` — `.then_with(|| name.cmp(name))`
+- **Go:** `app.go:834-866` — kein Tiebreaker
+- **Fix:** Name-Vergleich als Tiebreaker bei Gleichheit
+- **Status:** [x] FIXED
+
+### H10. State-Reihenfolge beim Sort falsch
+- **Source:** Data Model Review #14
+- **Rust:** `container_state.rs:316-327` — Healthy=0, Unhealthy=1, Paused=2, Restarting=3, etc.
+- **Go:** iota-Reihenfolge weicht ab (Exited vor Restarting)
+- **Fix:** `order()` Methode mit Rust-Mapping
+- **Status:** [x] FIXED
+
+### H11. Search-Highlight: ganze Zeile statt Substring
+- **Source:** Charts/Ports Review #22
+- **Rust:** Substring-Level Highlighting
+- **Go:** `app.go:1422-1423` — ganze Zeile gelb
+- **Fix:** Nur gematchten Substring highlighten
+- **Status:** [x] FIXED
+
+### H12. Help wird als Vollbild gerendert statt Overlay
+- **Source:** Popups Review #11
+- **Rust:** `mod.rs:477-480` — Overlay auf Base View
+- **Go:** `app.go:1175-1177` — ersetzt komplett den View
+- **Fix:** Base View rendern, dann Help darüber legen
+- **Status:** [x] FIXED
+
+### H13. Log-Zeilen: Byte-Length statt Rune-Length für UTF-8
+- **Source:** Main UI Review #28
+- **Rust:** `.chars().count()` für Width
+- **Go:** `app.go:1409-1414` — `len(line)` (Bytes)
+- **Fix:** `[]rune(line)` oder `runewidth` verwenden
+- **Status:** [x] FIXED
+
+### H14. Bandwidth-Chart: Keine historischen Daten gerendert
+- **Source:** Charts/Ports Review #6
+- **Rust:** `chart_bandwidth.rs:92-109` — zwei Line-Datasets (RX/TX)
+- **Go:** `app.go:1493-1508` — nur Text-Labels, kein Sparkline
+- **Fix:** Sparklines für RX/TX History hinzufügen
+- **Status:** [x] FIXED
+
+### H15. LogHeight Default: 40 statt 75
+- **Source:** Popups Review #23
+- **Rust:** `gui_state.rs:220` — default `75`
+- **Go:** `app.go:213` — default `40`
+- **Fix:** Default auf `75` ändern
+- **Status:** [x] FIXED
+
+---
+
+## MEDIUM (Verhaltensunterschiede)
+
+### M1. Binate Stats-Sammlung fehlt (keine Deduplizierung)
+- **Source:** Docker Integration Review #2
+- **Rust:** `docker_data/mod.rs:44-61` — Binate-Enum, Spawn-Deduplizierung
+- **Go:** `app.go:1043-1081` — keine Tracking, Duplikate möglich
+- **Fix:** `pendingStats map[string]bool` für In-Flight Tracking
+- **Status:** [x] FIXED
+
+### M2. Logs: Tail-500 statt inkrementell (since-Timestamp)
+- **Source:** Docker Integration Review #9
+- **Rust:** `docker_data/mod.rs:256-273` — `since` Parameter, akkumuliert
+- **Go:** `app.go:1091` — `Tail: "500"`, ersetzt jedes Mal
+- **Status:** [x] FIXED — uses `since` for incremental fetching after initial load
+
+### M3. Per-Container Log-Speicher fehlt
+- **Source:** Data Model Review #3
+- **Rust:** `ContainerItem.logs` — HashSet mit Dedup, per-Container Scroll
+- **Go:** `App.LogLines` — einzelner globaler Slice
+- **Status:** [x] FIXED — Container.Logs/LogScroll/LogHScroll with save/restore on selection change
+
+### M4. Container-Selbstfilterung (oxker-Container verstecken) fehlt
+- **Source:** Docker Integration Review #12, Data Model Review #9
+- **Rust:** `docker_data/mod.rs:229-234` — ENTRY_POINT Filter
+- **Go:** keine Selbstfilterung
+- **Status:** [x] FIXED — respects Config.ShowSelf
+
+### M5. Docker Ping-Check bei Startup fehlt
+- **Source:** Docker Integration Review #15
+- **Rust:** `main.rs:68-88` — Ping + Error mit Host-Pfad
+- **Go:** `app.go:207` — `docker.New()` Error wird ignoriert
+- **Status:** [x] FIXED — Ping + Host in error message
+
+### M6. Filter-Mode: `/` beendet nicht den Modus (wird als Text eingegeben)
+- **Source:** Input Review #14
+- **Rust:** `input_handler:523-528` — `/` beendet Filter-Mode
+- **Go:** `app.go:570-590` — `/` wird als Zeichen eingefügt
+- **Status:** [x] FIXED (already implemented — `/` in enter case)
+
+### M7. Search-Mode: `#` beendet nicht den Modus
+- **Source:** Input Review #15
+- **Rust:** `input_handler:409-414` — `#` beendet Search-Mode
+- **Go:** `app.go:598-631` — `#` wird als Zeichen eingefügt
+- **Status:** [x] FIXED (already implemented — `#` in enter case)
+
+### M8. Direkte Action-Keys (s/x/r/d/p/u) existieren in Rust nicht
+- **Source:** Input Review #17
+- **Rust:** Actions nur über Commands-Panel mit Enter
+- **Go:** `app.go:478-489` — direkte Shortcuts
+- **Note:** Go-Erweiterung, könnte gewollt sein, aber kollidiert mit Rust-Keybindings
+- **Status:** [x] WONTFIX — bewusste Erweiterung, Shortcuts sind nützlich
+
+### M9. Mouse-Scroll-Amount: 3 statt 1 (mit 10x Modifier)
+- **Source:** Input Review #19
+- **Rust:** `input_handler:828-829` — Scroll by 1 oder 10 mit Ctrl
+- **Go:** `app.go:639-644` — hardcoded 3
+- **Status:** [x] FIXED (already 1)
+
+### M10. Mouse-Scroll in Inspect-Mode nicht unterstützt
+- **Source:** Input Review #20
+- **Rust:** `input_handler:810-818` — Mouse-Scroll im Inspect
+- **Go:** `handleMouse` hat keinen Inspect-Check
+- **Status:** [x] FIXED (via C9)
+
+### M11. Error-Mode: andere Keys nicht blockiert
+- **Source:** Input Review #24
+- **Rust:** `handle_error` — nur clear/quit Keys
+- **Go:** Sort-Keys, Scroll-Keys etc. funktionieren während Error
+- **Status:** [x] FIXED (via C8)
+
+### M12. Unknown-State: falsche Commands
+- **Source:** Main UI Review #7
+- **Rust:** `container_state.rs:452` — `Unknown => [Delete]` nur
+- **Go:** `app.go:1753-1754` — `Unknown => [start, restart, delete]`
+- **Status:** [x] FIXED (via C6)
+
+### M13. Commands-Panel Scroll fehlt
+- **Source:** Input Review #5
+- **Rust:** `docker_controls_scroll` bewegt Command-Selection
+- **Go:** Scroll im Commands-Panel ändert Container-Selection
+- **Status:** [x] FIXED (via C7)
+
+### M14. Commands-Panel Breite: fest 14 statt 10%
+- **Source:** Main UI Review #4
+- **Rust:** `ui/mod.rs:419` — `Percentage(10)`
+- **Go:** `app.go:1278` — `cmdW := 14`
+- **Status:** [x] FIXED — 10% mit min 12
+
+### M15. DockerConnect Error: kein Countdown, kein Auto-Exit
+- **Source:** Popups Review #6/#17
+- **Rust:** 5-Sekunden Countdown, Auto-Exit, Host-Anzeige
+- **Go:** Standard-Error-Popup
+- **Status:** [x] FIXED — 5s countdown + auto-exit + host in error message
+
+### M16. Delete-Dialog: Name nicht bold/highlighted
+- **Source:** Popups Review #1
+- **Rust:** `delete_confirm.rs:44-53` — Name bold + highlighted
+- **Go:** `app.go:1542` — einfacher String
+- **Status:** [x] FIXED
+
+### M17. Help-View: stark reduzierter Inhalt
+- **Source:** Popups Review #12
+- **Rust:** ~570 Zeilen, Logo, Version, Config-Pfad, Timezone, alle Keys
+- **Go:** ~20 Zeilen, nur Basis-Keys
+- **Status:** [x] FIXED — erweitert mit Config-Pfad, Panel-Info, vollständiger Keybinding-Liste
+
+### M18. Container-Name: führender `/` wird nicht entfernt
+- **Source:** Charts/Ports Review #30
+- **Rust:** `inspect.rs:35-38` — Strip `/` Prefix
+- **Go:** Name direkt verwendet
+- **Status:** [x] FIXED (already done via TrimPrefix)
+
+### M19. Inspect: Wrapping statt Truncation
+- **Source:** Charts/Ports Review #29
+- **Rust:** `inspect.rs:133` — `Wrap { trim: false }`
+- **Go:** `app.go:1603` — Truncation
+- **Status:** [x] FIXED
+
+### M20. Spaltenbreiten fest statt dynamisch
+- **Source:** Main UI Review #1, Data Model Review #17
+- **Rust:** `mod.rs:845-879` — max Width pro Spalte aus Daten
+- **Go:** `app.go:1264-1273` — feste Prozent-Widths
+- **Status:** [x] FIXED — dynamic widths based on container data
+
+### M21. State-Icons: andere Unicode-Zeichen
+- **Source:** Main UI Review #24
+- **Rust:** `✓`, `✖`, `॥`, `↻`, `!`, `?`
+- **Go:** `✔`, `✖`, `‖`, `↻`, `!`, `?`
+- **Status:** [x] FIXED — ✓ statt ✔
+
+### M22. Search-Navigation: Ctrl+N/P statt Down/Up
+- **Source:** Input Review #16
+- **Rust:** Down/Up Arrow für nächsten/vorherigen Match
+- **Go:** Ctrl+N/Ctrl+P
+- **Status:** [x] FIXED (already supports both Down/Up and Ctrl+N/P)
+
+### M23. Log-Search Case-Sensitivity nicht konfigurierbar
+- **Source:** Data Model Review #19
+- **Rust:** `config.log_search_case_sensitive`
+- **Go:** immer case-insensitive
+- **Status:** [x] FIXED — respects Config.LogSearchCaseSensitive
+
+### M24. Filter wraps around (Go), Rust stoppt an Grenzen
+- **Source:** Data Model Review #16
+- **Rust:** `FilterBy::next()/prev()` gibt None an Grenzen
+- **Go:** Modulo-Wrapping
+- **Status:** [x] FIXED — stoppt an Grenzen
+
+### M25. Overlay-Popups: `base` Parameter wird ignoriert
+- **Source:** Popups Review #16
+- **Go:** `overlayError(base)`, `overlayInfo(base)` — base wird nie verwendet
+- **Status:** [x] FIXED — overlay placement with transparent bg
+
+---
+
+## LOW (Kosmetische/Konfigurationsunterschiede)
+
+### L1. Alle Farben hardcoded statt aus Config
+- Betrifft: alle Panels, Popups, Charts, Headers
+- Config `AppColors` existiert, wird aber nie gelesen
+- **Status:** [x] FIXED — colorOr() resolver, borders/commands/state colors from config
+
+### L2. Custom Keymaps nicht implementiert
+- Config `Keymap` existiert, wird aber nie verwendet
+- Alle Keys sind hardcoded Strings
+- **Status:** [x] FIXED — keyMatch() checks config keymap with hardcoded fallbacks
+
+### L3. Mouse-Capture Toggle (`m` Key) fehlt
+- **Source:** Input Review #1
+- **Status:** [x] FIXED
+
+### L4. Force-Redraw Key (`f`) fehlt
+- **Source:** Input Review #2
+- **Status:** [x] FIXED — tea.ClearScreen
+
+### L5. Container-Name/Image Truncation bei 30 Zeichen
+- **Source:** Data Model Review #18
+- **Status:** [x] FIXED (handled by dynamic column widths M20)
+
+### L6. CpuStats Epsilon: 0.001 statt 0.01
+- **Source:** Data Model Review #24
+- **Status:** [x] FIXED (already 0.001)
+
+### L7. fmtRate fehlt GB/s Tier
+- **Source:** Data Model Review #23
+- **Status:** [x] FIXED
+
+### L8. InspectData: Name/ID nicht beim Inspizieren gespeichert
+- **Source:** Data Model Review #21
+- **Status:** [x] FIXED (already shown in viewInspect title)
+
+### L9. Scroll-Speed Modifier: Shift statt Ctrl
+- **Source:** Input Review #3
+- **Status:** [x] FIXED (already uses J/K = Shift+j/k)
+
+### L10. Horizontal-Scroll in Search-Mode fehlt
+- **Source:** Input Review #8
+- **Status:** [x] FIXED — left/right in search mode
+
+### L11. Header: "show help" → "exit help" Toggle fehlt
+- **Source:** Main UI Review #19
+- **Status:** [x] FIXED
+
+### L12. Header: `↓ rx` / `↑ tx` Pfeile existieren nicht in Rust
+- **Source:** Main UI Review #20
+- **Status:** [x] FIXED — removed arrows
+
+### L13. Charts: State-abhängige Farben fehlen
+- **Source:** Charts/Ports Review #4/#8
+- **Status:** [x] FIXED — dim color for non-running states
+
+### L14. Charts: Y-Achse Max-Wert fehlt
+- **Source:** Charts/Ports Review #2
+- **Status:** [x] FIXED — max label shown
+
+### L15. Filter-Bar: kein dediziertes UI (nur inline Text)
+- **Source:** Charts/Ports Review #17/#18
+- **Status:** [x] FIXED — dedicated styled filter bar
+
+### L16. Search-Bar: kein dediziertes UI (nur inline Text)
+- **Source:** Charts/Ports Review #20/#21
+- **Status:** [x] FIXED — dedicated styled search bar
+
+### L17. Ports: Title nicht zentriert, nicht als Border-Title
+- **Source:** Charts/Ports Review #31
+- **Status:** [x] FIXED — centered title
+
+### L18. Inspect: Scroll-Clamping fehlt
+- **Source:** Charts/Ports Review #27
+- **Status:** [x] FIXED — clampInspectScroll()
+
+### L19. "No containers" Message fehlt
+- **Source:** Main UI Review #29
+- **Status:** [x] FIXED
+
+### L20. Minimum Terminal-Size Handling fehlt
+- **Source:** Main UI Review #30
+- **Status:** [x] FIXED — 60x10 minimum with message
+
+### L21. Logs: "parsing logs" Init-State fehlt
+- **Source:** Main UI Review #14
+- **Status:** [x] FIXED
+
+### L22. Logs: scroll_padding fehlt
+- **Source:** Main UI Review #15
+- **Status:** [x] FIXED — auto-follow when at bottom
+
+### L23. Logs: color_logs Toggle fehlt
+- **Source:** Main UI Review #16
+- **Status:** [x] FIXED — stripAnsi when ColorLogs=false
+
+### L24. appendMax Slice-Leak (kein Ring-Buffer)
+- **Source:** Data Model Review #22
+- **Status:** [x] FIXED — in-place copy instead of reslice
+
+### L25. Delete-Dialog: Container-Not-Found Guard fehlt
+- **Source:** Popups Review #2
+- **Status:** [x] FIXED — guard + default name
+
+### L26. Network: alle Interfaces statt nur eth0
+- **Source:** Docker Integration Review #3
+- **Note:** Go-Verhalten ist besser, bewusste Abweichung
+- **Status:** [x] WONTFIX — bewusste Verbesserung
diff --git a/_typos.toml b/_typos.toml
deleted file mode 100644
index 372dc95..0000000
--- a/_typos.toml
+++ /dev/null
@@ -1,2 +0,0 @@
-[default.extend-words]
-ratatui = "ratatui"
diff --git a/build.sh b/build.sh
new file mode 100755
index 0000000..4d7645a
--- /dev/null
+++ b/build.sh
@@ -0,0 +1,18 @@
+#!/bin/bash
+
+# Build script for Oxker Go TUI
+# This script builds the Go application
+
+set -e
+
+cd "$(dirname "$0")"
+
+echo "Building Oxker..."
+go build -o oxker ./cmd/oxker
+echo "Build complete: ./oxker"
+
+echo "Running go vet..."
+go vet ./...
+
+echo "Running go mod tidy..."
+go mod tidy
\ No newline at end of file
diff --git a/cmd/oxker/cli.go b/cmd/oxker/cli.go
new file mode 100644
index 0000000..b961844
--- /dev/null
+++ b/cmd/oxker/cli.go
@@ -0,0 +1,110 @@
+package main
+
+import (
+ "flag"
+ "fmt"
+ "os"
+ "path/filepath"
+
+ "github.com/oxker/oxker/internal/config"
+)
+
+// CLIArgs represents parsed command-line arguments
+type CLIArgs struct {
+ DockerIntervalMs int
+ RawLogs bool
+ ColorLogs bool
+ ShowTimestamp bool
+ ShowSelf bool
+ DebugMode bool
+ ConfigFile string
+ Host string
+ NoStdErr bool
+ SaveDir string
+ Timezone string
+ UseCLI bool
+}
+
+// ParseCLIArgs parses command-line arguments
+func ParseCLIArgs() (*CLIArgs, error) {
+ args := &CLIArgs{}
+
+ // Define flags
+ flag.IntVar(&args.DockerIntervalMs, "d", 1000, "Minimum update interval for docker information in milliseconds")
+ flag.BoolVar(&args.RawLogs, "r", false, "Show raw logs (no ANSI formatting)")
+ flag.BoolVar(&args.ColorLogs, "c", false, "Attempt to color the logs")
+ flag.BoolVar(&args.ShowTimestamp, "t", false, "Remove timestamps from each log entry")
+ flag.BoolVar(&args.ShowSelf, "s", false, "Display the oxker container")
+ flag.BoolVar(&args.DebugMode, "g", false, "No TUI, debugging mode")
+ flag.StringVar(&args.ConfigFile, "config-file", "", "Location of config file (TOML/JSON/JSONC)")
+ flag.StringVar(&args.Host, "host", "", "Connect to Docker with a custom hostname")
+ flag.BoolVar(&args.NoStdErr, "no-stderr", false, "Do not include stderr output in logs")
+ flag.StringVar(&args.SaveDir, "save-dir", "", "Save exported logs into a custom directory")
+ flag.StringVar(&args.Timezone, "timezone", "", "Display Docker logs timestamps in a given timezone")
+ flag.BoolVar(&args.UseCLI, "use-cli", false, "Use Docker CLI when exec-ing into a container")
+
+ flag.Parse()
+
+ // Validate docker interval
+ if args.DockerIntervalMs < 1 {
+ return nil, fmt.Errorf("docker interval must be greater than 0")
+ }
+
+ // Handle conflicting log options
+ if args.RawLogs && args.ColorLogs {
+ args.RawLogs = false
+ }
+
+ return args, nil
+}
+
+// LoadConfig loads configuration from file or returns defaults
+func LoadConfig(cliArgs *CLIArgs) (*config.Config, error) {
+ cfg := config.NewConfig()
+
+ // If config file specified, try to load it
+ if cliArgs.ConfigFile != "" {
+ path := cliArgs.ConfigFile
+ // Check if absolute or relative path
+ if !filepath.IsAbs(path) {
+ // Try relative to current directory
+ fullPath := filepath.Join(".", path)
+ if err := config.LoadConfigPath(fullPath, cfg); err != nil {
+ // Try relative to config directory
+ home, _ := os.UserHomeDir()
+ fullPath = filepath.Join(home, ".config", "oxker", path)
+ if err := config.LoadConfigPath(fullPath, cfg); err != nil {
+ return nil, fmt.Errorf("failed to load config file: %w", err)
+ }
+ }
+ } else {
+ if err := config.LoadConfigPath(path, cfg); err != nil {
+ return nil, fmt.Errorf("failed to load config file: %w", err)
+ }
+ }
+ }
+
+ // Override with CLI args
+ if cliArgs.DockerIntervalMs > 0 {
+ cfg.DockerIntervalMs = cliArgs.DockerIntervalMs
+ }
+ cfg.RawLogs = cliArgs.RawLogs
+ cfg.ColorLogs = cliArgs.ColorLogs
+ cfg.ShowTimestamp = !cliArgs.ShowTimestamp
+ cfg.UseCLI = cliArgs.UseCLI
+ cfg.GUI = !cliArgs.DebugMode
+ if cliArgs.Host != "" {
+ cfg.Host = cliArgs.Host
+ }
+ cfg.DirConfig = cliArgs.ConfigFile
+
+ return cfg, nil
+}
+
+// ShowDebugInfo displays information in debug mode (no TUI)
+func ShowDebugInfo(containers interface{}) {
+ // Debug mode - display basic information without TUI
+ fmt.Println("Oxker Debug Mode - Container Information")
+ fmt.Println("=========================================")
+ // TODO: Implement debug mode display
+}
diff --git a/cmd/oxker/main.go b/cmd/oxker/main.go
new file mode 100644
index 0000000..749ec31
--- /dev/null
+++ b/cmd/oxker/main.go
@@ -0,0 +1,40 @@
+package main
+
+import (
+ "fmt"
+ "os"
+
+ tea "charm.land/bubbletea/v2"
+ "github.com/oxker/oxker/internal/app"
+)
+
+func main() {
+ // Parse command-line arguments
+ cliArgs, err := ParseCLIArgs()
+ if err != nil {
+ fmt.Fprintf(os.Stderr, "Error parsing CLI args: %v\n", err)
+ os.Exit(1)
+ }
+
+ // Load configuration
+ cfg, err := LoadConfig(cliArgs)
+ if err != nil {
+ fmt.Fprintf(os.Stderr, "Error loading config: %v\n", err)
+ os.Exit(1)
+ }
+
+ // Debug mode - no TUI
+ if !cfg.GUI {
+ ShowDebugInfo(nil)
+ return
+ }
+
+ // Create and start the Bubble Tea program
+ // AltScreen and MouseMode are now controlled via View() return value
+ p := tea.NewProgram(app.New(cfg))
+
+ if _, err := p.Run(); err != nil {
+ fmt.Fprintf(os.Stderr, "Error: %v\n", err)
+ os.Exit(1)
+ }
+}
diff --git a/cmd/oxker/main_test.go b/cmd/oxker/main_test.go
new file mode 100644
index 0000000..fcd9d1f
--- /dev/null
+++ b/cmd/oxker/main_test.go
@@ -0,0 +1,42 @@
+package main
+
+import (
+ "testing"
+)
+
+func TestAppStart(t *testing.T) {
+ // Test that the application can be instantiated
+ // This is a simple smoke test to verify the app compiles and starts
+
+ // Parse default CLI args
+ cliArgs, err := ParseCLIArgs()
+ if err != nil {
+ t.Fatalf("Failed to parse CLI args: %v", err)
+ }
+
+ if cliArgs == nil {
+ t.Fatal("CLI args should not be nil")
+ }
+
+ // Test config loading
+ cfg, err := LoadConfig(cliArgs)
+ if err != nil {
+ t.Fatalf("Failed to load config: %v", err)
+ }
+
+ if cfg == nil {
+ t.Fatal("Config should not be nil")
+ }
+
+ // Test that debug mode works
+ cfg.GUI = false
+ if !cfg.GUI {
+ // Debug mode - should not error
+ }
+
+ // Test that GUI mode is enabled by default
+ cfg.GUI = true
+ if !cfg.GUI {
+ t.Fatal("GUI mode should be enabled")
+ }
+}
\ No newline at end of file
diff --git a/containerised/DOCKERHUB_README.md b/containerised/DOCKERHUB_README.md
deleted file mode 100644
index 4a0b238..0000000
--- a/containerised/DOCKERHUB_README.md
+++ /dev/null
@@ -1,30 +0,0 @@
-
-
- 
-
oxker
-
- A simple tui to view & control docker containers
-
-
-
-
-
- 
-
-
-
-
- link to alternative screenshot
-
-
-
-
-## Run
-
-Images built for `linux/amd64`, `linux/arm64`, and `linux/arm/v6`
-
-`docker run --rm -it -v /var/run/docker.sock:/var/run/docker.sock:ro --pull=always mrjackwills/oxker`
-
-## Help
-
-visit the Github repo
\ No newline at end of file
diff --git a/containerised/Dockerfile b/containerised/Dockerfile
deleted file mode 100644
index 0f93266..0000000
--- a/containerised/Dockerfile
+++ /dev/null
@@ -1,61 +0,0 @@
-#############
-## Builder ##
-#############
-
-FROM --platform=$BUILDPLATFORM rust:slim AS builder
-
-ARG TARGETARCH
-
-# These are build platform dependant, but will be ignored if not needed
-ENV CARGO_TARGET_AARCH64_UNKNOWN_LINUX_MUSL_LINKER="aarch64-linux-gnu-gcc"
-ENV CARGO_TARGET_AARCH64_UNKNOWN_LINUX_MUSL_RUSTFLAGS="-C target-feature=+crt-static -C link-arg=-lgcc"
-ENV CARGO_TARGET_ARM_UNKNOWN_LINUX_MUSLEABIHF_LINKER="arm-linux-gnueabihf-ld"
-
-COPY ./containerised/target.sh .
-
-RUN chmod +x ./target.sh && ./target.sh
-
-RUN apt-get update && apt-get install $(cat /.compiler) -y
-
-WORKDIR /usr/src
-
-# Create blank project
-RUN cargo new oxker
-
-# We want dependencies cached, so copy those first
-COPY Cargo.* /usr/src/oxker/
-
-# Set the working directory
-WORKDIR /usr/src/oxker
-
-# Install target platform (Cross-Compilation)
-RUN rustup target add $(cat /.target)
-
-# This is a dummy build to get the dependencies cached - probably not needed - as run via a github action
-RUN cargo build --target $(cat /.target) --release
-
-# Now copy in the rest of the sources
-COPY src /usr/src/oxker/src/
-
-# Touch main.rs to prevent cached release build
-RUN touch /usr/src/oxker/src/main.rs
-
-# This is the actual application build
-RUN cargo build --release --target $(cat /.target)
-
-RUN cp /usr/src/oxker/target/$(cat /.target)/release/oxker /
-
-#############
-## Runtime ##
-#############
-
-FROM scratch
-
-# Set an ENV to indicate that we're running in a container
-ENV OXKER_RUNTIME=container
-
-COPY --from=builder /oxker /app/
-
-# Run the application
-# this is used in the application itself so DO NOT EDIT
-ENTRYPOINT [ "/app/oxker"]
\ No newline at end of file
diff --git a/containerised/Dockerfile_dev b/containerised/Dockerfile_dev
deleted file mode 100644
index f8315da..0000000
--- a/containerised/Dockerfile_dev
+++ /dev/null
@@ -1,39 +0,0 @@
-#############
-## Runtime ##
-#############
-FROM scratch
-
-# Set env that we're running in a container
-ENV OXKER_RUNTIME=container
-
-# Copy application binary from builder image
-COPY ./target/x86_64-unknown-linux-musl/release/oxker /app/
-
-# Run the application
-# this is used in the application itself, to stop itself show when running from a docker container, so DO NOT EDIT
-ENTRYPOINT [ "/app/oxker"]
-
-
-# Dev build for testing
-# docker build -t oxker_dev -f containerised/Dockerfile_dev . && docker run --rm -it --volume /var/run/docker.sock:/var/run/docker.sock:ro oxker_dev
-
-# Dev build one liner, x86 host
-# docker image prune -a; cargo build --release --target x86_64-unknown-linux-musl && docker build -t oxker_dev -f containerised/Dockerfile_dev . && docker run --rm -it --volume /var/run/docker.sock:/var/run/docker.sock:ro oxker_dev
-
-# Buildx command to build musl version for all three platforms, should probably be executed in create_release
-# docker buildx create --use
-# docker buildx build --platform linux/arm/v6,linux/arm64,linux/amd64 -t oxker_dev_all -o type=tar,dest=/tmp/oxker_dev_all.tar -f containerised/Dockerfile .
-
-### Build docker files and save to .tar file
-
-# docker build --platform linux/amd64 -t oxker_amd64 -f containerised/Dockerfile .; docker save -o ./oxker_amd64.tar oxker_amd64
-# docker load -i oxker_amd64.tar
-# docker run --rm -it --volume /var/run/docker.sock:/var/run/docker.sock:ro oxker_amd64
-
-# docker build --platform linux/arm64 -t oxker_arm64 -f containerised/Dockerfile .; docker save -o ./oxker_arm64.tar oxker_arm64
-# docker load -i oxker_arm64.tar
-# docker run --rm -it --volume /var/run/docker.sock:/var/run/docker.sock:ro oxker_arm64
-
-# docker build --platform linux/arm/v6 -t oxker_armv6 -f containerised/Dockerfile .; docker save -o ./oxker_armv6.tar oxker_armv6
-# docker load -i oxker_armv6.tar
-# docker run --rm -it --volume /var/run/docker.sock:/var/run/docker.sock:ro oxker_armv6
\ No newline at end of file
diff --git a/containerised/target.sh b/containerised/target.sh
deleted file mode 100644
index 40ba3d6..0000000
--- a/containerised/target.sh
+++ /dev/null
@@ -1,18 +0,0 @@
-#!/bin/sh
-# Used in Docker build to set platform dependent variables
-
-case $TARGETARCH in
-
-"amd64")
- echo "x86_64-unknown-linux-musl" >/.target
- echo "" >/.compiler
- ;;
-"arm64")
- echo "aarch64-unknown-linux-musl" >/.target
- echo "gcc-aarch64-linux-gnu" >/.compiler
- ;;
-"arm")
- echo "arm-unknown-linux-musleabihf" >/.target
- echo "gcc-arm-linux-gnueabihf" >/.compiler
- ;;
-esac
diff --git a/create_release.sh b/create_release.sh
deleted file mode 100755
index 393ccbf..0000000
--- a/create_release.sh
+++ /dev/null
@@ -1,541 +0,0 @@
-#!/bin/bash
-
-# rust create_release v0.6.3
-# 2025-09-20
-
-STAR_LINE='****************************************'
-CWD=$(pwd)
-
-RED='\033[0;31m'
-GREEN='\033[0;32m'
-YELLOW='\033[0;33m'
-PURPLE='\033[0;35m'
-RESET='\033[0m'
-
-# $1 string - error message
-error_close() {
- echo -e "\n${RED}ERROR - EXITED: ${YELLOW}$1${RESET}\n"
- exit 1
-}
-
-# Check that dialog is installed
-if ! [ -x "$(command -v dialog)" ]; then
- error_close "dialog is not installed"
-fi
-
-# $1 string - question to ask
-# $1 question to ask
-# Ask a yes no question, only accepts `y` or `n` as a valid answer, returns 0 for yes, 1 for no
-ask_yn() {
- while true; do
- printf "\n%b%s? [y/N]:%b " "${GREEN}" "$1" "${RESET}"
- read -r answer
- if [[ "$answer" == "y" ]]; then
- return 0
- elif [[ "$answer" == "n" ]]; then
- return 1
- else
- echo -e "${RED}\nPlease enter 'y' or 'n'${RESET}"
- fi
- done
-}
-
-# ask continue, or quit
-ask_continue() {
- if ! ask_yn "continue"; then
- exit
- fi
-}
-
-# semver major update
-update_major() {
- local bumped_major
- bumped_major=$((MAJOR + 1))
- echo "${bumped_major}.0.0"
-}
-
-# semver minor update
-update_minor() {
- local bumped_minor
- bumped_minor=$((MINOR + 1))
- MINOR=bumped_minor
- echo "${MAJOR}.${bumped_minor}.0"
-}
-
-# semver patch update
-update_patch() {
- local bumped_patch
- bumped_patch=$((PATCH + 1))
- PATCH=bumped_patch
- echo "${MAJOR}.${MINOR}.${bumped_patch}"
-}
-
-# Get the url of the github repo, strip .git from the end of it
-get_git_remote_url() {
- GIT_REPO_URL="$(git config --get remote.origin.url | sed 's/\.git$//')"
-}
-
-# Check that git status is clean
-check_git_clean() {
- GIT_CLEAN=$(git status --porcelain)
- if [[ -n $GIT_CLEAN ]]; then
- error_close "git dirty"
- fi
-}
-
-# Check currently on dev branch
-check_git() {
- CURRENT_GIT_BRANCH=$(git branch --show-current)
- check_git_clean
- if [[ ! "$CURRENT_GIT_BRANCH" =~ ^dev$ ]]; then
- error_close "not on dev branch"
- fi
-}
-
-# Ask user if current changelog is acceptable
-ask_changelog_update() {
- echo "${STAR_LINE}"
- RELEASE_BODY_TEXT=$(sed '/# CHANGELOG.md for more details" >.github/release-body.md
-
- # Add subheading with release version and date of release
- echo -e "# ${NEW_TAG_WITH_V}\n${DATE_SUBHEADING}${CHANGELOG_ADDITION}$(cat CHANGELOG.md)" >CHANGELOG.md
-
- # Update changelog to add links to commits [hex:8](url_with_full_commit)
- # "[aaaaaaaaaabbbbbbbbbbccccccccccddddddddd]" -> "[aaaaaaaa](https:/www.../commit/aaaaaaaaaabbbbbbbbbbccccccccccddddddddd)"
- sed -i -E "s=(\s)\[([0-9a-f]{8})([0-9a-f]{32})\]= [\2](${GIT_REPO_URL}/commit/\2\3)=g" CHANGELOG.md
-
- # Update changelog to add links to closed issues
- # "closes #1" -> "closes [#1](https:/www.../issues/1)""
- sed -i -r -E "s=closes \#([0-9]+)=closes [#\1](${GIT_REPO_URL}/issues/\1)=g" CHANGELOG.md
-
- # Update changelog to add links to merged PR's
- # "merges #1" -> "merges [#1](https:/www.../pull/1)""
- sed -i -r -E "s=merges \#([0-9]+)=merges [#\1](${GIT_REPO_URL}/pull/\1)=g" CHANGELOG.md
-}
-
-# update version in cargo.toml, to match selected current version
-update_version_number_in_files() {
- sed -i "s|^version = .*|version = \"${MAJOR}.${MINOR}.${PATCH}\"|" Cargo.toml
-}
-
-# Work out the current version, based on git tags
-# create new semver version based on user input
-# Set MAJOR MINOR PATCH
-check_tag() {
- LATEST_TAG=$(git describe --tags "$(git rev-list --tags --max-count=1)")
- echo -e "\nCurrent tag: ${PURPLE}${LATEST_TAG}${RESET}\n"
- echo -e "${YELLOW}Choose new tag version:${RESET}\n"
- if [[ $LATEST_TAG =~ ^v(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)(-((0|[1-9][0-9]*|[0-9]*[a-zA-Z-][0-9a-zA-Z-]*)(\.(0|[1-9][0-9]*|[0-9]*[a-zA-Z-][0-9a-zA-Z-]*))*))?(\+([0-9a-zA-Z-]+(\.[0-9a-zA-Z-]+)*))?$ ]]; then
- IFS="." read -r MAJOR MINOR PATCH <<<"${LATEST_TAG:1}"
- else
- MAJOR="0"
- MINOR="0"
- PATCH="0"
- fi
- OP_MAJOR="major___v$(update_major)"
- OP_MINOR="minor___v$(update_minor)"
- OP_PATCH="patch___v$(update_patch)"
- OPTIONS=("$OP_MAJOR" "$OP_MINOR" "$OP_PATCH")
- select choice in "${OPTIONS[@]}"; do
- case $choice in
- "$OP_MAJOR")
- MAJOR=$((MAJOR + 1))
- MINOR=0
- PATCH=0
- break
- ;;
- "$OP_MINOR")
- MINOR=$((MINOR + 1))
- PATCH=0
- break
- ;;
- "$OP_PATCH")
- PATCH=$((PATCH + 1))
- break
- ;;
- *)
- error_close "invalid option $REPLY"
- ;;
- esac
- done
-}
-
-# run all tests
-cargo_test() {
- cargo test -- --test-threads=1
- ask_continue
-}
-
-# Simulate publishing to crates.io
-cargo_publish_dry_run() {
- echo -e "${PURPLE}cargo publish --dry-run${RESET}"
- cargo publish --dry-run
- ask_continue
-}
-
-# Check to see if cross is installed - if not then install
-check_cross() {
- if ! [ -x "$(command -v cross)" ]; then
- echo -e "${GREEN}cargo install cross${RESET}"
- cargo install cross
- fi
-}
-
-# Build, using cross-rs, for linux x86 musl
-cross_build_x86_linux() {
- check_cross
- echo -e "${YELLOW}cross build --target x86_64-unknown-linux-musl --release${RESET}"
- cross build --target x86_64-unknown-linux-musl --release
-}
-
-# Build, using cross-rs, for linux arm64 musl
-cross_build_aarch64_linux() {
- check_cross
- echo -e "${YELLOW}cross build --target aarch64-unknown-linux-musl --release${RESET}"
- cross build --target aarch64-unknown-linux-musl --release
-}
-
-# Build, using cross-rs, for linux armv6 musl
-cross_build_armv6_linux() {
- check_cross
- echo -e "${YELLOW}cross build --target arm-unknown-linux-musleabihf --release${RESET}"
- cross build --target arm-unknown-linux-musleabihf --release
-}
-
-# Build, using cross-rs, for windows x86
-cross_build_x86_windows() {
- check_cross
- echo -e "${YELLOW}cross build --target x86_64-pc-windows-gnu --release${RESET}"
- cross build --target x86_64-pc-windows-gnu --release
-}
-
-# Build, using zig-build, for Apple silicon
-zig_build_aarch64_apple() {
- # mkdir /workspace/oxker/target
- echo -e "${YELLOW}docker run --rm -v $(pwd):/io -w /io ghcr.io/rust-cross/cargo-zigbuild bash -e -c 'rustup update stable && rustup default stable && rustup target add aarch64-apple-darwin && cargo zigbuild --release --target aarch64-apple-darwin${RESET}"
-
- docker run --rm -v "$(pwd):/io" -w /io \
- ghcr.io/rust-cross/cargo-zigbuild \
- bash -ec 'rustup update stable && rustup default stable && rustup target add aarch64-apple-darwin && cargo zigbuild --release --target aarch64-apple-darwin'
-
- if ask_yn "sudo chown $(pwd)/target"; then
- echo -e "${YELLOW}sudo chown -R vscode:vscode $(pwd)/target${RESET}"
- sudo chown -R vscode:vscode "$(pwd)/target"
- fi
-}
-
-cargo_clean() {
- echo -e "${YELLOW}cargo clean${RESET}"
- cargo clean
-}
-
-# Build all releases that GitHub workflow would
-# This will download GB's of docker images
-# $1 is 0 or 1, if 1 won't run ask_continue
-cross_build_all() {
- if ask_yn "cargo clean"; then
- cargo_clean
- fi
- skip_confirm=$1
- cross_build_armv6_linux
- [ "$skip_confirm" -ne 1 ] && ask_continue
- cross_build_aarch64_linux
- [ "$skip_confirm" -ne 1 ] && ask_continue
- cross_build_x86_linux
- [ "$skip_confirm" -ne 1 ] && ask_continue
- cross_build_x86_windows
- [ "$skip_confirm" -ne 1 ] && ask_continue
- zig_build_aarch64_apple
- [ "$skip_confirm" -ne 1 ] && ask_continue
-}
-
-# $1 text to colourise
-release_continue() {
- echo -e "\n${PURPLE}$1${RESET}"
- ask_continue
-}
-
-# Check repository for typos
-check_typos() {
- echo -e "\n${PURPLE}check typos${RESET}"
- typos
- ask_continue
-}
-
-# Make sure the unused lint isn't used
-check_allow_unused() {
- matches_any=$(find . -type d \( -name .git -o -name target \) -prune -o -type f -exec grep -lE '^#!\[allow\(unused\)\]$' {} +)
- matches_cargo=$(grep "^unused = \"allow\"" ./Cargo.toml)
- if [ -n "$matches_any" ]; then
- echo "\"#[allow(unused)]\" in ${matches_any}"
- ask_continue
- elif [ -n "$matches_cargo" ]; then
- echo "\"unused = \"allow\"\" in Cargo.toml"
- ask_continue
- fi
-}
-
-# build container for amd64 platform
-build_container_amd64() {
- echo -e "${YELLOW}docker build --platform linux/amd64 --no-cache -t oxker_amd64 --no-cache -f containerised/Dockerfile .; docker save -o /tmp/oxker_amd64.tar oxker_amd64${RESET}"
- docker build --platform linux/amd64 --no-cache -t oxker_amd64 -f containerised/Dockerfile .
- docker save -o /tmp/oxker_amd64.tar oxker_amd64
-}
-
-# build container for aarm64 platform
-build_container_arm64() {
- echo -e "${YELLOW}docker build --platform linux/arm64 --no-cache -t oxker_arm64 --no-cache -f containerised/Dockerfile .; docker save -o /tmp/oxker_arm64.tar oxker_arm64${RESET}"
- docker build --platform linux/arm64 --no-cache -t oxker_arm64 -f containerised/Dockerfile .
- docker save -o /tmp/oxker_arm64.tar oxker_arm64
-}
-
-# build container for armv6 platform
-build_container_armv6() {
- echo -e "${YELLOW}docker build --platform linux/arm/v6 --no-cache -t oxker_armv6 --no-cache -f containerised/Dockerfile .; docker save -o /tmp/oxker_armv6.tar oxker_armv6${RESET}"
- docker build --platform linux/arm/v6 --no-cache -t oxker_armv6 -f containerised/Dockerfile .
- docker save -o /tmp/oxker_armv6.tar oxker_armv6
-}
-
-# Build all the containers, this get executed in the github action
-# $1 is 0 or 1, if 1 won't run ask_continue
-build_container_all() {
- skip_confirm=$1
- build_container_amd64
- [ "$skip_confirm" -ne 1 ] && ask_continue
- build_container_arm64
- [ "$skip_confirm" -ne 1 ] && ask_continue
- build_container_armv6
- [ "$skip_confirm" -ne 1 ] && ask_continue
-}
-
-# Full flow to create a new release
-release_flow() {
- check_allow_unused
- check_typos
-
- check_git
- get_git_remote_url
-
- cargo_test
- cross_build_all 0
- build_container_all 0
- cargo_publish_dry_run
-
- cd "${CWD}" || error_close "Can't find ${CWD}"
- check_tag
-
- NEW_TAG_WITH_V="v${MAJOR}.${MINOR}.${PATCH}"
- printf "\nnew tag chosen: %s\n\n" "${NEW_TAG_WITH_V}"
-
- RELEASE_BRANCH=release-$NEW_TAG_WITH_V
- echo -e
- ask_changelog_update
-
- release_continue "checkout ${RELEASE_BRANCH}"
- git checkout -b "$RELEASE_BRANCH"
-
- release_continue "update_version_number_in_files"
- update_version_number_in_files
-
- echo -e "\ncargo fmt"
- cargo fmt
-
- echo -e "\n${PURPLE}cargo check${RESET}\n"
- cargo check
-
- release_continue "git add ."
- git add .
-
- release_continue "git commit -m \"chore: release \"${NEW_TAG_WITH_V}\""
- git commit -m "chore: release ${NEW_TAG_WITH_V}"
-
- release_continue "git checkout main"
- git checkout main
-
- echo -e "${PURPLE}git pull origin main${RESET}"
- git pull origin main
-
- echo -e "${PURPLE}git merge --no-ff \"${RELEASE_BRANCH}\" -m \"chore: merge ${RELEASE_BRANCH} into main\"${RESET}"
- git merge --no-ff "$RELEASE_BRANCH" -m "chore: merge ${RELEASE_BRANCH} into main"
-
- echo -e "\n${PURPLE}cargo check${RESET}\n"
- cargo check
-
- release_continue "git tag -am \"${RELEASE_BRANCH}\" \"$NEW_TAG_WITH_V\""
- git tag -am "${RELEASE_BRANCH}" "$NEW_TAG_WITH_V"
-
- release_continue "git push --atomic origin main \"$NEW_TAG_WITH_V\""
- git push --atomic origin main "$NEW_TAG_WITH_V"
-
- release_continue "git checkout dev"
- git checkout dev
-
- release_continue "git merge --no-ff main -m \"chore: merge main into dev\""
- git merge --no-ff main -m "chore: merge main into dev"
-
- release_continue "git push origin dev"
- git push origin dev
-
- release_continue "git branch -d \"$RELEASE_BRANCH\""
- git branch -d "$RELEASE_BRANCH"
-}
-
-build_choice() {
- cmd=(dialog --backtitle "Choose option" --keep-tite --radiolist "choose" 14 80 16)
- options=(
- 1 "x86 musl linux" off
- 2 "aarch64 musl linux" off
- 3 "armv6 musl linux" off
- 4 "aarch64 apple" off
- 5 "x86 windows" off
- 6 "all" off
- 7 "all automatic" off
- )
- choices=$("${cmd[@]}" "${options[@]}" 2>&1 >/dev/tty)
- exitStatus=$?
- if [ $exitStatus -ne 0 ]; then
- exit
- fi
- for choice in $choices; do
- case $choice in
- 0)
- exit
- ;;
- 1)
- cross_build_x86_linux
- exit
- ;;
- 2)
- cross_build_aarch64_linux
- exit
- ;;
- 3)
- cross_build_armv6_linux
- exit
- ;;
- 4)
- zig_build_aarch64_apple
- exit
- ;;
- 5)
- cross_build_x86_windows
- exit
- ;;
- 6)
- cross_build_all 0
- exit
- ;;
- 7)
- cross_build_all 1
- exit
- ;;
- esac
- done
-}
-
-build_container_choice() {
- cmd=(dialog --backtitle "Choose option" --keep-tite --radiolist "choose" 14 80 16)
- options=(
- 1 "x86 " off
- 2 "aarch64" off
- 3 "armv6" off
- 4 "all" off
- 5 "all automatic" off
- )
- choices=$("${cmd[@]}" "${options[@]}" 2>&1 >/dev/tty)
- exitStatus=$?
- if [ $exitStatus -ne 0 ]; then
- exit
- fi
- for choice in $choices; do
- case $choice in
- 0)
- exit
- ;;
- 1)
- build_container_amd64
- exit
- ;;
- 2)
- build_container_arm64
- exit
- ;;
- 3)
- build_container_armv6
- exit
- ;;
- 4)
- build_container_all 0
- exit
- ;;
- 5)
- build_container_all 1
- exit
- ;;
- esac
- done
-
-}
-
-main() {
- cmd=(dialog --backtitle "Choose option" --keep-tite --radiolist "choose" 14 80 16)
- options=(
- 1 "test" off
- 2 "release" off
- 3 "build" off
- 4 "docker builds" off
- )
- choices=$("${cmd[@]}" "${options[@]}" 2>&1 >/dev/tty)
- exitStatus=$?
- if [ $exitStatus -ne 0 ]; then
- exit
- fi
- for choice in $choices; do
- case $choice in
- 0)
- exit
- ;;
- 1)
- cargo_test
- main
- break
- ;;
- 2)
- release_flow
- break
- ;;
- 3)
- build_choice
- main
- break
- ;;
- 4)
- build_container_choice
- main
- break
- ;;
- esac
- done
-}
-
-main
diff --git a/docker/Dockerfile.unhealthy b/docker/Dockerfile.unhealthy
deleted file mode 100644
index 4a6d10a..0000000
--- a/docker/Dockerfile.unhealthy
+++ /dev/null
@@ -1,17 +0,0 @@
-# Use an official lightweight image as a base
-FROM alpine:latest
-
-# Install a simple utility (e.g., curl) to run as a health check
-RUN apk --no-cache add curl speedtest-cli
-
-# Create a dummy file that we will use in our health check
-RUN touch /tmp/healthy
-
-# Define a simple health check
-HEALTHCHECK --interval=5s --timeout=3s --retries=3 \
- CMD [ ! -f /tmp/healthy ] || exit 1
-
-# Start a basic loop that keeps the container running
-CMD ["sh", "-c", "speedtest-cli; while :; do >&2 echo 'Container is running but will be unhealthy (also printing to stderr)'; sleep 30; done"]
-
-# docker build -t unhealthy-container . -f Dockerfile.unhealthy; docker run -d --name unhealthy unhealthy-container
\ No newline at end of file
diff --git a/docker/docker-compose.yml b/docker/docker-compose.yml
deleted file mode 100644
index 2ef1418..0000000
--- a/docker/docker-compose.yml
+++ /dev/null
@@ -1,58 +0,0 @@
-
-networks:
- oxker-example-net:
- name: oxker-examaple-net
-services:
- postgres:
- image: postgres:18-alpine
- container_name: postgres
- environment:
- - POSTGRES_PASSWORD=never_use_this_password_in_production
- ipc: private
- restart: always
- shm_size: 256MB
- networks:
- - oxker-example-net
- deploy:
- resources:
- limits:
- memory: 1024M
- redis:
- image: redis:latest
- container_name: redis
- ipc: private
- restart: always
- networks:
- - oxker-example-net
- deploy:
- resources:
- limits:
- memory: 384M
- rabbitmq:
- image: rabbitmq:3
- container_name: rabbitmq
- ipc: private
- restart: always
- networks:
- - oxker-example-net
- deploy:
- resources:
- limits:
- memory: 512M
- some_container:
- container_name: some_container
- image: some_container
- build:
- context: .
- dockerfile: Dockerfile.unhealthy
- ipc: private
- restart: always
- networks:
- - oxker-example-net
- deploy:
- resources:
- limits:
- memory: 128M
-
-
-
diff --git a/example_config/example.config.jsonc b/example_config/example.config.jsonc
deleted file mode 100644
index db1251f..0000000
--- a/example_config/example.config.jsonc
+++ /dev/null
@@ -1,372 +0,0 @@
-{
- // Example JSONC config file
- // This needs to be renamed to "config.jsonc" ("config.json" will also work, even if the file is actually a jsonc) in order for oxker to automatically load
- // oxker will also read .toml and .json files which use the same key/value structure & format as this file
- // Every key is optional, with defaults that oxker will choose if missing or invalid
- // The `--config-file` cli argument can be used to load configuration files from any readable location
- // Docker update interval in ms, minimum effectively 1000
- "docker_interval": 1000,
- // Attempt to colorize the logs, conflicts with "raw"
- "color_logs": false,
- // Show raw logs, default is to remove ansi formatting, conflicts with "color"
- "raw_logs": false,
- // Show self (the oxker container) when running as a docker container
- "show_self": false,
- // Show std_err in logs
- "show_std_err": true,
- // Show a timestamp for every log entry
- "show_timestamp": true,
- // Don't draw gui - for debugging - mostly pointless
- "gui": true,
- // Docker host location. Will take priority over a DOCKER_HOST env.
- // "host": "/var/run/docker.sock",
- // Display the timestamp in a custom format, if given option is invalid, it will default to %Y-%m-%dT%H:%M:%S.%8f -> 2025-02-18T12:34:56.01234567
- // *Should* accept any valid strftime string up to 32 chars, see https://strftime.org/
- "timestamp_format": "%Y-%m-%dT%H:%M:%S.%8f",
- // Display the container logs timestamp with a given timezone, if timezone is unknown, defaults to UTC
- "timezone": "Etc/UTC",
- // Directory for saving exported logs, defaults to `$HOME`, this is automatically *correctly* calculated for Linux, Mac, and Windows
- // "save_dir": "$HOME",
- // Force use of docker cli when execing into containers, honestly mostly pointless
- "use_cli": false,
- // Show the logs section - this can be changed during operation with the log_section_toggle key
- "show_logs": true,
- // Use case-sensitive matching for logs
- "log_search_case_sensitive": true,
- //////////////////
- // Custom Keymap //
- //////////////////
- // Available keys are;
- // 1) a-z and A-Z
- // 2) 0-9
- // WARNING if using the \ key, it needs to be escaped, e.g. "log_section_toggle": ["\\"]
- // 3) / \ , . # ' [ ] ; = -
- // 3) F1-F12
- // 4) backspace, tab, backtab, delete, end, esc, home, insert, pagedown, pageup, left, right, up, down
- // Each definition can have two keys associated with it
- // WARNING "scroll_many" only accepts control, alt, shift, with no secondary option
- // If any key clashes are found, oxker will revert to it's default keymap
- "keymap": {
- // Clear any popup boxes, filter panel, or help panel
- "clear": [
- "c",
- "esc"
- ],
- // Cancel delete - clear also works here
- "delete_deny": [
- "n"
- ],
- // Confirm Delete
- "delete_confirm": [
- "y"
- ],
- // Exec into the selected container
- "exec": [
- "e"
- ],
- // Enter filter mode
- "filter_mode": [
- "/",
- "F1"
- ],
- // Enter log search mode
- "log_search_mode": [
- "#"
- ],
- // Quit at anytime
- "quit": [
- "q"
- ],
- // Save logs of selected container to file on disk
- "save_logs": [
- "s"
- ],
- // Scroll down a list by one item
- "scroll_down": [
- "down",
- "j"
- ],
- // Scroll down to the end of a list
- "scroll_end": [
- "end"
- ],
- // Modifier to scroll by 10 lines instead of one, used in conjunction with scroll_up/scroll_down
- "scroll_many": [
- "control"
- ],
- // Scroll up to the start of a list
- "scroll_start": [
- "home"
- ],
- // Scroll up a list by one item
- "scroll_up": [
- "up",
- "k"
- ],
- // Horizontal scroll of the logs
- "scroll_forward": [
- "right"
- ],
- "scroll_back": [
- "left"
- ],
- // Select next panel
- "select_next_panel": [
- "tab"
- ],
- // Select previous panel
- "select_previous_panel": [
- "backtab"
- ],
- // Sort the containers based on specific column
- "sort_by_name": [
- "1"
- ],
- "sort_by_state": [
- "2"
- ],
- "sort_by_status": [
- "3"
- ],
- "sort_by_cpu": [
- "4"
- ],
- "sort_by_memory": [
- "5"
- ],
- "sort_by_id": [
- "6"
- ],
- "sort_by_image": [
- "7"
- ],
- "sort_by_rx": [
- "8"
- ],
- "sort_by_tx": [
- "9"
- ],
- // Reset the sorted containers
- "sort_reset": [
- "0"
- ],
- // Toggle the help panel
- "toggle_help": [
- "h"
- ],
- // Toggle mouse capture
- "toggle_mouse_capture": [
- "m"
- ],
- // Reduce the height of the logs list section
- "log_section_height_decrease": [
- "-"
- ],
- // Increase the height of the logs list section
- "log_section_height_increase": [
- "+"
- ],
- // Toggle visibility of the log section
- "log_section_toggle": [
- "\\"
- ],
- // Toggle to inspect container screen
- "inspect": [
- "i"
- ],
- // Force a complete clear & redraw of the screen
- "force_redraw": [
- "f"
- ]
- },
- ////////////////////
- // Custom Colors //
- ////////////////////
- // Colors be listed as either;
- // 1) named ANSI: 'red', case insensitive, see https://en.wikipedia.org/wiki/ANSI_escape_code#Colors
- // 2) Hex values: '#FF0000', case insensitive
- // 3) 'reset' for transparency
- // Some background/foreground combinations don't work, I *think* this is an issue/feature of ratatui - but I may have just made a mistake somewhere
- "colors": {
- // The single line bar at the uppermost of the display. Contains name/state/status headings etc
- "headers_bar": {
- // Background color of the entire line
- "background": "magenta",
- // Animated loading icon at the start of the bar
- "loading_spinner": "white",
- // Text color
- "text": "black",
- // Text color of a selected header
- "text_selected": "gray"
- },
- // The borders around the selectable panels - Containers, Commands, Logs
- "borders": {
- // Border when selected
- "selected": "lightcyan",
- // Border when not selected
- "unselected": "grey"
- },
- // The containers sections, in the future more color customization options should be made available in this section
- "containers": {
- // The icon use to illustrate which container is currently selected
- "icon": "white",
- // Background color of panel
- "background": "reset",
- // At the moment, this will only change the color of the name, id, and image columns
- "text": "blue",
- // Text color of the RX column
- "text_rx": "#FFE9C1",
- // Text color of the TX column
- "text_tx": "#CD8C8C"
- },
- // Each state of a container has a color, which is used in multiple places, i.e. chart titles, state/status/cpu/memory columns in the container section
- "container_state": {
- "dead": "red",
- "exited": "red",
- "paused": "yellow",
- "removing": "lightred",
- "restarting": "lightgreen",
- "running_healthy": "green",
- "running_unhealthy": "#FFB224",
- "unknown": "red"
- },
- // The color the of Docker commands available for each container
- "commands": {
- // Background color of panel
- "background": "reset",
- "pause": "yellow",
- "restart": "magenta",
- "stop": "red",
- "delete": "gray",
- "resume": "blue",
- "start": "green"
- },
- // The cpu chart
- "chart_cpu": {
- // Background color of panel
- "background": "reset",
- // Border color
- "border": "white",
- // Chart title
- "title": "green",
- // Maximum CPU percentage
- "max": "#FFB224",
- // Points on the chart
- "points": "magenta",
- // The charts y-axis
- "y_axis": "white"
- },
- // The memory chart
- "chart_memory": {
- // Background color of panel
- "background": "reset",
- // Border color
- "border": "white",
- // Chart title
- "title": "green",
- // Maximum memory use
- "max": "#FFB224",
- // Points on the chart
- "points": "cyan",
- // The charts y-axis
- "y_axis": "white"
- },
- // The ports chart
- "chart_ports": {
- // Background color of panel
- "background": "reset",
- // Border color
- "border": "white",
- // Chart title
- "title": "green",
- // Private/Public/IP headings
- "headings": "yellow",
- // Ports & IP listing text
- "text": "white"
- },
- // The bandwidth chart
- "chart_bandwidth": {
- //Background color of panel
- "background": "reset",
- // Border color
- "border": "white",
- // Maximum RX value - again paused & stopped colors not yet customizable
- "max_rx": "#FFE9C1",
- // # Maximum TX value - again paused & stopped colors not yet customizable
- "max_tx": "#CD8C8C",
- // RX points on the chart - again paused & stopped colors not yet customizable
- "points_rx": "#FFE9C1",
- // TX points on the chart - again paused & stopped colors not yet customizable
- "points_tx": "#CD8C8C",
- // RX title color
- "title_rx": "#FFE9C1",
- // TX title color
- "title_tx": "#CD8C8C",
- // The charts y-axis
- "y_axis": "white"
- },
- // The filter panel
- "filter": {
- // Background color of panel
- "background": "reset",
- // color of text
- "text": "gray",
- // background color of the selected filter by item (Name/Image/Status/All)
- "selected_filter_background": "gray",
- // text color of the selected filter by item (Name/Image/Status/All)
- "selected_filter_text": "black",
- // Highlighted text color
- "highlight": "magenta"
- },
- // The log search panel
- "log_search": {
- // Background color of panel
- "background": "reset",
- // color of text
- "text": "gray",
- // text color of the buttons text
- "button_text": "black",
- // Highlighted text color
- "highlight": "magenta"
- },
- // The logs panel, will only be applied if color_logs is false
- "logs": {
- // Background color of panel
- "background": "reset",
- // text color
- "text": "reset"
- },
- // The help popup
- "popup_help": {
- // Background color
- "background": "magenta",
- // Text color
- "text": "black",
- // Highlighted text color
- "text_highlight": "white"
- },
- // The info popup - used to display small messages - such as saving logs to disk, or change of mouse capture settings
- "popup_info": {
- // Background color
- "background": "blue",
- // Text color
- "text": "white"
- },
- // The delete popup - used to display a confirmation warning when about to delete a container
- "popup_delete": {
- // Background color
- "background": "white",
- // Text color
- "text": "black",
- // Highlighted text color
- "text_highlight": "red"
- },
- // The error popup - hopefully you'll never have to see this
- "popup_error": {
- // Background color
- "background": "red",
- // Text color
- "text": "white"
- }
- }
-}
\ No newline at end of file
diff --git a/example_config/example.config.toml b/example_config/example.config.toml
deleted file mode 100644
index 1b1a0c1..0000000
--- a/example_config/example.config.toml
+++ /dev/null
@@ -1,323 +0,0 @@
-# oxker config file
-# oxker will also read .jsonc and .json files which use the same key/value structure & format as this file
-# Every key is optional, with defaults that oxker will choose if missing or invalid
-# The `--config-file` cli argument can be used to load configuration files from any readable location
-
-# Docker update interval in ms, minimum effectively 1000
-docker_interval = 1000
-
-# Attempt to colorize the logs, conflicts with "raw"
-color_logs = false
-
-# Show raw logs, default is to remove ansi formatting, conflicts with "color"
-raw_logs = false
-
-# Show self (the oxker container) when running as a docker container
-show_self = false
-
-# Show std_err in logs
-show_std_err = true
-
-# Show a timestamp for every log entry
-show_timestamp = true
-
-# Don't draw gui - for debugging - mostly pointless
-gui = true
-
-# Docker host location. Will take priority over a DOCKER_HOST env.
-# host = "/var/run/docker.sock"
-
-# Display the container logs timestamp with a given timezone, if timezone is unknown, defaults to UTC
-timezone = "Etc/UTC"
-
-# Display the timestamp in a custom format, if given option is invalid, it will default to %Y-%m-%dT%H:%M:%S.%8f -> 2025-02-18T12:34:56.012345678Z
-# *Should* accept any valid strftime string up to 32 chars, see https://strftime.org/
-timestamp_format = "%Y-%m-%dT%H:%M:%S.%8f"
-
-# Directory for saving exported logs, defaults to `$HOME`, this is automatically *correctly* calculated for Linux, Mac, and Windows
-# save_dir = "$HOME"
-
-# Force use of docker cli when execing into containers, honestly mostly pointless
-use_cli = false
-
-# Show the logs section - this can be changed during operation with the log_section_toggle key
-show_logs = true
-
-# Use case-sensitive matching for logs
-log_search_case_sensitive = true
-
-#################
-# Custom Keymap #
-#################
-
-# Available keys are;
-# 1) a-z and A-Z
-# 2) 0-9
-# WARNING if using the \ key, it needs to be escaped, e.g. log_section_toggle = ["\\"]
-# 3) / \ , . # ' [ ] ; = -
-# 3) F1-F12
-# 4) backspace, tab, backtab, delete, end, esc, home, insert, pagedown, pageup, left, right, up, down
-
-# Each definition can have two keys associated with it
-
-# WARNING "scroll_many" only accepts control, alt, shift, with no secondary option
-
-# If any key clashes are found, oxker will revert to it's default keymap
-
-[keymap]
-# Clear any popup boxes, filter panel, or help panel
-clear = ["c", "esc"]
-# Cancel delete - clear also works here
-delete_deny = ["n"]
-# Confirm Delete
-delete_confirm = ["y"]
-# Exec into the selected container
-exec = ["e"]
-# Enter filter mode
-filter_mode = ["/", "F1"]
-
-# Enter log search mode
-log_search_mode = ["#"]
-
-# Quit at anytime
-quit = ["q"]
-# Save logs of selected container to file on disk
-save_logs = ["s"]
-# scroll down a list by one item
-scroll_down = ["down", "j"]
-
-# scroll down to the end of a list
-scroll_end = ["end"]
-# Modifier to scroll by 10 lines instead of one, used in conjunction with scroll_up/scroll_down
-scroll_many = ["control"]
-# scroll up to the start of a list
-scroll_start = ["home"]
-# scroll up a list by one item
-scroll_up = ["up", "k"]
-# Horizontal scroll of the logs
-scroll_forward = ["right"]
-scroll_back = ["left"]
-# Select next panel
-select_next_panel = ["tab"]
-# Select previous panel
-select_previous_panel = ["backtab"]
-# Sort the containers based on specific column
-sort_by_name = ["1"]
-sort_by_state = ["2"]
-sort_by_status = ["3"]
-sort_by_cpu = ["4"]
-sort_by_memory = ["5"]
-sort_by_id = ["6"]
-sort_by_image = ["7"]
-sort_by_rx = ["8"]
-sort_by_tx = ["9"]
-# Reset the sorted containers
-sort_reset = ["0"]
-# Toggle the help panel
-toggle_help = ["h"]
-# Toggle mouse capture
-toggle_mouse_capture = ["m"]
-# Reduce the height of the logs list section
-log_section_height_decrease = ["-"]
-log_section_height_increase = ["+"]
-# Toggle visibility of the log section
-log_section_toggle = ["\\"]
-# Toggle to inspect container screen
-inspect = ["i"]
-
-
-
-# Force a complete clear & redraw of the screen
-force_redraw = ["f"]
-
-#################
-# Custom Colors #
-#################
-
-# Colors be listed as either;
-# 1) named ANSI: 'red', case insensitive, see https://en.wikipedia.org/wiki/ANSI_escape_code#Colors
-# 2) Hex values: '#FF0000', case insensitive
-# 3) 'reset' for transparency
-
-# Some background/foreground combinations don't work, I *think* this is an issue/feature of ratatui - but I may have just made a mistake somewhere
-
-# The single line bar at the uppermost of the display. Contains name/state/status headings etc
-[colors.headers_bar]
-# Background color of the entire line
-background = "magenta"
-# Animated loading icon at the start of the bar
-loading_spinner = "white"
-# Text color
-text = "black"
-# Text color of a selected header
-text_selected = "gray"
-
-# The borders around the selectable panels - Containers, Commands, Logs
-[colors.borders]
-# Border when selected
-selected = "lightcyan"
-# Border when not selected
-unselected = "grey"
-
-# The containers sections, in the future more color customization options should be made available in this section
-[colors.containers]
-# The icon use to illustrate which container is currently selected - at the moment the TUI library, ratatui, doesn't seem allow changing the color of the highlight symbol
-icon = "white"
-# Background color of panel
-background = "reset"
-# At the moment, this will only change the color of the name, id, and image columns
-text = "blue"
-# Text color of the RX column
-text_rx = "#FFE9C1"
-# Text color of the TX column
-text_tx = "#CD8C8C"
-
-# The logs panel, will only be applied if color_logs is false
-[colors.logs]
-# Background color of panel
-background = "reset"
-# text color
-text = "reset"
-
-# Each state of a container has a color, which is used in multiple places, i.e. chart titles, state/status/cpu/memory columns in the container section
-[colors.container_state]
-dead = "red"
-exited = "red"
-paused = "yellow"
-removing = "lightred"
-restarting = "lightgreen"
-running_healthy = "green"
-running_unhealthy = "#FFB224"
-unknown = "red"
-
-# The filter panel
-[colors.filter]
-# Background color of panel
-background = "reset"
-# color of text
-text = "gray"
-# background color of the selected filter by item (Name/Image/Status/All)
-selected_filter_background = "gray"
-# text color of the selected filter by item (Name/Image/Status/All)
-selected_filter_text = "black"
-# Highlighted text color
-highlight = "magenta"
-
-
-# The log search panel
-[colors.log_search]
-# Background color of panel
-background = "reset"
-# color of text
-text = "gray"
-# text color of the buttons text
-button_text = "black"
-# Highlighted text color
-highlight = "magenta"
-
-# The color the of Docker commands available for each container
-[colors.commands]
-# Background color of panel
-background = "reset"
-pause = "yellow"
-restart = "magenta"
-stop = "red"
-delete = "gray"
-resume = "blue"
-start = "green"
-
-# The cpu chart
-[colors.chart_cpu]
-# Background color of panel
-background = "reset"
-# Border color
-border = "white"
-# Chart title - only whilst container is running, paused & stopped colors not yet customizable - or could just use state color?
-title = "green"
-# Maximum CPU percentage - again paused & stopped colors not yet customizable
-max = "#FFB224"
-# Points on the chart - again paused & stopped colors not yet customizable
-points = "magenta"
-# The charts y-axis
-y_axis = "white"
-
-# The memory chart
-[colors.chart_memory]
-# Background color of panel
-background = "reset"
-# Border color
-border = "white"
-# Chart title - only whilst container is running, paused & stopped will use colors.container_state
-title = "green"
-# Maximum memory use - again paused & stopped will use colors.container_state
-max = "#FFB224"
-# Points on the chart - again paused & stopped will use colors.container_state
-points = "cyan"
-# The charts y-axis
-y_axis = "white"
-
-# The bandwidth chart
-[colors.chart_bandwidth]
-# Background color of panel
-background = "reset"
-# Border color
-border = "white"
-# Maximum RX value - again paused & stopped colors not yet customizable
-max_rx = "#FFE9C1"
-# Maximum TX value - again paused & stopped colors not yet customizable
-max_tx = "#CD8C8C"
-# RX points on the chart - again paused & stopped colors not yet customizable
-points_rx = "#FFE9C1"
-# TX points on the chart - again paused & stopped colors not yet customizable
-points_tx = "#CD8C8C"
-# TX title color
-title_tx = "#FFE9C1"
-# RX title color
-title_rx = "#CD8C8C"
-# The charts y-axis
-y_axis = "white"
-
-# The ports chart
-[colors.chart_ports]
-# Background color of panel
-background = "reset"
-# Border color
-border = "white"
-# Chart title - only whilst container is running, paused & stopped will use colors.container_state
-title = "green"
-# Private/Public/IP headings
-headings = "yellow"
-# Ports & IP listing text
-text = "white"
-
-# The help popup
-[colors.popup_help]
-# Background color
-background = "magenta"
-# Text color
-text = "black"
-# Highlighted text color
-text_highlight = "white"
-
-# The info popup - used to display small messages - such as saving logs to disk, or change of mouse capture settings
-[colors.popup_info]
-# Background color
-background = "blue"
-# Text color
-text = "white"
-
-# The delete popup - used to display a confirmation warning when about to delete a container
-[colors.popup_delete]
-# Background color
-background = "white"
-# Text color
-text = "black"
-# Highlighted text color
-text_highlight = "red"
-
-# The error popup - hopefully you'll never have to see this
-[colors.popup_error]
-# Background color
-background = "red"
-# Text color
-text = "white"
diff --git a/go.mod b/go.mod
new file mode 100644
index 0000000..0f757aa
--- /dev/null
+++ b/go.mod
@@ -0,0 +1,63 @@
+module github.com/oxker/oxker
+
+go 1.24.4
+
+require (
+ charm.land/bubbletea/v2 v2.0.2
+ github.com/BurntSushi/toml v1.3.2
+ github.com/charmbracelet/lipgloss v1.1.0
+ github.com/creack/pty v1.1.24
+ github.com/docker/docker v28.5.2+incompatible
+ github.com/hinshun/vt10x v0.0.0-20220301184237-5011da428d02
+ github.com/olekukonko/tablewriter v0.0.5
+)
+
+require (
+ github.com/Microsoft/go-winio v0.6.2 // indirect
+ github.com/aymanbagabas/go-osc52/v2 v2.0.1 // indirect
+ github.com/aymanbagabas/go-udiff v0.3.1 // indirect
+ github.com/cespare/xxhash/v2 v2.3.0 // indirect
+ github.com/charmbracelet/colorprofile v0.4.1 // indirect
+ github.com/charmbracelet/ultraviolet v0.0.0-20260205113103-524a6607adb8 // indirect
+ github.com/charmbracelet/x/ansi v0.11.6 // indirect
+ github.com/charmbracelet/x/cellbuf v0.0.15 // indirect
+ github.com/charmbracelet/x/term v0.2.2 // indirect
+ github.com/charmbracelet/x/termios v0.1.1 // indirect
+ github.com/charmbracelet/x/windows v0.2.2 // indirect
+ github.com/clipperhouse/displaywidth v0.9.0 // indirect
+ github.com/clipperhouse/stringish v0.1.1 // indirect
+ github.com/clipperhouse/uax29/v2 v2.5.0 // indirect
+ github.com/containerd/errdefs v1.0.0 // indirect
+ github.com/containerd/errdefs/pkg v0.3.0 // indirect
+ github.com/containerd/log v0.1.0 // indirect
+ github.com/distribution/reference v0.6.0 // indirect
+ github.com/docker/go-connections v0.6.0 // indirect
+ github.com/docker/go-units v0.5.0 // indirect
+ github.com/felixge/httpsnoop v1.0.4 // indirect
+ github.com/go-logr/logr v1.4.3 // indirect
+ github.com/go-logr/stdr v1.2.2 // indirect
+ github.com/lucasb-eyer/go-colorful v1.3.0 // indirect
+ github.com/mattn/go-isatty v0.0.20 // indirect
+ github.com/mattn/go-runewidth v0.0.19 // indirect
+ github.com/moby/docker-image-spec v1.3.1 // indirect
+ github.com/moby/sys/atomicwriter v0.1.0 // indirect
+ github.com/moby/term v0.5.2 // indirect
+ github.com/morikuni/aec v1.1.0 // indirect
+ github.com/muesli/cancelreader v0.2.2 // indirect
+ github.com/muesli/termenv v0.16.0 // indirect
+ github.com/opencontainers/go-digest v1.0.0 // indirect
+ github.com/opencontainers/image-spec v1.1.1 // indirect
+ github.com/pkg/errors v0.9.1 // indirect
+ github.com/rivo/uniseg v0.4.7 // indirect
+ github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e // indirect
+ go.opentelemetry.io/auto/sdk v1.2.1 // indirect
+ go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.66.0 // indirect
+ go.opentelemetry.io/otel v1.41.0 // indirect
+ go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.34.0 // indirect
+ go.opentelemetry.io/otel/metric v1.41.0 // indirect
+ go.opentelemetry.io/otel/trace v1.41.0 // indirect
+ golang.org/x/sync v0.19.0 // indirect
+ golang.org/x/sys v0.41.0 // indirect
+ golang.org/x/time v0.14.0 // indirect
+ gotest.tools/v3 v3.5.2 // indirect
+)
diff --git a/go.sum b/go.sum
new file mode 100644
index 0000000..23c937f
--- /dev/null
+++ b/go.sum
@@ -0,0 +1,157 @@
+charm.land/bubbletea/v2 v2.0.2 h1:4CRtRnuZOdFDTWSff9r8QFt/9+z6Emubz3aDMnf/dx0=
+charm.land/bubbletea/v2 v2.0.2/go.mod h1:3LRff2U4WIYXy7MTxfbAQ+AdfM3D8Xuvz2wbsOD9OHQ=
+github.com/Azure/go-ansiterm v0.0.0-20250102033503-faa5f7b0171c h1:udKWzYgxTojEKWjV8V+WSxDXJ4NFATAsZjh8iIbsQIg=
+github.com/Azure/go-ansiterm v0.0.0-20250102033503-faa5f7b0171c/go.mod h1:xomTg63KZ2rFqZQzSB4Vz2SUXa1BpHTVz9L5PTmPC4E=
+github.com/BurntSushi/toml v1.3.2 h1:o7IhLm0Msx3BaB+n3Ag7L8EVlByGnpq14C4YWiu/gL8=
+github.com/BurntSushi/toml v1.3.2/go.mod h1:CxXYINrC8qIiEnFrOxCa7Jy5BFHlXnUU2pbicEuybxQ=
+github.com/Microsoft/go-winio v0.6.2 h1:F2VQgta7ecxGYO8k3ZZz3RS8fVIXVxONVUPlNERoyfY=
+github.com/Microsoft/go-winio v0.6.2/go.mod h1:yd8OoFMLzJbo9gZq8j5qaps8bJ9aShtEA8Ipt1oGCvU=
+github.com/aymanbagabas/go-osc52/v2 v2.0.1 h1:HwpRHbFMcZLEVr42D4p7XBqjyuxQH5SMiErDT4WkJ2k=
+github.com/aymanbagabas/go-osc52/v2 v2.0.1/go.mod h1:uYgXzlJ7ZpABp8OJ+exZzJJhRNQ2ASbcXHWsFqH8hp8=
+github.com/aymanbagabas/go-udiff v0.3.1 h1:LV+qyBQ2pqe0u42ZsUEtPiCaUoqgA9gYRDs3vj1nolY=
+github.com/aymanbagabas/go-udiff v0.3.1/go.mod h1:G0fsKmG+P6ylD0r6N/KgQD/nWzgfnl8ZBcNLgcbrw8E=
+github.com/cenkalti/backoff/v4 v4.3.0 h1:MyRJ/UdXutAwSAT+s3wNd7MfTIcy71VQueUuFK343L8=
+github.com/cenkalti/backoff/v4 v4.3.0/go.mod h1:Y3VNntkOUPxTVeUxJ/G5vcM//AlwfmyYozVcomhLiZE=
+github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
+github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
+github.com/charmbracelet/colorprofile v0.4.1 h1:a1lO03qTrSIRaK8c3JRxJDZOvhvIeSco3ej+ngLk1kk=
+github.com/charmbracelet/colorprofile v0.4.1/go.mod h1:U1d9Dljmdf9DLegaJ0nGZNJvoXAhayhmidOdcBwAvKk=
+github.com/charmbracelet/lipgloss v1.1.0 h1:vYXsiLHVkK7fp74RkV7b2kq9+zDLoEU4MZoFqR/noCY=
+github.com/charmbracelet/lipgloss v1.1.0/go.mod h1:/6Q8FR2o+kj8rz4Dq0zQc3vYf7X+B0binUUBwA0aL30=
+github.com/charmbracelet/ultraviolet v0.0.0-20260205113103-524a6607adb8 h1:eyFRbAmexyt43hVfeyBofiGSEmJ7krjLOYt/9CF5NKA=
+github.com/charmbracelet/ultraviolet v0.0.0-20260205113103-524a6607adb8/go.mod h1:SQpCTRNBtzJkwku5ye4S3HEuthAlGy2n9VXZnWkEW98=
+github.com/charmbracelet/x/ansi v0.11.6 h1:GhV21SiDz/45W9AnV2R61xZMRri5NlLnl6CVF7ihZW8=
+github.com/charmbracelet/x/ansi v0.11.6/go.mod h1:2JNYLgQUsyqaiLovhU2Rv/pb8r6ydXKS3NIttu3VGZQ=
+github.com/charmbracelet/x/cellbuf v0.0.15 h1:ur3pZy0o6z/R7EylET877CBxaiE1Sp1GMxoFPAIztPI=
+github.com/charmbracelet/x/cellbuf v0.0.15/go.mod h1:J1YVbR7MUuEGIFPCaaZ96KDl5NoS0DAWkskup+mOY+Q=
+github.com/charmbracelet/x/exp/golden v0.0.0-20241212170349-ad4b7ae0f25f h1:UytXHv0UxnsDFmL/7Z9Q5SBYPwSuRLXHbwx+6LycZ2w=
+github.com/charmbracelet/x/exp/golden v0.0.0-20241212170349-ad4b7ae0f25f/go.mod h1:wDlXFlCrmJ8J+swcL/MnGUuYnqgQdW9rhSD61oNMb6U=
+github.com/charmbracelet/x/term v0.2.2 h1:xVRT/S2ZcKdhhOuSP4t5cLi5o+JxklsoEObBSgfgZRk=
+github.com/charmbracelet/x/term v0.2.2/go.mod h1:kF8CY5RddLWrsgVwpw4kAa6TESp6EB5y3uxGLeCqzAI=
+github.com/charmbracelet/x/termios v0.1.1 h1:o3Q2bT8eqzGnGPOYheoYS8eEleT5ZVNYNy8JawjaNZY=
+github.com/charmbracelet/x/termios v0.1.1/go.mod h1:rB7fnv1TgOPOyyKRJ9o+AsTU/vK5WHJ2ivHeut/Pcwo=
+github.com/charmbracelet/x/windows v0.2.2 h1:IofanmuvaxnKHuV04sC0eBy/smG6kIKrWG2/jYn2GuM=
+github.com/charmbracelet/x/windows v0.2.2/go.mod h1:/8XtdKZzedat74NQFn0NGlGL4soHB0YQZrETF96h75k=
+github.com/clipperhouse/displaywidth v0.9.0 h1:Qb4KOhYwRiN3viMv1v/3cTBlz3AcAZX3+y9OLhMtAtA=
+github.com/clipperhouse/displaywidth v0.9.0/go.mod h1:aCAAqTlh4GIVkhQnJpbL0T/WfcrJXHcj8C0yjYcjOZA=
+github.com/clipperhouse/stringish v0.1.1 h1:+NSqMOr3GR6k1FdRhhnXrLfztGzuG+VuFDfatpWHKCs=
+github.com/clipperhouse/stringish v0.1.1/go.mod h1:v/WhFtE1q0ovMta2+m+UbpZ+2/HEXNWYXQgCt4hdOzA=
+github.com/clipperhouse/uax29/v2 v2.5.0 h1:x7T0T4eTHDONxFJsL94uKNKPHrclyFI0lm7+w94cO8U=
+github.com/clipperhouse/uax29/v2 v2.5.0/go.mod h1:Wn1g7MK6OoeDT0vL+Q0SQLDz/KpfsVRgg6W7ihQeh4g=
+github.com/containerd/errdefs v1.0.0 h1:tg5yIfIlQIrxYtu9ajqY42W3lpS19XqdxRQeEwYG8PI=
+github.com/containerd/errdefs v1.0.0/go.mod h1:+YBYIdtsnF4Iw6nWZhJcqGSg/dwvV7tyJ/kCkyJ2k+M=
+github.com/containerd/errdefs/pkg v0.3.0 h1:9IKJ06FvyNlexW690DXuQNx2KA2cUJXx151Xdx3ZPPE=
+github.com/containerd/errdefs/pkg v0.3.0/go.mod h1:NJw6s9HwNuRhnjJhM7pylWwMyAkmCQvQ4GpJHEqRLVk=
+github.com/containerd/log v0.1.0 h1:TCJt7ioM2cr/tfR8GPbGf9/VRAX8D2B4PjzCpfX540I=
+github.com/containerd/log v0.1.0/go.mod h1:VRRf09a7mHDIRezVKTRCrOq78v577GXq3bSa3EhrzVo=
+github.com/creack/pty v1.1.24 h1:bJrF4RRfyJnbTJqzRLHzcGaZK1NeM5kTC9jGgovnR1s=
+github.com/creack/pty v1.1.24/go.mod h1:08sCNb52WyoAwi2QDyzUCTgcvVFhUzewun7wtTfvcwE=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/distribution/reference v0.6.0 h1:0IXCQ5g4/QMHHkarYzh5l+u8T3t73zM5QvfrDyIgxBk=
+github.com/distribution/reference v0.6.0/go.mod h1:BbU0aIcezP1/5jX/8MP0YiH4SdvB5Y4f/wlDRiLyi3E=
+github.com/docker/docker v28.5.2+incompatible h1:DBX0Y0zAjZbSrm1uzOkdr1onVghKaftjlSWt4AFexzM=
+github.com/docker/docker v28.5.2+incompatible/go.mod h1:eEKB0N0r5NX/I1kEveEz05bcu8tLC/8azJZsviup8Sk=
+github.com/docker/go-connections v0.6.0 h1:LlMG9azAe1TqfR7sO+NJttz1gy6KO7VJBh+pMmjSD94=
+github.com/docker/go-connections v0.6.0/go.mod h1:AahvXYshr6JgfUJGdDCs2b5EZG/vmaMAntpSFH5BFKE=
+github.com/docker/go-units v0.5.0 h1:69rxXcBk27SvSaaxTtLh/8llcHD8vYHT7WSdRZ/jvr4=
+github.com/docker/go-units v0.5.0/go.mod h1:fgPhTUdO+D/Jk86RDLlptpiXQzgHJF7gydDDbaIK4Dk=
+github.com/felixge/httpsnoop v1.0.4 h1:NFTV2Zj1bL4mc9sqWACXbQFVBBg2W3GPvqp8/ESS2Wg=
+github.com/felixge/httpsnoop v1.0.4/go.mod h1:m8KPJKqk1gH5J9DgRY2ASl2lWCfGKXixSwevea8zH2U=
+github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A=
+github.com/go-logr/logr v1.4.3 h1:CjnDlHq8ikf6E492q6eKboGOC0T8CDaOvkHCIg8idEI=
+github.com/go-logr/logr v1.4.3/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
+github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag=
+github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE=
+github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
+github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
+github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
+github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/grpc-ecosystem/grpc-gateway/v2 v2.25.1 h1:VNqngBF40hVlDloBruUehVYC3ArSgIyScOAyMRqBxRg=
+github.com/grpc-ecosystem/grpc-gateway/v2 v2.25.1/go.mod h1:RBRO7fro65R6tjKzYgLAFo0t1QEXY1Dp+i/bvpRiqiQ=
+github.com/hinshun/vt10x v0.0.0-20220301184237-5011da428d02 h1:AgcIVYPa6XJnU3phs104wLj8l5GEththEw6+F79YsIY=
+github.com/hinshun/vt10x v0.0.0-20220301184237-5011da428d02/go.mod h1:Q48J4R4DvxnHolD5P8pOtXigYlRuPLGl6moFx3ulM68=
+github.com/lucasb-eyer/go-colorful v1.3.0 h1:2/yBRLdWBZKrf7gB40FoiKfAWYQ0lqNcbuQwVHXptag=
+github.com/lucasb-eyer/go-colorful v1.3.0/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0=
+github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
+github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/mattn/go-runewidth v0.0.9/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI=
+github.com/mattn/go-runewidth v0.0.19 h1:v++JhqYnZuu5jSKrk9RbgF5v4CGUjqRfBm05byFGLdw=
+github.com/mattn/go-runewidth v0.0.19/go.mod h1:XBkDxAl56ILZc9knddidhrOlY5R/pDhgLpndooCuJAs=
+github.com/moby/docker-image-spec v1.3.1 h1:jMKff3w6PgbfSa69GfNg+zN/XLhfXJGnEx3Nl2EsFP0=
+github.com/moby/docker-image-spec v1.3.1/go.mod h1:eKmb5VW8vQEh/BAr2yvVNvuiJuY6UIocYsFu/DxxRpo=
+github.com/moby/sys/atomicwriter v0.1.0 h1:kw5D/EqkBwsBFi0ss9v1VG3wIkVhzGvLklJ+w3A14Sw=
+github.com/moby/sys/atomicwriter v0.1.0/go.mod h1:Ul8oqv2ZMNHOceF643P6FKPXeCmYtlQMvpizfsSoaWs=
+github.com/moby/sys/sequential v0.6.0 h1:qrx7XFUd/5DxtqcoH1h438hF5TmOvzC/lspjy7zgvCU=
+github.com/moby/sys/sequential v0.6.0/go.mod h1:uyv8EUTrca5PnDsdMGXhZe6CCe8U/UiTWd+lL+7b/Ko=
+github.com/moby/term v0.5.2 h1:6qk3FJAFDs6i/q3W/pQ97SX192qKfZgGjCQqfCJkgzQ=
+github.com/moby/term v0.5.2/go.mod h1:d3djjFCrjnB+fl8NJux+EJzu0msscUP+f8it8hPkFLc=
+github.com/morikuni/aec v1.1.0 h1:vBBl0pUnvi/Je71dsRrhMBtreIqNMYErSAbEeb8jrXQ=
+github.com/morikuni/aec v1.1.0/go.mod h1:xDRgiq/iw5l+zkao76YTKzKttOp2cwPEne25HDkJnBw=
+github.com/muesli/cancelreader v0.2.2 h1:3I4Kt4BQjOR54NavqnDogx/MIoWBFa0StPA8ELUXHmA=
+github.com/muesli/cancelreader v0.2.2/go.mod h1:3XuTXfFS2VjM+HTLZY9Ak0l6eUKfijIfMUZ4EgX0QYo=
+github.com/muesli/termenv v0.16.0 h1:S5AlUN9dENB57rsbnkPyfdGuWIlkmzJjbFf0Tf5FWUc=
+github.com/muesli/termenv v0.16.0/go.mod h1:ZRfOIKPFDYQoDFF4Olj7/QJbW60Ol/kL1pU3VfY/Cnk=
+github.com/olekukonko/tablewriter v0.0.5 h1:P2Ga83D34wi1o9J6Wh1mRuqd4mF/x/lgBS7N7AbDhec=
+github.com/olekukonko/tablewriter v0.0.5/go.mod h1:hPp6KlRPjbx+hW8ykQs1w3UBbZlj6HuIJcUGPhkA7kY=
+github.com/opencontainers/go-digest v1.0.0 h1:apOUWs51W5PlhuyGyz9FCeeBIOUDA/6nW8Oi/yOhh5U=
+github.com/opencontainers/go-digest v1.0.0/go.mod h1:0JzlMkj0TRzQZfJkVvzbP0HBR3IKzErnv2BNG4W4MAM=
+github.com/opencontainers/image-spec v1.1.1 h1:y0fUlFfIZhPF1W537XOLg0/fcx6zcHCJwooC2xJA040=
+github.com/opencontainers/image-spec v1.1.1/go.mod h1:qpqAh3Dmcf36wStyyWU+kCeDgrGnAve2nCC8+7h8Q0M=
+github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
+github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
+github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
+github.com/sirupsen/logrus v1.9.3 h1:dueUQJ1C2q9oE3F7wvmSGAaVtTmUizReu6fjN8uqzbQ=
+github.com/sirupsen/logrus v1.9.3/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ=
+github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
+github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
+github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e h1:JVG44RsyaB9T2KIHavMF/ppJZNG9ZpyihvCd0w101no=
+github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e/go.mod h1:RbqR21r5mrJuqunuUZ/Dhy/avygyECGrLceyNeo4LiM=
+go.opentelemetry.io/auto/sdk v1.2.1 h1:jXsnJ4Lmnqd11kwkBV2LgLoFMZKizbCi5fNZ/ipaZ64=
+go.opentelemetry.io/auto/sdk v1.2.1/go.mod h1:KRTj+aOaElaLi+wW1kO/DZRXwkF4C5xPbEe3ZiIhN7Y=
+go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.66.0 h1:PnV4kVnw0zOmwwFkAzCN5O07fw1YOIQor120zrh0AVo=
+go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.66.0/go.mod h1:ofAwF4uinaf8SXdVzzbL4OsxJ3VfeEg3f/F6CeF49/Y=
+go.opentelemetry.io/otel v1.41.0 h1:YlEwVsGAlCvczDILpUXpIpPSL/VPugt7zHThEMLce1c=
+go.opentelemetry.io/otel v1.41.0/go.mod h1:Yt4UwgEKeT05QbLwbyHXEwhnjxNO6D8L5PQP51/46dE=
+go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.34.0 h1:OeNbIYk/2C15ckl7glBlOBp5+WlYsOElzTNmiPW/x60=
+go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.34.0/go.mod h1:7Bept48yIeqxP2OZ9/AqIpYS94h2or0aB4FypJTc8ZM=
+go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.34.0 h1:BEj3SPM81McUZHYjRS5pEgNgnmzGJ5tRpU5krWnV8Bs=
+go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.34.0/go.mod h1:9cKLGBDzI/F3NoHLQGm4ZrYdIHsvGt6ej6hUowxY0J4=
+go.opentelemetry.io/otel/metric v1.41.0 h1:rFnDcs4gRzBcsO9tS8LCpgR0dxg4aaxWlJxCno7JlTQ=
+go.opentelemetry.io/otel/metric v1.41.0/go.mod h1:xPvCwd9pU0VN8tPZYzDZV/BMj9CM9vs00GuBjeKhJps=
+go.opentelemetry.io/otel/sdk v1.41.0 h1:YPIEXKmiAwkGl3Gu1huk1aYWwtpRLeskpV+wPisxBp8=
+go.opentelemetry.io/otel/sdk v1.41.0/go.mod h1:ahFdU0G5y8IxglBf0QBJXgSe7agzjE4GiTJ6HT9ud90=
+go.opentelemetry.io/otel/sdk/metric v1.41.0 h1:siZQIYBAUd1rlIWQT2uCxWJxcCO7q3TriaMlf08rXw8=
+go.opentelemetry.io/otel/sdk/metric v1.41.0/go.mod h1:HNBuSvT7ROaGtGI50ArdRLUnvRTRGniSUZbxiWxSO8Y=
+go.opentelemetry.io/otel/trace v1.41.0 h1:Vbk2co6bhj8L59ZJ6/xFTskY+tGAbOnCtQGVVa9TIN0=
+go.opentelemetry.io/otel/trace v1.41.0/go.mod h1:U1NU4ULCoxeDKc09yCWdWe+3QoyweJcISEVa1RBzOis=
+go.opentelemetry.io/proto/otlp v1.5.0 h1:xJvq7gMzB31/d406fB8U5CBdyQGw4P399D1aQWU/3i4=
+go.opentelemetry.io/proto/otlp v1.5.0/go.mod h1:keN8WnHxOy8PG0rQZjJJ5A2ebUoafqWp0eVQ4yIXvJ4=
+golang.org/x/exp v0.0.0-20231006140011-7918f672742d h1:jtJma62tbqLibJ5sFQz8bKtEM8rJBtfilJ2qTU199MI=
+golang.org/x/exp v0.0.0-20231006140011-7918f672742d/go.mod h1:ldy0pHrwJyGW56pPQzzkH36rKxoZW1tw7ZJpeKx+hdo=
+golang.org/x/net v0.34.0 h1:Mb7Mrk043xzHgnRM88suvJFwzVrRfHEHJEl5/71CKw0=
+golang.org/x/net v0.34.0/go.mod h1:di0qlW3YNM5oh6GqDGQr92MyTozJPmybPK4Ev/Gm31k=
+golang.org/x/sync v0.19.0 h1:vV+1eWNmZ5geRlYjzm2adRgW2/mcpevXNg50YZtPCE4=
+golang.org/x/sync v0.19.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI=
+golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.41.0 h1:Ivj+2Cp/ylzLiEU89QhWblYnOE9zerudt9Ftecq2C6k=
+golang.org/x/sys v0.41.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
+golang.org/x/text v0.21.0 h1:zyQAAkrwaneQ066sspRyJaG9VNi/YJ1NfzcGB3hZ/qo=
+golang.org/x/text v0.21.0/go.mod h1:4IBbMaMmOPCJ8SecivzSH54+73PCFmPWxNTLm+vZkEQ=
+golang.org/x/time v0.14.0 h1:MRx4UaLrDotUKUdCIqzPC48t1Y9hANFKIRpNx+Te8PI=
+golang.org/x/time v0.14.0/go.mod h1:eL/Oa2bBBK0TkX57Fyni+NgnyQQN4LitPmob2Hjnqw4=
+google.golang.org/genproto/googleapis/api v0.0.0-20250115164207-1a7da9e5054f h1:gap6+3Gk41EItBuyi4XX/bp4oqJ3UwuIMl25yGinuAA=
+google.golang.org/genproto/googleapis/api v0.0.0-20250115164207-1a7da9e5054f/go.mod h1:Ic02D47M+zbarjYYUlK57y316f2MoN0gjAwI3f2S95o=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20250115164207-1a7da9e5054f h1:OxYkA3wjPsZyBylwymxSHa7ViiW1Sml4ToBrncvFehI=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20250115164207-1a7da9e5054f/go.mod h1:+2Yz8+CLJbIfL9z73EW45avw8Lmge3xVElCP9zEKi50=
+google.golang.org/grpc v1.69.4 h1:MF5TftSMkd8GLw/m0KM6V8CMOCY6NZ1NQDPGFgbTt4A=
+google.golang.org/grpc v1.69.4/go.mod h1:vyjdE6jLBI76dgpDojsFGNaHlxdjXN9ghpnd2o7JGZ4=
+google.golang.org/protobuf v1.36.3 h1:82DV7MYdb8anAVi3qge1wSnMDrnKK7ebr+I0hHRN1BU=
+google.golang.org/protobuf v1.36.3/go.mod h1:9fA7Ob0pmnwhb644+1+CVWFRbNajQ6iRojtC/QF5bRE=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gotest.tools/v3 v3.5.2 h1:7koQfIKdy+I8UTetycgUqXWSDwpgv193Ka+qRsmBY8Q=
+gotest.tools/v3 v3.5.2/go.mod h1:LtdLGcnqToBH83WByAAi/wiwSFCArdFIUV/xxN4pcjA=
diff --git a/install.sh b/install.sh
deleted file mode 100755
index 394c113..0000000
--- a/install.sh
+++ /dev/null
@@ -1,16 +0,0 @@
-#!/bin/bash
-
-UNAME_CMD="$(uname -m)"
-case "$UNAME_CMD" in
-x86_64) SUFFIX="x86_64" ;;
-aarch64) SUFFIX="aarch64" ;;
-armv6l) SUFFIX="armv6" ;;
-esac
-
-if [ -n "$SUFFIX" ]; then
- OXKER_GZ="oxker_linux_${SUFFIX}.tar.gz"
- curl -L -O "https://github.com/mrjackwills/oxker/releases/latest/download/${OXKER_GZ}"
- tar xzvf "${OXKER_GZ}" oxker
- install -Dm 755 oxker -t "${HOME}/.local/bin"
- rm "${OXKER_GZ}" oxker
-fi
diff --git a/internal/app/app.go b/internal/app/app.go
new file mode 100644
index 0000000..8033a97
--- /dev/null
+++ b/internal/app/app.go
@@ -0,0 +1,3255 @@
+package app
+
+import (
+ "bufio"
+ "encoding/base64"
+ "encoding/json"
+ "fmt"
+ "io"
+ "math"
+ "os"
+ "os/exec"
+ "path/filepath"
+ "regexp"
+ "strings"
+ "sync"
+ "time"
+
+ tea "charm.land/bubbletea/v2"
+ "github.com/charmbracelet/lipgloss"
+ "github.com/creack/pty"
+ "github.com/docker/docker/api/types/container"
+ "github.com/hinshun/vt10x"
+ "github.com/oxker/oxker/internal/config"
+ "github.com/oxker/oxker/internal/docker"
+)
+
+// ============================================================
+// TYPES
+// ============================================================
+
+type AppState int
+
+const (
+ StateLoading AppState = iota
+ StateReady
+ StateError
+)
+
+type Panel int
+
+const (
+ PanelContainers Panel = iota
+ PanelLogs
+ PanelCommands
+)
+
+type ContainerState int
+
+const (
+ RunningHealthy ContainerState = iota
+ RunningUnhealthy
+ Paused
+ Exited
+ Dead
+ Restarting
+ Removing
+ Created
+ Unknown
+)
+
+type SortOrder int
+
+const (
+ SortNone SortOrder = iota
+ SortAsc
+ SortDesc
+)
+
+type SortColumn int
+
+const (
+ SortName SortColumn = iota
+ SortState
+ SortStatus
+ SortCPU
+ SortMemory
+ SortID
+ SortImage
+ SortRX
+ SortTX
+)
+
+type FilterBy int
+
+const (
+ FilterByName FilterBy = iota
+ FilterByImage
+ FilterByStatus
+ FilterByAll
+)
+
+func (f FilterBy) String() string {
+ return [...]string{"Name", "Image", "Status", "All"}[f]
+}
+
+type ContainerPorts struct {
+ IP string
+ Private int
+ Public int
+}
+
+type Container struct {
+ ID string
+ Name string
+ Image string
+ State ContainerState
+ StateStr string
+ Status string
+ Ports []ContainerPorts
+ CreatedAt int64
+ CPUPercent float64
+ MemUsage uint64
+ MemLimit uint64
+ RxBytes uint64
+ TxBytes uint64
+ CPUHist []float64
+ MemHist []uint64
+ RxHist []uint64
+ TxHist []uint64
+ // Per-container log storage
+ Logs []string
+ LogScroll int
+ LogHScroll int
+ LogsSince string // timestamp for incremental fetching
+}
+
+// ============================================================
+// MESSAGES
+// ============================================================
+
+type ContainersLoadedMsg struct{ Containers []Container }
+type StatsUpdatedMsg struct {
+ ID string
+ CPU float64
+ MemUsage uint64
+ MemLimit uint64
+ Rx, Tx uint64
+}
+type ContainerActionMsg struct{ Action, ID string; Err error }
+type ErrorMsg struct{ Err error }
+type TickMsg struct{}
+type LogsLoadedMsg struct{ ID string; Lines []string; Since string }
+type InspectLoadedMsg struct{ Data string }
+type InfoDismissMsg struct{}
+type ExecDoneMsg struct{ Err error }
+type ConnectCountdownMsg struct{ SecsLeft int }
+type ExecOutputMsg struct{} // tick to refresh VTE display
+type ExecExitMsg struct{ Err error }
+
+// ============================================================
+// APP MODEL
+// ============================================================
+
+type App struct {
+ // State
+ State AppState
+ CmdMgr *docker.Client
+ Config *config.Config
+ Width int
+ Height int
+ Error error
+
+ // Containers
+ Containers []Container
+ SelectedIdx int
+ SelectedID string // persistent selected container ID
+ ScrollOffset int
+ PrevSelectedID string // track selection changes for log save/restore
+
+ // Panels
+ ActivePanel Panel
+
+ // Logs
+ LogLines []string
+ LogScroll int
+ LogHScroll int
+ LogHeight int // percentage 5-80
+ ShowLogs bool
+
+ // Sorting
+ SortCol SortColumn
+ SortOrd SortOrder
+
+ // Filtering
+ FilterMode bool
+ FilterText string
+ FilterBy FilterBy
+
+ // Log Search
+ SearchMode bool
+ SearchText string
+ SearchMatches []int
+ SearchIdx int
+
+ // Inspect
+ InspectMode bool
+ InspectData string
+ InspectScrollY int
+ InspectScrollX int
+
+ // Delete confirm
+ DeleteConfirm bool
+ DeleteTarget string
+
+ // Help
+ ShowHelp bool
+
+ // Command selection
+ CmdSelectedIdx int
+
+ // Stats dedup — prevent duplicate in-flight stats requests
+ PendingStats map[string]bool
+
+ // Info box (bottom-right, auto-dismiss)
+ InfoText string
+ InfoTimeout *time.Timer
+
+ // Loading animation
+ LoadingIdx int
+
+ // Mouse capture
+ MouseEnabled bool
+
+ // Docker connect error countdown (auto-exit)
+ ConnectCountdown int
+
+ // Embedded exec terminal (PTY + VTE)
+ ExecMode bool
+ ExecPTY *os.File // PTY master fd
+ ExecCmd *exec.Cmd // running docker exec process
+ ExecVT vt10x.Terminal // virtual terminal emulator
+ ExecMu sync.Mutex // protects ExecVT
+ ExecDone chan struct{} // closed when exec process exits
+ ExecContainer string // container name
+ ExecImage string // container image
+ ExecID string // container ID short
+
+ // Exec mouse selection
+ ExecSelecting bool // drag in progress
+ ExecSelActive bool // selection exists (show highlight)
+ ExecSelStartR int // start row (in visible area, 0-based)
+ ExecSelStartC int // start col
+ ExecSelEndR int // end row
+ ExecSelEndC int // end col
+}
+
+func New(cfg ...*config.Config) *App {
+ var c *config.Config
+ if len(cfg) > 0 && cfg[0] != nil {
+ c = cfg[0]
+ } else {
+ c = config.NewConfig()
+ }
+ cli, err := docker.New(c.Host)
+
+ app := &App{
+ State: StateLoading,
+ Config: c,
+ LogHeight: 75,
+ ShowLogs: c.ShowLogs,
+ MouseEnabled: true,
+ }
+
+ if err != nil {
+ app.Error = fmt.Errorf("Docker connect failed: %v", err)
+ app.ConnectCountdown = 5
+ } else if pingErr := cli.Ping(); pingErr != nil {
+ host := c.Host
+ if host == "" { host = "default socket" }
+ app.Error = fmt.Errorf("Cannot connect to Docker at %s: %v", host, pingErr)
+ app.ConnectCountdown = 5
+ } else {
+ app.CmdMgr = cli
+ }
+
+ return app
+}
+
+func (a *App) Init() tea.Cmd {
+ if a.ConnectCountdown > 0 {
+ return tea.Tick(time.Second, func(t time.Time) tea.Msg {
+ return ConnectCountdownMsg{SecsLeft: a.ConnectCountdown}
+ })
+ }
+ return tea.Batch(a.loadContainers(), a.tickCmd())
+}
+
+func (a *App) tickCmd() tea.Cmd {
+ return tea.Tick(time.Duration(a.Config.DockerIntervalMs)*time.Millisecond, func(t time.Time) tea.Msg {
+ return TickMsg{}
+ })
+}
+
+// quit cancels in-flight Docker calls and returns tea.Quit.
+func (a *App) quit() (*App, tea.Cmd) {
+ if a.CmdMgr != nil {
+ a.CmdMgr.Cancel()
+ }
+ return a, tea.Quit
+}
+
+// ============================================================
+// UPDATE
+// ============================================================
+
+func (a *App) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
+ // Exec mode: route most messages to exec handler
+ if a.ExecMode {
+ return a.updateExecMode(msg)
+ }
+
+ switch msg := msg.(type) {
+ case tea.WindowSizeMsg:
+ a.Width = msg.Width
+ a.Height = msg.Height
+ return a, nil
+
+ case tea.KeyPressMsg:
+ return a.handleKey(msg)
+
+ case tea.MouseClickMsg:
+ return a.handleMouseClick(msg)
+
+ case tea.MouseWheelMsg:
+ return a.handleMouseWheel(msg)
+
+ case tea.MouseMotionMsg:
+ // No-op in normal mode
+ return a, nil
+
+ case tea.MouseReleaseMsg:
+ // No-op in normal mode
+ return a, nil
+
+ case ContainersLoadedMsg:
+ return a.handleContainersLoaded(msg)
+
+ case StatsUpdatedMsg:
+ return a.handleStatsUpdated(msg)
+
+ case LogsLoadedMsg:
+ for i := range a.Containers {
+ if a.Containers[i].ID == msg.ID {
+ c := &a.Containers[i]
+ if msg.Since != "" && len(c.Logs) > 0 {
+ // Incremental: append new lines, dedup
+ existing := make(map[string]bool, len(c.Logs))
+ for _, l := range c.Logs {
+ existing[l] = true
+ }
+ for _, l := range msg.Lines {
+ if !existing[l] {
+ c.Logs = append(c.Logs, l)
+ }
+ }
+ } else {
+ c.Logs = msg.Lines
+ }
+ c.LogsSince = time.Now().UTC().Format(time.RFC3339Nano)
+ break
+ }
+ }
+ // Sync to active view if this is the selected container
+ if sel := a.selected(); sel != nil && sel.ID == msg.ID {
+ // Auto-follow: if we were at/near the bottom, scroll to new bottom
+ wasAtBottom := a.LogScroll >= len(a.LogLines) - a.logsVisibleRows() - 2
+ a.LogLines = sel.Logs
+ if wasAtBottom || len(a.LogLines) <= a.logsVisibleRows() {
+ max := len(a.LogLines) - a.logsVisibleRows()
+ if max < 0 { max = 0 }
+ a.LogScroll = max
+ }
+ }
+ return a, nil
+
+ case InspectLoadedMsg:
+ a.InspectData = msg.Data
+ a.InspectMode = true
+ a.InspectScrollX = 0
+ a.InspectScrollY = 0
+ return a, nil
+
+ case ContainerActionMsg:
+ if msg.Err != nil {
+ a.Error = msg.Err
+ } else {
+ dismissCmd := a.setInfo(fmt.Sprintf("%s: success", msg.Action))
+ return a, tea.Batch(a.loadContainers(), dismissCmd)
+ }
+ return a, a.loadContainers()
+
+ case ErrorMsg:
+ a.Error = msg.Err
+ a.State = StateError
+ return a, nil
+
+ case TickMsg:
+ a.LoadingIdx = (a.LoadingIdx + 1) % 10
+ cmds := []tea.Cmd{a.tickCmd(), a.loadContainers()}
+ // Update stats for all running containers
+ cmds = append(cmds, a.updateAllStats()...)
+ return a, tea.Batch(cmds...)
+
+ case InfoDismissMsg:
+ a.InfoText = ""
+ return a, nil
+
+ case ExecDoneMsg:
+ if msg.Err != nil {
+ a.Error = msg.Err
+ }
+ return a, a.loadContainers()
+
+ case ConnectCountdownMsg:
+ a.ConnectCountdown = msg.SecsLeft - 1
+ if a.ConnectCountdown <= 0 {
+ return a.quit()
+ }
+ return a, tea.Tick(time.Second, func(t time.Time) tea.Msg {
+ return ConnectCountdownMsg{SecsLeft: a.ConnectCountdown}
+ })
+ }
+
+ return a, nil
+}
+
+func (a *App) handleContainersLoaded(msg ContainersLoadedMsg) (*App, tea.Cmd) {
+ // Merge stats from existing containers
+ oldMap := make(map[string]*Container)
+ for i := range a.Containers {
+ oldMap[a.Containers[i].ID] = &a.Containers[i]
+ }
+ for i := range msg.Containers {
+ if old, ok := oldMap[msg.Containers[i].ID]; ok {
+ msg.Containers[i].CPUPercent = old.CPUPercent
+ msg.Containers[i].MemUsage = old.MemUsage
+ msg.Containers[i].MemLimit = old.MemLimit
+ msg.Containers[i].RxBytes = old.RxBytes
+ msg.Containers[i].TxBytes = old.TxBytes
+ msg.Containers[i].CPUHist = old.CPUHist
+ msg.Containers[i].MemHist = old.MemHist
+ msg.Containers[i].RxHist = old.RxHist
+ msg.Containers[i].TxHist = old.TxHist
+ // Preserve per-container logs
+ msg.Containers[i].Logs = old.Logs
+ msg.Containers[i].LogScroll = old.LogScroll
+ msg.Containers[i].LogHScroll = old.LogHScroll
+ msg.Containers[i].LogsSince = old.LogsSince
+ }
+ }
+ a.Containers = msg.Containers
+ a.State = StateReady
+ // Use persistent SelectedID to restore selection after sort
+ a.sortContainersWithID(a.SelectedID)
+ return a, a.loadLogsForSelected()
+}
+
+func (a *App) handleStatsUpdated(msg StatsUpdatedMsg) (*App, tea.Cmd) {
+ delete(a.PendingStats, msg.ID)
+ for i := range a.Containers {
+ if a.Containers[i].ID == msg.ID {
+ c := &a.Containers[i]
+ c.CPUPercent = msg.CPU
+ c.MemUsage = msg.MemUsage
+ c.MemLimit = msg.MemLimit
+ c.RxBytes = msg.Rx
+ c.TxBytes = msg.Tx
+ // History (max 60 samples)
+ c.CPUHist = appendMax(c.CPUHist, msg.CPU, 60)
+ c.MemHist = appendMaxU(c.MemHist, msg.MemUsage, 60)
+ c.RxHist = appendMaxU(c.RxHist, msg.Rx, 60)
+ c.TxHist = appendMaxU(c.TxHist, msg.Tx, 60)
+ break
+ }
+ }
+ return a, nil
+}
+
+// ============================================================
+// KEY HANDLING
+// ============================================================
+
+func (a *App) handleKey(msg tea.KeyPressMsg) (*App, tea.Cmd) {
+ // Ctrl+C always quits regardless of mode
+ if msg.String() == "ctrl+c" {
+ return a.quit()
+ }
+
+ // Inspect mode - separate handling
+ if a.InspectMode {
+ return a.handleInspectKey(msg)
+ }
+
+ // Delete confirm
+ if a.DeleteConfirm {
+ return a.handleDeleteConfirmKey(msg)
+ }
+
+ // Error mode - only allow clear/quit
+ if a.Error != nil {
+ k := msg.String()
+ if keyMatch(k, a.Config.Keymap.Clear) || k == "c" || k == "esc" {
+ a.Error = nil
+ a.ConnectCountdown = 0
+ if a.State == StateError {
+ a.State = StateReady
+ }
+ } else if keyMatch(k, a.Config.Keymap.Quit) || k == "q" {
+ return a.quit()
+ }
+ return a, nil
+ }
+
+ // Filter mode
+ if a.FilterMode {
+ return a.handleFilterKey(msg)
+ }
+
+ // Search mode
+ if a.SearchMode {
+ return a.handleSearchKey(msg)
+ }
+
+ // Help overlay
+ if a.ShowHelp {
+ switch msg.String() {
+ case "h", "esc", "q":
+ a.ShowHelp = false
+ }
+ return a, nil
+ }
+
+ key := msg.String()
+ km := &a.Config.Keymap
+
+ // Keymap-aware dispatch: check config keybindings first, fall back to defaults
+ switch {
+ case keyMatch(key, km.Quit) || key == "q":
+ return a.quit()
+
+ // Panel navigation
+ case keyMatch(key, km.SelectNextPanel) || key == "tab":
+ a.nextPanel()
+ case keyMatch(key, km.SelectPreviousPanel) || key == "shift+tab":
+ a.prevPanel()
+
+ // Scroll
+ case keyMatch(key, km.ScrollDown) || key == "j" || key == "down":
+ a.scrollDown(1)
+ return a, a.loadLogsForSelected()
+ case keyMatch(key, km.ScrollUp) || key == "k" || key == "up":
+ a.scrollUp(1)
+ return a, a.loadLogsForSelected()
+ case key == "J":
+ a.scrollDown(10)
+ return a, a.loadLogsForSelected()
+ case key == "K":
+ a.scrollUp(10)
+ return a, a.loadLogsForSelected()
+ case keyMatch(key, km.ScrollStart) || key == "g" || key == "home":
+ a.scrollHome()
+ return a, a.loadLogsForSelected()
+ case keyMatch(key, km.ScrollEnd) || key == "G" || key == "end":
+ a.scrollEnd()
+ return a, a.loadLogsForSelected()
+ case keyMatch(key, km.ScrollForward) || key == "pgdown":
+ a.scrollDown(a.visibleRows())
+ return a, a.loadLogsForSelected()
+ case keyMatch(key, km.ScrollBack) || key == "pgup":
+ a.scrollUp(a.visibleRows())
+ return a, a.loadLogsForSelected()
+
+ // Sorting
+ case keyMatch(key, km.SortByName) || key == "1":
+ a.toggleSort(SortName)
+ case keyMatch(key, km.SortByState) || key == "2":
+ a.toggleSort(SortState)
+ case keyMatch(key, km.SortByStatus) || key == "3":
+ a.toggleSort(SortStatus)
+ case keyMatch(key, km.SortByCPU) || key == "4":
+ a.toggleSort(SortCPU)
+ case keyMatch(key, km.SortByMemory) || key == "5":
+ a.toggleSort(SortMemory)
+ case keyMatch(key, km.SortByID) || key == "6":
+ a.toggleSort(SortID)
+ case keyMatch(key, km.SortByImage) || key == "7":
+ a.toggleSort(SortImage)
+ case keyMatch(key, km.SortByRX) || key == "8":
+ a.toggleSort(SortRX)
+ case keyMatch(key, km.SortByTX) || key == "9":
+ a.toggleSort(SortTX)
+ case keyMatch(key, km.SortReset) || key == "0":
+ a.SortOrd = SortNone
+ a.sortContainers()
+
+ // Filter
+ case keyMatch(key, km.FilterMode) || key == "/":
+ a.FilterMode = true
+ a.FilterText = ""
+
+ // Log search
+ case keyMatch(key, km.LogSearchMode) || key == "#":
+ a.SearchMode = true
+ a.SearchText = ""
+ a.SearchMatches = nil
+
+ // Log panel controls
+ case keyMatch(key, km.LogSectionToggle) || key == "l":
+ a.ShowLogs = !a.ShowLogs
+ case keyMatch(key, km.LogSectionHeightIncrease) || key == "]":
+ if a.LogHeight < 80 {
+ a.LogHeight += 5
+ }
+ case keyMatch(key, km.LogSectionHeightDecrease) || key == "[":
+ if a.LogHeight > 5 {
+ a.LogHeight -= 5
+ }
+
+ // Log horizontal scroll
+ case key == "right":
+ if a.ActivePanel == PanelLogs {
+ a.LogHScroll += 10
+ }
+ case key == "left":
+ if a.ActivePanel == PanelLogs {
+ a.LogHScroll -= 10
+ if a.LogHScroll < 0 {
+ a.LogHScroll = 0
+ }
+ }
+
+ // Container actions
+ case key == "enter":
+ return a, a.execSelectedCommand()
+ case key == "s":
+ return a, a.doAction((*docker.Client).StartContainer, "start")
+ case key == "x":
+ return a, a.doAction((*docker.Client).StopContainer, "stop")
+ case key == "r":
+ return a, a.doAction((*docker.Client).RestartContainer, "restart")
+ case key == "d":
+ a.confirmDelete()
+ case key == "p":
+ return a, a.doAction((*docker.Client).PauseContainer, "pause")
+ case key == "u":
+ return a, a.doAction((*docker.Client).UnpauseContainer, "unpause")
+
+ // Docker exec
+ case keyMatch(key, km.Exec) || key == "e":
+ return a, a.execIntoContainer()
+
+ // Inspect
+ case keyMatch(key, km.Inspect) || key == "i":
+ return a, a.inspectSelected()
+
+ // Save logs
+ case keyMatch(key, km.SaveLogs) || key == "ctrl+s" || key == "S":
+ return a, a.saveLogs()
+
+ // Help
+ case keyMatch(key, km.ToggleHelp) || key == "h":
+ a.ShowHelp = true
+
+ // Force redraw
+ case keyMatch(key, km.ForceRedraw) || key == "f":
+ return a, tea.ClearScreen
+
+ // Toggle mouse capture (controlled via View return)
+ case keyMatch(key, km.ToggleMouseCapture) || key == "m":
+ a.MouseEnabled = !a.MouseEnabled
+
+ // Clear
+ case keyMatch(key, km.Clear) || key == "esc":
+ a.ShowHelp = false
+ }
+
+ return a, nil
+}
+
+func (a *App) handleInspectKey(msg tea.KeyPressMsg) (*App, tea.Cmd) {
+ switch msg.String() {
+ case "esc", "i", "q":
+ a.InspectMode = false
+ case "j", "down":
+ a.InspectScrollY++
+ a.clampInspectScroll()
+ case "k", "up":
+ if a.InspectScrollY > 0 {
+ a.InspectScrollY--
+ }
+ case "l", "right":
+ a.InspectScrollX += 5
+ case "h", "left":
+ a.InspectScrollX -= 5
+ if a.InspectScrollX < 0 {
+ a.InspectScrollX = 0
+ }
+ case "g", "home":
+ a.InspectScrollY = 0
+ a.InspectScrollX = 0
+ case "G", "end":
+ lines := strings.Count(a.InspectData, "\n")
+ a.InspectScrollY = lines
+ a.clampInspectScroll()
+ }
+ return a, nil
+}
+
+func (a *App) handleDeleteConfirmKey(msg tea.KeyPressMsg) (*App, tea.Cmd) {
+ k := msg.String()
+ km := &a.Config.Keymap
+ switch {
+ case keyMatch(k, km.DeleteConfirm) || k == "y" || k == "enter":
+ a.DeleteConfirm = false
+ id := a.DeleteTarget
+ if id == "" || a.CmdMgr == nil {
+ return a, nil
+ }
+ return a, func() tea.Msg {
+ err := a.CmdMgr.DeleteContainer(id, true)
+ return ContainerActionMsg{Action: "delete", ID: id, Err: err}
+ }
+ case keyMatch(k, km.DeleteDeny) || k == "n" || k == "esc":
+ a.DeleteConfirm = false
+ a.DeleteTarget = ""
+ }
+ return a, nil
+}
+
+func (a *App) handleFilterKey(msg tea.KeyPressMsg) (*App, tea.Cmd) {
+ switch msg.String() {
+ case "esc":
+ a.FilterMode = false
+ a.FilterText = ""
+ case "enter", "/":
+ a.FilterMode = false
+ case "backspace":
+ if len(a.FilterText) > 0 {
+ a.FilterText = a.FilterText[:len(a.FilterText)-1]
+ }
+ case "ctrl+u":
+ a.FilterText = ""
+ case "left":
+ if a.FilterBy > 0 {
+ a.FilterBy--
+ }
+ case "right":
+ if a.FilterBy < FilterByAll {
+ a.FilterBy++
+ }
+ default:
+ if msg.Text != "" {
+ a.FilterText += msg.Text
+ }
+ }
+ return a, nil
+}
+
+func (a *App) handleSearchKey(msg tea.KeyPressMsg) (*App, tea.Cmd) {
+ switch msg.String() {
+ case "esc":
+ a.SearchMode = false
+ a.SearchText = ""
+ a.SearchMatches = nil
+ case "enter", "#":
+ a.SearchMode = false
+ case "backspace":
+ if len(a.SearchText) > 0 {
+ a.SearchText = a.SearchText[:len(a.SearchText)-1]
+ a.updateSearchMatches()
+ }
+ case "ctrl+n", "down":
+ if len(a.SearchMatches) > 0 {
+ a.SearchIdx = (a.SearchIdx + 1) % len(a.SearchMatches)
+ a.LogScroll = a.SearchMatches[a.SearchIdx]
+ }
+ case "ctrl+p", "up":
+ if len(a.SearchMatches) > 0 {
+ a.SearchIdx--
+ if a.SearchIdx < 0 {
+ a.SearchIdx = len(a.SearchMatches) - 1
+ }
+ a.LogScroll = a.SearchMatches[a.SearchIdx]
+ }
+ case "right":
+ a.LogHScroll += 10
+ case "left":
+ a.LogHScroll -= 10
+ if a.LogHScroll < 0 { a.LogHScroll = 0 }
+ default:
+ if msg.Text != "" {
+ a.SearchText += msg.Text
+ a.updateSearchMatches()
+ }
+ }
+ return a, nil
+}
+
+// ============================================================
+// MOUSE HANDLING
+// ============================================================
+
+func (a *App) handleMouseWheel(msg tea.MouseWheelMsg) (*App, tea.Cmd) {
+ // Block mouse in overlay modes
+ if a.DeleteConfirm || a.ShowHelp || a.FilterMode || a.SearchMode || a.Error != nil {
+ return a, nil
+ }
+
+ // Inspect mode: route scroll to inspect panel
+ if a.InspectMode {
+ if msg.Button == tea.MouseWheelUp {
+ if a.InspectScrollY > 0 {
+ a.InspectScrollY--
+ }
+ } else if msg.Button == tea.MouseWheelDown {
+ a.InspectScrollY++
+ }
+ return a, nil
+ }
+
+ if msg.Button == tea.MouseWheelUp {
+ a.scrollUp(1)
+ return a, a.loadLogsForSelected()
+ } else if msg.Button == tea.MouseWheelDown {
+ a.scrollDown(1)
+ return a, a.loadLogsForSelected()
+ }
+ return a, nil
+}
+
+func (a *App) handleMouseClick(msg tea.MouseClickMsg) (*App, tea.Cmd) {
+ // Block mouse in overlay modes
+ if a.DeleteConfirm || a.ShowHelp || a.FilterMode || a.SearchMode || a.Error != nil {
+ return a, nil
+ }
+ if a.InspectMode {
+ return a, nil
+ }
+ x, y := msg.X, msg.Y
+
+ // Header row (y == 0) → sort by column
+ if y == 0 {
+ col := a.headerColumnAt(x)
+ if col >= 0 {
+ a.toggleSort(SortColumn(col))
+ }
+ return a, nil
+ }
+
+ // Container area
+ containerH := a.containerAreaHeight()
+ cmdW := a.Width * 10 / 100
+ if cmdW < 12 { cmdW = 12 }
+ tableW := a.Width - cmdW - 4
+
+ if y >= 1 && y <= containerH {
+ if x < tableW+2 {
+ // Click in container table → select container
+ row := y - 3 + a.ScrollOffset // 3 = header + border + title
+ if row >= 0 && row < len(a.filtered()) {
+ a.SelectedIdx = row
+ a.CmdSelectedIdx = 0
+ a.syncSelectedID()
+ a.ensureVisible()
+ return a, a.loadLogsForSelected()
+ }
+ } else {
+ // Click in commands panel
+ a.ActivePanel = PanelCommands
+ }
+ return a, nil
+ }
+
+ // Logs area
+ logsStart := 1 + containerH
+ logsEnd := logsStart + a.logsAreaHeight()
+ if y >= logsStart && y < logsEnd {
+ a.ActivePanel = PanelLogs
+ return a, nil
+ }
+
+ return a, nil
+}
+
+func (a *App) headerColumnAt(x int) int {
+ cw := a.colWidths()
+ cols := []int{3, cw.name, cw.state, cw.status, cw.cpu, cw.mem, cw.id, cw.image, cw.rx, cw.tx}
+ pos := 0
+ for i, w := range cols {
+ pos += w
+ if x < pos {
+ if i == 0 {
+ return -1 // indicator column
+ }
+ return i - 1 // SortColumn index
+ }
+ }
+ return -1
+}
+
+// ============================================================
+// NAVIGATION & SCROLL
+// ============================================================
+
+func (a *App) nextPanel() {
+ if a.ShowLogs {
+ a.ActivePanel = Panel((int(a.ActivePanel) + 1) % 3)
+ } else {
+ if a.ActivePanel == PanelContainers {
+ a.ActivePanel = PanelCommands
+ } else {
+ a.ActivePanel = PanelContainers
+ }
+ }
+}
+
+func (a *App) prevPanel() {
+ if a.ShowLogs {
+ p := int(a.ActivePanel) - 1
+ if p < 0 {
+ p = 2
+ }
+ a.ActivePanel = Panel(p)
+ } else {
+ if a.ActivePanel == PanelContainers {
+ a.ActivePanel = PanelCommands
+ } else {
+ a.ActivePanel = PanelContainers
+ }
+ }
+}
+
+func (a *App) scrollDown(n int) {
+ if a.ActivePanel == PanelCommands {
+ c := a.selected()
+ if c == nil { return }
+ cmds := commandsForState(c.State)
+ a.CmdSelectedIdx += n
+ if a.CmdSelectedIdx >= len(cmds) {
+ a.CmdSelectedIdx = len(cmds) - 1
+ }
+ if a.CmdSelectedIdx < 0 { a.CmdSelectedIdx = 0 }
+ return
+ }
+ if a.ActivePanel == PanelLogs {
+ a.LogScroll += n
+ max := len(a.LogLines) - a.logsVisibleRows()
+ if max < 0 { max = 0 }
+ if a.LogScroll > max { a.LogScroll = max }
+ } else {
+ cs := a.filtered()
+ a.SelectedIdx += n
+ if a.SelectedIdx >= len(cs) {
+ a.SelectedIdx = len(cs) - 1
+ }
+ if a.SelectedIdx < 0 { a.SelectedIdx = 0 }
+ a.CmdSelectedIdx = 0
+ a.syncSelectedID()
+ a.ensureVisible()
+ }
+}
+
+func (a *App) scrollUp(n int) {
+ if a.ActivePanel == PanelCommands {
+ a.CmdSelectedIdx -= n
+ if a.CmdSelectedIdx < 0 { a.CmdSelectedIdx = 0 }
+ return
+ }
+ if a.ActivePanel == PanelLogs {
+ a.LogScroll -= n
+ if a.LogScroll < 0 { a.LogScroll = 0 }
+ } else {
+ a.SelectedIdx -= n
+ if a.SelectedIdx < 0 { a.SelectedIdx = 0 }
+ a.CmdSelectedIdx = 0
+ a.syncSelectedID()
+ a.ensureVisible()
+ }
+}
+
+func (a *App) scrollHome() {
+ if a.ActivePanel == PanelLogs {
+ a.LogScroll = 0
+ } else {
+ a.SelectedIdx = 0
+ a.ScrollOffset = 0
+ a.syncSelectedID()
+ }
+}
+
+func (a *App) scrollEnd() {
+ if a.ActivePanel == PanelLogs {
+ max := len(a.LogLines) - a.logsVisibleRows()
+ if max < 0 { max = 0 }
+ a.LogScroll = max
+ } else {
+ cs := a.filtered()
+ if len(cs) > 0 {
+ a.SelectedIdx = len(cs) - 1
+ a.syncSelectedID()
+ a.ensureVisible()
+ }
+ }
+}
+
+func (a *App) ensureVisible() {
+ vis := a.containerVisibleRows()
+ if a.SelectedIdx < a.ScrollOffset {
+ a.ScrollOffset = a.SelectedIdx
+ }
+ if a.SelectedIdx >= a.ScrollOffset+vis {
+ a.ScrollOffset = a.SelectedIdx - vis + 1
+ }
+}
+
+func (a *App) visibleRows() int {
+ return a.containerVisibleRows()
+}
+
+func (a *App) clampInspectScroll() {
+ total := strings.Count(a.InspectData, "\n") + 1
+ vis := a.Height - 4
+ if vis < 1 { vis = 1 }
+ max := total - vis
+ if max < 0 { max = 0 }
+ if a.InspectScrollY > max { a.InspectScrollY = max }
+ if a.InspectScrollY < 0 { a.InspectScrollY = 0 }
+}
+
+// ============================================================
+// SORTING
+// ============================================================
+
+func (a *App) toggleSort(col SortColumn) {
+ if a.SortCol == col {
+ switch a.SortOrd {
+ case SortNone:
+ a.SortOrd = SortAsc
+ case SortAsc:
+ a.SortOrd = SortDesc
+ case SortDesc:
+ a.SortOrd = SortNone
+ }
+ } else {
+ a.SortCol = col
+ a.SortOrd = SortAsc
+ }
+ a.sortContainers()
+}
+
+func (a *App) sortContainers() {
+ var selectedID string
+ if sel := a.selected(); sel != nil {
+ selectedID = sel.ID
+ }
+ a.sortContainersWithID(selectedID)
+}
+
+func (a *App) sortContainersWithID(selectedID string) {
+ cs := a.Containers
+ less := func(i, j int) bool {
+ var cmp int
+ if a.SortOrd == SortNone {
+ // Default sort: by CreatedAt, Name as tiebreaker
+ cmp = compareInt64(cs[i].CreatedAt, cs[j].CreatedAt)
+ } else {
+ switch a.SortCol {
+ case SortName:
+ cmp = strings.Compare(strings.ToLower(cs[i].Name), strings.ToLower(cs[j].Name))
+ case SortState:
+ cmp = int(stateOrder(cs[i].State)) - int(stateOrder(cs[j].State))
+ case SortStatus:
+ cmp = strings.Compare(cs[i].Status, cs[j].Status)
+ case SortCPU:
+ cmp = compareFloat(cs[i].CPUPercent, cs[j].CPUPercent)
+ case SortMemory:
+ cmp = compareUint(cs[i].MemUsage, cs[j].MemUsage)
+ case SortID:
+ cmp = strings.Compare(cs[i].ID, cs[j].ID)
+ case SortImage:
+ cmp = strings.Compare(strings.ToLower(cs[i].Image), strings.ToLower(cs[j].Image))
+ case SortRX:
+ cmp = compareUint(cs[i].RxBytes, cs[j].RxBytes)
+ case SortTX:
+ cmp = compareUint(cs[i].TxBytes, cs[j].TxBytes)
+ }
+ }
+ // Tiebreaker: sort by name
+ if cmp == 0 {
+ cmp = strings.Compare(strings.ToLower(cs[i].Name), strings.ToLower(cs[j].Name))
+ }
+ if a.SortOrd == SortDesc {
+ return cmp > 0
+ }
+ return cmp < 0
+ }
+ // Simple insertion sort (few items, stable)
+ for i := 1; i < len(cs); i++ {
+ for j := i; j > 0 && less(j, j-1); j-- {
+ cs[j], cs[j-1] = cs[j-1], cs[j]
+ }
+ }
+ // Restore selection by ID (H8)
+ if selectedID != "" {
+ for i, c := range cs {
+ if c.ID == selectedID {
+ a.SelectedIdx = i
+ break
+ }
+ }
+ }
+ // Clamp and sync SelectedID
+ if a.SelectedIdx >= len(cs) {
+ a.SelectedIdx = len(cs) - 1
+ }
+ if a.SelectedIdx < 0 {
+ a.SelectedIdx = 0
+ }
+ a.syncSelectedID()
+}
+
+// stateOrder returns semantic sort order matching Rust (H10)
+func stateOrder(s ContainerState) int {
+ switch s {
+ case RunningHealthy: return 0
+ case RunningUnhealthy: return 1
+ case Paused: return 2
+ case Restarting: return 3
+ case Removing: return 4
+ case Exited: return 5
+ case Dead: return 6
+ case Created: return 7
+ case Unknown: return 8
+ default: return 9
+ }
+}
+
+func compareInt64(a, b int64) int {
+ if a < b { return -1 }
+ if a > b { return 1 }
+ return 0
+}
+
+// ============================================================
+// SEARCH
+// ============================================================
+
+func (a *App) updateSearchMatches() {
+ a.SearchMatches = nil
+ a.SearchIdx = 0
+ if a.SearchText == "" {
+ return
+ }
+ caseSensitive := a.Config != nil && a.Config.LogSearchCaseSensitive
+ term := a.SearchText
+ if !caseSensitive {
+ term = strings.ToLower(term)
+ }
+ for i, line := range a.LogLines {
+ haystack := line
+ if !caseSensitive {
+ haystack = strings.ToLower(haystack)
+ }
+ if strings.Contains(haystack, term) {
+ a.SearchMatches = append(a.SearchMatches, i)
+ }
+ }
+}
+
+// ============================================================
+// CONTAINER ACTIONS
+// ============================================================
+
+func (a *App) selected() *Container {
+ cs := a.filtered()
+ if a.SelectedIdx >= 0 && a.SelectedIdx < len(cs) {
+ id := cs[a.SelectedIdx].ID
+ for i := range a.Containers {
+ if a.Containers[i].ID == id {
+ return &a.Containers[i]
+ }
+ }
+ }
+ return nil
+}
+
+// syncSelectedID updates SelectedID to match current SelectedIdx
+func (a *App) syncSelectedID() {
+ cs := a.filtered()
+ if a.SelectedIdx >= 0 && a.SelectedIdx < len(cs) {
+ a.SelectedID = cs[a.SelectedIdx].ID
+ }
+}
+
+// syncLogSelection saves scroll state to old container and restores from new one
+func (a *App) syncLogSelection() {
+ sel := a.selected()
+ newID := ""
+ if sel != nil { newID = sel.ID }
+
+ if newID == a.PrevSelectedID { return }
+
+ // Save scroll position to previous container
+ if a.PrevSelectedID != "" {
+ for i := range a.Containers {
+ if a.Containers[i].ID == a.PrevSelectedID {
+ a.Containers[i].LogScroll = a.LogScroll
+ a.Containers[i].LogHScroll = a.LogHScroll
+ break
+ }
+ }
+ }
+
+ // Restore from new container
+ if sel != nil {
+ a.LogLines = sel.Logs
+ a.LogScroll = sel.LogScroll
+ a.LogHScroll = sel.LogHScroll
+ } else {
+ a.LogLines = nil
+ a.LogScroll = 0
+ a.LogHScroll = 0
+ }
+ a.PrevSelectedID = newID
+}
+
+func (a *App) doAction(fn func(*docker.Client, string) error, action string) tea.Cmd {
+ c := a.selected()
+ if c == nil || a.CmdMgr == nil { return nil }
+ id := c.ID
+ mgr := a.CmdMgr
+ return func() tea.Msg {
+ err := fn(mgr, id)
+ return ContainerActionMsg{Action: action, ID: id, Err: err}
+ }
+}
+
+func (a *App) confirmDelete() {
+ c := a.selected()
+ if c == nil { return }
+ a.DeleteConfirm = true
+ a.DeleteTarget = c.ID
+}
+
+func (a *App) execSelectedCommand() tea.Cmd {
+ c := a.selected()
+ if c == nil { return nil }
+ cmds := commandsForState(c.State)
+ if len(cmds) == 0 { return nil }
+ idx := a.CmdSelectedIdx
+ if idx >= len(cmds) { idx = 0 }
+ cmd := cmds[idx]
+ switch cmd {
+ case "start":
+ return a.doAction((*docker.Client).StartContainer, "start")
+ case "stop":
+ return a.doAction((*docker.Client).StopContainer, "stop")
+ case "pause":
+ return a.doAction((*docker.Client).PauseContainer, "pause")
+ case "resume":
+ return a.doAction((*docker.Client).UnpauseContainer, "resume")
+ case "restart":
+ return a.doAction((*docker.Client).RestartContainer, "restart")
+ case "delete":
+ a.confirmDelete()
+ }
+ return nil
+}
+
+func (a *App) inspectSelected() tea.Cmd {
+ c := a.selected()
+ if c == nil || a.CmdMgr == nil { return nil }
+ id := c.ID
+ mgr := a.CmdMgr
+ return func() tea.Msg {
+ details, err := mgr.InspectContainer(id)
+ if err != nil {
+ return ErrorMsg{Err: err}
+ }
+ data, _ := json.MarshalIndent(details, "", " ")
+ return InspectLoadedMsg{Data: string(data)}
+ }
+}
+
+func (a *App) saveLogs() tea.Cmd {
+ c := a.selected()
+ if c == nil { return nil }
+ name := c.Name
+ lines := a.LogLines
+ saveDir := a.Config.DirSave
+ return func() tea.Msg {
+ filename := fmt.Sprintf("oxker_%s_%s.log", name, time.Now().Format("20060102_150405"))
+ if saveDir != "" {
+ filename = filepath.Join(saveDir, filename)
+ }
+ var sb strings.Builder
+ for _, l := range lines {
+ sb.WriteString(l + "\n")
+ }
+ if err := os.WriteFile(filename, []byte(sb.String()), 0644); err != nil {
+ return ErrorMsg{Err: err}
+ }
+ return ContainerActionMsg{Action: fmt.Sprintf("saved to %s", filename), Err: nil}
+ }
+}
+
+func (a *App) execIntoContainer() tea.Cmd {
+ c := a.selected()
+ if c == nil {
+ return nil
+ }
+ if c.State != RunningHealthy && c.State != RunningUnhealthy {
+ return a.setInfo("can only exec into running containers")
+ }
+
+ id := c.ID
+ shortID := id
+ if len(shortID) > 12 { shortID = shortID[:12] }
+
+ w, h := a.execPanelSize()
+ cmd := exec.Command("docker", "exec", "-it", id, "sh")
+
+ // Start with PTY
+ ptmx, err := pty.Start(cmd)
+ if err != nil {
+ return a.setInfo(fmt.Sprintf("exec failed: %v", err))
+ }
+ _ = pty.Setsize(ptmx, &pty.Winsize{Rows: uint16(h), Cols: uint16(w)})
+
+ // Create VTE with matching size
+ vt := vt10x.New(vt10x.WithSize(w, h), vt10x.WithWriter(ptmx))
+
+ a.ExecMode = true
+ a.ExecPTY = ptmx
+ a.ExecCmd = cmd
+ a.ExecVT = vt
+ a.ExecDone = make(chan struct{})
+ a.ExecContainer = c.Name
+ a.ExecImage = c.Image
+ a.ExecID = shortID
+ a.ExecSelActive = false
+ a.ExecSelecting = false
+
+ // Start VTE parser in background — it reads PTY and updates the screen buffer.
+ // When PTY closes (shell exits), signal via ExecDone.
+ done := a.ExecDone
+ go func() {
+ defer close(done)
+ br := bufio.NewReader(ptmx)
+ for {
+ if err := vt.Parse(br); err != nil {
+ return
+ }
+ }
+ // Also wait for the process to finish
+ }()
+
+ // Tick to refresh the exec view
+ return a.execTick()
+}
+
+func (a *App) execTick() tea.Cmd {
+ return tea.Tick(50*time.Millisecond, func(t time.Time) tea.Msg {
+ return ExecOutputMsg{}
+ })
+}
+
+func (a *App) execPanelSize() (w, h int) {
+ w = a.Width * 70 / 100
+ if w < 40 { w = 40 }
+ w -= 2 // subtract border columns
+ h = a.Height * 70 / 100
+ if h < 10 { h = 10 }
+ h -= 2 // subtract border rows (top + bottom)
+ return
+}
+
+func (a *App) execClose() {
+ if a.ExecPTY != nil {
+ a.ExecPTY.Close()
+ a.ExecPTY = nil
+ }
+ if a.ExecCmd != nil && a.ExecCmd.Process != nil {
+ a.ExecCmd.Process.Kill()
+ a.ExecCmd.Wait()
+ a.ExecCmd = nil
+ }
+ a.ExecVT = nil
+ a.ExecDone = nil
+ a.ExecMode = false
+}
+
+func (a *App) execWriteKey(msg tea.KeyPressMsg) {
+ if a.ExecPTY == nil { return }
+
+ var b []byte
+
+ // Check for ctrl+key combinations first
+ if msg.Mod&tea.ModCtrl != 0 {
+ switch msg.Code {
+ case 'c':
+ b = []byte{3}
+ case 'd':
+ b = []byte{4}
+ case 'z':
+ b = []byte{26}
+ case 'l':
+ b = []byte{12}
+ case 'a':
+ b = []byte{1}
+ case 'e':
+ b = []byte{5}
+ case 'u':
+ b = []byte{21}
+ case 'k':
+ b = []byte{11}
+ case 'w':
+ b = []byte{23}
+ }
+ } else {
+ switch msg.Code {
+ case tea.KeyEnter:
+ b = []byte{'\r'}
+ case tea.KeyTab:
+ b = []byte{'\t'}
+ case tea.KeyBackspace:
+ b = []byte{127}
+ case tea.KeyEscape:
+ b = []byte{27}
+ case tea.KeyUp:
+ b = []byte{27, '[', 'A'}
+ case tea.KeyDown:
+ b = []byte{27, '[', 'B'}
+ case tea.KeyRight:
+ b = []byte{27, '[', 'C'}
+ case tea.KeyLeft:
+ b = []byte{27, '[', 'D'}
+ case tea.KeySpace:
+ b = []byte{' '}
+ default:
+ // Regular character input
+ if msg.Text != "" {
+ b = []byte(msg.Text)
+ } else if msg.Code > 0 && msg.Code < 128 {
+ b = []byte{byte(msg.Code)}
+ }
+ }
+ }
+ if len(b) > 0 {
+ a.ExecPTY.Write(b)
+ }
+}
+
+// execPanelOrigin returns the top-left screen position of the content area
+func (a *App) execPanelOrigin() (x, y int) {
+ w, h := a.execPanelSize()
+ panelW := w + 2
+ panelH := h + 2
+ x = (a.Width - panelW) / 2
+ y = (a.Height - panelH) / 2
+ x += 1
+ y += 1
+ return
+}
+
+// execMouseToContent maps screen mouse position to VTE row/col
+func (a *App) execMouseToContent(mx, my int) (row, col int) {
+ ox, oy := a.execPanelOrigin()
+ w, h := a.execPanelSize()
+ col = mx - ox
+ row = my - oy
+ if col < 0 || col >= w || row < 0 || row >= h {
+ return -1, -1
+ }
+ return row, col
+}
+
+// execGetVisibleLines reads the VTE screen buffer into strings
+func (a *App) execGetVisibleLines() []string {
+ if a.ExecVT == nil {
+ return nil
+ }
+ a.ExecVT.Lock()
+ defer a.ExecVT.Unlock()
+ cols, rows := a.ExecVT.Size()
+ lines := make([]string, rows)
+ for y := 0; y < rows; y++ {
+ var sb strings.Builder
+ for x := 0; x < cols; x++ {
+ g := a.ExecVT.Cell(x, y)
+ if g.Char == 0 {
+ sb.WriteRune(' ')
+ } else {
+ sb.WriteRune(g.Char)
+ }
+ }
+ lines[y] = strings.TrimRight(sb.String(), " ")
+ }
+ return lines
+}
+
+// execSelectedText extracts text from the selection range
+func (a *App) execSelectedText(visible []string, w int) string {
+ if !a.ExecSelActive {
+ return ""
+ }
+ sr, sc, er, ec := a.ExecSelStartR, a.ExecSelStartC, a.ExecSelEndR, a.ExecSelEndC
+ if sr > er || (sr == er && sc > ec) {
+ sr, sc, er, ec = er, ec, sr, sc
+ }
+
+ var sb strings.Builder
+ for r := sr; r <= er && r < len(visible); r++ {
+ runes := []rune(visible[r])
+ if len(runes) > w {
+ runes = runes[:w]
+ }
+ cStart := 0
+ cEnd := len(runes)
+ if r == sr { cStart = sc }
+ if r == er { cEnd = ec + 1 }
+ if cStart > len(runes) { cStart = len(runes) }
+ if cEnd > len(runes) { cEnd = len(runes) }
+ if cStart < cEnd {
+ sb.WriteString(string(runes[cStart:cEnd]))
+ }
+ if r < er {
+ sb.WriteString("\n")
+ }
+ }
+ return sb.String()
+}
+
+// execCopySelection copies the mouse-selected text to clipboard
+func (a *App) execCopySelection() tea.Cmd {
+ w, _ := a.execPanelSize()
+ visible := a.execGetVisibleLines()
+ text := a.execSelectedText(visible, w)
+ if text == "" {
+ return nil
+ }
+ return a.copyToClipboard(text)
+}
+
+// copyToClipboard sends text to system clipboard
+func (a *App) copyToClipboard(text string) tea.Cmd {
+ return func() tea.Msg {
+ // Try native clipboard tools first
+ for _, cmd := range [][]string{
+ {"wl-copy"},
+ {"xclip", "-selection", "clipboard"},
+ {"xsel", "--clipboard", "--input"},
+ } {
+ c := exec.Command(cmd[0], cmd[1:]...)
+ c.Stdin = strings.NewReader(text)
+ if err := c.Run(); err == nil {
+ return ContainerActionMsg{Action: "copied to clipboard"}
+ }
+ }
+ // Fallback: OSC 52 escape sequence (works in most modern terminals)
+ encoded := base64.StdEncoding.EncodeToString([]byte(text))
+ fmt.Fprintf(os.Stderr, "\x1b]52;c;%s\x07", encoded)
+ return ContainerActionMsg{Action: "copied to clipboard (OSC 52)"}
+ }
+}
+
+func (a *App) updateExecMode(msg tea.Msg) (tea.Model, tea.Cmd) {
+ switch msg := msg.(type) {
+ case ContainerActionMsg:
+ return a, a.setInfo(msg.Action)
+
+ case InfoDismissMsg:
+ a.InfoText = ""
+ return a, nil
+
+ case ExecOutputMsg:
+ // VTE parses in background; just keep ticking to refresh the view
+ if a.ExecMode {
+ // Check if the exec process has exited
+ select {
+ case <-a.ExecDone:
+ a.execClose()
+ return a, nil
+ default:
+ }
+ return a, a.execTick()
+ }
+ return a, nil
+
+ case ExecExitMsg:
+ a.execClose()
+ return a, nil
+
+ case tea.WindowSizeMsg:
+ a.Width = msg.Width
+ a.Height = msg.Height
+ // Resize VTE + PTY to match new panel size
+ if a.ExecVT != nil && a.ExecPTY != nil {
+ w, h := a.execPanelSize()
+ a.ExecVT.Lock()
+ a.ExecVT.Resize(w, h)
+ a.ExecVT.Unlock()
+ _ = pty.Setsize(a.ExecPTY, &pty.Winsize{Rows: uint16(h), Cols: uint16(w)})
+ }
+ return a, nil
+
+ case tea.KeyPressMsg:
+ // Clear selection on any keypress
+ a.ExecSelActive = false
+ a.ExecSelecting = false
+ // Ctrl+Q exits exec mode
+ if msg.Code == 'q' && msg.Mod&tea.ModCtrl != 0 {
+ a.execClose()
+ return a, nil
+ }
+ // Forward all keys directly to PTY
+ a.execWriteKey(msg)
+ return a, nil
+
+ case tea.MouseClickMsg:
+ if msg.Button == tea.MouseLeft {
+ r, c := a.execMouseToContent(msg.X, msg.Y)
+ if r >= 0 {
+ a.ExecSelecting = true
+ a.ExecSelActive = true
+ a.ExecSelStartR = r
+ a.ExecSelStartC = c
+ a.ExecSelEndR = r
+ a.ExecSelEndC = c
+ }
+ }
+ return a, nil
+
+ case tea.MouseMotionMsg:
+ if a.ExecSelecting {
+ r, c := a.execMouseToContent(msg.X, msg.Y)
+ if r >= 0 {
+ a.ExecSelEndR = r
+ a.ExecSelEndC = c
+ }
+ }
+ return a, nil
+
+ case tea.MouseReleaseMsg:
+ if a.ExecSelecting {
+ a.ExecSelecting = false
+ r, c := a.execMouseToContent(msg.X, msg.Y)
+ if r >= 0 {
+ a.ExecSelEndR = r
+ a.ExecSelEndC = c
+ }
+ if a.ExecSelStartR == a.ExecSelEndR && a.ExecSelStartC == a.ExecSelEndC {
+ a.ExecSelActive = false
+ } else {
+ return a, a.execCopySelection()
+ }
+ }
+ return a, nil
+ }
+ return a, nil
+}
+
+func (a *App) viewExec() string {
+ w, h := a.execPanelSize()
+
+ // Title bar
+ title := fmt.Sprintf(" exec: %s (%s) [%s] ", a.ExecContainer, a.ExecImage, a.ExecID)
+ hint := " Ctrl+Q to exit "
+
+ // Styles
+ borderColor := lipgloss.NewStyle().Foreground(cGreen).Background(cMantle)
+ titleStyle := lipgloss.NewStyle().Foreground(cPeach).Background(cMantle).Bold(true)
+ hintStyle := lipgloss.NewStyle().Foreground(cOverlay0).Background(cMantle)
+ lineStyle := lipgloss.NewStyle().Foreground(cText).Background(cBase)
+ cursorStyle := lipgloss.NewStyle().Foreground(cBase).Background(cText)
+ selStyle := lipgloss.NewStyle().Foreground(cBase).Background(cBlue)
+
+ // Top border
+ titleLen := len([]rune(title))
+ hintLen := len([]rune(hint))
+ topW := w + 2
+ topAvail := topW - 2 - titleLen
+ if topAvail < 0 { topAvail = 0 }
+ topBorder := borderColor.Render("╭") +
+ borderColor.Render("─") +
+ titleStyle.Render(title) +
+ borderColor.Render(strings.Repeat("─", max(0, topAvail-1))) +
+ borderColor.Render("╮")
+
+ // Bottom border
+ botAvail := topW - 2 - hintLen
+ if botAvail < 0 { botAvail = 0 }
+ botBorder := borderColor.Render("╰") +
+ borderColor.Render("─") +
+ hintStyle.Render(hint) +
+ borderColor.Render(strings.Repeat("─", max(0, botAvail-1))) +
+ borderColor.Render("╯")
+
+ // Read VTE screen buffer
+ var curX, curY int
+ visible := make([]string, h)
+ if a.ExecVT != nil {
+ a.ExecVT.Lock()
+ cur := a.ExecVT.Cursor()
+ curX, curY = cur.X, cur.Y
+ for y := 0; y < h; y++ {
+ var sb strings.Builder
+ for x := 0; x < w; x++ {
+ g := a.ExecVT.Cell(x, y)
+ if g.Char == 0 {
+ sb.WriteRune(' ')
+ } else {
+ sb.WriteRune(g.Char)
+ }
+ }
+ visible[y] = sb.String()
+ }
+ a.ExecVT.Unlock()
+ }
+
+ // Normalize selection bounds
+ selSR, selSC, selER, selEC := a.ExecSelStartR, a.ExecSelStartC, a.ExecSelEndR, a.ExecSelEndC
+ if selSR > selER || (selSR == selER && selSC > selEC) {
+ selSR, selSC, selER, selEC = selER, selEC, selSR, selSC
+ }
+
+ // Render content lines from VTE buffer
+ var content strings.Builder
+ for y := 0; y < h; y++ {
+ var line string
+ if y < len(visible) {
+ line = visible[y]
+ }
+ runes := []rune(line)
+ // Pad to width
+ for len(runes) < w {
+ runes = append(runes, ' ')
+ }
+ if len(runes) > w {
+ runes = runes[:w]
+ }
+
+ // Check if this line has selection or cursor
+ hasSel := a.ExecSelActive && y >= selSR && y <= selER
+ hasCursor := y == curY
+
+ if !hasSel && !hasCursor {
+ // Fast path: render entire line at once
+ content.WriteString(borderColor.Render("│") + lineStyle.Render(string(runes)) + borderColor.Render("│") + "\n")
+ } else {
+ // Char-by-char for cursor and selection
+ var sb strings.Builder
+ for x := 0; x < w; x++ {
+ ch := string(runes[x])
+ isCursor := hasCursor && x == curX
+ inSel := hasSel
+ if inSel {
+ colStart := 0
+ colEnd := w
+ if y == selSR { colStart = selSC }
+ if y == selER { colEnd = selEC + 1 }
+ inSel = x >= colStart && x < colEnd
+ }
+
+ if inSel {
+ sb.WriteString(selStyle.Render(ch))
+ } else if isCursor {
+ sb.WriteString(cursorStyle.Render(ch))
+ } else {
+ sb.WriteString(lineStyle.Render(ch))
+ }
+ }
+ content.WriteString(borderColor.Render("│") + sb.String() + borderColor.Render("│") + "\n")
+ }
+ }
+
+ panel := topBorder + "\n" + content.String() + botBorder
+ bg := a.viewNormal()
+ return placeOverlay(bg, panel, lipgloss.Center, lipgloss.Center, a.Width, a.Height)
+}
+
+var ansiRegex = regexp.MustCompile(`\x1b\[[0-9;?]*[a-zA-Z]`)
+
+func stripAnsi(s string) string {
+ return ansiRegex.ReplaceAllString(s, "")
+}
+
+func (a *App) setInfo(text string) tea.Cmd {
+ a.InfoText = text
+ return tea.Tick(4*time.Second, func(t time.Time) tea.Msg {
+ return InfoDismissMsg{}
+ })
+}
+
+// ============================================================
+// DATA LOADING
+// ============================================================
+
+func (a *App) loadContainers() tea.Cmd {
+ mgr := a.CmdMgr
+ showSelf := a.Config.ShowSelf
+ return func() tea.Msg {
+ if mgr == nil {
+ return ErrorMsg{Err: fmt.Errorf("docker not connected")}
+ }
+ containers, err := mgr.ListContainers(true)
+ if err != nil {
+ return ErrorMsg{Err: err}
+ }
+ result := make([]Container, 0, len(containers))
+ for _, c := range containers {
+ name := ""
+ if len(c.Names) > 0 {
+ name = strings.TrimPrefix(c.Names[0], "/")
+ }
+ // Skip self (oxker container) unless ShowSelf is set
+ if !showSelf && strings.Contains(c.Image, "oxker") {
+ continue
+ }
+ result = append(result, Container{
+ ID: c.ID,
+ Name: name,
+ Image: c.Image,
+ State: mapState(c.State, c.Status),
+ StateStr: c.State,
+ Status: c.Status,
+ Ports: mapPorts(c.Ports),
+ CreatedAt: c.Created,
+ })
+ }
+ return ContainersLoadedMsg{Containers: result}
+ }
+}
+
+func (a *App) updateAllStats() []tea.Cmd {
+ if a.CmdMgr == nil { return nil }
+ if a.PendingStats == nil { a.PendingStats = make(map[string]bool) }
+ var cmds []tea.Cmd
+ mgr := a.CmdMgr
+ for _, c := range a.Containers {
+ if c.State != RunningHealthy && c.State != RunningUnhealthy && c.State != Paused {
+ continue
+ }
+ id := c.ID
+ if a.PendingStats[id] {
+ continue // already in-flight
+ }
+ a.PendingStats[id] = true
+ cmds = append(cmds, func() tea.Msg {
+ stats, err := mgr.ContainerStats(id)
+ if err != nil {
+ return nil // silently ignore stats errors
+ }
+ cpu := calculateCPU(stats)
+ memUsage := stats.MemoryStats.Usage
+ // Subtract cache
+ if cache, ok := stats.MemoryStats.Stats["inactive_file"]; ok {
+ if memUsage > cache {
+ memUsage -= cache
+ }
+ }
+ memLimit := stats.MemoryStats.Limit
+
+ var rx, tx uint64
+ for _, net := range stats.Networks {
+ rx += net.RxBytes
+ tx += net.TxBytes
+ }
+
+ return StatsUpdatedMsg{
+ ID: id, CPU: cpu,
+ MemUsage: memUsage, MemLimit: memLimit,
+ Rx: rx, Tx: tx,
+ }
+ })
+ }
+ return cmds
+}
+
+func (a *App) loadLogsForSelected() tea.Cmd {
+ a.syncLogSelection()
+ c := a.selected()
+ if c == nil || a.CmdMgr == nil { return nil }
+ id := c.ID
+ since := c.LogsSince
+ mgr := a.CmdMgr
+ showStderr := a.Config.ShowStdErr
+ return func() tea.Msg {
+ opts := container.LogsOptions{
+ Follow: false, ShowStdout: true, ShowStderr: showStderr,
+ Timestamps: true,
+ }
+ if since != "" {
+ opts.Since = since
+ } else {
+ opts.Tail = "500"
+ }
+ rc, err := mgr.Logs(id, opts)
+ if err != nil {
+ // Container may have been removed between list and log fetch; silently return empty
+ return LogsLoadedMsg{ID: id, Lines: nil}
+ }
+ defer rc.Close()
+ data, err := io.ReadAll(rc)
+ if err != nil {
+ return LogsLoadedMsg{ID: id, Lines: nil}
+ }
+ raw := strings.Split(strings.TrimRight(string(data), "\n"), "\n")
+ var cleaned []string
+ for _, line := range raw {
+ if len(line) > 8 && (line[0] == 0 || line[0] == 1 || line[0] == 2) {
+ line = line[8:]
+ }
+ if line != "" {
+ cleaned = append(cleaned, line)
+ }
+ }
+ return LogsLoadedMsg{ID: id, Lines: cleaned, Since: since}
+ }
+}
+
+// ============================================================
+// CPU CALCULATION (matching original Rust formula)
+// ============================================================
+
+func calculateCPU(stats *container.StatsResponse) float64 {
+ // Guard against uint64 underflow (saturating_sub equivalent)
+ if stats.CPUStats.CPUUsage.TotalUsage < stats.PreCPUStats.CPUUsage.TotalUsage {
+ return 0
+ }
+ if stats.CPUStats.SystemUsage < stats.PreCPUStats.SystemUsage {
+ return 0
+ }
+ cpuDelta := float64(stats.CPUStats.CPUUsage.TotalUsage - stats.PreCPUStats.CPUUsage.TotalUsage)
+ systemDelta := float64(stats.CPUStats.SystemUsage - stats.PreCPUStats.SystemUsage)
+
+ if cpuDelta <= 0 || systemDelta <= 0 {
+ return 0
+ }
+
+ onlineCPUs := float64(stats.CPUStats.OnlineCPUs)
+ if onlineCPUs == 0 {
+ onlineCPUs = float64(len(stats.CPUStats.CPUUsage.PercpuUsage))
+ }
+ if onlineCPUs == 0 {
+ onlineCPUs = 1
+ }
+
+ return (cpuDelta / systemDelta) * onlineCPUs * 100.0
+}
+
+// ============================================================
+// VIEW
+// ============================================================
+
+// Charm.sh / Catppuccin Mocha inspired color palette
+var (
+ cBase = lipgloss.Color("#1e1e2e")
+ cMantle = lipgloss.Color("#181825")
+ cSurface0 = lipgloss.Color("#313244")
+ cSurface1 = lipgloss.Color("#45475a")
+ cOverlay0 = lipgloss.Color("#6c7086")
+ cText = lipgloss.Color("#cdd6f4")
+ cSubtext0 = lipgloss.Color("#a6adc8")
+ cRed = lipgloss.Color("#f38ba8")
+ cGreen = lipgloss.Color("#a6e3a1")
+ cYellow = lipgloss.Color("#f9e2af")
+ cBlue = lipgloss.Color("#89b4fa")
+ cMauve = lipgloss.Color("#cba6f7")
+ cTeal = lipgloss.Color("#94e2d5")
+ cPeach = lipgloss.Color("#fab387")
+ cLavender = lipgloss.Color("#b4befe")
+ cFlamingo = lipgloss.Color("#f2cdcd")
+)
+
+// colorOr returns the config color if non-empty, otherwise the default
+func colorOr(cfgColor string, def lipgloss.Color) lipgloss.Color {
+ if cfgColor != "" { return lipgloss.Color(cfgColor) }
+ return def
+}
+
+// Resolved colors from config with defaults
+func (a *App) borderSelected() lipgloss.Color { return colorOr(a.Config.AppColors.Borders.Selected, cBlue) }
+func (a *App) borderUnselected() lipgloss.Color { return colorOr(a.Config.AppColors.Borders.Unselected, cSurface0) }
+
+func (a *App) cmdColorCfg(cmd string) lipgloss.Color {
+ cc := a.Config.AppColors.Commands
+ switch cmd {
+ case "start": return colorOr(cc.Start, cGreen)
+ case "resume": return colorOr(cc.Resume, cBlue)
+ case "restart": return colorOr(cc.Restart, cMauve)
+ case "pause": return colorOr(cc.Pause, cYellow)
+ case "stop": return colorOr(cc.Stop, cRed)
+ case "delete": return colorOr(cc.Delete, cOverlay0)
+ default: return cText
+ }
+}
+
+func (a *App) stateColorCfg(s ContainerState) lipgloss.Color {
+ cs := a.Config.AppColors.ContainerState
+ switch s {
+ case RunningHealthy: return colorOr(cs.RunningHealthy, cGreen)
+ case RunningUnhealthy: return colorOr(cs.RunningUnhealthy, cPeach)
+ case Paused: return colorOr(cs.Paused, cYellow)
+ case Exited: return colorOr(cs.Exited, cRed)
+ case Dead: return colorOr(cs.Dead, cRed)
+ case Restarting: return colorOr(cs.Restarting, cTeal)
+ case Removing: return colorOr(cs.Removing, cRed)
+ default: return colorOr(cs.Unknown, cOverlay0)
+ }
+}
+
+func (a *App) View() tea.View {
+ var content string
+ if a.Width == 0 || a.Height == 0 {
+ content = "Loading..."
+ } else if a.Width < 60 || a.Height < 10 {
+ content = a.centeredMsg(fmt.Sprintf("Terminal too small (%dx%d)\nMinimum: 60x10", a.Width, a.Height))
+ } else if a.State == StateLoading {
+ content = a.centeredMsg("Loading Docker containers...")
+ } else if a.ExecMode {
+ content = a.viewExec()
+ } else if a.InspectMode {
+ content = a.viewInspect()
+ } else {
+ content = a.viewNormal()
+ }
+
+ mouseMode := tea.MouseModeCellMotion
+ if !a.MouseEnabled {
+ mouseMode = tea.MouseModeNone
+ }
+
+ return tea.View{
+ Content: content,
+ AltScreen: true,
+ MouseMode: mouseMode,
+ }
+}
+
+func (a *App) viewNormal() string {
+ containerH := a.containerAreaHeight()
+ logsH := a.logsAreaHeight()
+ chartsH := a.chartsAreaHeight()
+
+ // Clamp
+ total := 1 + containerH + logsH + chartsH
+ if total > a.Height {
+ logsH -= total - a.Height
+ if logsH < 3 { logsH = 3 }
+ }
+
+ var sections []string
+ sections = append(sections, a.viewHeader())
+ sections = append(sections, a.viewContainerSection(containerH))
+ if a.ShowLogs {
+ sections = append(sections, a.viewLogs(logsH))
+ }
+ sections = append(sections, a.viewBottom(chartsH))
+
+ result := lipgloss.JoinVertical(lipgloss.Left, sections...)
+
+ // Clamp to terminal height to prevent overflow causing layout jumping
+ lines := strings.Split(result, "\n")
+ if len(lines) > a.Height {
+ lines = lines[:a.Height]
+ result = strings.Join(lines, "\n")
+ }
+
+ // Overlays
+ if a.ShowHelp {
+ result = a.overlayHelp(result)
+ }
+ if a.DeleteConfirm {
+ result = a.overlayDeleteConfirm(result)
+ }
+ if a.Error != nil {
+ result = a.overlayError(result)
+ }
+ if a.InfoText != "" {
+ result = a.overlayInfo(result)
+ }
+
+ return result
+}
+
+func (a *App) centeredMsg(msg string) string {
+ return lipgloss.Place(a.Width, a.Height, lipgloss.Center, lipgloss.Center,
+ lipgloss.NewStyle().Border(lipgloss.RoundedBorder()).BorderForeground(cBlue).Padding(1, 3).Render(msg))
+}
+
+// --- Header ---
+
+func (a *App) viewHeader() string {
+ bg := cMantle
+ fg := cText
+ hdr := lipgloss.NewStyle().Background(bg).Foreground(fg)
+ cw := a.colWidths()
+
+ spinnerFrames := []string{"⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"}
+ spinner := lipgloss.NewStyle().Background(bg).Foreground(cMauve).Render(spinnerFrames[a.LoadingIdx])
+
+ sortIcon := func(col SortColumn) string {
+ if a.SortCol == col && a.SortOrd != SortNone {
+ if a.SortOrd == SortAsc { return " ▲" }
+ return " ▼"
+ }
+ return ""
+ }
+
+ var b strings.Builder
+ b.WriteString(hdr.Width(1).Render(spinner))
+ b.WriteString(hdr.Width(2).Render(" "))
+ b.WriteString(hdr.Width(cw.name).Render("name" + sortIcon(SortName)))
+ b.WriteString(hdr.Width(cw.state).Render("state" + sortIcon(SortState)))
+ b.WriteString(hdr.Width(cw.status).Render("status" + sortIcon(SortStatus)))
+ b.WriteString(hdr.Width(cw.cpu).Render("cpu" + sortIcon(SortCPU)))
+ b.WriteString(hdr.Width(cw.mem).Render("memory/limit" + sortIcon(SortMemory)))
+ b.WriteString(hdr.Width(cw.id).Render("id" + sortIcon(SortID)))
+ b.WriteString(hdr.Width(cw.image).Render("image" + sortIcon(SortImage)))
+ b.WriteString(hdr.Width(cw.rx).Align(lipgloss.Right).Render("rx" + sortIcon(SortRX)))
+ b.WriteString(hdr.Width(cw.tx).Align(lipgloss.Right).Render("tx" + sortIcon(SortTX)))
+
+ content := b.String()
+ contentW := lipgloss.Width(content)
+ remaining := a.Width - contentW
+ if remaining > 0 {
+ helpText := "( h ) show help"
+ if a.ShowHelp { helpText = "( h ) exit help" }
+ hint := lipgloss.NewStyle().Background(bg).Foreground(cPeach).Width(remaining).Align(lipgloss.Right).Render(helpText)
+ content += hint
+ }
+
+ return content
+}
+
+type colW struct{ name, state, status, cpu, mem, id, image, rx, tx int }
+
+func (a *App) colWidths() colW {
+ cmdW := a.Width * 10 / 100
+ if cmdW < 12 { cmdW = 12 }
+ inner := a.Width - cmdW - 6 - 3 // -6 for borders, -3 for row selector prefix
+ if inner < 60 { inner = 60 }
+
+ // Fixed-width columns (content has predictable size)
+ const (
+ cpuW = 8 // "99.99%"
+ idW = 10 // 8 chars + pad
+ rxW = 9 // "999.9 MB"
+ txW = 9
+ )
+
+ // Compute max widths from data for variable columns (use rune count for unicode)
+ nameMax, stateMax, statusMax, memMax, imageMax := 6, 7, 8, 8, 7 // header minimums
+ for _, c := range a.filtered() {
+ if n := len([]rune(c.Name)); n > nameMax { nameMax = n }
+ stateLen := len([]rune(c.StateStr)) + 2 // icon + space
+ if stateLen > stateMax { stateMax = stateLen }
+ if n := len([]rune(c.Status)); n > statusMax { statusMax = n }
+ memStr := fmtBytes(c.MemUsage) + " / " + fmtBytes(c.MemLimit)
+ if n := len([]rune(memStr)); n > memMax { memMax = n }
+ if n := len([]rune(c.Image)); n > imageMax { imageMax = n }
+ }
+
+ fixed := cpuW + idW + rxW + txW
+ avail := inner - fixed
+ if avail < 30 { avail = 30 }
+
+ // Proportional distribution of variable columns
+ total := nameMax + stateMax + statusMax + memMax + imageMax
+ if total == 0 { total = 1 }
+
+ nameW := avail * nameMax / total
+ stateW := avail * stateMax / total
+ statusW := avail * statusMax / total
+ memW := avail * memMax / total
+ imageW := avail - nameW - stateW - statusW - memW // give remainder to image
+
+ // Apply minimums
+ if nameW < 6 { nameW = 6 }
+ if stateW < 7 { stateW = 7 }
+ if statusW < 8 { statusW = 8 }
+ if memW < 8 { memW = 8 }
+ if imageW < 7 { imageW = 7 }
+
+ return colW{
+ name: nameW, state: stateW, status: statusW,
+ cpu: cpuW, mem: memW, id: idW,
+ image: imageW, rx: rxW, tx: txW,
+ }
+}
+
+// --- Container Section ---
+
+func (a *App) viewContainerSection(h int) string {
+ cmdW := a.Width * 10 / 100
+ if cmdW < 12 { cmdW = 12 }
+ tableW := a.Width - cmdW - 4
+ table := a.viewContainerTable(tableW, h)
+ cmds := a.viewCommands(cmdW, h)
+ return lipgloss.JoinHorizontal(lipgloss.Top, table, cmds)
+}
+
+func (a *App) viewContainerTable(w, h int) string {
+ bc := a.borderUnselected()
+ if a.ActivePanel == PanelContainers { bc = a.borderSelected() }
+ style := lipgloss.NewStyle().Border(lipgloss.RoundedBorder()).BorderForeground(bc).Width(w).Height(h - 2)
+
+ cs := a.filtered()
+ total := len(cs)
+ sel := a.SelectedIdx + 1
+ if total == 0 { sel = 0 }
+
+ title := fmt.Sprintf("Containers %d/%d", sel, total)
+
+ var sb strings.Builder
+ sb.WriteString(lipgloss.NewStyle().Foreground(cPeach).Bold(true).Render(title) + "\n")
+
+ if a.FilterMode {
+ filterLabel := lipgloss.NewStyle().Foreground(cYellow).Bold(true).Render(fmt.Sprintf("Filter(%s): ", a.FilterBy))
+ filterInput := lipgloss.NewStyle().Foreground(cText).Render(a.FilterText + "_")
+ sb.WriteString(filterLabel + filterInput + "\n")
+ }
+
+ vis := h - 4
+ if vis < 1 { vis = 1 }
+ end := a.ScrollOffset + vis
+ if end > len(cs) { end = len(cs) }
+ cw := a.colWidths()
+
+ if total == 0 {
+ sb.WriteString(lipgloss.NewStyle().Foreground(cOverlay0).Render(" No containers found"))
+ return style.Render(sb.String())
+ }
+
+ for idx := a.ScrollOffset; idx < end; idx++ {
+ c := cs[idx]
+ selected := idx == a.SelectedIdx
+
+ var row strings.Builder
+ if selected {
+ row.WriteString(lipgloss.NewStyle().Foreground(cBlue).Render(" > "))
+ } else {
+ row.WriteString(" ")
+ }
+
+ textStyle := lipgloss.NewStyle().Foreground(cBlue)
+ rxStyle := lipgloss.NewStyle().Foreground(cTeal)
+ txStyle := lipgloss.NewStyle().Foreground(cPeach)
+ icon, _ := stateStyle(c.State)
+ sc := a.stateColorCfg(c.State)
+ row.WriteString(textStyle.Render(padR(c.Name, cw.name)))
+ stateText := icon + " " + c.StateStr
+ row.WriteString(lipgloss.NewStyle().Foreground(sc).Render(padR(stateText, cw.state)))
+ row.WriteString(lipgloss.NewStyle().Foreground(sc).Render(padR(trunc(c.Status, cw.status-1), cw.status)))
+ row.WriteString(padR(fmt.Sprintf("%05.2f%%", c.CPUPercent), cw.cpu))
+ row.WriteString(padR(fmtBytes(c.MemUsage)+" / "+fmtBytes(c.MemLimit), cw.mem))
+ idStr := c.ID
+ if len(idStr) > 8 { idStr = idStr[:8] }
+ row.WriteString(textStyle.Render(padR(idStr, cw.id)))
+ row.WriteString(textStyle.Render(padR(trunc(c.Image, cw.image-1), cw.image)))
+ row.WriteString(rxStyle.Render(padL(fmtBytes(c.RxBytes), cw.rx)))
+ row.WriteString(txStyle.Render(padL(fmtBytes(c.TxBytes), cw.tx)))
+
+ if selected {
+ sb.WriteString(lipgloss.NewStyle().Bold(true).Render(row.String()))
+ } else {
+ sb.WriteString(row.String())
+ }
+ sb.WriteString("\n")
+ }
+
+ return style.Render(sb.String())
+}
+
+func (a *App) viewCommands(w, h int) string {
+ bc := a.borderUnselected()
+ if a.ActivePanel == PanelCommands { bc = a.borderSelected() }
+ style := lipgloss.NewStyle().Border(lipgloss.RoundedBorder()).BorderForeground(bc).Width(w).Height(h - 2)
+
+ c := a.selected()
+ if c == nil { return style.Render("") }
+
+ cmds := commandsForState(c.State)
+ if a.CmdSelectedIdx >= len(cmds) {
+ a.CmdSelectedIdx = 0
+ }
+ arrow := lipgloss.NewStyle().Foreground(cBlue).Bold(true).Render("▶ ")
+
+ var sb strings.Builder
+ for i, cmd := range cmds {
+ color := a.cmdColorCfg(cmd)
+ if i == a.CmdSelectedIdx {
+ sb.WriteString(arrow + lipgloss.NewStyle().Foreground(color).Bold(true).Render(cmd) + "\n")
+ } else {
+ sb.WriteString(" " + lipgloss.NewStyle().Foreground(color).Bold(true).Render(cmd) + "\n")
+ }
+ }
+
+ return style.Render(sb.String())
+}
+
+// --- Logs ---
+
+func (a *App) viewLogs(h int) string {
+ bc := a.borderUnselected()
+ if a.ActivePanel == PanelLogs { bc = a.borderSelected() }
+ style := lipgloss.NewStyle().Border(lipgloss.RoundedBorder()).BorderForeground(bc).Width(a.Width - 2).Height(h - 2)
+
+ c := a.selected()
+ name := ""
+ if c != nil { name = c.Name }
+
+ total := len(a.LogLines)
+ vis := a.logsVisibleRows()
+ end := a.LogScroll + vis
+ if end > total { end = total }
+
+ title := fmt.Sprintf("Logs %d/%d - %s", end, total, name)
+
+ var sb strings.Builder
+ sb.WriteString(lipgloss.NewStyle().Foreground(cPeach).Bold(true).Render(title) + "\n")
+
+ if a.SearchMode {
+ searchLabel := lipgloss.NewStyle().Foreground(cYellow).Bold(true).Render("Search: ")
+ searchInput := lipgloss.NewStyle().Foreground(cText).Render(a.SearchText + "_")
+ matchInfo := lipgloss.NewStyle().Foreground(cSubtext0).Render(fmt.Sprintf(" (%d matches)", len(a.SearchMatches)))
+ sb.WriteString(searchLabel + searchInput + matchInfo + "\n")
+ }
+
+ rows := h - 4
+ if rows < 1 { rows = 1 }
+
+ if total == 0 {
+ if c != nil && c.LogsSince == "" {
+ sb.WriteString(lipgloss.NewStyle().Foreground(cOverlay0).Render("parsing logs..."))
+ } else {
+ sb.WriteString(lipgloss.NewStyle().Foreground(cOverlay0).Render("No logs available"))
+ }
+ } else {
+ start := a.LogScroll
+ end := start + rows
+ if end > total { end = total; start = end - rows; if start < 0 { start = 0 } }
+
+ maxW := a.Width - 8
+ if maxW < 20 { maxW = 20 }
+
+ for i := start; i < end; i++ {
+ line := stripAnsi(a.LogLines[i])
+ runes := []rune(line)
+ // Horizontal scroll (rune-based for UTF-8)
+ if a.LogHScroll > 0 && len(runes) > a.LogHScroll {
+ runes = runes[a.LogHScroll:]
+ } else if a.LogHScroll > 0 {
+ runes = nil
+ }
+ if len(runes) > maxW { runes = runes[:maxW] }
+ line = string(runes)
+
+ prefix := " "
+ if i == end-1 {
+ prefix = lipgloss.NewStyle().Foreground(cBlue).Render("▶ ")
+ }
+
+ // Highlight search matches (substring-level)
+ if a.SearchText != "" {
+ caseSensitive := a.Config != nil && a.Config.LogSearchCaseSensitive
+ line = highlightMatches(line, a.SearchText, caseSensitive)
+ }
+
+ sb.WriteString(prefix + line + "\n")
+ }
+ }
+
+ return style.Render(sb.String())
+}
+
+// --- Bottom: Charts + Ports ---
+
+func (a *App) viewBottom(h int) string {
+ c := a.selected()
+ portsW := a.Width * 18 / 100
+ if portsW < 22 { portsW = 22 }
+ remaining := a.Width - portsW - 8
+ chartW := remaining / 3
+
+ cpu := a.viewSparkChart("cpu", chartW, h, c)
+ mem := a.viewSparkChart("memory", chartW, h, c)
+ bw := a.viewBWChart(chartW, h, c)
+ ports := a.viewPorts(portsW, h, c)
+
+ return lipgloss.JoinHorizontal(lipgloss.Top, cpu, mem, bw, ports)
+}
+
+func (a *App) viewSparkChart(typ string, w, h int, c *Container) string {
+ bc := a.borderUnselected()
+ var title string
+ var data []float64
+ var color lipgloss.Color
+ var yLabel string
+
+ if c != nil {
+ isActive := c.State == RunningHealthy || c.State == RunningUnhealthy
+ switch typ {
+ case "cpu":
+ title = fmt.Sprintf("cpu %05.2f%%", c.CPUPercent)
+ data = c.CPUHist
+ if isActive { color = cGreen } else { color = cOverlay0 }
+ case "memory":
+ title = fmt.Sprintf("memory %s", fmtBytes(c.MemUsage))
+ for _, v := range c.MemHist { data = append(data, float64(v)) }
+ if isActive { color = cBlue } else { color = cOverlay0 }
+ }
+ } else {
+ switch typ {
+ case "cpu":
+ title = "cpu 00.00%"
+ color = cGreen
+ case "memory":
+ title = "memory 0.00 kB"
+ color = cBlue
+ }
+ }
+
+ // Y-axis label: max value
+ maxVal := 0.0
+ for _, v := range data {
+ if v > maxVal { maxVal = v }
+ }
+ if typ == "cpu" && maxVal > 0 {
+ yLabel = fmt.Sprintf("%05.2f%%", maxVal)
+ } else if typ == "memory" && maxVal > 0 {
+ yLabel = fmtBytes(uint64(maxVal))
+ }
+
+ return a.renderBrailleChart(title, yLabel, data, color, bc, w, h)
+}
+
+func (a *App) viewBWChart(w, h int, c *Container) string {
+ bc := a.borderUnselected()
+
+ rxRate, txRate := "0.00 kB/s", "0.00 kB/s"
+ var rxData, txData []float64
+ if c != nil {
+ rxData = histDeltas(c.RxHist)
+ txData = histDeltas(c.TxHist)
+ if len(rxData) > 0 {
+ rxRate = fmtRate(uint64(rxData[len(rxData)-1]))
+ }
+ if len(txData) > 0 {
+ txRate = fmtRate(uint64(txData[len(txData)-1]))
+ }
+ }
+
+ title := lipgloss.NewStyle().Foreground(cTeal).Render("rx: "+rxRate) +
+ " " + lipgloss.NewStyle().Foreground(cPeach).Render("tx: "+txRate)
+
+ return a.renderBrailleBWChart(title, rxData, txData, rxRate, txRate, bc, w, h)
+}
+
+// renderBrailleChart renders a single-dataset braille chart with Y-axis label and title in border
+func (a *App) renderBrailleChart(title, yLabel string, data []float64, color, borderColor lipgloss.Color, w, h int) string {
+ innerH := h - 2 // border takes 2
+ innerW := w - 2 // border takes 2
+ if innerH < 1 { innerH = 1 }
+ if innerW < 4 { innerW = 4 }
+
+ yLabelW := 0
+ if yLabel != "" {
+ yLabelW = len([]rune(yLabel)) + 1 // +1 for separator
+ }
+ chartW := innerW - yLabelW
+ if chartW < 2 { chartW = 2 }
+
+ chart := brailleChart(data, chartW, innerH, color)
+ chartLines := strings.Split(chart, "\n")
+ if len(chartLines) == 0 {
+ chartLines = []string{""}
+ }
+
+ // Build content with Y-axis label
+ var sb strings.Builder
+ yStyle := lipgloss.NewStyle().Foreground(color)
+ for i, line := range chartLines {
+ if i == 0 && yLabel != "" {
+ sb.WriteString(yStyle.Render(padL(yLabel, yLabelW-1)))
+ sb.WriteString(lipgloss.NewStyle().Foreground(cSurface0).Render("│"))
+ } else if yLabelW > 0 {
+ sb.WriteString(strings.Repeat(" ", yLabelW-1))
+ sb.WriteString(lipgloss.NewStyle().Foreground(cSurface0).Render("│"))
+ }
+ sb.WriteString(line)
+ if i < len(chartLines)-1 {
+ sb.WriteString("\n")
+ }
+ }
+
+ // Title in top border (like original Rust)
+ titleRendered := " " + lipgloss.NewStyle().Foreground(cText).Bold(true).Render(title) + " "
+ titleW := lipgloss.Width(titleRendered)
+ topBorder := "╭"
+ leftDash := (w - 2 - titleW) / 2
+ if leftDash < 1 { leftDash = 1 }
+ rightDash := w - 2 - titleW - leftDash
+ if rightDash < 1 { rightDash = 1 }
+ topBorder += strings.Repeat("─", leftDash) + titleRendered + strings.Repeat("─", rightDash) + "╮"
+
+ // Bottom border
+ bottomBorder := "╰" + strings.Repeat("─", w-2) + "╯"
+
+ // Side borders around content
+ contentLines := strings.Split(sb.String(), "\n")
+ var result strings.Builder
+ bStyle := lipgloss.NewStyle().Foreground(borderColor)
+ result.WriteString(bStyle.Render(topBorder) + "\n")
+ for i := 0; i < innerH; i++ {
+ line := ""
+ if i < len(contentLines) { line = contentLines[i] }
+ lineW := lipgloss.Width(line)
+ pad := innerW - lineW
+ if pad < 0 { pad = 0 }
+ result.WriteString(bStyle.Render("│") + line + strings.Repeat(" ", pad) + bStyle.Render("│"))
+ if i < innerH-1 {
+ result.WriteString("\n")
+ }
+ }
+ result.WriteString("\n" + bStyle.Render(bottomBorder))
+
+ return result.String()
+}
+
+// renderBrailleBWChart renders RX/TX as two braille charts stacked, with title in border
+func (a *App) renderBrailleBWChart(title string, rxData, txData []float64, rxRate, txRate string, borderColor lipgloss.Color, w, h int) string {
+ innerH := h - 2
+ innerW := w - 2
+ if innerH < 2 { innerH = 2 }
+ if innerW < 4 { innerW = 4 }
+
+ halfH := (innerH - 1) / 2 // -1 for separator between rx/tx
+ if halfH < 1 { halfH = 1 }
+
+ // Y-axis label width (use rx or tx rate)
+ yLabelW := 0
+ rxYLabel := fmtRateShort(rxData)
+ txYLabel := fmtRateShort(txData)
+ if len([]rune(rxYLabel)) > yLabelW { yLabelW = len([]rune(rxYLabel)) }
+ if len([]rune(txYLabel)) > yLabelW { yLabelW = len([]rune(txYLabel)) }
+ if yLabelW > 0 { yLabelW += 1 } // separator
+ chartW := innerW - yLabelW
+ if chartW < 2 { chartW = 2 }
+
+ rxChart := brailleChart(rxData, chartW, halfH, cTeal)
+ txChart := brailleChart(txData, chartW, halfH, cPeach)
+
+ rxLines := strings.Split(rxChart, "\n")
+ txLines := strings.Split(txChart, "\n")
+
+ // Build content
+ var sb strings.Builder
+ yStyle := lipgloss.NewStyle()
+ sepStyle := lipgloss.NewStyle().Foreground(cSurface0)
+
+ // RX section
+ for i, line := range rxLines {
+ if i == 0 && rxYLabel != "" {
+ sb.WriteString(yStyle.Foreground(cTeal).Render(padL(rxYLabel, yLabelW-1)))
+ sb.WriteString(sepStyle.Render("│"))
+ } else if yLabelW > 0 {
+ sb.WriteString(strings.Repeat(" ", yLabelW-1))
+ sb.WriteString(sepStyle.Render("│"))
+ }
+ sb.WriteString(line + "\n")
+ }
+
+ // TX section
+ for i, line := range txLines {
+ if i == 0 && txYLabel != "" {
+ sb.WriteString(yStyle.Foreground(cPeach).Render(padL(txYLabel, yLabelW-1)))
+ sb.WriteString(sepStyle.Render("│"))
+ } else if yLabelW > 0 {
+ sb.WriteString(strings.Repeat(" ", yLabelW-1))
+ sb.WriteString(sepStyle.Render("│"))
+ }
+ sb.WriteString(line)
+ if i < len(txLines)-1 {
+ sb.WriteString("\n")
+ }
+ }
+
+ // Title in top border
+ titleW := lipgloss.Width(title)
+ titleRendered := " " + title + " "
+ titleRW := titleW + 2
+ topBorder := "╭"
+ leftDash := (w - 2 - titleRW) / 2
+ if leftDash < 1 { leftDash = 1 }
+ rightDash := w - 2 - titleRW - leftDash
+ if rightDash < 1 { rightDash = 1 }
+ topBorder += strings.Repeat("─", leftDash) + titleRendered + strings.Repeat("─", rightDash) + "╮"
+
+ bottomBorder := "╰" + strings.Repeat("─", w-2) + "╯"
+
+ contentLines := strings.Split(sb.String(), "\n")
+ var result strings.Builder
+ bStyle := lipgloss.NewStyle().Foreground(borderColor)
+ result.WriteString(bStyle.Render(topBorder) + "\n")
+ for i := 0; i < innerH; i++ {
+ line := ""
+ if i < len(contentLines) { line = contentLines[i] }
+ lineW := lipgloss.Width(line)
+ pad := innerW - lineW
+ if pad < 0 { pad = 0 }
+ result.WriteString(bStyle.Render("│") + line + strings.Repeat(" ", pad) + bStyle.Render("│"))
+ if i < innerH-1 {
+ result.WriteString("\n")
+ }
+ }
+ result.WriteString("\n" + bStyle.Render(bottomBorder))
+
+ return result.String()
+}
+
+func fmtRateShort(data []float64) string {
+ if len(data) == 0 { return "" }
+ maxV := 0.0
+ for _, v := range data {
+ if v > maxV { maxV = v }
+ }
+ if maxV == 0 { return "" }
+ return fmtRate(uint64(maxV))
+}
+
+// histDeltas computes per-interval deltas from cumulative history
+func histDeltas(hist []uint64) []float64 {
+ if len(hist) < 2 {
+ return nil
+ }
+ deltas := make([]float64, 0, len(hist)-1)
+ for i := 1; i < len(hist); i++ {
+ if hist[i] >= hist[i-1] {
+ deltas = append(deltas, float64(hist[i]-hist[i-1]))
+ } else {
+ deltas = append(deltas, 0)
+ }
+ }
+ return deltas
+}
+
+func (a *App) viewPorts(w, h int, c *Container) string {
+ style := lipgloss.NewStyle().Border(lipgloss.RoundedBorder()).BorderForeground(cSurface0).Width(w).Height(h - 2)
+
+ var sb strings.Builder
+ titleStr := "ports"
+ pad := (w - len(titleStr)) / 2
+ if pad < 0 { pad = 0 }
+ sb.WriteString(strings.Repeat(" ", pad) + lipgloss.NewStyle().Foreground(cText).Bold(true).Render(titleStr) + "\n")
+
+ if c == nil || len(c.Ports) == 0 {
+ sb.WriteString(lipgloss.NewStyle().Foreground(cOverlay0).Render("no ports"))
+ } else {
+ sb.WriteString(lipgloss.NewStyle().Foreground(cOverlay0).Render(fmt.Sprintf("%-10s %8s %8s", "ip", "private", "public")) + "\n")
+ for _, p := range c.Ports {
+ ip := p.IP
+ pubStr := ""
+ if p.Public > 0 {
+ pubStr = fmt.Sprintf("%d", p.Public)
+ }
+ sb.WriteString(fmt.Sprintf("%-10s %8d %8s\n", ip, p.Private, pubStr))
+ }
+ }
+
+ return style.Render(sb.String())
+}
+
+// --- Overlays ---
+
+func (a *App) overlayDeleteConfirm(base string) string {
+ name := ""
+ for _, c := range a.Containers {
+ if c.ID == a.DeleteTarget { name = c.Name; break }
+ }
+ if a.DeleteTarget == "" {
+ a.DeleteConfirm = false
+ return base
+ }
+ box := lipgloss.NewStyle().
+ Border(lipgloss.RoundedBorder()).
+ BorderForeground(cRed).
+ Background(cMantle).
+ Padding(1, 3).
+ Render(fmt.Sprintf("Delete container %s?\n\n (y) Confirm (n) Cancel",
+ lipgloss.NewStyle().Bold(true).Foreground(cPeach).Render(name)))
+
+ return placeOverlay(base, box, lipgloss.Center, lipgloss.Center, a.Width, a.Height)
+}
+
+func (a *App) overlayError(base string) string {
+ msg := fmt.Sprintf("Error: %v\n\nPress (c) to clear or (esc) to dismiss", a.Error)
+ if a.ConnectCountdown > 0 {
+ msg = fmt.Sprintf("Error: %v\n\nExiting in %d seconds... Press (q) to quit now", a.Error, a.ConnectCountdown)
+ }
+ box := lipgloss.NewStyle().
+ Border(lipgloss.RoundedBorder()).
+ BorderForeground(cRed).
+ Foreground(cRed).
+ Padding(1, 3).
+ Render(msg)
+
+ return placeOverlay(base, box, lipgloss.Center, lipgloss.Center, a.Width, a.Height)
+}
+
+func (a *App) overlayInfo(base string) string {
+ box := lipgloss.NewStyle().
+ Border(lipgloss.RoundedBorder()).
+ BorderForeground(cTeal).
+ Padding(0, 2).
+ Render(a.InfoText)
+
+ // Bottom right — overlay on base
+ return placeOverlay(base, box, lipgloss.Right, lipgloss.Bottom, a.Width, a.Height)
+}
+
+// --- Inspect View ---
+
+func (a *App) viewInspect() string {
+ lines := strings.Split(a.InspectData, "\n")
+ total := len(lines)
+ maxLineW := 0
+ for _, l := range lines {
+ if len(l) > maxLineW { maxLineW = len(l) }
+ }
+
+ vis := a.Height - 4
+ if vis < 1 { vis = 1 }
+ start := a.InspectScrollY
+ if start >= total { start = total - 1 }
+ if start < 0 { start = 0 }
+ end := start + vis
+ if end > total { end = total }
+
+ c := a.selected()
+ name := ""
+ if c != nil { name = c.Name + " " + c.ID[:minI(8, len(c.ID))] }
+
+ titleTop := fmt.Sprintf("inspecting: %s (esc/i/q to exit)", name)
+ titleBot := fmt.Sprintf("↑ %d/%d ↓ ← %d/%d →", a.InspectScrollY, total, a.InspectScrollX, maxLineW)
+
+ var sb strings.Builder
+ for i := start; i < end; i++ {
+ line := lines[i]
+ if a.InspectScrollX > 0 && len(line) > a.InspectScrollX {
+ line = line[a.InspectScrollX:]
+ } else if a.InspectScrollX > 0 {
+ line = ""
+ }
+ // Wrap long lines instead of truncating
+ lineW := a.Width - 6
+ if lineW < 10 { lineW = 10 }
+ for len(line) > lineW {
+ sb.WriteString(line[:lineW] + "\n")
+ line = line[lineW:]
+ }
+ sb.WriteString(line + "\n")
+ }
+
+ style := lipgloss.NewStyle().
+ Border(lipgloss.RoundedBorder()).
+ BorderForeground(cBlue).
+ Width(a.Width - 2).
+ Height(a.Height - 2)
+
+ header := lipgloss.NewStyle().Foreground(cPeach).Bold(true).Render(titleTop)
+ footer := lipgloss.NewStyle().Foreground(cSubtext0).Render(titleBot)
+ content := lipgloss.NewStyle().Foreground(cOverlay0).Render(sb.String())
+
+ return style.Render(header + "\n" + content + "\n" + footer)
+}
+
+// --- Help View ---
+
+func (a *App) overlayHelp(base string) string {
+ configPath := ""
+ if a.Config != nil && a.Config.DirConfig != "" {
+ configPath = a.Config.DirConfig
+ }
+
+ var sb strings.Builder
+ sb.WriteString(" oxker — Docker TUI (Go)\n\n")
+ if configPath != "" {
+ sb.WriteString(fmt.Sprintf(" Config: %s\n\n", configPath))
+ }
+ sb.WriteString(` Navigation
+ j/k ↑/↓ Scroll containers/logs/commands
+ J/K Scroll 10x speed
+ PgUp/PgDn Page scroll
+ g/G Top / Bottom
+ Tab/Shift+Tab Switch panels (Containers → Commands → Logs)
+ ←/→ Scroll logs horizontally
+
+ Sorting
+ 1 Name 2 State 3 Status
+ 4 CPU 5 Memory 6 ID
+ 7 Image 8 RX 9 TX
+ 0 Reset sort
+
+ Filtering & Search
+ / Filter containers (←/→ change filter: Name/Image/Status/All)
+ # Search logs (↑/↓ or Ctrl+N/P next/prev match)
+
+ Container Actions
+ s Start x Stop r Restart
+ p Pause u Unpause d Delete
+ e Exec into container (sh)
+ Enter Execute selected command (in Commands panel)
+
+ Display
+ l Toggle logs panel
+ [ / ] Resize logs panel
+ i Inspect container (JSON, scroll with j/k/h/l)
+ S / Ctrl+S Save logs to file
+ c Clear errors
+ h Toggle help
+ Esc Dismiss overlays
+
+ Quit
+ q / Ctrl+C`)
+
+ help := sb.String()
+
+ box := lipgloss.NewStyle().
+ Border(lipgloss.RoundedBorder()).
+ BorderForeground(cMauve).
+ Padding(1, 3).
+ Render(help)
+
+ return placeOverlay(base, box, lipgloss.Center, lipgloss.Center, a.Width, a.Height)
+}
+
+// ============================================================
+// OVERLAY HELPER
+// ============================================================
+
+// placeOverlay renders fg on top of bg at the given position.
+// hPos: lipgloss.Left, Center, Right. vPos: lipgloss.Top, Center, Bottom.
+func placeOverlay(bg string, fg string, hPos, vPos lipgloss.Position, bgW, bgH int) string {
+ bgLines := strings.Split(bg, "\n")
+ fgLines := strings.Split(fg, "\n")
+ fgW := 0
+ for _, l := range fgLines {
+ if w := lipgloss.Width(l); w > fgW { fgW = w }
+ }
+ fgH := len(fgLines)
+
+ // Compute top-left corner of overlay
+ var x, y int
+ switch hPos {
+ case lipgloss.Left:
+ x = 0
+ case lipgloss.Right:
+ x = bgW - fgW
+ default: // Center
+ x = (bgW - fgW) / 2
+ }
+ switch vPos {
+ case lipgloss.Top:
+ y = 0
+ case lipgloss.Bottom:
+ y = bgH - fgH
+ default: // Center
+ y = (bgH - fgH) / 2
+ }
+ if x < 0 { x = 0 }
+ if y < 0 { y = 0 }
+
+ // Pad bg to ensure enough lines
+ for len(bgLines) < bgH {
+ bgLines = append(bgLines, strings.Repeat(" ", bgW))
+ }
+
+ // Overlay fg onto bg line by line
+ for i, fgLine := range fgLines {
+ bgIdx := y + i
+ if bgIdx >= len(bgLines) { break }
+
+ // Pad the fg line to fgW so overlay has consistent width
+ fgLineW := lipgloss.Width(fgLine)
+ if fgLineW < fgW {
+ fgLine += strings.Repeat(" ", fgW-fgLineW)
+ }
+
+ // Build: [left padding] + [fg line] + [right padding]
+ // We sacrifice the bg content under the overlay (acceptable for small overlays)
+ bgLine := bgLines[bgIdx]
+ bgLineW := lipgloss.Width(bgLine)
+
+ left := strings.Repeat(" ", x)
+ rightW := bgW - x - fgW
+ right := ""
+ if rightW > 0 {
+ right = strings.Repeat(" ", rightW)
+ }
+
+ // Try to preserve bg content outside the overlay area
+ // Left part: use bg line if it has content
+ if bgLineW > 0 && x > 0 {
+ left = lipgloss.NewStyle().Width(x).MaxWidth(x).Inline(true).Render(bgLine)
+ if lipgloss.Width(left) < x {
+ left += strings.Repeat(" ", x-lipgloss.Width(left))
+ }
+ }
+
+ bgLines[bgIdx] = left + fgLine + right
+ }
+
+ return strings.Join(bgLines[:bgH], "\n")
+}
+
+// ============================================================
+// LAYOUT HELPERS
+// ============================================================
+
+func (a *App) containerAreaHeight() int {
+ h := a.Height * 30 / 100
+ if h < 6 { h = 6 }
+ return h
+}
+
+func (a *App) logsAreaHeight() int {
+ if !a.ShowLogs { return 0 }
+ ch := a.containerAreaHeight()
+ bh := a.chartsAreaHeight()
+ lh := a.Height - ch - bh - 1
+ if lh < 5 { lh = 5 }
+ // Apply log height percentage
+ maxLogs := a.Height * a.LogHeight / 100
+ if lh > maxLogs { lh = maxLogs }
+ return lh
+}
+
+func (a *App) chartsAreaHeight() int {
+ h := a.Height * 22 / 100
+ if h < 7 { h = 7 }
+ return h
+}
+
+func (a *App) containerVisibleRows() int {
+ h := a.containerAreaHeight() - 4
+ if h < 1 { h = 1 }
+ return h
+}
+
+func (a *App) logsVisibleRows() int {
+ h := a.logsAreaHeight() - 4
+ if h < 1 { h = 1 }
+ return h
+}
+
+// ============================================================
+// FILTERING
+// ============================================================
+
+func (a *App) filtered() []Container {
+ if a.FilterText == "" { return a.Containers }
+ term := strings.ToLower(a.FilterText)
+ var out []Container
+ for _, c := range a.Containers {
+ match := false
+ switch a.FilterBy {
+ case FilterByName:
+ match = strings.Contains(strings.ToLower(c.Name), term)
+ case FilterByImage:
+ match = strings.Contains(strings.ToLower(c.Image), term)
+ case FilterByStatus:
+ match = strings.Contains(strings.ToLower(c.Status), term)
+ case FilterByAll:
+ match = strings.Contains(strings.ToLower(c.Name), term) ||
+ strings.Contains(strings.ToLower(c.Image), term) ||
+ strings.Contains(strings.ToLower(c.Status), term)
+ }
+ if match { out = append(out, c) }
+ }
+ return out
+}
+
+// ============================================================
+// HELPERS
+// ============================================================
+
+func stateStyle(s ContainerState) (string, lipgloss.Color) {
+ switch s {
+ case RunningHealthy: return "✓", cGreen
+ case RunningUnhealthy: return "!", cPeach
+ case Paused: return "‖", cYellow
+ case Exited: return "✖", cRed
+ case Dead: return "✖", cRed
+ case Restarting: return "↻", cTeal
+ case Removing: return "…", cRed
+ case Created: return "?", cOverlay0
+ default: return "?", cOverlay0
+ }
+}
+
+func commandsForState(s ContainerState) []string {
+ switch s {
+ case RunningHealthy:
+ return []string{"pause", "restart", "stop", "delete"}
+ case RunningUnhealthy:
+ return []string{"pause", "restart", "stop", "delete"}
+ case Paused:
+ return []string{"resume", "stop", "delete"}
+ case Exited, Dead, Created:
+ return []string{"start", "restart", "delete"}
+ case Unknown:
+ return []string{"delete"}
+ case Restarting:
+ return []string{"stop", "delete"}
+ case Removing:
+ return []string{"delete"}
+ default:
+ return []string{"delete"}
+ }
+}
+
+func cmdColor(cmd string) lipgloss.Color {
+ switch cmd {
+ case "start":
+ return cGreen
+ case "resume":
+ return cBlue
+ case "restart":
+ return cMauve
+ case "pause":
+ return cYellow
+ case "stop":
+ return cRed
+ case "delete":
+ return cOverlay0
+ default:
+ return cText
+ }
+}
+
+// brailleChart renders data as a braille dot chart (matching original Rust ratatui style).
+// Each terminal cell is a 2×4 braille grid, giving (w*2) × (h*4) resolution.
+func brailleChart(data []float64, w, h int, color lipgloss.Color) string {
+ if w <= 0 || h <= 0 { return "" }
+
+ // Braille dot offsets: each char is 2 cols × 4 rows
+ // Bit positions: col0=[0,1,2,6] col1=[3,4,5,7] for rows 0,1,2,3
+ dotBits := [2][4]rune{
+ {0x01, 0x02, 0x04, 0x40}, // left column (col 0)
+ {0x08, 0x10, 0x20, 0x80}, // right column (col 1)
+ }
+
+ pixW := w * 2 // horizontal pixel resolution
+ pixH := h * 4 // vertical pixel resolution
+
+ // Take last pixW data points (each data point = 1 pixel column)
+ start := 0
+ if len(data) > pixW { start = len(data) - pixW }
+ visible := data[start:]
+
+ maxV := 0.0
+ for _, v := range visible {
+ if v > maxV { maxV = v }
+ }
+ if maxV == 0 { maxV = 1 }
+
+ // Create pixel grid (row 0 = bottom)
+ grid := make([][]bool, pixH)
+ for i := range grid {
+ grid[i] = make([]bool, pixW)
+ }
+
+ // Plot data points
+ for i, v := range visible {
+ py := int(v / maxV * float64(pixH-1))
+ if py >= pixH { py = pixH - 1 }
+ if py < 0 { py = 0 }
+ grid[py][i] = true
+ }
+
+ // Render braille characters
+ s := lipgloss.NewStyle().Foreground(color)
+ dimS := lipgloss.NewStyle().Foreground(cSurface1)
+ var lines []string
+
+ for cellRow := h - 1; cellRow >= 0; cellRow-- {
+ var b strings.Builder
+ for cellCol := 0; cellCol < w; cellCol++ {
+ var ch rune = 0x2800 // braille base
+ hasDot := false
+ for dc := 0; dc < 2; dc++ {
+ for dr := 0; dr < 4; dr++ {
+ px := cellCol*2 + dc
+ // Map: cellRow*4 + dr, but row 0 of cell = top visually = highest pixel
+ py := cellRow*4 + (3 - dr)
+ if px < len(grid[0]) && py >= 0 && py < pixH && grid[py][px] {
+ ch |= dotBits[dc][dr]
+ hasDot = true
+ }
+ }
+ }
+ if hasDot {
+ b.WriteString(s.Render(string(ch)))
+ } else {
+ b.WriteString(dimS.Render(string(rune(0x2800)))) // empty braille
+ }
+ }
+ lines = append(lines, b.String())
+ }
+ return strings.Join(lines, "\n")
+}
+
+// SI units (1000-based, matching original)
+func fmtBytes(b uint64) string {
+ if b == 0 { return "0.00 kB" }
+ kb := float64(b) / 1000
+ if kb < 1000 { return fmt.Sprintf("%.2f kB", kb) }
+ mb := kb / 1000
+ if mb < 1000 { return fmt.Sprintf("%.2f MB", mb) }
+ gb := mb / 1000
+ return fmt.Sprintf("%.2f GB", gb)
+}
+
+func fmtRate(b uint64) string {
+ if b == 0 { return "0.00 kb/s" }
+ kb := float64(b) / 1000
+ if kb < 1000 { return fmt.Sprintf("%.2f kb/s", kb) }
+ mb := kb / 1000
+ if mb < 1000 { return fmt.Sprintf("%.2f Mb/s", mb) }
+ gb := mb / 1000
+ return fmt.Sprintf("%.2f Gb/s", gb)
+}
+
+func trunc(s string, n int) string {
+ if n <= 0 { return "" }
+ r := []rune(s)
+ if len(r) <= n { return s }
+ if n <= 3 { return string(r[:n]) }
+ return string(r[:n-3]) + "..."
+}
+
+func padR(s string, w int) string {
+ r := []rune(s)
+ if len(r) >= w { return string(r[:w]) }
+ return s + strings.Repeat(" ", w-len(r))
+}
+
+func padL(s string, w int) string {
+ r := []rune(s)
+ if len(r) >= w { return string(r[:w]) }
+ return strings.Repeat(" ", w-len(r)) + s
+}
+
+func highlightMatches(line, search string, caseSensitive bool) string {
+ haystack := line
+ term := search
+ if !caseSensitive {
+ haystack = strings.ToLower(line)
+ term = strings.ToLower(search)
+ }
+ idx := strings.Index(haystack, term)
+ if idx < 0 {
+ return line
+ }
+ hl := lipgloss.NewStyle().Foreground(cYellow).Bold(true)
+ var result strings.Builder
+ for idx >= 0 {
+ result.WriteString(line[:idx])
+ result.WriteString(hl.Render(line[idx : idx+len(search)]))
+ line = line[idx+len(search):]
+ if !caseSensitive {
+ haystack = strings.ToLower(line)
+ } else {
+ haystack = line
+ }
+ idx = strings.Index(haystack, term)
+ }
+ result.WriteString(line)
+ return result.String()
+}
+
+func minI(a, b int) int { if a < b { return a }; return b }
+func maxI(a, b int) int { if a > b { return a }; return b }
+
+// keyMatch checks if a key string matches any key in the slice (from config keymap)
+func keyMatch(key string, bindings []string) bool {
+ for _, b := range bindings {
+ if key == b { return true }
+ }
+ return false
+}
+
+func compareFloat(a, b float64) int {
+ if math.Abs(a-b) < 0.001 { return 0 }
+ if a < b { return -1 }
+ return 1
+}
+
+func compareUint(a, b uint64) int {
+ if a == b { return 0 }
+ if a < b { return -1 }
+ return 1
+}
+
+func appendMax(s []float64, v float64, max int) []float64 {
+ if len(s) >= max {
+ copy(s, s[1:])
+ s[len(s)-1] = v
+ return s
+ }
+ return append(s, v)
+}
+
+func appendMaxU(s []uint64, v uint64, max int) []uint64 {
+ if len(s) >= max {
+ copy(s, s[1:])
+ s[len(s)-1] = v
+ return s
+ }
+ return append(s, v)
+}
+
+func mapState(state, status string) ContainerState {
+ switch strings.ToLower(state) {
+ case "running":
+ if strings.Contains(strings.ToLower(status), "unhealthy") {
+ return RunningUnhealthy
+ }
+ return RunningHealthy
+ case "exited":
+ return Exited
+ case "paused":
+ return Paused
+ case "restarting":
+ return Restarting
+ case "removing":
+ return Removing
+ case "dead":
+ return Dead
+ case "created":
+ return Created
+ default:
+ return Unknown
+ }
+}
+
+func mapPorts(ports []container.Port) []ContainerPorts {
+ result := make([]ContainerPorts, len(ports))
+ for i, p := range ports {
+ result[i] = ContainerPorts{IP: p.IP, Private: int(p.PrivatePort), Public: int(p.PublicPort)}
+ }
+ return result
+}
diff --git a/internal/config/config.go b/internal/config/config.go
new file mode 100644
index 0000000..3ef5ff3
--- /dev/null
+++ b/internal/config/config.go
@@ -0,0 +1,645 @@
+package config
+
+import (
+ "encoding/json"
+ "os"
+ "path/filepath"
+ "strings"
+
+ "github.com/BurntSushi/toml"
+)
+
+type AppColors struct {
+ Borders Borders `toml:"borders,omitempty" json:"borders,omitempty"`
+ ChartCPU ChartCPU `toml:"chart_cpu,omitempty" json:"chart_cpu,omitempty"`
+ ChartMemory ChartMemory `toml:"chart_memory,omitempty" json:"chart_memory,omitempty"`
+ ChartBandwidth ChartBandwidth `toml:"chart_bandwidth,omitempty" json:"chart_bandwidth,omitempty"`
+ ChartPorts ChartPorts `toml:"chart_ports,omitempty" json:"chart_ports,omitempty"`
+ Commands Commands `toml:"commands,omitempty" json:"commands,omitempty"`
+ ContainerState ContainerState `toml:"container_state,omitempty" json:"container_state,omitempty"`
+ Containers Containers `toml:"containers,omitempty" json:"containers,omitempty"`
+ LogSearch LogSearch `toml:"log_search,omitempty" json:"log_search,omitempty"`
+ Filter Filter `toml:"filter,omitempty" json:"filter,omitempty"`
+ HeadersBar HeadersBar `toml:"headers_bar,omitempty" json:"headers_bar,omitempty"`
+ Logs Logs `toml:"logs,omitempty" json:"logs,omitempty"`
+ PopupDelete PopupDelete `toml:"popup_delete,omitempty" json:"popup_delete,omitempty"`
+ PopupError PopupError `toml:"popup_error,omitempty" json:"popup_error,omitempty"`
+ PopupHelp PopupHelp `toml:"popup_help,omitempty" json:"popup_help,omitempty"`
+ PopupInfo PopupInfo `toml:"popup_info,omitempty" json:"popup_info,omitempty"`
+}
+
+type Borders struct {
+ Selected string `toml:"selected,omitempty" json:"selected,omitempty"`
+ Unselected string `toml:"unselected,omitempty" json:"unselected,omitempty"`
+}
+
+type ChartCPU struct {
+ Background string `toml:"background,omitempty" json:"background,omitempty"`
+ Border string `toml:"border,omitempty" json:"border,omitempty"`
+ Title string `toml:"title,omitempty" json:"title,omitempty"`
+ Max string `toml:"max,omitempty" json:"max,omitempty"`
+ Points string `toml:"points,omitempty" json:"points,omitempty"`
+ YAxis string `toml:"y_axis,omitempty" json:"y_axis,omitempty"`
+}
+
+type ChartMemory struct {
+ Background string `toml:"background,omitempty" json:"background,omitempty"`
+ Border string `toml:"border,omitempty" json:"border,omitempty"`
+ Title string `toml:"title,omitempty" json:"title,omitempty"`
+ Max string `toml:"max,omitempty" json:"max,omitempty"`
+ Points string `toml:"points,omitempty" json:"points,omitempty"`
+ YAxis string `toml:"y_axis,omitempty" json:"y_axis,omitempty"`
+}
+
+type ChartBandwidth struct {
+ Background string `toml:"background,omitempty" json:"background,omitempty"`
+ Border string `toml:"border,omitempty" json:"border,omitempty"`
+ MaxRX string `toml:"max_rx,omitempty" json:"max_rx,omitempty"`
+ MaxTX string `toml:"max_tx,omitempty" json:"max_tx,omitempty"`
+ PointsRX string `toml:"points_rx,omitempty" json:"points_rx,omitempty"`
+ PointsTX string `toml:"points_tx,omitempty" json:"points_tx,omitempty"`
+ TitleRX string `toml:"title_rx,omitempty" json:"title_rx,omitempty"`
+ TitleTX string `toml:"title_tx,omitempty" json:"title_tx,omitempty"`
+ YAxis string `toml:"y_axis,omitempty" json:"y_axis,omitempty"`
+}
+
+type ChartPorts struct {
+ Background string `toml:"background,omitempty" json:"background,omitempty"`
+ Border string `toml:"border,omitempty" json:"border,omitempty"`
+ Title string `toml:"title,omitempty" json:"title,omitempty"`
+ Headings string `toml:"headings,omitempty" json:"headings,omitempty"`
+ Text string `toml:"text,omitempty" json:"text,omitempty"`
+}
+
+type Commands struct {
+ Background string `toml:"background,omitempty" json:"background,omitempty"`
+ Pause string `toml:"pause,omitempty" json:"pause,omitempty"`
+ Restart string `toml:"restart,omitempty" json:"restart,omitempty"`
+ Stop string `toml:"stop,omitempty" json:"stop,omitempty"`
+ Delete string `toml:"delete,omitempty" json:"delete,omitempty"`
+ Resume string `toml:"resume,omitempty" json:"resume,omitempty"`
+ Start string `toml:"start,omitempty" json:"start,omitempty"`
+}
+
+type ContainerState struct {
+ Dead string `toml:"dead,omitempty" json:"dead,omitempty"`
+ Exited string `toml:"exited,omitempty" json:"exited,omitempty"`
+ Paused string `toml:"paused,omitempty" json:"paused,omitempty"`
+ Removing string `toml:"removing,omitempty" json:"removing,omitempty"`
+ Restarting string `toml:"restarting,omitempty" json:"restarting,omitempty"`
+ RunningHealthy string `toml:"running_healthy,omitempty" json:"running_healthy,omitempty"`
+ RunningUnhealthy string `toml:"running_unhealthy,omitempty" json:"running_unhealthy,omitempty"`
+ Unknown string `toml:"unknown,omitempty" json:"unknown,omitempty"`
+}
+
+type Containers struct {
+ Background string `toml:"background,omitempty" json:"background,omitempty"`
+ Icon string `toml:"icon,omitempty" json:"icon,omitempty"`
+ Text string `toml:"text,omitempty" json:"text,omitempty"`
+ TextRX string `toml:"text_rx,omitempty" json:"text_rx,omitempty"`
+ TextTX string `toml:"text_tx,omitempty" json:"text_tx,omitempty"`
+}
+
+type LogSearch struct {
+ Background string `toml:"background,omitempty" json:"background,omitempty"`
+ Text string `toml:"text,omitempty" json:"text,omitempty"`
+ ButtonText string `toml:"button_text,omitempty" json:"button_text,omitempty"`
+ Highlight string `toml:"highlight,omitempty" json:"highlight,omitempty"`
+}
+
+type Filter struct {
+ Background string `toml:"background,omitempty" json:"background,omitempty"`
+ Text string `toml:"text,omitempty" json:"text,omitempty"`
+ SelectedFilterBackground string `toml:"selected_filter_background,omitempty" json:"selected_filter_background,omitempty"`
+ SelectedFilterText string `toml:"selected_filter_text,omitempty" json:"selected_filter_text,omitempty"`
+ Highlight string `toml:"highlight,omitempty" json:"highlight,omitempty"`
+}
+
+type HeadersBar struct {
+ Background string `toml:"background,omitempty" json:"background,omitempty"`
+ LoadingSpinner string `toml:"loading_spinner,omitempty" json:"loading_spinner,omitempty"`
+ Text string `toml:"text,omitempty" json:"text,omitempty"`
+ TextSelected string `toml:"text_selected,omitempty" json:"text_selected,omitempty"`
+}
+
+type Logs struct {
+ Background string `toml:"background,omitempty" json:"background,omitempty"`
+ Text string `toml:"text,omitempty" json:"text,omitempty"`
+}
+
+type PopupDelete struct {
+ Background string `toml:"background,omitempty" json:"background,omitempty"`
+ Text string `toml:"text,omitempty" json:"text,omitempty"`
+ TextHighlight string `toml:"text_highlight,omitempty" json:"text_highlight,omitempty"`
+}
+
+type PopupError struct {
+ Background string `toml:"background,omitempty" json:"background,omitempty"`
+ Text string `toml:"text,omitempty" json:"text,omitempty"`
+}
+
+type PopupHelp struct {
+ Background string `toml:"background,omitempty" json:"background,omitempty"`
+ Text string `toml:"text,omitempty" json:"text,omitempty"`
+ TextHighlight string `toml:"text_highlight,omitempty" json:"text_highlight,omitempty"`
+}
+
+type PopupInfo struct {
+ Background string `toml:"background,omitempty" json:"background,omitempty"`
+ Text string `toml:"text,omitempty" json:"text,omitempty"`
+}
+
+type Keymap struct {
+ Clear []string `toml:"clear,omitempty" json:"clear,omitempty"`
+ ClearSecondary []string `toml:"-" json:"-"`
+ DeleteConfirm []string `toml:"delete_confirm,omitempty" json:"delete_confirm,omitempty"`
+ DeleteConfirmSecondary []string `toml:"-" json:"-"`
+ DeleteDeny []string `toml:"delete_deny,omitempty" json:"delete_deny,omitempty"`
+ DeleteDenySecondary []string `toml:"-" json:"-"`
+ Exec []string `toml:"exec,omitempty" json:"exec,omitempty"`
+ ExecSecondary []string `toml:"-" json:"-"`
+ FilterMode []string `toml:"filter_mode,omitempty" json:"filter_mode,omitempty"`
+ FilterModeSecondary []string `toml:"-" json:"-"`
+ Inspect []string `toml:"inspect,omitempty" json:"inspect,omitempty"`
+ InspectSecondary []string `toml:"-" json:"-"`
+ ForceRedraw []string `toml:"force_redraw,omitempty" json:"force_redraw,omitempty"`
+ ForceRedrawSecondary []string `toml:"-" json:"-"`
+ ScrollBack []string `toml:"scroll_back,omitempty" json:"scroll_back,omitempty"`
+ ScrollBackSecondary []string `toml:"-" json:"-"`
+ ScrollForward []string `toml:"scroll_forward,omitempty" json:"scroll_forward,omitempty"`
+ ScrollForwardSecondary []string `toml:"-" json:"-"`
+ LogSearchMode []string `toml:"log_search_mode,omitempty" json:"log_search_mode,omitempty"`
+ LogSearchModeSecondary []string `toml:"-" json:"-"`
+ LogSectionHeightDecrease []string `toml:"log_section_height_decrease,omitempty" json:"log_section_height_decrease,omitempty"`
+ LogSectionHeightDecreaseSecondary []string `toml:"-" json:"-"`
+ LogSectionHeightIncrease []string `toml:"log_section_height_increase,omitempty" json:"log_section_height_increase,omitempty"`
+ LogSectionHeightIncreaseSecondary []string `toml:"-" json:"-"`
+ LogSectionToggle []string `toml:"log_section_toggle,omitempty" json:"log_section_toggle,omitempty"`
+ LogSectionToggleSecondary []string `toml:"-" json:"-"`
+ Quit []string `toml:"quit,omitempty" json:"quit,omitempty"`
+ QuitSecondary []string `toml:"-" json:"-"`
+ SaveLogs []string `toml:"save_logs,omitempty" json:"save_logs,omitempty"`
+ SaveLogsSecondary []string `toml:"-" json:"-"`
+ ScrollDown []string `toml:"scroll_down,omitempty" json:"scroll_down,omitempty"`
+ ScrollDownSecondary []string `toml:"-" json:"-"`
+ ScrollEnd []string `toml:"scroll_end,omitempty" json:"scroll_end,omitempty"`
+ ScrollEndSecondary []string `toml:"-" json:"-"`
+ ScrollStart []string `toml:"scroll_start,omitempty" json:"scroll_start,omitempty"`
+ ScrollStartSecondary []string `toml:"-" json:"-"`
+ ScrollUp []string `toml:"scroll_up,omitempty" json:"scroll_up,omitempty"`
+ ScrollUpSecondary []string `toml:"-" json:"-"`
+ SelectNextPanel []string `toml:"select_next_panel,omitempty" json:"select_next_panel,omitempty"`
+ SelectNextPanelSecondary []string `toml:"-" json:"-"`
+ SelectPreviousPanel []string `toml:"select_previous_panel,omitempty" json:"select_previous_panel,omitempty"`
+ SelectPreviousPanelSecondary []string `toml:"-" json:"-"`
+ SortByName []string `toml:"sort_by_name,omitempty" json:"sort_by_name,omitempty"`
+ SortByNameSecondary []string `toml:"-" json:"-"`
+ SortByState []string `toml:"sort_by_state,omitempty" json:"sort_by_state,omitempty"`
+ SortByStateSecondary []string `toml:"-" json:"-"`
+ SortByStatus []string `toml:"sort_by_status,omitempty" json:"sort_by_status,omitempty"`
+ SortByStatusSecondary []string `toml:"-" json:"-"`
+ SortByCPU []string `toml:"sort_by_cpu,omitempty" json:"sort_by_cpu,omitempty"`
+ SortByCPUSecondary []string `toml:"-" json:"-"`
+ SortByMemory []string `toml:"sort_by_memory,omitempty" json:"sort_by_memory,omitempty"`
+ SortByMemorySecondary []string `toml:"-" json:"-"`
+ SortByID []string `toml:"sort_by_id,omitempty" json:"sort_by_id,omitempty"`
+ SortByIDSecondary []string `toml:"-" json:"-"`
+ SortByImage []string `toml:"sort_by_image,omitempty" json:"sort_by_image,omitempty"`
+ SortByImageSecondary []string `toml:"-" json:"-"`
+ SortByRX []string `toml:"sort_by_rx,omitempty" json:"sort_by_rx,omitempty"`
+ SortByRXSecondary []string `toml:"-" json:"-"`
+ SortByTX []string `toml:"sort_by_tx,omitempty" json:"sort_by_tx,omitempty"`
+ SortByTXSecondary []string `toml:"-" json:"-"`
+ SortReset []string `toml:"sort_reset,omitempty" json:"sort_reset,omitempty"`
+ SortResetSecondary []string `toml:"-" json:"-"`
+ ToggleHelp []string `toml:"toggle_help,omitempty" json:"toggle_help,omitempty"`
+ ToggleHelpSecondary []string `toml:"-" json:"-"`
+ ToggleMouseCapture []string `toml:"toggle_mouse_capture,omitempty" json:"toggle_mouse_capture,omitempty"`
+ ToggleMouseCaptureSecondary []string `toml:"-" json:"-"`
+ LogSectionToggleAlt []string `toml:"-" json:"-"`
+ ScrollMany string `toml:"scroll_many,omitempty" json:"scroll_many,omitempty"`
+}
+
+type Config struct {
+ AppColors AppColors `toml:"colors,omitempty" json:"colors,omitempty"`
+ ColorLogs bool `toml:"color_logs,omitempty" json:"color_logs,omitempty"`
+ DirSave string `toml:"save_dir,omitempty" json:"save_dir,omitempty"`
+ DirConfig string `toml:"-" json:"-"`
+ DockerIntervalMs int `toml:"docker_interval,omitempty" json:"docker_interval,omitempty"`
+ GUI bool `toml:"gui,omitempty" json:"gui,omitempty"`
+ Host string `toml:"host,omitempty" json:"host,omitempty"`
+ InContainer bool `toml:"-" json:"-"`
+ Keymap Keymap `toml:"keymap,omitempty" json:"keymap,omitempty"`
+ LogSearchCaseSensitive bool `toml:"log_search_case_sensitive,omitempty" json:"log_search_case_sensitive,omitempty"`
+ RawLogs bool `toml:"raw_logs,omitempty" json:"raw_logs,omitempty"`
+ ShowLogs bool `toml:"show_logs,omitempty" json:"show_logs,omitempty"`
+ ShowSelf bool `toml:"show_self,omitempty" json:"show_self,omitempty"`
+ ShowStdErr bool `toml:"show_std_err,omitempty" json:"show_std_err,omitempty"`
+ ShowTimestamp bool `toml:"show_timestamp,omitempty" json:"show_timestamp,omitempty"`
+ TimestampFormat string `toml:"timestamp_format,omitempty" json:"timestamp_format,omitempty"`
+ Timezone string `toml:"timezone,omitempty" json:"timezone,omitempty"`
+ UseCLI bool `toml:"use_cli,omitempty" json:"use_cli,omitempty"`
+}
+
+func NewConfig() *Config {
+ return &Config{
+ DockerIntervalMs: 1000,
+ ShowLogs: true,
+ ColorLogs: false,
+ RawLogs: false,
+ ShowTimestamp: true,
+ TimestampFormat: "%Y-%m-%dT%H:%M:%S.%8f",
+ Timezone: "UTC",
+ UseCLI: false,
+ GUI: true,
+ LogSearchCaseSensitive: true,
+ ShowSelf: false,
+ ShowStdErr: true,
+ DirSave: "",
+ Host: "",
+ }
+}
+
+func LoadConfigPath(path string, cfg *Config) error {
+ data, err := os.ReadFile(path)
+ if err != nil {
+ return err
+ }
+
+ content := string(data)
+
+ if strings.HasSuffix(path, ".toml") {
+ _, err = toml.Decode(content, cfg)
+ if err != nil {
+ return err
+ }
+ } else if strings.HasSuffix(path, ".jsonc") || strings.HasSuffix(path, ".json") {
+ err = parseJSONC(content, cfg)
+ if err != nil {
+ return err
+ }
+ }
+
+ cfg.DirConfig = path
+ return nil
+}
+
+func LoadConfig(path string) (*Config, error) {
+ cfg := NewConfig()
+ err := LoadConfigPath(path, cfg)
+ if err != nil {
+ return nil, err
+ }
+ return cfg, nil
+}
+
+func parseJSONC(content string, cfg *Config) error {
+ var raw map[string]interface{}
+ commentsRemoved := removeJSONCComments(content)
+ err := json.Unmarshal([]byte(commentsRemoved), &raw)
+ if err != nil {
+ return err
+ }
+
+ if colors, ok := raw["colors"].(map[string]interface{}); ok {
+ cfg.AppColors = parseAppColors(colors)
+ }
+
+ if keymap, ok := raw["keymap"].(map[string]interface{}); ok {
+ cfg.Keymap = parseKeymap(keymap)
+ }
+
+ if val, ok := raw["color_logs"].(bool); ok {
+ cfg.ColorLogs = val
+ }
+ if val, ok := raw["docker_interval"].(float64); ok {
+ cfg.DockerIntervalMs = int(val)
+ }
+ if val, ok := raw["gui"].(bool); ok {
+ cfg.GUI = val
+ }
+ if val, ok := raw["host"].(string); ok {
+ cfg.Host = val
+ }
+ if val, ok := raw["log_search_case_sensitive"].(bool); ok {
+ cfg.LogSearchCaseSensitive = val
+ }
+ if val, ok := raw["raw_logs"].(bool); ok {
+ cfg.RawLogs = val
+ }
+ if val, ok := raw["save_dir"].(string); ok {
+ cfg.DirSave = val
+ }
+ if val, ok := raw["show_logs"].(bool); ok {
+ cfg.ShowLogs = val
+ }
+ if val, ok := raw["show_self"].(bool); ok {
+ cfg.ShowSelf = val
+ }
+ if val, ok := raw["show_std_err"].(bool); ok {
+ cfg.ShowStdErr = val
+ }
+ if val, ok := raw["show_timestamp"].(bool); ok {
+ cfg.ShowTimestamp = val
+ }
+ if val, ok := raw["timestamp_format"].(string); ok {
+ cfg.TimestampFormat = val
+ }
+ if val, ok := raw["timezone"].(string); ok {
+ cfg.Timezone = val
+ }
+ if val, ok := raw["use_cli"].(bool); ok {
+ cfg.UseCLI = val
+ }
+
+ return nil
+}
+
+func removeJSONCComments(content string) string {
+ lines := strings.Split(content, "\n")
+ var result []string
+ for _, line := range lines {
+ trimmed := strings.TrimSpace(line)
+ if strings.HasPrefix(trimmed, "//") || strings.HasPrefix(trimmed, "/*") || strings.HasPrefix(trimmed, "*") || strings.HasPrefix(trimmed, "*/") {
+ continue
+ }
+ if idx := strings.Index(trimmed, "//"); idx >= 0 {
+ result = append(result, strings.TrimSpace(line[:idx]))
+ } else {
+ result = append(result, line)
+ }
+ }
+ return strings.Join(result, "\n")
+}
+
+func parseAppColors(colors map[string]interface{}) AppColors {
+ acc := AppColors{}
+ if borders, ok := colors["borders"].(map[string]interface{}); ok {
+ acc.Borders = Borders{
+ Selected: toString(borders["selected"]),
+ Unselected: toString(borders["unselected"]),
+ }
+ }
+ if chartCPU, ok := colors["chart_cpu"].(map[string]interface{}); ok {
+ acc.ChartCPU = ChartCPU{
+ Background: toString(chartCPU["background"]),
+ Border: toString(chartCPU["border"]),
+ Title: toString(chartCPU["title"]),
+ Max: toString(chartCPU["max"]),
+ Points: toString(chartCPU["points"]),
+ YAxis: toString(chartCPU["y_axis"]),
+ }
+ }
+ if chartMemory, ok := colors["chart_memory"].(map[string]interface{}); ok {
+ acc.ChartMemory = ChartMemory{
+ Background: toString(chartMemory["background"]),
+ Border: toString(chartMemory["border"]),
+ Title: toString(chartMemory["title"]),
+ Max: toString(chartMemory["max"]),
+ Points: toString(chartMemory["points"]),
+ YAxis: toString(chartMemory["y_axis"]),
+ }
+ }
+ if chartBandwidth, ok := colors["chart_bandwidth"].(map[string]interface{}); ok {
+ acc.ChartBandwidth = ChartBandwidth{
+ Background: toString(chartBandwidth["background"]),
+ Border: toString(chartBandwidth["border"]),
+ MaxRX: toString(chartBandwidth["max_rx"]),
+ MaxTX: toString(chartBandwidth["max_tx"]),
+ PointsRX: toString(chartBandwidth["points_rx"]),
+ PointsTX: toString(chartBandwidth["points_tx"]),
+ TitleRX: toString(chartBandwidth["title_rx"]),
+ TitleTX: toString(chartBandwidth["title_tx"]),
+ YAxis: toString(chartBandwidth["y_axis"]),
+ }
+ }
+ if chartPorts, ok := colors["chart_ports"].(map[string]interface{}); ok {
+ acc.ChartPorts = ChartPorts{
+ Background: toString(chartPorts["background"]),
+ Border: toString(chartPorts["border"]),
+ Title: toString(chartPorts["title"]),
+ Headings: toString(chartPorts["headings"]),
+ Text: toString(chartPorts["text"]),
+ }
+ }
+ if commands, ok := colors["commands"].(map[string]interface{}); ok {
+ acc.Commands = Commands{
+ Background: toString(commands["background"]),
+ Pause: toString(commands["pause"]),
+ Restart: toString(commands["restart"]),
+ Stop: toString(commands["stop"]),
+ Delete: toString(commands["delete"]),
+ Resume: toString(commands["resume"]),
+ Start: toString(commands["start"]),
+ }
+ }
+ if containerState, ok := colors["container_state"].(map[string]interface{}); ok {
+ acc.ContainerState = ContainerState{
+ Dead: toString(containerState["dead"]),
+ Exited: toString(containerState["exited"]),
+ Paused: toString(containerState["paused"]),
+ Removing: toString(containerState["removing"]),
+ Restarting: toString(containerState["restarting"]),
+ RunningHealthy: toString(containerState["running_healthy"]),
+ RunningUnhealthy: toString(containerState["running_unhealthy"]),
+ Unknown: toString(containerState["unknown"]),
+ }
+ }
+ if containers, ok := colors["containers"].(map[string]interface{}); ok {
+ acc.Containers = Containers{
+ Background: toString(containers["background"]),
+ Icon: toString(containers["icon"]),
+ Text: toString(containers["text"]),
+ TextRX: toString(containers["text_rx"]),
+ TextTX: toString(containers["text_tx"]),
+ }
+ }
+ if logSearch, ok := colors["log_search"].(map[string]interface{}); ok {
+ acc.LogSearch = LogSearch{
+ Background: toString(logSearch["background"]),
+ Text: toString(logSearch["text"]),
+ ButtonText: toString(logSearch["button_text"]),
+ Highlight: toString(logSearch["highlight"]),
+ }
+ }
+ if filter, ok := colors["filter"].(map[string]interface{}); ok {
+ acc.Filter = Filter{
+ Background: toString(filter["background"]),
+ Text: toString(filter["text"]),
+ SelectedFilterBackground: toString(filter["selected_filter_background"]),
+ SelectedFilterText: toString(filter["selected_filter_text"]),
+ Highlight: toString(filter["highlight"]),
+ }
+ }
+ if headersBar, ok := colors["headers_bar"].(map[string]interface{}); ok {
+ acc.HeadersBar = HeadersBar{
+ Background: toString(headersBar["background"]),
+ LoadingSpinner: toString(headersBar["loading_spinner"]),
+ Text: toString(headersBar["text"]),
+ TextSelected: toString(headersBar["text_selected"]),
+ }
+ }
+ if logs, ok := colors["logs"].(map[string]interface{}); ok {
+ acc.Logs = Logs{
+ Background: toString(logs["background"]),
+ Text: toString(logs["text"]),
+ }
+ }
+ if popupDelete, ok := colors["popup_delete"].(map[string]interface{}); ok {
+ acc.PopupDelete = PopupDelete{
+ Background: toString(popupDelete["background"]),
+ Text: toString(popupDelete["text"]),
+ TextHighlight: toString(popupDelete["text_highlight"]),
+ }
+ }
+ if popupError, ok := colors["popup_error"].(map[string]interface{}); ok {
+ acc.PopupError = PopupError{
+ Background: toString(popupError["background"]),
+ Text: toString(popupError["text"]),
+ }
+ }
+ if popupHelp, ok := colors["popup_help"].(map[string]interface{}); ok {
+ acc.PopupHelp = PopupHelp{
+ Background: toString(popupHelp["background"]),
+ Text: toString(popupHelp["text"]),
+ TextHighlight: toString(popupHelp["text_highlight"]),
+ }
+ }
+ if popupInfo, ok := colors["popup_info"].(map[string]interface{}); ok {
+ acc.PopupInfo = PopupInfo{
+ Background: toString(popupInfo["background"]),
+ Text: toString(popupInfo["text"]),
+ }
+ }
+ return acc
+}
+
+func parseKeymap(keymap map[string]interface{}) Keymap {
+ k := Keymap{}
+ applyKeymapEntry(&k.Clear, keymap, "clear")
+ applyKeymapEntry(&k.DeleteConfirm, keymap, "delete_confirm")
+ applyKeymapEntry(&k.DeleteDeny, keymap, "delete_deny")
+ applyKeymapEntry(&k.Exec, keymap, "exec")
+ applyKeymapEntry(&k.FilterMode, keymap, "filter_mode")
+ applyKeymapEntry(&k.Inspect, keymap, "inspect")
+ applyKeymapEntry(&k.ForceRedraw, keymap, "force_redraw")
+ applyKeymapEntry(&k.ScrollBack, keymap, "scroll_back")
+ applyKeymapEntry(&k.ScrollForward, keymap, "scroll_forward")
+ applyKeymapEntry(&k.LogSearchMode, keymap, "log_search_mode")
+ applyKeymapEntry(&k.LogSectionHeightDecrease, keymap, "log_section_height_decrease")
+ applyKeymapEntry(&k.LogSectionHeightIncrease, keymap, "log_section_height_increase")
+ applyKeymapEntry(&k.LogSectionToggle, keymap, "log_section_toggle")
+ applyKeymapEntry(&k.Quit, keymap, "quit")
+ applyKeymapEntry(&k.SaveLogs, keymap, "save_logs")
+ applyKeymapEntry(&k.ScrollDown, keymap, "scroll_down")
+ applyKeymapEntry(&k.ScrollEnd, keymap, "scroll_end")
+ applyKeymapEntry(&k.ScrollStart, keymap, "scroll_start")
+ applyKeymapEntry(&k.ScrollUp, keymap, "scroll_up")
+ applyKeymapEntry(&k.SelectNextPanel, keymap, "select_next_panel")
+ applyKeymapEntry(&k.SelectPreviousPanel, keymap, "select_previous_panel")
+ applyKeymapEntry(&k.SortByName, keymap, "sort_by_name")
+ applyKeymapEntry(&k.SortByState, keymap, "sort_by_state")
+ applyKeymapEntry(&k.SortByStatus, keymap, "sort_by_status")
+ applyKeymapEntry(&k.SortByCPU, keymap, "sort_by_cpu")
+ applyKeymapEntry(&k.SortByMemory, keymap, "sort_by_memory")
+ applyKeymapEntry(&k.SortByID, keymap, "sort_by_id")
+ applyKeymapEntry(&k.SortByImage, keymap, "sort_by_image")
+ applyKeymapEntry(&k.SortByRX, keymap, "sort_by_rx")
+ applyKeymapEntry(&k.SortByTX, keymap, "sort_by_tx")
+ applyKeymapEntry(&k.SortReset, keymap, "sort_reset")
+ applyKeymapEntry(&k.ToggleHelp, keymap, "toggle_help")
+ applyKeymapEntry(&k.ToggleMouseCapture, keymap, "toggle_mouse_capture")
+ if scrollMany, ok := keymap["scroll_many"].(string); ok {
+ k.ScrollMany = scrollMany
+ }
+ return k
+}
+
+func applyKeymapEntry(target *[]string, keymap map[string]interface{}, key string) {
+ if val, ok := keymap[key].([]interface{}); ok {
+ for _, v := range val {
+ if s, ok := v.(string); ok {
+ *target = append(*target, s)
+ }
+ }
+ }
+}
+
+func toString(val interface{}) string {
+ if s, ok := val.(string); ok {
+ return s
+ }
+ return ""
+}
+
+func (c *Config) SaveConfig() error {
+ path := c.DirConfig
+ if path == "" {
+ var err error
+ path, err = GetDefaultConfigPath()
+ if err != nil {
+ return err
+ }
+ }
+
+ file, err := os.Create(path)
+ if err != nil {
+ return err
+ }
+ defer file.Close()
+
+ if strings.HasSuffix(path, ".toml") {
+ return toml.NewEncoder(file).Encode(c)
+ } else if strings.HasSuffix(path, ".jsonc") || strings.HasSuffix(path, ".json") {
+ data, err := json.MarshalIndent(c, "", " ")
+ if err != nil {
+ return err
+ }
+ _, err = file.Write(data)
+ return err
+ }
+
+ return nil
+}
+
+func GetDefaultConfigPath() (string, error) {
+ home, err := os.UserHomeDir()
+ if err != nil {
+ return "", err
+ }
+ configDir := filepath.Join(home, ".config", "oxker")
+ return filepath.Join(configDir, "config.toml"), nil
+}
+
+func (c *Config) MergeCLIArgs(cliArgs *CLIArgs) {
+ if cliArgs == nil {
+ return
+ }
+ if cliArgs.DockerIntervalMs > 0 {
+ c.DockerIntervalMs = cliArgs.DockerIntervalMs
+ }
+ c.RawLogs = cliArgs.RawLogs
+ c.ColorLogs = cliArgs.ColorLogs
+ c.ShowTimestamp = !cliArgs.ShowTimestamp
+ c.UseCLI = cliArgs.UseCLI
+ c.GUI = !cliArgs.DebugMode
+ if cliArgs.Host != "" {
+ c.Host = cliArgs.Host
+ }
+ c.DirConfig = cliArgs.ConfigFile
+}
+
+type CLIArgs struct {
+ DockerIntervalMs int
+ RawLogs bool
+ ColorLogs bool
+ ShowTimestamp bool
+ ShowSelf bool
+ DebugMode bool
+ ConfigFile string
+ Host string
+ NoStdErr bool
+ SaveDir string
+ Timezone string
+ UseCLI bool
+}
diff --git a/internal/docker/client.go b/internal/docker/client.go
new file mode 100644
index 0000000..66a82d6
--- /dev/null
+++ b/internal/docker/client.go
@@ -0,0 +1,112 @@
+package docker
+
+import (
+ "context"
+ "encoding/json"
+ "io"
+
+ "github.com/docker/docker/api/types"
+ "github.com/docker/docker/api/types/container"
+ "github.com/docker/docker/client"
+)
+
+type Client struct {
+ cli *client.Client
+ ctx context.Context
+ cancel context.CancelFunc
+}
+
+func New(host ...string) (*Client, error) {
+ opts := []client.Opt{client.FromEnv, client.WithAPIVersionNegotiation()}
+ if len(host) > 0 && host[0] != "" {
+ opts = append(opts, client.WithHost(host[0]))
+ }
+ cli, err := client.NewClientWithOpts(opts...)
+ if err != nil {
+ return nil, err
+ }
+ ctx, cancel := context.WithCancel(context.Background())
+ return &Client{cli: cli, ctx: ctx, cancel: cancel}, nil
+}
+
+// Cancel cancels all in-flight Docker API calls.
+func (c *Client) Cancel() {
+ c.cancel()
+}
+
+func (c *Client) Ping() error {
+ _, err := c.cli.Ping(c.ctx)
+ return err
+}
+
+func (c *Client) ListContainers(all bool) ([]types.Container, error) {
+ opts := container.ListOptions{All: all}
+ return c.cli.ContainerList(c.ctx, opts)
+}
+
+func (c *Client) InspectContainer(id string) (types.ContainerJSON, error) {
+ return c.cli.ContainerInspect(c.ctx, id)
+}
+
+func (c *Client) StartContainer(id string) error {
+ return c.cli.ContainerStart(c.ctx, id, container.StartOptions{})
+}
+
+func (c *Client) StopContainer(id string) error {
+ return c.cli.ContainerStop(c.ctx, id, container.StopOptions{})
+}
+
+func (c *Client) RestartContainer(id string) error {
+ return c.cli.ContainerRestart(c.ctx, id, container.StopOptions{})
+}
+
+func (c *Client) DeleteContainer(id string, force bool) error {
+ return c.cli.ContainerRemove(c.ctx, id, container.RemoveOptions{Force: force})
+}
+
+func (c *Client) PauseContainer(id string) error {
+ return c.cli.ContainerPause(c.ctx, id)
+}
+
+func (c *Client) UnpauseContainer(id string) error {
+ return c.cli.ContainerUnpause(c.ctx, id)
+}
+
+func (c *Client) Logs(id string, options container.LogsOptions) (io.ReadCloser, error) {
+ return c.cli.ContainerLogs(c.ctx, id, options)
+}
+
+// ContainerStats gets a single stats snapshot for a container.
+// Uses stream=false (NOT one-shot) so Docker fills in precpu_stats for accurate CPU delta.
+func (c *Client) ContainerStats(id string) (*container.StatsResponse, error) {
+ resp, err := c.cli.ContainerStats(c.ctx, id, false)
+ if err != nil {
+ return nil, err
+ }
+ defer resp.Body.Close()
+
+ var stats container.StatsResponse
+ if err := json.NewDecoder(resp.Body).Decode(&stats); err != nil {
+ return nil, err
+ }
+ return &stats, nil
+}
+
+func (c *Client) ContainerExec(id string, cmd []string, tty bool) (types.HijackedResponse, error) {
+ execConfig := container.ExecOptions{
+ Cmd: cmd,
+ Tty: tty,
+ AttachStdin: true,
+ AttachStdout: true,
+ AttachStderr: true,
+ }
+ exec, err := c.cli.ContainerExecCreate(c.ctx, id, execConfig)
+ if err != nil {
+ return types.HijackedResponse{}, err
+ }
+ return c.cli.ContainerExecAttach(c.ctx, exec.ID, container.ExecStartOptions{})
+}
+
+func (c *Client) Close() error {
+ return c.cli.Close()
+}
diff --git a/internal/utils/ratelimiter.go b/internal/utils/ratelimiter.go
new file mode 100644
index 0000000..421f433
--- /dev/null
+++ b/internal/utils/ratelimiter.go
@@ -0,0 +1,29 @@
+package utils
+
+import (
+ "time"
+)
+
+type RateLimiter struct {
+ lastTime time.Time
+ minInterval time.Duration
+}
+
+func NewRateLimiter(interval time.Duration) *RateLimiter {
+ return &RateLimiter{
+ minInterval: interval,
+ }
+}
+
+func (r *RateLimiter) Allow() bool {
+ now := time.Now()
+ if now.Sub(r.lastTime) >= r.minInterval {
+ r.lastTime = now
+ return true
+ }
+ return false
+}
+
+func (r *RateLimiter) Reset() {
+ r.lastTime = time.Time{}
+}
diff --git a/internal/utils/scroll.go b/internal/utils/scroll.go
new file mode 100644
index 0000000..6297b63
--- /dev/null
+++ b/internal/utils/scroll.go
@@ -0,0 +1,31 @@
+package utils
+
+type ScrollDirection int
+
+const (
+ ScrollUp ScrollDirection = iota
+ ScrollDown
+ ScrollPageUp
+ ScrollPageDown
+ ScrollHome
+ ScrollEnd
+)
+
+func (sd ScrollDirection) String() string {
+ switch sd {
+ case ScrollUp:
+ return "up"
+ case ScrollDown:
+ return "down"
+ case ScrollPageUp:
+ return "pageup"
+ case ScrollPageDown:
+ return "pagedown"
+ case ScrollHome:
+ return "home"
+ case ScrollEnd:
+ return "end"
+ default:
+ return "unknown"
+ }
+}
diff --git a/internal/utils/stats.go b/internal/utils/stats.go
new file mode 100644
index 0000000..b7ebbda
--- /dev/null
+++ b/internal/utils/stats.go
@@ -0,0 +1,24 @@
+package utils
+
+type ContainerStats struct {
+ ID string
+ CPU float64
+ Memory uint64
+ MemoryLimit uint64
+ RX uint64
+ TX uint64
+}
+
+func ContainerStatsFromDocker(stats interface{}, id string) *ContainerStats {
+ var cpu float64
+ var mem, memLimit, rx, tx uint64
+
+ return &ContainerStats{
+ ID: id,
+ CPU: cpu,
+ Memory: mem,
+ MemoryLimit: memLimit,
+ RX: rx,
+ TX: tx,
+ }
+}
diff --git a/internal/utils/table.go b/internal/utils/table.go
new file mode 100644
index 0000000..216c9d8
--- /dev/null
+++ b/internal/utils/table.go
@@ -0,0 +1,26 @@
+package utils
+
+import (
+ "strings"
+
+ "github.com/olekukonko/tablewriter"
+)
+
+func FormatTable(data [][]string) string {
+ var sb strings.Builder
+ table := tablewriter.NewWriter(&sb)
+ table.SetHeader([]string{})
+ table.SetBorder(false)
+ table.SetColMinWidth(0, 10)
+ table.SetColMinWidth(1, 20)
+ table.SetColMinWidth(2, 25)
+ table.SetColMinWidth(3, 15)
+ table.SetColMinWidth(4, 20)
+
+ for _, row := range data {
+ table.Append(row)
+ }
+
+ table.Render()
+ return sb.String()
+}
diff --git a/source/oxker b/source/oxker
new file mode 160000
index 0000000..e020eb1
--- /dev/null
+++ b/source/oxker
@@ -0,0 +1 @@
+Subproject commit e020eb157ca317b0a2ba100f0024f444698552a2
diff --git a/src/app_data/container_state.rs b/src/app_data/container_state.rs
deleted file mode 100644
index 252d982..0000000
--- a/src/app_data/container_state.rs
+++ /dev/null
@@ -1,1684 +0,0 @@
-use std::{
- cmp::Ordering,
- collections::{HashSet, VecDeque},
- fmt,
- net::IpAddr,
-};
-
-use bollard::secret::{ContainerSummaryHealthStatusEnum, PortSummary};
-use jiff::{Timestamp, tz::TimeZone};
-use ratatui::{
- layout::Size,
- style::Color,
- text::{Line, Text},
- widgets::ListState,
-};
-
-use crate::config::AppColors;
-
-use super::Header;
-
-const ONE_KB: f64 = 1000.0;
-const ONE_MB: f64 = ONE_KB * 1000.0;
-const ONE_GB: f64 = ONE_MB * 1000.0;
-
-#[derive(Debug, Clone, Eq, Hash, PartialEq)]
-pub enum ScrollDirection {
- // Next,
- // Previous,
- Up,
- Down,
- Left,
- Right,
-}
-
-#[derive(Debug, Clone, Eq, Hash, PartialEq)]
-pub struct ContainerId(String);
-
-impl From<&str> for ContainerId {
- fn from(x: &str) -> Self {
- Self(x.to_owned())
- }
-}
-
-impl ContainerId {
- pub const fn get(&self) -> &str {
- self.0.as_str()
- }
-
- /// Only return first 8 chars of id, is usually more than enough for uniqueness
- /// need to update tests to use real ids, or atleast strings of the correct-ish length
- pub fn get_short(&self) -> String {
- self.0.chars().take(8).collect::()
- }
-}
-
-impl Ord for ContainerId {
- fn cmp(&self, other: &Self) -> Ordering {
- self.0.cmp(&other.0)
- }
-}
-
-impl PartialOrd for ContainerId {
- fn partial_cmp(&self, other: &Self) -> Option {
- Some(self.cmp(other))
- }
-}
-
-pub trait Contains {
- fn contains(&self, input: &str) -> bool;
-}
-/// ContainerName and ContainerImage are simple structs, used so can implement custom fmt functions to them
-macro_rules! unit_struct {
- ($name:ident) => {
- #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
- pub struct $name(String);
-
- impl From for $name {
- fn from(value: String) -> Self {
- Self(value)
- }
- }
-
- #[cfg(test)]
- impl From<&str> for $name {
- fn from(value: &str) -> Self {
- Self(value.to_owned())
- }
- }
-
- impl $name {
- pub const fn get(&self) -> &str {
- self.0.as_str()
- }
-
- pub fn set(&mut self, value: String) {
- self.0 = value;
- }
- }
-
- impl Contains for $name {
- fn contains(&self, input: &str) -> bool {
- self.0.to_lowercase().contains(input)
- }
- }
-
- impl std::fmt::Display for $name {
- fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
- if self.0.chars().count() >= 30 {
- write!(f, "{}…", self.0.chars().take(29).collect::())
- } else {
- write!(f, "{}", self.0)
- }
- }
- }
- };
-}
-
-unit_struct!(ContainerName);
-unit_struct!(ContainerImage);
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub struct ContainerPorts {
- pub ip: Option,
- pub private: u16,
- pub public: Option,
-}
-
-impl From for ContainerPorts {
- fn from(value: PortSummary) -> Self {
- Self {
- ip: value.ip.and_then(|i| i.parse::().ok()),
- private: value.private_port,
- public: value.public_port,
- }
- }
-}
-
-impl ContainerPorts {
- pub fn len_ip(&self) -> usize {
- self.ip
- .as_ref()
- .map_or(0, |i| i.to_string().chars().count())
- }
- pub fn len_private(&self) -> usize {
- format!("{}", self.private).chars().count()
- }
- pub fn len_public(&self) -> usize {
- format!("{}", self.public.unwrap_or_default())
- .chars()
- .count()
- }
-
- /// Return as tuple of Strings, ip address, private port, and public port
- pub fn get_all(&self) -> (String, String, String) {
- (
- self.ip
- .as_ref()
- .map_or(String::new(), std::string::ToString::to_string),
- format!("{}", self.private),
- self.public.map_or(String::new(), |s| s.to_string()),
- )
- }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct StatefulList {
- pub state: ListState,
- pub items: Vec,
-}
-
-impl StatefulList {
- pub fn new(items: Vec) -> Self {
- Self {
- state: ListState::default(),
- items,
- }
- }
-
- pub fn end(&mut self) {
- let len = self.items.len();
- if len > 0 {
- self.state.select(Some(self.items.len() - 1));
- }
- }
-
- pub fn start(&mut self) {
- self.state.select(Some(0));
- }
-
- pub fn scroll(&mut self, scroll: &ScrollDirection) {
- match scroll {
- ScrollDirection::Down => self.next(),
- ScrollDirection::Up => self.previous(),
- // TODO set offset
- _ => (),
- }
- }
-
- fn next(&mut self) {
- if !self.items.is_empty() {
- self.state.select(Some(
- self.state.selected().map_or(
- 0,
- |i| {
- if i < self.items.len() - 1 { i + 1 } else { i }
- },
- ),
- ));
- }
- }
-
- fn previous(&mut self) {
- if !self.items.is_empty() {
- self.state.select(Some(
- self.state
- .selected()
- .map_or(0, |i| if i == 0 { 0 } else { i - 1 }),
- ));
- }
- }
-
- /// Return the current status of the select list, e.g. 2/5,
- /// MAYBE add up down arrows, check if at start or end etc
- pub fn get_state_title(&self) -> String {
- if self.items.is_empty() {
- String::new()
- } else {
- let len = self.items.len();
- let count = self
- .state
- .selected()
- .map_or(0, |value| if len > 0 { value + 1 } else { value });
- format!(" {count}/{len}")
- }
- }
-}
-
-/// Store the containers status in a struct, so can then check for healthy/unhealthy status
-/// It's usually something like "Up 1 hour", "Exited (0) 10 hours ago", "Up 10 minutes (unhealthy)"
-#[derive(Debug, Clone, Eq, PartialEq, PartialOrd)]
-pub struct ContainerStatus(String);
-
-impl From for ContainerStatus {
- fn from(value: String) -> Self {
- Self(value)
- }
-}
-
-impl ContainerStatus {
- /// Check if a container is unhealthy
- pub fn unhealthy(&self) -> bool {
- self.contains("(unhealthy)")
- }
-
- /// Get a reference to the source string
- pub const fn get(&self) -> &String {
- &self.0
- }
-}
-
-impl Contains for ContainerStatus {
- /// Check if the state contains a specific string
- fn contains(&self, item: &str) -> bool {
- self.0.to_lowercase().contains(item)
- }
-}
-
-/// By default a container's running status will be healthy
-#[derive(Debug, Clone, Copy, Eq, PartialEq, PartialOrd)]
-pub enum RunningState {
- Healthy,
- Unhealthy,
-}
-/// States of the container
-#[derive(Debug, Clone, Copy, Eq, PartialEq)]
-pub enum State {
- Dead,
- Exited,
- Paused,
- Removing,
- Restarting,
- Running(RunningState),
- Unknown,
-}
-
-impl State {
- /// The container is alive if the start is Running, either healthy or unhealthy
- pub const fn is_alive(self) -> bool {
- matches!(self, Self::Running(_))
- }
-
- /// Check if state is running & healthy
- pub const fn is_healthy(self) -> bool {
- match self {
- Self::Running(x) => match x {
- RunningState::Healthy => true,
- RunningState::Unhealthy => false,
- },
- _ => false,
- }
- }
- /// Color of the state for the containers section
- pub const fn get_color(self, colors: AppColors) -> Color {
- match self {
- Self::Dead => colors.container_state.dead,
- Self::Exited => colors.container_state.exited,
- Self::Paused => colors.container_state.paused,
- Self::Removing => colors.container_state.removing,
- Self::Restarting => colors.container_state.restarting,
- Self::Running(RunningState::Healthy) => colors.container_state.running_healthy,
- Self::Running(RunningState::Unhealthy) => colors.container_state.running_unhealthy,
- Self::Unknown => colors.container_state.unknown,
- }
- }
- /// Dirty way to create order for the state, rather than impl Ord
- pub const fn order(self) -> u8 {
- match self {
- Self::Running(RunningState::Healthy) => 0,
- Self::Running(RunningState::Unhealthy) => 1,
- Self::Paused => 2,
- Self::Restarting => 3,
- Self::Removing => 4,
- Self::Exited => 5,
- Self::Dead => 6,
- Self::Unknown => 7,
- }
- }
-}
-
-/// Need status, to check if container is unhealthy or not
-impl From<(&str, &ContainerStatus)> for State {
- fn from((input, status): (&str, &ContainerStatus)) -> Self {
- match input {
- "dead" => Self::Dead,
- "exited" => Self::Exited,
- "paused" => Self::Paused,
- "removing" => Self::Removing,
- "restarting" => Self::Restarting,
- "running" => {
- if status.unhealthy() {
- Self::Running(RunningState::Unhealthy)
- } else {
- Self::Running(RunningState::Healthy)
- }
- }
- _ => Self::Unknown,
- }
- }
-}
-
-/// Need status, to check if container is unhealthy or not
-impl
- From<(
- &bollard::secret::ContainerSummaryStateEnum,
- &ContainerStatus,
- )> for State
-{
- fn from(
- (input, status): (
- &bollard::secret::ContainerSummaryStateEnum,
- &ContainerStatus,
- ),
- ) -> Self {
- match input {
- bollard::secret::ContainerSummaryStateEnum::DEAD => Self::Dead,
- bollard::secret::ContainerSummaryStateEnum::EXITED => Self::Exited,
- bollard::secret::ContainerSummaryStateEnum::PAUSED => Self::Paused,
- bollard::secret::ContainerSummaryStateEnum::REMOVING => Self::Removing,
- bollard::secret::ContainerSummaryStateEnum::RESTARTING => Self::Restarting,
- bollard::secret::ContainerSummaryStateEnum::RUNNING => {
- if status.unhealthy() {
- Self::Running(RunningState::Unhealthy)
- } else {
- Self::Running(RunningState::Healthy)
- }
- }
- _ => Self::Unknown,
- }
- }
-}
-
-/// Again, need status, to check if container is unhealthy or not
-impl
- From<(
- Option<&bollard::secret::ContainerSummaryStateEnum>,
- &ContainerStatus,
- )> for State
-{
- fn from(
- (input, status): (
- Option<&bollard::secret::ContainerSummaryStateEnum>,
- &ContainerStatus,
- ),
- ) -> Self {
- input.map_or(Self::Unknown, |input| Self::from((input, status)))
- }
-}
-
-/// Again, need status, to check if container is unhealthy or not
-impl From<(Option, &ContainerStatus)> for State {
- fn from((input, status): (Option, &ContainerStatus)) -> Self {
- input.map_or(Self::Unknown, |input| Self::from((input.as_str(), status)))
- }
-}
-
-impl fmt::Display for State {
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- let disp = match self {
- Self::Dead => "✖ dead",
- Self::Exited => "✖ exited",
- Self::Paused => "॥ paused",
- Self::Removing => "removing",
- Self::Restarting => "↻ restarting",
- Self::Running(RunningState::Healthy) => "✓ running",
- Self::Running(RunningState::Unhealthy) => "! running",
- Self::Unknown => "? unknown",
- };
- write!(f, "{disp}")
- }
-}
-
-/// Items for the container control list
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
-pub enum DockerCommand {
- Pause,
- Restart,
- Start,
- Stop,
- Resume,
- Delete,
-}
-
-impl DockerCommand {
- pub const fn get_color(self, colors: AppColors) -> Color {
- match self {
- Self::Pause => colors.commands.pause,
- Self::Restart => colors.commands.restart,
- Self::Start => colors.commands.start,
- Self::Stop => colors.commands.stop,
- Self::Delete => colors.commands.delete,
- Self::Resume => colors.commands.resume,
- }
- }
-
- /// Docker commands available depending on the containers state
- pub fn gen_vec(state: State) -> Vec {
- match state {
- State::Dead | State::Exited => vec![Self::Start, Self::Restart, Self::Delete],
- State::Paused => vec![Self::Resume, Self::Stop, Self::Delete],
- State::Restarting => vec![Self::Stop, Self::Delete],
- State::Running(_) => vec![Self::Pause, Self::Restart, Self::Stop, Self::Delete],
- _ => vec![Self::Delete],
- }
- }
-}
-
-impl fmt::Display for DockerCommand {
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- let disp = match self {
- Self::Pause => "pause",
- Self::Delete => "delete",
- Self::Restart => "restart",
- Self::Start => "start",
- Self::Stop => "stop",
- Self::Resume => "resume",
- };
- write!(f, "{disp}")
- }
-}
-
-pub trait Stats {
- fn get_value(&self) -> f64;
-}
-
-/// Struct for frequently updated CPU stats
-/// So can use custom display formatter
-/// Use trait Stats for use as generic in draw_chart function
-#[derive(Debug, Default, Clone, Copy)]
-pub struct CpuStats(f64);
-
-impl CpuStats {
- pub const fn new(value: f64) -> Self {
- Self(value)
- }
-}
-
-impl Eq for CpuStats {}
-
-impl PartialEq for CpuStats {
- fn eq(&self, other: &Self) -> bool {
- self.0 == other.0
- }
-}
-
-impl PartialOrd for CpuStats {
- fn partial_cmp(&self, other: &Self) -> Option {
- Some(self.cmp(other))
- }
-}
-
-impl Ord for CpuStats {
- fn cmp(&self, other: &Self) -> Ordering {
- if self.0 > other.0 {
- Ordering::Greater
- } else if (self.0 - other.0).abs() < 0.01 {
- Ordering::Equal
- } else {
- Ordering::Less
- }
- }
-}
-
-impl Stats for CpuStats {
- fn get_value(&self) -> f64 {
- self.0
- }
-}
-
-impl fmt::Display for CpuStats {
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- let disp = format!("{:05.2}%", self.0);
- write!(f, "{disp:>x$}", x = f.width().unwrap_or(1))
- }
-}
-
-/// Struct for frequently updated memory usage stats
-/// So can use custom display formatter
-/// Use trait Stats for use as generic in draw_chart function
-#[derive(Debug, Default, Clone, Copy, Eq)]
-pub struct ByteStats(u64);
-
-impl PartialEq for ByteStats {
- fn eq(&self, other: &Self) -> bool {
- self.0 == other.0
- }
-}
-
-impl PartialOrd for ByteStats {
- fn partial_cmp(&self, other: &Self) -> Option {
- Some(self.cmp(other))
- }
-}
-
-impl Ord for ByteStats {
- fn cmp(&self, other: &Self) -> Ordering {
- self.0.cmp(&other.0)
- }
-}
-
-impl ByteStats {
- pub const fn new(value: u64) -> Self {
- Self(value)
- }
- pub const fn update(&mut self, value: u64) {
- self.0 = value;
- }
-}
-
-#[allow(clippy::cast_precision_loss)]
-impl Stats for ByteStats {
- fn get_value(&self) -> f64 {
- self.0 as f64
- }
-}
-
-/// convert from bytes to kB, MB, GB etc
-impl fmt::Display for ByteStats {
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- let as_f64 = self.get_value();
- let p = match as_f64 {
- x if x >= ONE_GB => format!("{y:.2} GB", y = as_f64 / ONE_GB),
- x if x >= ONE_MB => format!("{y:.2} MB", y = as_f64 / ONE_MB),
- _ => format!("{y:.2} kB", y = as_f64 / ONE_KB),
- };
- write!(f, "{p:>x$}", x = f.width().unwrap_or(1))
- }
-}
-
-#[derive(Debug, Default, Clone, Copy, Eq)]
-pub struct BandwidthStat(u64);
-
-#[cfg(test)]
-impl BandwidthStat {
- pub fn new(x: u64) -> Self {
- Self(x)
- }
-}
-
-impl PartialEq for BandwidthStat {
- fn eq(&self, other: &Self) -> bool {
- self.0 == other.0
- }
-}
-
-impl PartialOrd for BandwidthStat {
- fn partial_cmp(&self, other: &Self) -> Option {
- Some(self.cmp(other))
- }
-}
-
-impl Ord for BandwidthStat {
- fn cmp(&self, other: &Self) -> Ordering {
- self.0.cmp(&other.0)
- }
-}
-
-#[allow(clippy::cast_precision_loss)]
-impl Stats for BandwidthStat {
- fn get_value(&self) -> f64 {
- self.0 as f64
- }
-}
-
-/// convert from bytes to per second, using 1000 instead of 1024
-impl fmt::Display for BandwidthStat {
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- let as_f64 = self.get_value();
- let p = match as_f64 {
- x if x >= ONE_GB => format!("{y:.2} GB/s", y = as_f64 / ONE_GB),
- x if x >= ONE_MB => format!("{y:.2} Mb/s", y = as_f64 / ONE_MB),
- _ => format!("{y:.2} kb/s", y = as_f64 / ONE_KB),
- };
- write!(f, "{p:>x$}", x = f.width().unwrap_or(1))
- }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct NetworkBandwidth(VecDeque);
-
-impl NetworkBandwidth {
- pub fn new() -> Self {
- Self(VecDeque::with_capacity(60))
- }
-
- pub fn is_empty(&self) -> bool {
- self.0.is_empty()
- }
-
- /// Find the highest speed recorded in the vecque
- pub fn max(&self) -> BandwidthStat {
- self.to_vec_f64()
- .iter()
- .map(|(_, speed)| *speed)
- .max_by(|a, b| a.total_cmp(b))
- .map(|m| BandwidthStat(m as u64))
- .unwrap_or(BandwidthStat(0))
- }
-
- pub fn push(&mut self, x: u64) {
- if self.0.len() >= 60 {
- self.0.pop_front();
- }
- self.0.push_back(BandwidthStat(x));
- }
-
- /// Get the current total amount of traffic on a given device
- pub fn current_total(&self) -> ByteStats {
- self.0
- .back()
- .map_or(ByteStats::default(), |i| ByteStats::new(i.0))
- }
-
- /// Convert to f64 for use in the network graph
- pub fn to_vec_f64(&self) -> Vec<(f64, f64)> {
- self.0
- .iter()
- .zip(self.0.iter().skip(1))
- .enumerate()
- .map(|(i, (prev, current))| (i as f64, current.0.saturating_sub(prev.0) as f64))
- .collect()
- }
-}
-
-#[derive(Debug, Clone, PartialEq)]
-pub struct ChartsData {
- pub memory: ChartSeries,
- pub cpu: ChartSeries,
- pub rx: ChartSeries,
- pub tx: ChartSeries,
- pub state: State,
-}
-
-#[derive(Debug, Clone, PartialEq)]
-pub struct ChartSeries {
- pub dataset: Vec<(f64, f64)>,
- pub max: T,
- pub current: T,
-}
-
-/// Used to make sure that each log entry, for each container, is unique,
-/// will only push a log entry into the logs vec if timestamp of said log entry isn't in the hashset
-#[derive(Debug, Clone, Hash, PartialEq, Eq)]
-pub struct LogsTz(String);
-
-impl fmt::Display for LogsTz {
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- write!(f, "{}", self.0)
- }
-}
-
-impl LogsTz {
- /// With a given &str, split into a logtz and content, so that we only need to `use split_once()` once
- /// The docker log, which should always contain a timestamp, is in the format `2023-01-14T19:13:30.783138328Z Lorem ipsum dolor sit amet`
- pub fn splitter(input: &str) -> (Self, String) {
- let (tz, content) = input.split_once(' ').unwrap_or_default();
- (Self(tz.to_owned()), content.to_owned())
- }
-
- /// Display the timestamp in a given format, and if provided, with a timezone offset
- pub fn display_with_formatter(&self, tz: Option<&TimeZone>, format: &str) -> Option {
- self.0.parse::().map_or(None, |t| {
- if let Some(tz) = tz.as_ref() {
- let tz = tz.iana_name()?;
- let z = t.in_tz(tz).ok()?;
- Some(z.strftime(format).to_string())
- } else {
- Some(t.strftime(format).to_string())
- }
- })
- }
-}
-
-/// Store the logs alongside a HashSet, each log *should* generate a unique timestamp,
-/// so if we store the timestamp separately in a HashSet, we can then check if we should insert a log line into the
-/// stateful list dependent on whether the timestamp is in the HashSet or not
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct Logs {
- lines: StatefulList>,
- tz: HashSet,
- search_results: Vec,
- search_term: Option,
- offset: usize,
- max_offset: usize,
- max_log_len: usize,
- adjusted_max_width: usize,
- adjust_max_width_text_len: usize,
-}
-
-impl Default for Logs {
- fn default() -> Self {
- let mut lines = StatefulList::new(vec![]);
- lines.end();
- Self {
- lines,
- tz: HashSet::new(),
- offset: 0,
- max_offset: 0,
- search_term: None,
- search_results: vec![],
- adjusted_max_width: 0,
- adjust_max_width_text_len: 0,
- max_log_len: 0,
- }
- }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Ord, PartialOrd, Hash)]
-pub enum LogsButton {
- Both,
- Next,
- Previous,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
-pub struct LogSearch {
- pub term: Option,
- pub result: Option,
- pub buttons: Option,
-}
-
-/// LogSearch is used in FrameData
-impl From<&Logs> for LogSearch {
- fn from(l: &Logs) -> Self {
- let buttons = l.lines.state.selected().as_ref().and_then(|x| {
- let show_next = l.search_results.iter().any(|n| n > x);
- let show_previous = l.search_results.iter().any(|n| n < x);
- match (show_next, show_previous) {
- (true, true) => Some(LogsButton::Both),
- (true, false) => Some(LogsButton::Next),
- (false, true) => Some(LogsButton::Previous),
- (false, false) => None,
- }
- });
- Self {
- term: l.search_term.clone(),
- result: l.get_search_result(),
- buttons,
- }
- }
-}
-
-impl Logs {
- pub fn gen_log_search(&self) -> LogSearch {
- LogSearch::from(self)
- }
-
- /// Scroll to the next or previous search result, accounts for when currently selected line isn't in the results vec
- pub fn search_scroll(&mut self, sd: &ScrollDirection) -> Option<()> {
- if let Some(current_selected) = self.lines.state.selected() {
- if let Some(current_position) = self
- .search_results
- .iter()
- .position(|i| i == ¤t_selected)
- {
- if let Some(new_index) = match sd {
- ScrollDirection::Down => current_position.checked_add(1),
- ScrollDirection::Up => current_position.checked_sub(1),
- // TODO set offset
- _ => None,
- } && let Some(f) = self.search_results.get(new_index)
- {
- self.lines.state.select(Some(*f));
- return Some(());
- }
- } else {
- let range = match sd {
- ScrollDirection::Up => (0..=current_selected).rev().collect::>(),
- ScrollDirection::Down => (current_selected
- ..=self
- .search_results
- .last()
- .map_or_else(|| current_selected, |i| *i))
- .collect::>(),
- // TODO set offset
- _ => vec![],
- };
- for i in range {
- if self.search_results.contains(&i) {
- self.lines.state.select(Some(i));
- return Some(());
- }
- }
- }
- }
- None
- }
-
- /// Get a string x/y, where y is total matches found, and x is current ordered selected line
- /// WIll be padded by max chars of total matches
- fn get_search_result(&self) -> Option {
- if self.search_results.is_empty() {
- return None;
- }
- Some(self.lines.state.selected().map_or_else(
- || format!("{}", self.search_results.len()),
- |current_index| {
- self.search_results
- .iter()
- .position(|i| i == ¤t_index)
- .map_or_else(
- || format!("{}", self.search_results.len()),
- |index| {
- let len = format!("{}", self.search_results.len());
- let len_width = len.chars().count();
- format!("{:>len_width$}/{len:>len_width$}", index + 1)
- },
- )
- },
- ))
- }
-
- /// Search through the logs for a matching string
- pub fn search(&mut self, case_sensitive: bool, scroll: bool) {
- if let Some(search_term) = self.search_term.as_ref() {
- let term = if case_sensitive {
- search_term.to_owned()
- } else {
- search_term.to_lowercase()
- };
- self.search_results = self
- .lines
- .items
- .iter()
- .enumerate()
- .filter_map(|(index, a)| {
- a.lines
- .iter()
- .any(|b| {
- b.spans.iter().any(|c| {
- if case_sensitive {
- c.content.contains(&term)
- } else {
- c.content.to_lowercase().contains(&term)
- }
- })
- })
- .then_some(index)
- })
- .collect();
- if !self.search_results.is_empty() && scroll {
- self.lines.state.select(self.search_results.last().copied());
- self.offset = 0;
- }
- } else {
- self.search_results.clear();
- }
- }
-
- /// Set a single char into the filter term
- pub fn search_term_push(&mut self, c: char, case_sensitive: bool) {
- if let Some(term) = self.search_term.as_mut() {
- term.push(c);
- } else {
- self.search_term = Some(format!("{c}"));
- }
- self.search(case_sensitive, true);
- }
-
- /// Delete the final char of the filter term
- pub fn search_term_pop(&mut self, case_sensitive: bool) {
- if let Some(term) = self.search_term.as_mut() {
- term.pop();
- if term.is_empty() {
- self.search_term = None;
- }
- }
- self.search(case_sensitive, true);
- }
-
- /// Remove the filter completely
- pub fn search_term_clear(&mut self) {
- self.search_term = None;
- self.search_results.clear();
- }
-
- /// Only allow a new log line to be inserted if the log timestamp isn't in the tz HashSet
- pub fn insert(&mut self, line: Text<'static>, tz: LogsTz, case_sensitive: bool) {
- if self.tz.insert(tz) {
- self.max_log_len = self.max_log_len.max(line.width());
- self.lines.items.push(line);
- // Maybe - Ideally we'd re-render here
- if self.search_term.is_some() {
- self.search(case_sensitive, false);
- }
- }
- }
-
- /// If scrolling horizontally along the logs, display a counter of the position in the in the scroll, `x/y`
- pub fn get_scroll_title(&mut self, width: u16) -> Option {
- if self.horizontal_scroll_able(width) {
- let text_width = self.adjust_max_width_text_len;
- let arrow_left = if self.offset > 0 { " ←" } else { " " };
- let arrow_right = if self.offset < self.adjusted_max_width {
- "→ "
- } else {
- " "
- };
- Some(format!(
- "{left} {offset:>text_width$}/{adjusted_max_width} {right}",
- offset = self.offset,
- adjusted_max_width = self.adjusted_max_width,
- left = arrow_left,
- right = arrow_right,
- ))
- } else {
- None
- }
- }
-
- /// Format a log lone. Only return screen width amount of chars
- /// If offset set, remove `char_offset` number of chars from a Text
- /// `text` *should* only be a single line, so just use the .first() method rather than trying to iterate
- fn format_log_line(text: &Text<'static>, char_offset: usize, width: u16) -> Text<'static> {
- let mut skipped = 0;
- text.lines.first().map_or_else(Text::default, |line| {
- Text::from(Line::from(
- line.spans
- .iter()
- .filter_map(|span| {
- if skipped >= char_offset {
- Some(ratatui::text::Span::styled(
- span.content.chars().take(width.into()).collect::(),
- span.style,
- ))
- } else {
- let span_len = span.content.chars().count();
- if skipped + span_len <= char_offset {
- skipped += span_len;
- None
- } else {
- let start_index = char_offset - skipped;
- skipped = char_offset;
- Some(ratatui::text::Span::styled(
- span.content
- .chars()
- .skip(start_index)
- .take(width.into())
- .collect::(),
- span.style,
- ))
- }
- }
- })
- .collect::>(),
- ))
- })
- }
-
- /// Get the logs vec, but instead of cloning to whole vec, only clone items within x of the currently selected index, as well as only the current screen widths number of chars
- /// Where x is the abs different of the index plus the panel height & a padding
- /// Take into account the char offset, so that can scroll a line
- /// The rest can be just empty list items
- pub fn get_visible_logs(&self, size: Size, padding: usize) -> Vec> {
- let current_index = self.lines.state.selected().unwrap_or_default();
- let height_padding = usize::from(size.height) + padding;
- let char_offset = if self.offset > self.max_log_len {
- self.max_log_len
- } else {
- self.offset
- };
-
- self.lines
- .items
- .iter()
- .enumerate()
- .map(|(index, item)| {
- if current_index.abs_diff(index) <= height_padding {
- Self::format_log_line(item, char_offset, size.width)
- } else {
- Text::from("")
- }
- })
- .collect()
- }
-
- /// The rest of the methods are basically forwarding from the underlying StatefulList
- pub fn get_state_title(&self) -> String {
- self.lines.get_state_title()
- }
-
- /// Return true it currently selected container logs are wide enough to horizontally scroll
- pub fn horizontal_scroll_able(&mut self, width: u16) -> bool {
- if self.lines.items.is_empty() {
- return false;
- }
- self.adjusted_max_width = self.max_log_len.saturating_sub(width.into()) + 4;
- self.adjust_max_width_text_len = self.adjusted_max_width.to_string().chars().count();
- self.max_log_len + 4 > usize::from(width)
- }
-
- /// Add a padding so one char will always be visilbe?
- pub fn forward(&mut self, width: u16) {
- // Need to set a max_offset, instead of using a width each time
- if self.horizontal_scroll_able(width)
- && self.adjusted_max_width > 0
- && self.offset < self.adjusted_max_width
- {
- self.offset = self.offset.saturating_add(1);
- }
- }
-
- /// Reduce the char offset
- pub const fn back(&mut self) {
- self.offset = self.offset.saturating_sub(1);
- }
-
- /// Scroll lines down by one
- pub fn next(&mut self) {
- self.lines.next();
- }
-
- /// Scroll lines up by one
- pub fn previous(&mut self) {
- self.lines.previous();
- }
-
- /// Go to the end of the lines
- pub fn end(&mut self) {
- self.lines.end();
- }
-
- /// Go to the start of the lines
- pub fn start(&mut self) {
- self.lines.start();
- }
-
- /// Get total number of log lines
- pub const fn len(&self) -> usize {
- self.lines.items.len()
- }
-
- pub const fn state(&mut self) -> &mut ListState {
- &mut self.lines.state
- }
-}
-
-/// Info for each container
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct ContainerItem {
- pub cpu_stats: VecDeque,
- pub created: u64,
- pub docker_controls: StatefulList,
- pub health: Option,
- pub id: ContainerId,
- pub image: ContainerImage,
- pub is_oxker: bool,
- pub last_updated: u64,
- pub logs: Logs,
- pub mem_limit: ByteStats,
- pub mem_stats: VecDeque,
- pub name: ContainerName,
- pub ports: Vec,
- pub rx: NetworkBandwidth,
- pub state: State,
- pub status: ContainerStatus,
- pub tx: NetworkBandwidth,
-}
-
-/// Basic display information, for when running in debug mode
-impl fmt::Display for ContainerItem {
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- write!(
- f,
- "{}, {}, {}, {}",
- self.id.get_short(),
- self.name,
- self.cpu_stats.back().unwrap_or(&CpuStats::new(0.0)),
- self.mem_stats.back().unwrap_or(&ByteStats::new(0))
- )
- }
-}
-
-impl ContainerItem {
- #[allow(clippy::too_many_arguments)]
- /// Create a new container item
- pub fn new(
- created: u64,
- id: ContainerId,
- image: String,
- is_oxker: bool,
- name: String,
- ports: Vec,
- state: State,
- status: ContainerStatus,
- ) -> Self {
- let mut docker_controls = StatefulList::new(DockerCommand::gen_vec(state));
- docker_controls.start();
-
- Self {
- cpu_stats: VecDeque::with_capacity(60),
- created,
- docker_controls,
- health: None,
- id,
- image: image.into(),
- is_oxker,
- last_updated: 0,
- logs: Logs::default(),
- mem_limit: ByteStats::default(),
- mem_stats: VecDeque::with_capacity(60),
- name: name.into(),
- ports,
- rx: NetworkBandwidth::new(),
- state,
- status,
- tx: NetworkBandwidth::new(),
- }
- }
-
- /// Find the max value in the cpu stats VecDeque
- fn max_cpu_stats(&self) -> CpuStats {
- self.cpu_stats
- .iter()
- .max()
- .map_or_else(CpuStats::default, |value| *value)
- }
-
- /// Find the max value in the mem stats VecDeque
- fn max_mem_stats(&self) -> ByteStats {
- self.mem_stats
- .iter()
- .max()
- .map_or_else(ByteStats::default, |value| *value)
- }
-
- /// Convert cpu stats into a vec for the charts function
- #[allow(clippy::cast_precision_loss)]
- fn get_cpu_dataset(&self) -> Vec<(f64, f64)> {
- self.cpu_stats
- .iter()
- .enumerate()
- .map(|(i, v)| (i as f64, v.0))
- .collect::>()
- }
-
- /// Convert mem stats into a Vec for the charts function
- #[allow(clippy::cast_precision_loss)]
- fn get_mem_dataset(&self) -> Vec<(f64, f64)> {
- self.mem_stats
- .iter()
- .enumerate()
- .map(|(i, v)| (i as f64, v.0 as f64))
- .collect::>()
- }
-
- /// Get all cpu chart data
- fn get_cpu_chart_data(&self) -> ChartSeries {
- ChartSeries {
- dataset: self.get_cpu_dataset(),
- max: self.max_cpu_stats(),
- current: self
- .cpu_stats
- .back()
- .map_or_else(|| CpuStats::new(0.0), |i| *i),
- }
- }
-
- /// Get all mem chart data
- fn get_mem_chart_data(&self) -> ChartSeries {
- ChartSeries {
- dataset: self.get_mem_dataset(),
- max: self.max_mem_stats(),
- current: self
- .mem_stats
- .back()
- .map_or_else(|| ByteStats::new(0), |i| *i),
- }
- }
-
- /// Get all mem chart data
- /// Don't understand what we are doing here
- fn get_bandwidth_chart_tx_data(&self) -> ChartSeries {
- let data = self.tx.to_vec_f64();
- ChartSeries {
- current: BandwidthStat(data.last().map_or(0, |i| i.1 as u64)),
- dataset: data,
- max: self.tx.max(),
- }
- }
-
- /// Get all mem chart data
- fn get_bandwidth_chart_rx_data(&self) -> ChartSeries {
- let data = self.rx.to_vec_f64();
- ChartSeries {
- current: BandwidthStat(data.last().map_or(0, |i| i.1 as u64)),
- dataset: data,
- max: self.rx.max(),
- }
- }
-
- /// Get chart info for cpu & memory in one function
- /// So only need to call .lock() once
- pub fn get_chart_data(&self) -> ChartsData {
- ChartsData {
- memory: self.get_mem_chart_data(),
- cpu: self.get_cpu_chart_data(),
- rx: self.get_bandwidth_chart_rx_data(),
- tx: self.get_bandwidth_chart_tx_data(),
- state: self.state,
- }
- }
-}
-
-/// Container information panel headings + widths, for nice pretty formatting
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub struct Columns {
- pub name: (Header, u8),
- pub state: (Header, u8),
- pub status: (Header, u8),
- pub cpu: (Header, u8),
- pub mem: (Header, u8, u8),
- pub id: (Header, u8),
- pub image: (Header, u8),
- pub net_rx: (Header, u8),
- pub net_tx: (Header, u8),
-}
-
-impl Columns {
- /// (Column titles, minimum header string length)
- pub const fn new() -> Self {
- Self {
- name: (Header::Name, 4),
- state: (Header::State, 5),
- status: (Header::Status, 6),
- cpu: (Header::Cpu, 3),
- mem: (Header::Memory, 7, 7),
- id: (Header::Id, 8),
- image: (Header::Image, 5),
- net_rx: (Header::Rx, 4),
- net_tx: (Header::Tx, 4),
- }
- }
-}
-
-#[cfg(test)]
-#[allow(clippy::unwrap_used)]
-mod tests {
-
- use jiff::tz::TimeZone;
- use ratatui::{
- layout::Size,
- text::{Line, Text},
- };
-
- use crate::{
- app_data::{ContainerImage, LogSearch, Logs, LogsTz, RunningState},
- ui::log_sanitizer,
- };
-
- use super::{ByteStats, ContainerName, ContainerStatus, CpuStats, State};
-
- #[test]
- /// Display CpuStats as a string
- fn test_container_state_cpustats_to_string() {
- let test = |f: f64, s: &str| {
- assert_eq!(CpuStats::new(f).to_string(), s);
- };
-
- test(0.0, "00.00%");
- test(1.5, "01.50%");
- test(15.15, "15.15%");
- test(150.15, "150.15%");
- }
-
- #[test]
- /// Display bytestats as a string, convert into correct data unit (Kb, MB, GB)
- fn test_container_state_bytestats_to_string() {
- let test = |u: u64, s: &str| {
- assert_eq!(ByteStats::new(u).to_string(), s);
- };
-
- test(0, "0.00 kB");
- test(150, "0.15 kB");
- test(1500, "1.50 kB");
- test(150_000, "150.00 kB");
- test(1_500_000, "1.50 MB");
- test(15_000_000, "15.00 MB");
- test(150_000_000, "150.00 MB");
- test(1_500_000_000, "1.50 GB");
- test(15_000_000_000, "15.00 GB");
- test(150_000_000_000, "150.00 GB");
- }
-
- #[test]
- /// ContainerName as string truncated correctly
- fn test_container_state_container_name_to_string() {
- let result = ContainerName::from("name_01");
- assert_eq!(result.to_string(), "name_01");
-
- let result = ContainerName::from("name_01_name_01_name_01_name_01_");
- assert_eq!(result.to_string(), "name_01_name_01_name_01_name_…");
-
- let result = result.get();
- assert_eq!(result, "name_01_name_01_name_01_name_01_");
- }
-
- #[test]
- /// ContainerImage as string truncated correctly
- fn test_container_state_container_image() {
- let result = ContainerImage::from("name_01");
- assert_eq!(result.to_string(), "name_01");
-
- let result = ContainerImage::from("name_01_name_01_name_01_name_01_");
- assert_eq!(result.to_string(), "name_01_name_01_name_01_name_…");
-
- let result = result.get();
- assert_eq!(result, "name_01_name_01_name_01_name_01_");
- }
-
- #[test]
- /// LogzTz correctly splits a line by timestamp
- fn test_container_state_logz_splitter() {
- let input = "2023-01-14T12:01:20.012345678Z Lorem ipsum dolor sit amet";
- let log_tz = LogsTz::splitter(input);
-
- assert_eq!(
- log_tz.0,
- super::LogsTz("2023-01-14T12:01:20.012345678Z".to_owned())
- );
- assert_eq!(log_tz.1, "Lorem ipsum dolor sit amet");
- }
-
- #[test]
- /// LogsTz display correctly formats with a given timestamp string
- fn test_container_state_logz_display() {
- let input = "2023-01-14T12:01:20.012345678Z Lorem ipsum dolor sit amet";
- let log_tz = LogsTz::splitter(input);
-
- let result = log_tz
- .0
- .display_with_formatter(None, "%Y-%m-%dT%H:%M:%S.%8f");
- assert!(result.is_some());
- let result = result.unwrap();
- assert_eq!(result, "2023-01-14T12:01:20.01234567");
-
- let result = log_tz.0.display_with_formatter(None, "%Y-%m-%d %H:%M:%S");
- assert!(result.is_some());
- let result = result.unwrap();
- assert_eq!(result, "2023-01-14 12:01:20");
-
- let result = log_tz.0.display_with_formatter(None, "%Y-%j");
- assert!(result.is_some());
- let result = result.unwrap();
-
- assert_eq!(result, "2023-014");
- }
-
- #[test]
- /// LogsTz display correctly formats with a given timestamp string & timezone
- fn test_container_state_logz_display_with_timezone() {
- let input = "2023-01-14T12:01:20.012345678Z Lorem ipsum dolor sit amet";
- let log_tz = LogsTz::splitter(input);
-
- let timezone = Some(TimeZone::get("Asia/Tokyo").unwrap());
- let result = log_tz
- .0
- .display_with_formatter(timezone.as_ref(), "%Y-%m-%dT%H:%M:%S.%8f");
- assert!(result.is_some());
- let result = result.unwrap();
- assert_eq!(result, "2023-01-14T21:01:20.01234567");
-
- let result = log_tz
- .0
- .display_with_formatter(timezone.as_ref(), "%Y-%m-%d %H:%M:%S");
- assert!(result.is_some());
- let result = result.unwrap();
- assert_eq!(result, "2023-01-14 21:01:20");
-
- let result = log_tz.0.display_with_formatter(timezone.as_ref(), "%Y-%j");
- assert!(result.is_some());
- let result = result.unwrap();
- assert_eq!(result, "2023-014");
- }
-
- #[test]
- /// Logs can only contain 1 entry per LogzTz
- fn test_container_state_logz() {
- let input = "2023-01-14T19:13:30.783138328Z Lorem ipsum dolor sit amet";
- let (tz, _) = LogsTz::splitter(input);
- let mut logs = Logs::default();
- let line = log_sanitizer::remove_ansi(input);
-
- logs.insert(Text::from(line.clone()), tz.clone(), true);
- logs.insert(Text::from(line.clone()), tz.clone(), true);
- logs.insert(Text::from(line), tz, true);
-
- assert_eq!(logs.lines.items.len(), 1);
-
- let input = "2023-01-15T19:13:30.783138328Z Lorem ipsum dolor sit amet";
- let (tz, _) = LogsTz::splitter(input);
- let line = log_sanitizer::remove_ansi(input);
-
- logs.insert(Text::from(line.clone()), tz.clone(), true);
- logs.insert(Text::from(line.clone()), tz.clone(), true);
- logs.insert(Text::from(line), tz, true);
-
- assert_eq!(logs.lines.items.len(), 2);
- }
-
- #[test]
- /// check ContainerStatus unhealthy state
- fn test_container_state_unhealthy() {
- let input = ContainerStatus::from("Up 1 hour".to_owned());
-
- assert!(!input.unhealthy());
-
- let input = ContainerStatus::from("Up 1 hour (unhealthy)".to_owned());
-
- assert!(input.unhealthy());
- }
-
- #[test]
- /// Generate container State from a &str and &ContainerStatus
- fn test_container_status_unhealthy() {
- let healthy = ContainerStatus::from("Up 1 hour".to_owned());
- let unhealthy = ContainerStatus::from("Up 1 hour (unhealthy)".to_owned());
-
- // Running and healthy
- let input = State::from(("running", &healthy));
- assert_eq!(input, State::Running(RunningState::Healthy));
-
- // Running and unhealthy
- let input = State::from(("running", &unhealthy));
- assert_eq!(input, State::Running(RunningState::Unhealthy));
-
- // Dead
- let input = State::from(("dead", &healthy));
- assert_eq!(input, State::Dead);
-
- // Exited
- let input = State::from(("exited", &healthy));
- assert_eq!(input, State::Exited);
-
- // Paused
- let input = State::from(("paused", &healthy));
- assert_eq!(input, State::Paused);
-
- // Removing
- let input = State::from(("removing", &healthy));
- assert_eq!(input, State::Removing);
-
- // Restarting
- let input = State::from(("restarting", &healthy));
- assert_eq!(input, State::Restarting);
-
- // Unknown
- let input = State::from(("oxker", &healthy));
- assert_eq!(input, State::Unknown);
- }
-
- #[test]
- /// Test the format_log_line methods, should ideally check colours are being correct kept as well
- fn test_to_vec() {
- let mut logs = Logs::default();
-
- let input = "2023-01-14T19:13:30.783138328Z Hello world some long line".to_owned();
- let (tz, _) = LogsTz::splitter(&input);
- logs.insert(Text::from(input), tz, true);
-
- let input = "2023-01-14T19:13:31.783138328Z Hello world some line".to_owned();
- let (tz, _) = LogsTz::splitter(&input);
- logs.insert(Text::from(input), tz, true);
-
- let input = "2023-01-14T19:13:32.783138328Z Hello world".to_owned();
- let (tz, _) = LogsTz::splitter(&input);
- logs.insert(Text::from(input), tz, true);
-
- logs.offset = 43;
- let result = logs.get_visible_logs(
- Size {
- width: 14,
- height: 10,
- },
- 10,
- );
- assert_eq!(
- vec![
- Text::from(Line::from("some long line")),
- Text::from(Line::from("some line")),
- Text::from(Line::default())
- ],
- result
- );
- }
-
- #[test]
- /// Test the get_scroll_title methods
- fn test_scroll_title() {
- let mut logs = Logs::default();
-
- let result = logs.get_scroll_title(10);
- assert!(result.is_none());
-
- let input = "short".to_owned();
- let (tz, _) = LogsTz::splitter(&input);
- logs.insert(Text::from(input), tz, true);
-
- let result = logs.get_scroll_title(10);
- assert!(result.is_none());
-
- let input = "2023-01-14T19:13:30.783138328Z Hello world some long line".to_owned();
- let (tz, _) = LogsTz::splitter(&input);
- logs.insert(Text::from(input), tz, true);
-
- let result = logs.get_scroll_title(10);
- assert_eq!(result, Some(" 0/51 → ".to_owned()));
-
- logs.forward(10);
-
- let result = logs.get_scroll_title(10);
- assert_eq!(result, Some(" ← 1/51 → ".to_owned()));
-
- for _ in 0..=49 {
- logs.forward(10);
- }
- let result = logs.get_scroll_title(10);
- assert_eq!(result, Some(" ← 51/51 ".to_owned()));
- }
-
- #[test]
- /// Test the log search
- fn test_logsearch() {
- let mut logs = Logs::default();
-
- for i in 1..=10 {
- let input = if i % 2 == 0 {
- format!("{i}, hello world some long line {i}")
- } else {
- format!("{i}, Hello world some long line {i}")
- };
- let (tz, _) = LogsTz::splitter(&input);
- logs.insert(Text::from(input), tz, true);
- }
-
- logs.search_term_push('H', true);
- assert_eq!(logs.search_results, [0, 2, 4, 6, 8]);
- logs.search_term_clear();
- logs.search_term_push('H', false);
- assert_eq!(logs.search_results, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
- }
-
- #[test]
- /// Test the LogSearch::From() methods
- fn test_logsearch_from() {
- let mut logs = Logs::default();
-
- for i in 1..=10 {
- let input = format!("{i}, Hello world some long line {i}");
- let (tz, _) = LogsTz::splitter(&input);
- logs.insert(Text::from(input), tz, true);
- }
-
- let log_search = LogSearch::from(&logs);
- assert_eq!(
- log_search,
- LogSearch {
- term: None,
- result: None,
- buttons: None
- }
- );
-
- logs.search_term_push('H', true);
- let log_search = LogSearch::from(&logs);
- assert_eq!(
- log_search,
- LogSearch {
- term: Some("H".to_owned()),
- result: Some("10/10".to_owned()),
- buttons: Some(crate::app_data::LogsButton::Previous)
- }
- );
-
- logs.previous();
-
- let log_search = LogSearch::from(&logs);
- assert_eq!(
- log_search,
- LogSearch {
- term: Some("H".to_owned()),
- result: Some(" 9/10".to_owned()),
- buttons: Some(crate::app_data::LogsButton::Both)
- }
- );
-
- logs.start();
-
- let log_search = LogSearch::from(&logs);
- assert_eq!(
- log_search,
- LogSearch {
- term: Some("H".to_owned()),
- result: Some(" 1/10".to_owned()),
- buttons: Some(crate::app_data::LogsButton::Next)
- }
- );
-
- logs.search_term_push('H', true);
- let log_search = LogSearch::from(&logs);
- assert_eq!(
- log_search,
- LogSearch {
- term: Some("HH".to_owned()),
- result: None,
- buttons: None
- }
- );
-
- logs.search_term_clear();
- logs.search_term_push('2', true);
- let log_search = LogSearch::from(&logs);
- assert_eq!(logs.lines.state.selected(), Some(1));
- assert_eq!(
- log_search,
- LogSearch {
- term: Some("2".to_owned()),
- result: Some("1/1".to_owned()),
- buttons: None
- }
- );
-
- logs.next();
-
- let log_search = LogSearch::from(&logs);
- assert_eq!(
- log_search,
- LogSearch {
- term: Some("2".to_owned()),
- result: Some("1".to_owned()),
- buttons: Some(crate::app_data::LogsButton::Previous)
- }
- );
- }
-}
diff --git a/src/app_data/mod.rs b/src/app_data/mod.rs
deleted file mode 100644
index 9e05986..0000000
--- a/src/app_data/mod.rs
+++ /dev/null
@@ -1,2571 +0,0 @@
-use bollard::{models::ContainerSummary, secret::ContainerInspectResponse};
-use core::fmt;
-use parking_lot::Mutex;
-use ratatui::{layout::Size, text::Text, widgets::ListState};
-use std::{
- hash::Hash,
- sync::Arc,
- time::{SystemTime, UNIX_EPOCH},
-};
-
-mod container_state;
-
-use crate::{
- ENTRY_POINT,
- app_error::AppError,
- config::Config,
- ui::{GuiState, Rerender, Status, log_sanitizer},
-};
-pub use container_state::*;
-
-#[derive(Debug, Clone, Copy, Eq, PartialEq)]
-pub enum SortedOrder {
- Asc,
- Desc,
-}
-
-#[derive(Debug, Clone, Copy, Eq, Hash, PartialEq)]
-pub enum Header {
- State,
- Status,
- Cpu,
- Memory,
- Id,
- Name,
- Image,
- Rx,
- Tx,
-}
-
-/// Convert Header enum into strings to display
-impl fmt::Display for Header {
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- let disp = match self {
- Self::State => "state",
- Self::Status => "status",
- Self::Cpu => "cpu",
- Self::Memory => "memory/limit",
- Self::Id => "id",
- Self::Name => "name",
- Self::Image => "image",
- Self::Rx => "↓ rx",
- Self::Tx => "↑ tx",
- };
- write!(f, "{disp:>x$}", x = f.width().unwrap_or(1))
- }
-}
-
-#[derive(Debug, Clone, Default, Copy, PartialEq, Eq, PartialOrd, Ord)]
-pub enum FilterBy {
- #[default]
- Name,
- Image,
- Status,
- All,
-}
-
-/// Convert errors into strings to display
-impl fmt::Display for FilterBy {
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- write!(
- f,
- "{}",
- match self {
- Self::Name => "Name",
- Self::Image => "Image",
- Self::Status => "Status",
- Self::All => "All",
- }
- )
- }
-}
-
-impl FilterBy {
- const fn next(self) -> Option {
- match self {
- Self::Name => Some(Self::Image),
- Self::Image => Some(Self::Status),
- Self::Status => Some(Self::All),
- Self::All => None,
- }
- }
-
- const fn prev(self) -> Option {
- match self {
- Self::Name => None,
- Self::Image => Some(Self::Name),
- Self::Status => Some(Self::Image),
- Self::All => Some(Self::Status),
- }
- }
-}
-
-#[derive(Debug, Clone)]
-pub struct Filter {
- pub term: Option,
- pub by: FilterBy,
-}
-impl Filter {
- pub fn new() -> Self {
- Self {
- term: None,
- by: FilterBy::default(),
- }
- }
-}
-
-#[derive(Debug, Clone)]
-pub struct InspectData {
- pub width: usize,
- pub height: usize,
- pub as_string: String,
- pub name: String,
- pub id: ContainerId, // pub as_lines: Vec>,
-}
-
-impl From for InspectData {
- fn from(input: ContainerInspectResponse) -> Self {
- let as_string = serde_json::to_string_pretty(&input)
- .unwrap_or_default()
- .lines()
- .skip(1)
- .collect::>()
- .split_last()
- .map(|(_, data)| data)
- .unwrap_or_default()
- .join("\n");
-
- let height = as_string.lines().count();
-
- let mut width = 0;
- for i in as_string.lines() {
- width = width.max(i.chars().count());
- }
-
- Self {
- name: input.name.unwrap_or_default(),
- // TODO maybe make this an Option?
- id: ContainerId::from(input.id.unwrap_or_default().as_str()),
- width,
- height,
- as_string,
- }
- }
-}
-
-/// Global app_state, stored in an Arc
-#[derive(Debug, Clone)]
-#[cfg(not(test))]
-pub struct AppData {
- containers: StatefulList,
- error: Option,
- filter: Filter,
- hidden_containers: Vec,
- inspect_data: Option,
- rerender: Arc,
- sorted_by: Option<(Header, SortedOrder)>,
- current_sorted_id: Vec,
- pub config: Config,
-}
-
-#[derive(Debug, Clone)]
-#[cfg(test)]
-pub struct AppData {
- pub config: Config,
- pub containers: StatefulList,
- pub error: Option,
- pub filter: Filter,
- pub hidden_containers: Vec,
- pub inspect_data: Option,
- pub current_sorted_id: Vec,
- pub rerender: Arc,
- pub sorted_by: Option<(Header, SortedOrder)>,
-}
-
-impl AppData {
- /// Generate a default app_state
- pub fn new(config: Config, redraw: &Arc) -> Self {
- Self {
- config,
- containers: StatefulList::new(vec![]),
- current_sorted_id: vec![],
- error: None,
- filter: Filter::new(),
- hidden_containers: vec![],
- inspect_data: None,
- rerender: Arc::clone(redraw),
- sorted_by: None,
- }
- }
-
- /// Current time as unix timestamp
- #[allow(clippy::expect_used)]
- fn get_systemtime() -> u64 {
- SystemTime::now()
- .duration_since(UNIX_EPOCH)
- .expect("In our known reality, this error should never occur")
- .as_secs()
- }
-
- pub fn clear_inspect_data(&mut self) {
- self.inspect_data = None;
- }
-
- pub fn set_inspect_data(&mut self, data: ContainerInspectResponse) {
- self.inspect_data = Some(InspectData::from(data))
- // self.inspect_data = Some(data)
- }
-
- pub fn get_inspect_data(&self) -> Option {
- self.inspect_data.clone()
- }
- /// Filter related methods
- /// Get the filterby and filter_term
- pub const fn get_filter(&self) -> (FilterBy, Option<&String>) {
- (self.filter.by, self.filter.term.as_ref())
- }
-
- pub fn log_search_scroll(&mut self, np: &ScrollDirection) {
- if let Some(i) = self.get_mut_selected_container()
- && i.logs.search_scroll(np).is_some()
- {
- self.rerender.update_draw();
- }
- }
-
- pub fn gen_log_search(&self) -> Option {
- self.get_selected_container()
- .map(|i| i.logs.gen_log_search())
- }
-
- /// Check if a given container can be inserted into the "visible" list, based on current filter term and filter_by
- fn can_insert(&self, container: &ContainerItem) -> bool {
- self.filter.term.as_ref().is_none_or(|term| {
- let term = term.to_lowercase();
- match self.filter.by {
- FilterBy::All => {
- container.name.contains(&term)
- || container.image.contains(&term)
- || container.status.contains(&term)
- }
- FilterBy::Image => container.image.contains(&term),
- FilterBy::Name => container.name.contains(&term),
- FilterBy::Status => container.status.contains(&term),
- }
- })
- }
-
- /// Remove items from the containers list based on the filter term, and insert into a "hidden" vec
- /// sets the state to start if any filtering has occurred
- /// Also search in the "hidden" vec for items and insert back into the main containers vec
- fn filter_containers(&mut self) {
- self.rerender.update_draw();
- let pre_len = self.get_container_len();
-
- if !self.hidden_containers.is_empty() {
- let (mut new_items, tmp_items): (Vec<_>, Vec<_>) = self
- .hidden_containers
- .iter()
- .cloned()
- .partition(|item| self.can_insert(item));
-
- while let Some(x) = new_items.pop() {
- self.containers.items.push(x);
- }
- self.hidden_containers = tmp_items;
- }
-
- let (new_items, tmp_items) = self
- .containers
- .items
- .iter()
- .cloned()
- .partition(|item| self.can_insert(item));
-
- self.containers.items = new_items;
- self.hidden_containers.extend(tmp_items);
-
- self.sort_containers();
- if self.get_container_len() != pre_len {
- self.containers.start();
- }
- }
-
- pub fn logs_search_clear(&mut self) {
- if let Some(selected_container) = self.get_mut_selected_container() {
- selected_container.logs.search_term_clear();
- self.rerender.update_draw();
- }
- }
-
- /// Set a single char into the filter term
- pub fn log_search_push(&mut self, c: char) {
- let cs = self.config.log_search_case_sensitive;
- if let Some(selected_container) = self.get_mut_selected_container() {
- selected_container.logs.search_term_push(c, cs);
- self.rerender.update_draw();
- }
- }
-
- /// Delete the final char of the filter term
- pub fn log_search_pop(&mut self) {
- let cs = self.config.log_search_case_sensitive;
- if let Some(selected_container) = self.get_mut_selected_container() {
- selected_container.logs.search_term_pop(cs);
- self.rerender.update_draw();
- }
- }
-
- /// Re-filter the containers, used after the filter.by has been changed
- fn re_filter(&mut self) {
- self.containers.items.append(&mut self.hidden_containers);
- self.hidden_containers = vec![];
- self.filter_containers();
- }
-
- /// Set a single char into the filter term
- pub fn filter_term_push(&mut self, c: char) {
- if let Some(term) = self.filter.term.as_mut() {
- term.push(c);
- } else {
- self.filter.term = Some(format!("{c}"));
- }
- self.filter_containers();
- }
-
- /// Delete the final char of the filter term
- pub fn filter_term_pop(&mut self) {
- if let Some(term) = self.filter.term.as_mut() {
- // should now search for items in the tmp vec, and insert into containers if found
- term.pop();
- if term.is_empty() {
- self.filter.term = None;
- }
- }
- self.filter_containers();
- }
-
- /// change the filter_by option
- pub fn filter_by_next(&mut self) {
- if let Some(by) = self.filter.by.next() {
- self.filter.by = by;
- self.re_filter();
- }
- }
-
- /// change the filter_by option
- pub fn filter_by_prev(&mut self) {
- if let Some(by) = self.filter.by.prev() {
- self.filter.by = by;
- self.re_filter();
- }
- }
-
- /// Remove the filter completely
- pub fn filter_term_clear(&mut self) {
- self.filter.term = None;
- while let Some(i) = self.hidden_containers.pop() {
- if self.get_container_by_id(&i.id).is_none() {
- self.containers.items.push(i);
- }
- }
- self.sort_containers();
- }
-
- /// Container sort related methods
- /// Change the sorted order, also set the selected container state to match new order
- fn set_sorted(&mut self, x: Option<(Header, SortedOrder)>) {
- self.sorted_by = x;
- self.sort_containers();
- self.containers.state.select(
- self.containers
- .items
- .iter()
- .position(|i| self.get_selected_container_id().as_ref() == Some(&i.id)),
- );
- self.rerender.update_draw();
- }
-
- /// Remove the sorted header & order, and sort by default - created datetime
- pub fn reset_sorted(&mut self) {
- self.set_sorted(None);
- self.rerender.update_draw();
- }
-
- /// Sort containers based on a given header, if headings match, and already ascending, remove sorting
- pub fn set_sort_by_header(&mut self, selected_header: Header) {
- let mut output = Some((selected_header, SortedOrder::Asc));
- if let Some((current_header, order)) = self.get_sorted()
- && current_header == selected_header
- {
- match order {
- SortedOrder::Desc => output = None,
- SortedOrder::Asc => output = Some((selected_header, SortedOrder::Desc)),
- }
- }
- self.set_sorted(output);
- }
-
- pub const fn get_sorted(&self) -> Option<(Header, SortedOrder)> {
- self.sorted_by
- }
-
- /// Get a vec of the containers ID's in the order they are displayed in the containers panel
- fn get_current_ids(&self) -> Vec {
- self.containers
- .items
- .iter()
- .map(|i| i.id.clone())
- .collect::>()
- }
- /// Sort the containers vec, based on a heading (and if clash, then by name), either ascending or descending,
- /// If not sort set, then sort by created time
- pub fn sort_containers(&mut self) {
- if let Some((head, ord)) = self.sorted_by {
- let pre_order = self.get_current_ids();
- let sort_closure = |a: &ContainerItem, b: &ContainerItem| -> std::cmp::Ordering {
- let item_ord = match ord {
- SortedOrder::Asc => (a, b),
- SortedOrder::Desc => (b, a),
- };
- match head {
- Header::State => item_ord
- .0
- .state
- .order()
- .cmp(&item_ord.1.state.order())
- .then_with(|| item_ord.0.name.get().cmp(item_ord.1.name.get())),
- Header::Status => item_ord
- .0
- .status
- .get()
- .cmp(item_ord.1.status.get())
- .then_with(|| item_ord.0.name.get().cmp(item_ord.1.name.get())),
- Header::Cpu => item_ord
- .0
- .cpu_stats
- .back()
- .cmp(&item_ord.1.cpu_stats.back())
- .then_with(|| item_ord.0.name.get().cmp(item_ord.1.name.get())),
- Header::Memory => item_ord
- .0
- .mem_stats
- .back()
- .cmp(&item_ord.1.mem_stats.back())
- .then_with(|| item_ord.0.name.get().cmp(item_ord.1.name.get())),
- Header::Id => item_ord
- .0
- .id
- .cmp(&item_ord.1.id)
- .then_with(|| item_ord.0.name.get().cmp(item_ord.1.name.get())),
- Header::Image => item_ord
- .0
- .image
- .get()
- .cmp(item_ord.1.image.get())
- .then_with(|| item_ord.0.name.get().cmp(item_ord.1.name.get())),
- Header::Rx => item_ord
- .0
- .rx
- .current_total()
- .cmp(&item_ord.1.rx.current_total())
- .then_with(|| item_ord.0.name.get().cmp(item_ord.1.name.get())),
- Header::Tx => item_ord
- .0
- .tx
- .current_total()
- .cmp(&item_ord.1.tx.current_total())
- .then_with(|| item_ord.0.name.get().cmp(item_ord.1.name.get())),
- Header::Name => item_ord
- .0
- .name
- .get()
- .cmp(item_ord.1.name.get())
- .then_with(|| item_ord.0.id.cmp(&item_ord.1.id)),
- }
- };
-
- self.containers.items.sort_by(sort_closure);
- if pre_order != self.get_current_ids() {
- self.rerender.update_draw();
- }
- } else if self.current_sorted_id != self.get_current_ids() {
- self.containers.items.sort_by(|a, b| {
- a.created
- .cmp(&b.created)
- .then_with(|| a.name.get().cmp(b.name.get()))
- });
- self.rerender.update_draw();
- self.current_sorted_id = self.get_current_ids();
- }
- }
-
- /// Container state methods
- /// Get the total number of none "hidden" containers
- pub const fn get_container_len(&self) -> usize {
- self.containers.items.len()
- }
-
- pub fn get_all_id_state(&self) -> Vec<(State, ContainerId)> {
- self.containers
- .items
- .iter()
- .map(|i| (i.state, i.id.clone()))
- .collect::>()
- }
-
- /// Get all the ContainerItems
- /// Thnk this allow block can be removed with the 1.87 release of Clippy
- pub fn get_container_items(&self) -> &[ContainerItem] {
- &self.containers.items
- }
-
- /// Get title for containers section, add a suffix indicating if the containers are currently under filter
- pub fn get_container_title(&self) -> String {
- let suffix = if !self.hidden_containers.is_empty() && !self.containers.items.is_empty() {
- " - filtered"
- } else {
- ""
- };
- format!("{}{}", self.containers.get_state_title(), suffix)
- }
-
- /// Select the first container
- pub fn containers_start(&mut self) {
- self.containers.start();
- self.rerender.update_draw();
- }
-
- /// select the last container
- pub fn containers_end(&mut self) {
- self.containers.end();
- self.rerender.update_draw();
- }
-
- pub fn containers_scroll(&mut self, scroll: &ScrollDirection) {
- self.containers.scroll(scroll);
- self.rerender.update_draw();
- }
-
- /// Get ListState of containers
- pub const fn get_container_state(&mut self) -> &mut ListState {
- &mut self.containers.state
- }
-
- /// Get Option of the current selected container
- pub fn get_selected_container(&self) -> Option<&ContainerItem> {
- self.containers
- .state
- .selected()
- .and_then(|i| self.containers.items.get(i))
- }
-
- /// Find the longest port when it's transformed into a string, defaults are header lens (ip, private, public)
- ///display like this: "│ ip, private, public│", so (5,10,9) are the minimum lengths required
- pub fn get_longest_port(&self) -> (usize, usize, usize) {
- let mut output = (5, 10, 9);
-
- for item in [&self.containers.items, &self.hidden_containers] {
- for item in item {
- output.0 = output.0.max(
- item.ports
- .iter()
- .map(ContainerPorts::len_ip)
- .max()
- .unwrap_or(output.0),
- );
- output.1 = output.1.max(
- item.ports
- .iter()
- .map(ContainerPorts::len_private)
- .max()
- .unwrap_or(output.1),
- );
- output.2 = output.2.max(
- item.ports
- .iter()
- .map(ContainerPorts::len_public)
- .max()
- .unwrap_or(output.2),
- );
- }
- }
- output
- }
-
- /// Get Option of the current selected container's ports, sorted by private port
- pub fn get_selected_ports(&self) -> Option<(Vec, State)> {
- if let Some(item) = self.get_selected_container() {
- let mut ports = item.ports.clone();
- ports.sort_by(|a, b| a.private.cmp(&b.private));
- return Some((ports, item.state));
- }
- None
- }
-
- /// Get mutable Option of the current selected container
- fn get_mut_selected_container(&mut self) -> Option<&mut ContainerItem> {
- self.containers
- .state
- .selected()
- .and_then(|i| self.containers.items.get_mut(i))
- }
-
- /// Get a mutable container by given id
- #[cfg(not(test))]
- fn get_container_by_id(&mut self, id: &ContainerId) -> Option<&mut ContainerItem> {
- self.containers.items.iter_mut().find(|i| &i.id == id)
- }
-
- /// As above, but make it public to testing
- #[cfg(test)]
- pub fn get_container_by_id(&mut self, id: &ContainerId) -> Option<&mut ContainerItem> {
- self.containers.items.iter_mut().find(|i| &i.id == id)
- }
-
- /// Get a mutable container by given id in the tmp_container vec
- fn get_hidden_container_by_id(&mut self, id: &ContainerId) -> Option<&mut ContainerItem> {
- self.hidden_containers.iter_mut().find(|i| &i.id == id)
- }
-
- /// Get the ContainerName of by ID
- pub fn get_container_name_by_id(&mut self, id: &ContainerId) -> Option<&ContainerName> {
- self.containers
- .items
- .iter_mut()
- .find(|i| &i.id == id)
- .map(|i| &i.name)
- }
-
- /// Find the id of the currently selected container.
- /// If any containers on system, will always return a ContainerId
- /// Only returns None when no containers found.
- pub fn get_selected_container_id(&self) -> Option {
- self.get_selected_container().map(|i| i.id.clone())
- }
-
- /// Check if a given ID matches the currently selected container
- pub fn is_selected_container(&self, id: &ContainerId) -> bool {
- self.get_selected_container().is_some_and(|i| &i.id == id)
- }
-
- /// Get the Id and State for the currently selected container - used by the exec check method
- pub fn get_selected_container_id_state_name(&self) -> Option<(ContainerId, State, String)> {
- self.get_selected_container()
- .map(|i| (i.id.clone(), i.state, i.name.get().to_owned()))
- }
-
- /// Selected DockerCommand methods
- /// Get the current selected docker command
- /// So know which command to execute
- pub fn selected_docker_controls(&self) -> Option {
- self.get_selected_container().and_then(|i| {
- i.docker_controls.state.selected().and_then(|x| {
- i.docker_controls
- .items
- .get(x)
- .map(std::borrow::ToOwned::to_owned)
- })
- })
- }
-
- /// Change selected choice of docker commands of selected container
- pub fn docker_controls_scroll(&mut self, scroll: &ScrollDirection) {
- if let Some(i) = self.get_mut_selected_container() {
- i.docker_controls.scroll(scroll);
- // i.docker_controls.next();
- self.rerender.update_draw();
- }
- }
-
- /// Change selected choice of docker commands of selected container
- pub fn docker_controls_start(&mut self) {
- if let Some(i) = self.get_mut_selected_container() {
- i.docker_controls.start();
- self.rerender.update_draw();
- }
- }
-
- /// Change selected choice of docker commands of selected container
- pub fn docker_controls_end(&mut self) {
- if let Some(i) = self.get_mut_selected_container() {
- i.docker_controls.end();
- self.rerender.update_draw();
- }
- }
-
- /// Get mutable Option of the currently selected container DockerCommand state
- pub fn get_control_state(&mut self) -> Option<&mut ListState> {
- self.get_mut_selected_container()
- .map(|i| &mut i.docker_controls.state)
- }
-
- /// Get mutable Option of the currently selected container DockerCommand items
- pub fn get_control_items(&mut self) -> Option<&mut Vec> {
- self.get_mut_selected_container()
- .map(|i| &mut i.docker_controls.items)
- }
-
- /// Logs related methods
- /// Get the title for log panel for selected container, will be either
- /// 1) "logs x/x - container_name - container_image"
- /// 2) "logs - container_name - container_image" when no logs found
- /// 3) " " no container currently selected - aka no containers on system
- pub fn get_log_title(&self) -> String {
- self.get_selected_container()
- .map_or_else(String::new, |ci| {
- let logs_len = ci.logs.get_state_title();
- let prefix = if logs_len.is_empty() {
- String::from(" ")
- } else {
- format!("{logs_len} ")
- };
- format!("{}- {} - {}", prefix, ci.name.get(), ci.image.get())
- })
- }
-
- /// If scrolling horizontally along the logs, display a counter of the position in the in the scroll, `x/y`
- pub fn get_scroll_title(&mut self, width: u16) -> Option {
- self.get_mut_selected_container()
- .and_then(|i| i.logs.get_scroll_title(width))
- }
-
- pub fn logs_horizontal_scroll(&mut self, sd: &ScrollDirection, width: u16) {
- // Change this to set a max_offset, instead of taking in width each time, then can be combined with the log_scroll beneath
- match sd {
- ScrollDirection::Down => {
- if let Some(i) = self.get_mut_selected_container() {
- i.logs.forward(width);
- self.rerender.update_draw();
- }
- }
- ScrollDirection::Up => {
- if let Some(i) = self.get_mut_selected_container() {
- i.logs.back();
- self.rerender.update_draw();
- }
- }
- // TODO set offset
- _ => (),
- }
- }
-
- /// select next selected log line
- pub fn log_scroll(&mut self, scroll: &ScrollDirection) {
- if let Some(i) = self.get_mut_selected_container() {
- match scroll {
- ScrollDirection::Down => i.logs.next(),
- ScrollDirection::Up => i.logs.previous(),
- // TODO set offset
- _ => (),
- }
- self.rerender.update_draw();
- }
- }
-
- /// select last selected log line
- pub fn log_end(&mut self) {
- if let Some(i) = self.get_mut_selected_container() {
- i.logs.end();
- self.rerender.update_draw();
- }
- }
-
- /// select first selected log line
- pub fn log_start(&mut self) {
- if let Some(i) = self.get_mut_selected_container() {
- i.logs.start();
- self.rerender.update_draw();
- }
- }
-
- /// Get mutable Vec of current containers logs
- pub fn get_logs(&self, size: Size, padding: usize) -> Vec> {
- self.containers
- .state
- .selected()
- .and_then(|i| self.containers.items.get(i))
- .map_or(vec![], |i| i.logs.get_visible_logs(size, padding))
- }
-
- /// Get mutable Option of the currently selected container Logs state
- pub fn get_log_state(&mut self) -> Option<&mut ListState> {
- self.containers
- .state
- .selected()
- .and_then(|i| self.containers.items.get_mut(i))
- .map(|i| i.logs.state())
- }
-
- /// Chart data related methods
- /// Get mutable Option of the currently selected container chart data
- pub fn get_chart_data(&self) -> Option {
- self.containers
- .state
- .selected()
- .and_then(|i| self.containers.items.get(i))
- .map(container_state::ContainerItem::get_chart_data)
- }
-
- /// Error related methods
- /// Get single app_state error
- pub fn get_error(&self) -> Option {
- self.error.clone()
- }
-
- /// Remove single app_state error
- pub fn remove_error(&mut self) {
- self.error = None;
- self.rerender.update_draw();
- }
-
- /// Insert single app_state error
- pub fn set_error(&mut self, error: AppError, gui_state: &Arc>, status: Status) {
- gui_state.lock().status_push(status);
- self.error = Some(error);
- self.rerender.update_draw();
- }
-
- /// Check if the selected container is a dockerised version of oxker
- /// So that can disallow commands to be send
- /// Is a shabby way of implementing this
- pub fn is_oxker(&self) -> bool {
- self.get_selected_container().is_some_and(|i| i.is_oxker)
- }
-
- /// Check if selected container is oxker and also that oxker is being run in a container
- pub fn is_oxker_in_container(&self) -> bool {
- self.get_selected_container()
- .is_some_and(|i| i.is_oxker && self.config.in_container)
- }
-
- /// Find the widths for the strings in the containers panel.
- /// So can display nicely and evenly
- /// Searches in both contains & hidden_containers
- pub fn get_width(&self) -> Columns {
- let mut columns = Columns::new();
- let count = |x: &str| u8::try_from(x.chars().count()).unwrap_or(12);
-
- for container in [&self.containers.items, &self.hidden_containers] {
- for container in container {
- // TODO refactor these
- let cpu_count = container.cpu_stats.back().map_or_else(
- || count(&CpuStats::default().to_string()),
- |i| count(&i.to_string()),
- );
-
- let mem_current_count = container.mem_stats.back().map_or_else(
- || count(&ByteStats::default().to_string()),
- |i| count(&i.to_string()),
- );
- columns.cpu.1 = columns.cpu.1.max(cpu_count);
- columns.image.1 = columns.image.1.max(count(&container.image.to_string()));
- columns.mem.1 = columns.mem.1.max(mem_current_count);
- columns.mem.2 = columns.mem.2.max(count(&container.mem_limit.to_string()));
- columns.name.1 = columns.name.1.max(count(&container.name.to_string()));
- columns.net_rx.1 = columns
- .net_rx
- .1
- .max(count(&container.rx.current_total().to_string()));
- columns.net_tx.1 = columns
- .net_tx
- .1
- .max(count(&container.tx.current_total().to_string()));
- columns.state.1 = columns.state.1.max(count(&container.state.to_string()));
- columns.status.1 = columns.status.1.max(count(container.status.get()));
- }
- }
- columns
- }
-
- /// Update related methods
- /// Get mutable reference to a container in the containers vec & the hidden_containers vec
- fn get_any_container_by_id(&mut self, id: &ContainerId) -> Option<&mut ContainerItem> {
- if self.get_hidden_container_by_id(id).is_some() {
- self.get_hidden_container_by_id(id)
- } else {
- self.get_container_by_id(id)
- }
- }
-
- /// Update container mem, cpu, & network stats, in single function so only need to call .lock() once
- /// Will also, if a sort is set, sort the containers
- pub fn update_stats_by_id(
- &mut self,
- id: &ContainerId,
- cpu_stat: Option,
- mem_stat: Option,
- mem_limit: u64,
- rx: u64,
- tx: u64,
- ) {
- if let Some(container) = self.get_any_container_by_id(id) {
- if container.cpu_stats.len() >= 60 {
- container.cpu_stats.pop_front();
- }
- if container.mem_stats.len() >= 60 {
- container.mem_stats.pop_front();
- }
-
- if let Some(cpu) = cpu_stat {
- container.cpu_stats.push_back(CpuStats::new(cpu));
- }
- if let Some(mem) = mem_stat {
- container.mem_stats.push_back(ByteStats::new(mem));
- }
-
- // Only insert if alive, or if is empty, need two to create an entry in the bandwidth chart, so instead this fills in the RX/TX total columns
- if container.rx.is_empty() || container.state.is_alive() {
- container.rx.push(rx);
- container.tx.push(tx);
- }
-
- container.mem_limit.update(mem_limit);
- }
- if self.is_selected_container(id) {
- self.rerender.update_draw();
- }
- self.sort_containers();
- }
-
- /// Update, or insert, containers
- pub fn update_containers(&mut self, mut all_containers: Vec) {
- let all_ids = self
- .containers
- .items
- .iter()
- .map(|i| i.id.clone())
- .collect::>();
-
- // Only sort it no containers currently set, as afterwards the order is fixed
- if self.containers.items.is_empty() {
- all_containers.sort_by(|a, b| a.created.cmp(&b.created));
- }
-
- if !all_containers.is_empty() && self.containers.state.selected().is_none() {
- self.containers.start();
- }
-
- for (index, id) in all_ids.iter().enumerate() {
- if !all_containers
- .iter()
- .filter_map(|i| i.id.as_ref())
- .any(|x| x == id.get())
- {
- // If removed container is currently selected, then change selected to previous
- // This will default to 0 in any edge cases
- if self.containers.state.selected().is_some() {
- self.containers.scroll(&ScrollDirection::Up);
- }
- // Check is some, else can cause out of bounds error, if containers get removed before a docker update
- if self.containers.items.get(index).is_some() {
- self.containers.items.remove(index);
- if self.is_selected_container(id) {
- self.rerender.update_draw();
- }
- }
- }
- }
-
- for mut i in all_containers {
- if let Some(id) = i.id.as_ref() {
- let name = i.names.as_mut().map_or(String::new(), |names| {
- names.first_mut().map_or(String::new(), |f| {
- if f.starts_with('/') {
- f.remove(0);
- }
- (*f).clone()
- })
- });
-
- let ports = i.ports.map_or(vec![], |i| {
- i.into_iter().map(ContainerPorts::from).collect::>()
- });
-
- let id = ContainerId::from(id.as_str());
-
- let is_oxker = i
- .command
- .as_ref()
- .is_some_and(|i| i.starts_with(ENTRY_POINT));
-
- let status = ContainerStatus::from(
- i.status
- .as_ref()
- .map_or(String::new(), std::clone::Clone::clone),
- );
- let state = State::from((
- i.state
- .as_ref()
- .map_or(&bollard::secret::ContainerSummaryStateEnum::DEAD, |z| z),
- &status,
- ));
- let image = i
- .image
- .as_ref()
- .map_or(String::new(), std::clone::Clone::clone);
-
- let created = i
- .created
- .map_or(0, |i| u64::try_from(i).unwrap_or_default());
-
- if let Some(item) = self.get_any_container_by_id(&id) {
- if item.name.get() != name {
- item.name.set(name);
- }
- if item.status != status {
- item.status = status;
- }
- if item.state != state {
- item.docker_controls.items = DockerCommand::gen_vec(state);
- // Update the list state, needs to be None if the gen_vec returns an empty vec
- match state {
- State::Removing | State::Restarting | State::Unknown => {
- item.docker_controls.state.select(None);
- }
- _ => item.docker_controls.start(),
- }
- item.state = state;
- }
-
- item.ports = ports;
-
- if item.image.get() != image {
- item.image.set(image);
- }
- } else {
- // container not known, so make new ContainerItem and push into containers Ve
- let container = ContainerItem::new(
- created, id, image, is_oxker, name, ports, state, status,
- );
- let can_insert = self.can_insert(&container);
- if can_insert {
- self.containers.items.push(container);
- } else {
- self.hidden_containers.push(container);
- }
- }
- }
- // self.redraw.set_true("update_containers");
- }
- }
-
- /// Update logs of a given container, based on id
- pub fn update_log_by_id(&mut self, logs: Vec, id: &ContainerId) {
- let color = self.config.color_logs;
- let raw = self.config.raw_logs;
- let format = self.config.timestamp_format.clone();
- let config_tz = self.config.timezone.clone();
-
- let cs = self.config.log_search_case_sensitive;
-
- let show_timestamp = self.config.show_timestamp;
-
- if let Some(container) = self.get_any_container_by_id(id) {
- if !container.is_oxker {
- container.last_updated = Self::get_systemtime();
- let current_len = container.logs.len();
- for mut i in logs {
- let (log_tz, log_content) = LogsTz::splitter(i.as_str());
- if show_timestamp {
- i = format!(
- "{} {}",
- log_tz
- .display_with_formatter(config_tz.as_ref(), &format)
- .unwrap_or_else(|| log_tz.to_string()),
- log_content
- );
- } else {
- i = log_content;
- }
- let lines = if color {
- log_sanitizer::colorize_logs(&i)
- } else if raw {
- log_sanitizer::raw(&i)
- } else {
- log_sanitizer::remove_ansi(&i)
- };
- container.logs.insert(Text::from(lines), log_tz, cs);
- }
-
- // Set the logs selected row for each container
- // Either when no long currently selected, or currently selected (before updated) is already at end
- if container.logs.state().selected().is_none()
- || container.logs.state().selected().map_or(1, |f| f + 1) == current_len
- {
- container.logs.end();
- }
- }
- if self.is_selected_container(id) {
- self.rerender.update_draw();
- }
- }
- }
-}
-
-#[cfg(test)]
-#[allow(clippy::unwrap_used)]
-mod tests {
-
- use super::*;
- use crate::tests::{gen_appdata, gen_container_summary, gen_containers};
- use std::collections::VecDeque;
-
- // ******* //
- // Sort by //
- // ******* //
-
- #[test]
- /// Sort by header: name
- fn test_app_data_set_sort_by_header_name() {
- let (_ids, containers) = gen_containers();
-
- let mut app_data = gen_appdata(&containers);
-
- let result = app_data.get_container_items();
- assert_eq!(result, &containers);
-
- // descending
- app_data.set_sorted(Some((Header::Name, SortedOrder::Desc)));
- let result = app_data.get_container_items();
- let (a, b, c) = (&result[0], &result[1], &result[2]);
- assert_eq!(a.id, ContainerId::from("3"));
- assert_eq!(b.id, ContainerId::from("2"));
- assert_eq!(c.id, ContainerId::from("1"));
-
- // ascending
- app_data.set_sorted(Some((Header::Name, SortedOrder::Asc)));
- let result = app_data.get_container_items();
- let (a, b, c) = (&result[0], &result[1], &result[2]);
- assert_eq!(a.id, ContainerId::from("1"));
- assert_eq!(b.id, ContainerId::from("2"));
- assert_eq!(c.id, ContainerId::from("3"));
- }
-
- #[test]
- /// Sort by header: state
- fn test_app_data_set_sort_by_header_state() {
- let (_ids, containers) = gen_containers();
-
- let mut app_data = gen_appdata(&containers);
-
- let result = app_data.get_container_items();
- assert_eq!(result, &containers);
-
- if let Some(i) = app_data.get_container_by_id(&ContainerId::from("1")) {
- i.state = State::Exited;
- }
- if let Some(i) = app_data.get_container_by_id(&ContainerId::from("2")) {
- i.state = State::Running(RunningState::Healthy);
- }
- if let Some(i) = app_data.get_container_by_id(&ContainerId::from("3")) {
- i.state = State::Paused;
- }
-
- // descending
- app_data.set_sorted(Some((Header::State, SortedOrder::Desc)));
- let result = app_data.get_container_items();
- let (a, b, c) = (&result[0], &result[1], &result[2]);
- assert_eq!(a.id, ContainerId::from("1"));
- assert_eq!(b.id, ContainerId::from("3"));
- assert_eq!(c.id, ContainerId::from("2"));
-
- // ascending
- app_data.set_sorted(Some((Header::State, SortedOrder::Asc)));
- let result = app_data.get_container_items();
- let (a, b, c) = (&result[0], &result[1], &result[2]);
- assert_eq!(a.id, ContainerId::from("2"));
- assert_eq!(b.id, ContainerId::from("3"));
- assert_eq!(c.id, ContainerId::from("1"));
- }
-
- #[test]
- /// Sort by header: status
- fn test_app_data_set_sort_by_header_status() {
- let (_ids, containers) = gen_containers();
-
- let mut app_data = gen_appdata(&containers);
-
- let result = app_data.get_container_items();
- assert_eq!(result, &containers);
-
- if let Some(i) = app_data.get_container_by_id(&ContainerId::from("2")) {
- ContainerStatus::from("Exited (0) 10 minutes ago".to_owned()).clone_into(&mut i.status);
- }
-
- if let Some(i) = app_data.get_container_by_id(&ContainerId::from("3")) {
- // "Up 2 hours (Paused)".clone_into(&mut i.status);
- ContainerStatus::from("Up 2 hours (Paused)".to_owned()).clone_into(&mut i.status);
- }
-
- // Sort by status
- // descending
- app_data.set_sorted(Some((Header::Status, SortedOrder::Desc)));
- let result = app_data.get_container_items();
- let (a, b, c) = (&result[0], &result[1], &result[2]);
- assert_eq!(a.id, ContainerId::from("3"));
- assert_eq!(b.id, ContainerId::from("1"));
- assert_eq!(c.id, ContainerId::from("2"));
-
- // ascending
- app_data.set_sorted(Some((Header::Status, SortedOrder::Asc)));
- let result = app_data.get_container_items();
- let (a, b, c) = (&result[0], &result[1], &result[2]);
- assert_eq!(a.id, ContainerId::from("2"));
- assert_eq!(b.id, ContainerId::from("1"));
- assert_eq!(c.id, ContainerId::from("3"));
- }
-
- #[test]
- /// Sort by header: cpu
- fn test_app_data_set_sort_by_header_cpu() {
- let (_ids, containers) = gen_containers();
-
- let mut app_data = gen_appdata(&containers);
-
- let result = app_data.get_container_items();
- assert_eq!(result, &containers);
-
- if let Some(i) = app_data.get_container_by_id(&ContainerId::from("1")) {
- i.cpu_stats = VecDeque::from([CpuStats::new(10.1)]);
- }
- if let Some(i) = app_data.get_container_by_id(&ContainerId::from("2")) {
- i.cpu_stats = VecDeque::from([CpuStats::new(8.1)]);
- }
- if let Some(i) = app_data.get_container_by_id(&ContainerId::from("3")) {
- i.cpu_stats = VecDeque::from([CpuStats::new(20.3)]);
- }
-
- // descending
- app_data.set_sorted(Some((Header::Cpu, SortedOrder::Desc)));
- let result = app_data.get_container_items();
- let (a, b, c) = (&result[0], &result[1], &result[2]);
- assert_eq!(a.id, ContainerId::from("3"));
- assert_eq!(b.id, ContainerId::from("1"));
- assert_eq!(c.id, ContainerId::from("2"));
-
- // ascending
- app_data.set_sorted(Some((Header::Cpu, SortedOrder::Asc)));
- let result = app_data.get_container_items();
- let (a, b, c) = (&result[0], &result[1], &result[2]);
- assert_eq!(a.id, ContainerId::from("2"));
- assert_eq!(b.id, ContainerId::from("1"));
- assert_eq!(c.id, ContainerId::from("3"));
- }
-
- #[test]
- /// Sort by header: memory
- fn test_app_data_set_sort_by_header_mem() {
- let (_ids, containers) = gen_containers();
-
- let mut app_data = gen_appdata(&containers);
-
- let result = app_data.get_container_items();
- assert_eq!(result, &containers);
-
- if let Some(i) = app_data.get_container_by_id(&ContainerId::from("1")) {
- i.mem_stats = VecDeque::from([ByteStats::new(40)]);
- }
- if let Some(i) = app_data.get_container_by_id(&ContainerId::from("2")) {
- i.mem_stats = VecDeque::from([ByteStats::new(80)]);
- }
- if let Some(i) = app_data.get_container_by_id(&ContainerId::from("3")) {
- i.mem_stats = VecDeque::from([ByteStats::new(2)]);
- }
-
- // descending
- app_data.set_sorted(Some((Header::Memory, SortedOrder::Desc)));
- let result = app_data.get_container_items();
- let (a, b, c) = (&result[0], &result[1], &result[2]);
- assert_eq!(a.id, ContainerId::from("2"));
- assert_eq!(b.id, ContainerId::from("1"));
- assert_eq!(c.id, ContainerId::from("3"));
-
- // ascending
- app_data.set_sorted(Some((Header::Memory, SortedOrder::Asc)));
- let result = app_data.get_container_items();
- let (a, b, c) = (&result[0], &result[1], &result[2]);
- assert_eq!(a.id, ContainerId::from("3"));
- assert_eq!(b.id, ContainerId::from("1"));
- assert_eq!(c.id, ContainerId::from("2"));
- }
-
- #[test]
- /// Sort by header: id
- fn test_app_data_set_sort_by_header_id() {
- let (_ids, containers) = gen_containers();
-
- let mut app_data = gen_appdata(&containers);
-
- let result = app_data.get_container_items();
- assert_eq!(result, &containers);
-
- // descending
- app_data.set_sorted(Some((Header::Id, SortedOrder::Desc)));
- let result = app_data.get_container_items();
- let (a, b, c) = (&result[0], &result[1], &result[2]);
- assert_eq!(a.id, ContainerId::from("3"));
- assert_eq!(b.id, ContainerId::from("2"));
- assert_eq!(c.id, ContainerId::from("1"));
-
- // ascending
- app_data.set_sorted(Some((Header::Id, SortedOrder::Asc)));
- let result = app_data.get_container_items();
- let (a, b, c) = (&result[0], &result[1], &result[2]);
- assert_eq!(a.id, ContainerId::from("1"));
- assert_eq!(b.id, ContainerId::from("2"));
- assert_eq!(c.id, ContainerId::from("3"));
- }
-
- #[test]
- /// Sort by header: image
- fn test_app_data_set_sort_by_header_image() {
- let (_ids, containers) = gen_containers();
-
- let mut app_data = gen_appdata(&containers);
-
- let result = app_data.get_container_items();
- assert_eq!(result, &containers);
-
- // descending
- app_data.set_sorted(Some((Header::Image, SortedOrder::Desc)));
- let result = app_data.get_container_items();
- let (a, b, c) = (&result[0], &result[1], &result[2]);
- assert_eq!(a.id, ContainerId::from("3"));
- assert_eq!(b.id, ContainerId::from("2"));
- assert_eq!(c.id, ContainerId::from("1"));
-
- // ascending
- app_data.set_sorted(Some((Header::Image, SortedOrder::Asc)));
- let result = app_data.get_container_items();
- let (a, b, c) = (&result[0], &result[1], &result[2]);
- assert_eq!(a.id, ContainerId::from("1"));
- assert_eq!(b.id, ContainerId::from("2"));
- assert_eq!(c.id, ContainerId::from("3"));
- }
-
- #[test]
- /// Sort by header: rx
- fn test_app_data_set_sort_by_header_rx() {
- let (_ids, containers) = gen_containers();
-
- let mut app_data = gen_appdata(&containers);
-
- let result = app_data.get_container_items();
- assert_eq!(result, &containers);
-
- if let Some(i) = app_data.get_container_by_id(&ContainerId::from("1")) {
- i.rx = NetworkBandwidth::new();
- i.rx.push(40);
- }
- if let Some(i) = app_data.get_container_by_id(&ContainerId::from("2")) {
- i.rx = NetworkBandwidth::new();
- i.rx.push(80);
- }
- if let Some(i) = app_data.get_container_by_id(&ContainerId::from("3")) {
- i.rx = NetworkBandwidth::new();
- i.rx.push(2);
- }
-
- // descending
- app_data.set_sorted(Some((Header::Rx, SortedOrder::Desc)));
- let result = app_data.get_container_items();
- let (a, b, c) = (&result[0], &result[1], &result[2]);
- assert_eq!(a.id, ContainerId::from("2"));
- assert_eq!(b.id, ContainerId::from("1"));
- assert_eq!(c.id, ContainerId::from("3"));
-
- // ascending
- app_data.set_sorted(Some((Header::Rx, SortedOrder::Asc)));
- let result = app_data.get_container_items();
- let (a, b, c) = (&result[0], &result[1], &result[2]);
- assert_eq!(a.id, ContainerId::from("3"));
- assert_eq!(b.id, ContainerId::from("1"));
- assert_eq!(c.id, ContainerId::from("2"));
- }
-
- #[test]
- /// Sort by header: tx
- fn test_app_data_set_sort_by_header_tx() {
- let (_ids, containers) = gen_containers();
-
- let mut app_data = gen_appdata(&containers);
-
- let result = app_data.get_container_items();
- assert_eq!(result, &containers);
-
- if let Some(i) = app_data.get_container_by_id(&ContainerId::from("1")) {
- i.rx = NetworkBandwidth::new();
- i.rx.push(400);
- }
- if let Some(i) = app_data.get_container_by_id(&ContainerId::from("2")) {
- i.rx = NetworkBandwidth::new();
- i.rx.push(80);
- }
- if let Some(i) = app_data.get_container_by_id(&ContainerId::from("3")) {
- i.rx = NetworkBandwidth::new();
- i.rx.push(83);
- }
-
- // descending
- app_data.set_sorted(Some((Header::Rx, SortedOrder::Desc)));
- let result = app_data.get_container_items();
- let (a, b, c) = (&result[0], &result[1], &result[2]);
- assert_eq!(a.id, ContainerId::from("1"));
- assert_eq!(b.id, ContainerId::from("3"));
- assert_eq!(c.id, ContainerId::from("2"));
-
- // ascending
- app_data.set_sorted(Some((Header::Rx, SortedOrder::Asc)));
- let result = app_data.get_container_items();
- let (a, b, c) = (&result[0], &result[1], &result[2]);
- assert_eq!(a.id, ContainerId::from("2"));
- assert_eq!(b.id, ContainerId::from("3"));
- assert_eq!(c.id, ContainerId::from("1"));
- }
-
- #[test]
- /// Sort by header when selected headers match
- fn test_app_data_set_sort_by_header_match() {
- let (_ids, containers) = gen_containers();
-
- let mut app_data = gen_appdata(&containers);
-
- let result = app_data.get_container_items();
- assert_eq!(result, &containers);
-
- // descending
- app_data.set_sorted(Some((Header::Rx, SortedOrder::Desc)));
- let result = app_data.get_container_items();
- let (a, b, c) = (&result[0], &result[1], &result[2]);
- assert_eq!(a.id, ContainerId::from("3"));
- assert_eq!(b.id, ContainerId::from("2"));
- assert_eq!(c.id, ContainerId::from("1"));
-
- // ascending
- app_data.set_sorted(Some((Header::Rx, SortedOrder::Asc)));
- let result = app_data.get_container_items();
- let (a, b, c) = (&result[0], &result[1], &result[2]);
- assert_eq!(a.id, ContainerId::from("1"));
- assert_eq!(b.id, ContainerId::from("2"));
- assert_eq!(c.id, ContainerId::from("3"));
- }
-
- #[test]
- /// reset sorted
- fn test_app_data_reset_sorted() {
- let (_ids, containers) = gen_containers();
-
- let mut app_data = gen_appdata(&containers);
-
- let result = app_data.get_container_items();
- assert_eq!(result, &containers);
-
- if let Some(i) = app_data.get_container_by_id(&ContainerId::from("1")) {
- i.rx = NetworkBandwidth::new();
- i.rx.push(400);
- }
- if let Some(i) = app_data.get_container_by_id(&ContainerId::from("2")) {
- i.rx = NetworkBandwidth::new();
- i.rx.push(80);
- }
- if let Some(i) = app_data.get_container_by_id(&ContainerId::from("3")) {
- i.rx = NetworkBandwidth::new();
- i.rx.push(83);
- }
-
- app_data.set_sorted(Some((Header::Rx, SortedOrder::Asc)));
- let result = app_data.get_container_items();
- let (a, b, c) = (&result[0], &result[1], &result[2]);
- assert_eq!(a.id, ContainerId::from("2"));
- assert_eq!(b.id, ContainerId::from("3"));
- assert_eq!(c.id, ContainerId::from("1"));
-
- app_data.set_sorted(None);
- let result = app_data.get_container_items();
- let (a, b, c) = (&result[0], &result[1], &result[2]);
- assert_eq!(a.id, ContainerId::from("1"));
- assert_eq!(b.id, ContainerId::from("2"));
- assert_eq!(c.id, ContainerId::from("3"));
- }
-
- // **************** //
- // Container state //
- // **************** //
-
- #[test]
- /// Get len of current containers vec
- fn test_app_data_get_container_len() {
- let (_ids, containers) = gen_containers();
- let app_data = gen_appdata(&containers);
- assert_eq!(app_data.get_container_len(), 3);
- }
-
- #[test]
- /// Select the first container
- fn test_app_data_containers_start() {
- let (_ids, containers) = gen_containers();
- let mut app_data = gen_appdata(&containers);
-
- // No container selected
- let result = app_data.get_container_state();
- assert_eq!(result.selected(), None);
- assert_eq!(result.offset(), 0);
-
- // First container selected
- app_data.containers_start();
- let result = app_data.get_container_state();
- assert_eq!(result.selected(), Some(0));
- assert_eq!(result.offset(), 0);
-
- let result = app_data.get_selected_container_id();
- assert_eq!(result, Some(ContainerId::from("1")));
- let result = app_data.get_selected_container_id_state_name();
- assert_eq!(
- result,
- Some((
- ContainerId::from("1"),
- State::Running(RunningState::Healthy),
- "container_1".to_owned()
- ))
- );
-
- // Calling previous when at start has no effect
- app_data.containers_scroll(&ScrollDirection::Up);
- let result = app_data.get_selected_container_id();
- assert_eq!(result, Some(ContainerId::from("1")));
- let result = app_data.get_selected_container_id_state_name();
- assert_eq!(
- result,
- Some((
- ContainerId::from("1"),
- State::Running(RunningState::Healthy),
- "container_1".to_owned()
- ))
- );
- }
-
- #[test]
- /// advance container list state by one
- /// get get_selected_container_id() & get_selected_container_id_state_name() return valid Some data
- fn test_app_data_containers_next() {
- let (_ids, containers) = gen_containers();
- let mut app_data = gen_appdata(&containers);
-
- // Advance list state by 1
- app_data.containers_start();
- app_data.containers.scroll(&ScrollDirection::Down);
-
- let result = app_data.get_container_state();
- assert_eq!(result.selected(), Some(1));
- assert_eq!(result.offset(), 0);
-
- let result = app_data.get_selected_container_id();
- assert_eq!(result, Some(ContainerId::from("2")));
- let result = app_data.get_selected_container_id_state_name();
- assert_eq!(
- result,
- Some((
- ContainerId::from("2"),
- State::Running(RunningState::Healthy),
- "container_2".to_owned()
- ))
- );
- }
-
- #[test]
- /// advance container list state to the end
- /// get get_selected_container_id() & get_selected_container_id_state_name() return valid Some data
- fn test_app_data_containers_end() {
- let (_ids, containers) = gen_containers();
- let mut app_data = gen_appdata(&containers);
-
- app_data.containers_end();
- let result = app_data.get_container_state();
- assert_eq!(result.selected(), Some(2));
- assert_eq!(result.offset(), 0);
-
- let result = app_data.get_selected_container_id();
- assert_eq!(result, Some(ContainerId::from("3")));
- let result = app_data.get_selected_container_id_state_name();
- assert_eq!(
- result,
- Some((
- ContainerId::from("3"),
- State::Running(RunningState::Healthy),
- "container_3".to_owned()
- ))
- );
-
- // Calling previous when at end has no effect
- app_data.containers.scroll(&ScrollDirection::Down);
- let result = app_data.get_selected_container_id();
- assert_eq!(result, Some(ContainerId::from("3")));
- let result = app_data.get_selected_container_id_state_name();
- assert_eq!(
- result,
- Some((
- ContainerId::from("3"),
- State::Running(RunningState::Healthy),
- "container_3".to_owned()
- ))
- );
- }
-
- #[test]
- /// go to previous container
- fn test_app_data_containers_prev() {
- let (_ids, containers) = gen_containers();
- let mut app_data = gen_appdata(&containers);
-
- app_data.containers_end();
- app_data.containers.scroll(&ScrollDirection::Up);
- let result = app_data.get_container_state();
- assert_eq!(result.selected(), Some(1));
- assert_eq!(result.offset(), 0);
- }
-
- #[test]
- /// Get the currently selected container
- fn test_app_data_get_selected_container() {
- let (_ids, mut containers) = gen_containers();
- let mut app_data = gen_appdata(&containers);
-
- let result = app_data.get_selected_container();
- assert_eq!(result, None);
-
- app_data.containers.start();
- app_data.containers.scroll(&ScrollDirection::Down);
-
- let result = app_data.get_selected_container();
- assert_eq!(result, Some(&containers[1]));
-
- // As above, but now as mut
- let result = app_data.get_mut_selected_container();
- assert_eq!(result, Some(&mut containers[1]));
- }
-
- #[test]
- /// Get mut container by id
- fn test_app_data_get_container_by_id() {
- let (_ids, mut containers) = gen_containers();
- let mut app_data = gen_appdata(&containers);
-
- let result = app_data.get_container_by_id(&ContainerId::from("2"));
- assert_eq!(result, Some(&mut containers[1]));
- }
-
- #[test]
- /// Get just the containers name by id
- fn test_app_data_get_container_name_by_id() {
- let (_ids, containers) = gen_containers();
- let mut app_data = gen_appdata(&containers);
-
- let result = app_data.get_container_name_by_id(&ContainerId::from("2"));
- assert_eq!(result, Some(&ContainerName::from("container_2")));
- }
-
- #[test]
- /// Get the id of the currently selected container
- fn test_app_data_get_selected_container_id() {
- let (_ids, containers) = gen_containers();
- let mut app_data = gen_appdata(&containers);
- app_data.containers_end();
-
- let result = app_data.get_selected_container_id();
- assert_eq!(result, Some(ContainerId::from("3")));
- }
-
- #[test]
- fn test_app_data_get_selected_container_id_state_name() {
- let (_ids, containers) = gen_containers();
- let mut app_data = gen_appdata(&containers);
- app_data.containers_end();
-
- let result = app_data.get_selected_container_id_state_name();
- assert_eq!(
- result,
- Some((
- ContainerId::from("3"),
- State::Running(RunningState::Healthy),
- "container_3".to_owned()
- ))
- );
- }
-
- // ************** //
- // DockerControls //
- // ************** //
-
- #[test]
- /// Docker commands returned correctly
- fn test_app_data_selected_docker_command() {
- let (_ids, containers) = gen_containers();
- let mut app_data = gen_appdata(&containers);
-
- // No commands when no container selected
- let result = app_data.selected_docker_controls();
- assert!(result.is_none());
-
- // Correct commands returned
- app_data.containers_start();
- app_data.docker_controls_start();
-
- let result = app_data.selected_docker_controls();
- assert_eq!(result, Some(DockerCommand::Pause));
- }
-
- #[test]
- /// Docker command next works
- fn test_app_data_selected_docker_command_next() {
- let (_ids, containers) = gen_containers();
- let mut app_data = gen_appdata(&containers);
- app_data.containers_start();
- app_data.docker_controls_start();
- app_data.docker_controls_scroll(&ScrollDirection::Down);
-
- let result = app_data.selected_docker_controls();
- assert_eq!(result, Some(DockerCommand::Restart));
- }
-
- #[test]
- /// Dockercommand end works, and next has no effect when at end
- fn test_app_data_selected_docker_command_end() {
- let (_ids, containers) = gen_containers();
- let mut app_data = gen_appdata(&containers);
- app_data.containers_start();
- app_data.docker_controls_end();
-
- let result = app_data.selected_docker_controls();
- assert_eq!(result, Some(DockerCommand::Delete));
-
- // Next has no effect when at end
- app_data.docker_controls_scroll(&ScrollDirection::Down);
- let result = app_data.selected_docker_controls();
- assert_eq!(result, Some(DockerCommand::Delete));
- }
-
- #[test]
- /// Docker commands previous works, and has no effect when at start
- fn test_app_data_selected_docker_command_previous() {
- let (_ids, containers) = gen_containers();
- let mut app_data = gen_appdata(&containers);
- app_data.containers_start();
- app_data.docker_controls_end();
- app_data.docker_controls_scroll(&ScrollDirection::Up);
-
- let result = app_data.selected_docker_controls();
- assert_eq!(result, Some(DockerCommand::Stop));
-
- // previous has no effect when at start
- app_data.docker_controls_start();
- app_data.docker_controls_scroll(&ScrollDirection::Up);
- let result = app_data.selected_docker_controls();
- assert_eq!(result, Some(DockerCommand::Pause));
- }
-
- #[test]
- /// DockerCommands get correct controls dependant on container state
- fn test_app_data_get_control_items() {
- let test_state = |state: State, expected: &mut Vec| {
- let gen_item_state = |state: State| {
- ContainerItem::new(
- 1,
- ContainerId::from("1"),
- "image_1".to_owned(),
- false,
- "container_1".to_owned(),
- vec![],
- state,
- ContainerStatus::from("Up 1 hour".to_owned()),
- )
- };
- let mut app_data = gen_appdata(&[gen_item_state(state)]);
- app_data.containers_start();
- app_data.docker_controls_start();
-
- let result = app_data.get_control_items();
- assert_eq!(result, Some(expected));
- };
-
- test_state(
- State::Dead,
- &mut vec![
- DockerCommand::Start,
- DockerCommand::Restart,
- DockerCommand::Delete,
- ],
- );
- test_state(
- State::Exited,
- &mut vec![
- DockerCommand::Start,
- DockerCommand::Restart,
- DockerCommand::Delete,
- ],
- );
- test_state(
- State::Paused,
- &mut vec![
- DockerCommand::Resume,
- DockerCommand::Stop,
- DockerCommand::Delete,
- ],
- );
- test_state(State::Removing, &mut vec![DockerCommand::Delete]);
- test_state(
- State::Restarting,
- &mut vec![DockerCommand::Stop, DockerCommand::Delete],
- );
- test_state(
- State::Running(RunningState::Healthy),
- &mut vec![
- DockerCommand::Pause,
- DockerCommand::Restart,
- DockerCommand::Stop,
- DockerCommand::Delete,
- ],
- );
- test_state(State::Unknown, &mut vec![DockerCommand::Delete]);
- }
-
- // ****** //
- // Filter //
- // ****** //
-
- #[test]
- /// Data is filtered correctly by name
- fn test_app_data_filter_by_name() {
- let (_, containers) = gen_containers();
-
- let mut app_data = gen_appdata(&containers);
-
- assert!(app_data.get_filter().1.is_none());
-
- let pre_len = app_data.containers.items.len();
- app_data.filter_term_push('_');
- app_data.filter_term_push('2');
-
- assert_eq!(app_data.get_filter().1, Some(&"_2".to_string()));
-
- app_data.filter_containers();
- let post_len = app_data.containers.items.len();
- assert!(pre_len != post_len);
- assert_eq!(post_len, 1);
-
- // Can insert checks against the current filter term
- assert!(app_data.can_insert(&containers[1]));
- assert!(!app_data.can_insert(&containers[0]));
- assert!(!app_data.can_insert(&containers[2]));
- }
-
- #[test]
- /// Data is filtered correctly by image
- fn test_app_data_filter_by_image() {
- let (_, containers) = gen_containers();
-
- let mut app_data = gen_appdata(&containers);
-
- assert!(app_data.get_filter().1.is_none());
-
- let pre_len = app_data.containers.items.len();
- for c in ['i', 'm', 'a', 'g', 'e', '_', '2'] {
- app_data.filter_term_push(c);
- }
- // app_data.filter_term_push('2');
- app_data.filter_by_next();
-
- assert_eq!(
- app_data.get_filter(),
- (FilterBy::Image, Some(&"image_2".to_string()))
- );
-
- app_data.filter_containers();
- let post_len = app_data.containers.items.len();
- assert!(pre_len != post_len);
- assert_eq!(post_len, 1);
-
- assert!(!app_data.can_insert(&containers[0]));
- assert!(app_data.can_insert(&containers[1]));
- assert!(!app_data.can_insert(&containers[2]));
- }
-
- #[test]
- /// Data is filtered correctly by status
- fn test_app_data_filter_by_status() {
- let (_, mut containers) = gen_containers();
- ContainerStatus::from("Exited".to_owned()).clone_into(&mut containers[0].status);
- let mut app_data = gen_appdata(&containers);
-
- assert!(app_data.get_filter().1.is_none());
-
- let pre_len = app_data.containers.items.len();
- app_data.filter_term_push('x');
-
- app_data.filter_by_next();
- app_data.filter_by_next();
-
- assert_eq!(
- app_data.get_filter(),
- (FilterBy::Status, Some(&"x".to_string()))
- );
-
- app_data.filter_containers();
- let post_len = app_data.containers.items.len();
- assert!(pre_len != post_len);
- assert_eq!(post_len, 1);
-
- assert!(app_data.can_insert(&containers[0]));
- assert!(!app_data.can_insert(&containers[1]));
- assert!(!app_data.can_insert(&containers[2]));
- }
-
- #[test]
- /// Data is filtered correctly by all
- fn test_app_data_filter_by_all() {
- let (_, mut containers) = gen_containers();
- ContainerStatus::from("Exited".to_owned()).clone_into(&mut containers[0].status);
- let mut app_data = gen_appdata(&containers);
-
- assert!(app_data.get_filter().1.is_none());
-
- let pre_len = app_data.containers.items.len();
- app_data.filter_term_push('x');
-
- app_data.filter_by_next();
- app_data.filter_by_next();
- app_data.filter_by_next();
-
- assert_eq!(
- app_data.get_filter(),
- (FilterBy::All, Some(&"x".to_string()))
- );
-
- app_data.filter_containers();
- let post_len = app_data.containers.items.len();
- assert!(pre_len != post_len);
- assert_eq!(post_len, 1);
-
- assert!(app_data.can_insert(&containers[0]));
- assert!(!app_data.can_insert(&containers[1]));
- assert!(!app_data.can_insert(&containers[2]));
- }
-
- #[test]
- /// Data is filtered correctly after various next() and previous() commands
- fn test_app_data_filter_prev() {
- let (_, mut containers) = gen_containers();
- ContainerStatus::from("Exited".to_owned()).clone_into(&mut containers[0].status);
- let mut app_data = gen_appdata(&containers);
-
- assert!(app_data.get_filter().1.is_none());
-
- let pre_len = app_data.containers.items.len();
- app_data.filter_term_push('x');
-
- app_data.filter_by_next();
- app_data.filter_by_next();
-
- assert_eq!(
- app_data.get_filter(),
- (FilterBy::Status, Some(&"x".to_string()))
- );
-
- app_data.filter_containers();
- let post_len = app_data.containers.items.len();
- assert!(pre_len != post_len);
- assert_eq!(post_len, 1);
-
- assert!(app_data.can_insert(&containers[0]));
- assert!(!app_data.can_insert(&containers[1]));
- assert!(!app_data.can_insert(&containers[2]));
-
- app_data.filter_by_prev();
- assert_eq!(
- app_data.get_filter(),
- (FilterBy::Image, Some(&"x".to_string()))
- );
-
- app_data.filter_containers();
- let post_len = app_data.containers.items.len();
- assert!(pre_len != post_len);
- assert_eq!(post_len, 0);
-
- assert!(!app_data.can_insert(&containers[0]));
- assert!(!app_data.can_insert(&containers[1]));
- assert!(!app_data.can_insert(&containers[2]));
- }
-
- // **** //
- // Logs //
- // **** //
-
- #[test]
- /// log title string generated correctly
- fn test_app_data_get_log_title() {
- let (ids, containers) = gen_containers();
-
- let mut app_data = gen_appdata(&containers);
-
- // No container selected select
- let result = app_data.get_log_title();
- assert_eq!(result, "");
-
- // No logs
- app_data.containers.start();
- let result = app_data.get_log_title();
- assert_eq!(result, " - container_1 - image_1");
-
- // On last line of logs
- let logs = (1..=3).map(|i| format!("{i} {i}")).collect::>();
- app_data.update_log_by_id(logs, &ids[0]);
- let result = app_data.get_log_title();
- assert_eq!(result, " 3/3 - container_1 - image_1");
-
- // Change log state to no longer be at the end
- app_data.log_scroll(&ScrollDirection::Up);
- let result = app_data.get_log_title();
- assert_eq!(result, " 2/3 - container_1 - image_1");
- }
-
- #[test]
- /// log title string generated correctly after container change
- fn test_app_data_get_log_title_after_container_change() {
- let (ids, containers) = gen_containers();
- let mut app_data = gen_appdata(&containers);
-
- // No container selected select
- let result = app_data.get_log_title();
- assert_eq!(result, "");
-
- app_data.containers_start();
-
- let result = app_data.get_log_title();
- assert_eq!(result, " - container_1 - image_1");
-
- // change container
- app_data.containers_scroll(&ScrollDirection::Down);
- let result = app_data.get_log_title();
- assert_eq!(result, " - container_2 - image_2");
-
- // On last line of logs
- let logs = (1..=3).map(|i| format!("{i} {i}")).collect::>();
- app_data.update_log_by_id(logs, &ids[1]);
- let result = app_data.get_log_title();
- assert_eq!(result, " 3/3 - container_2 - image_2");
-
- // Change log state to no longer be at the end
- app_data.log_scroll(&ScrollDirection::Up);
- let result = app_data.get_log_title();
- assert_eq!(result, " 2/3 - container_2 - image_2");
- }
-
- #[test]
- /// update logs by id works
- fn test_app_data_update_log_by_id() {
- let (ids, containers) = gen_containers();
- let mut app_data = gen_appdata(&containers);
-
- // No container selected select
- let result = app_data.get_log_title();
- assert_eq!(result, "");
-
- app_data.containers_start();
- let logs = (1..=3).map(|i| format!("{i} {i}")).collect::>();
-
- app_data.update_log_by_id(logs, &ids[0]);
-
- let result = app_data.get_log_state();
- assert!(result.is_some());
- assert_eq!(result.as_ref().unwrap().selected(), Some(2));
- assert_eq!(result.unwrap().offset(), 0);
-
- let result = app_data.get_logs(
- Size {
- width: 20,
- height: 4,
- },
- 1,
- );
- assert_eq!(result.len(), 3);
-
- let result = app_data.get_log_title();
- assert_eq!(result, " 3/3 - container_1 - image_1");
- }
-
- #[test]
- /// logs state reset to start
- fn test_app_data_logs_start() {
- let (ids, containers) = gen_containers();
- let mut app_data = gen_appdata(&containers);
- let logs = (1..=3).map(|i| format!("{i} {i}")).collect::>();
- app_data.containers_start();
- app_data.update_log_by_id(logs, &ids[0]);
-
- app_data.log_start();
-
- let result = app_data.get_log_state();
- assert!(result.is_some());
- assert_eq!(result.as_ref().unwrap().selected(), Some(0));
- assert_eq!(result.unwrap().offset(), 0);
-
- let result = app_data.get_log_title();
- assert_eq!(result, " 1/3 - container_1 - image_1");
- }
-
- #[test]
- /// logs state end goes to the end of the logs list
- fn test_app_data_logs_end() {
- let (ids, containers) = gen_containers();
- let mut app_data = gen_appdata(&containers);
- let logs = (1..=3).map(|i| format!("{i} {i}")).collect::>();
- app_data.containers_start();
- app_data.update_log_by_id(logs, &ids[0]);
-
- app_data.log_start();
-
- let result = app_data.get_log_state();
- assert!(result.is_some());
- assert_eq!(result.as_ref().unwrap().selected(), Some(0));
- assert_eq!(result.unwrap().offset(), 0);
-
- let result = app_data.get_log_title();
- assert_eq!(result, " 1/3 - container_1 - image_1");
-
- app_data.log_end();
- let result = app_data.get_log_state();
- assert!(result.is_some());
- assert_eq!(result.as_ref().unwrap().selected(), Some(2));
- assert_eq!(result.unwrap().offset(), 0);
-
- let result = app_data.get_log_title();
- assert_eq!(result, " 3/3 - container_1 - image_1");
- }
-
- #[test]
- /// logs state next works
- /// At end has no effect
- fn test_app_data_logs_next() {
- let (ids, containers) = gen_containers();
- let mut app_data = gen_appdata(&containers);
- let logs = (1..=3).map(|i| format!("{i} {i}")).collect::>();
- app_data.containers_start();
- app_data.update_log_by_id(logs, &ids[0]);
-
- app_data.log_start();
-
- let result = app_data.get_log_state();
- assert!(result.is_some());
- assert_eq!(result.as_ref().unwrap().selected(), Some(0));
- assert_eq!(result.unwrap().offset(), 0);
-
- let result = app_data.get_log_title();
- assert_eq!(result, " 1/3 - container_1 - image_1");
-
- app_data.log_scroll(&ScrollDirection::Down);
- let result = app_data.get_log_state();
- assert!(result.is_some());
- assert_eq!(result.as_ref().unwrap().selected(), Some(1));
- assert_eq!(result.unwrap().offset(), 0);
-
- let result = app_data.get_log_title();
- assert_eq!(result, " 2/3 - container_1 - image_1");
-
- app_data.log_scroll(&ScrollDirection::Down);
- let result = app_data.get_log_state();
- assert!(result.is_some());
- assert_eq!(result.as_ref().unwrap().selected(), Some(2));
- assert_eq!(result.unwrap().offset(), 0);
-
- let result = app_data.get_log_title();
- assert_eq!(result, " 3/3 - container_1 - image_1");
- app_data.log_scroll(&ScrollDirection::Down);
-
- let result = app_data.get_log_state();
- assert!(result.is_some());
- assert_eq!(result.as_ref().unwrap().selected(), Some(2));
- assert_eq!(result.unwrap().offset(), 0);
-
- let result = app_data.get_log_title();
- assert_eq!(result, " 3/3 - container_1 - image_1");
- }
-
- #[test]
- /// logs state previous works
- /// previous at start has no effect
- fn test_app_data_logs_previous() {
- let (ids, containers) = gen_containers();
- let mut app_data = gen_appdata(&containers);
- let logs = (1..=3).map(|i| format!("{i} {i}")).collect::>();
- app_data.containers_start();
- app_data.update_log_by_id(logs, &ids[0]);
-
- app_data.log_end();
-
- let result = app_data.get_log_state();
- assert!(result.is_some());
- assert_eq!(result.as_ref().unwrap().selected(), Some(2));
- assert_eq!(result.unwrap().offset(), 0);
-
- let result = app_data.get_log_title();
- assert_eq!(result, " 3/3 - container_1 - image_1");
-
- app_data.log_scroll(&ScrollDirection::Up);
-
- let result = app_data.get_log_state();
- assert!(result.is_some());
- assert_eq!(result.as_ref().unwrap().selected(), Some(1));
- assert_eq!(result.unwrap().offset(), 0);
- let result = app_data.get_log_title();
- assert_eq!(result, " 2/3 - container_1 - image_1");
-
- app_data.log_scroll(&ScrollDirection::Up);
- let result = app_data.get_log_state();
- assert!(result.is_some());
- assert_eq!(result.as_ref().unwrap().selected(), Some(0));
- assert_eq!(result.unwrap().offset(), 0);
- let result = app_data.get_log_title();
- assert_eq!(result, " 1/3 - container_1 - image_1");
-
- app_data.log_scroll(&ScrollDirection::Up);
- let result = app_data.get_log_state();
- assert!(result.is_some());
- assert_eq!(result.as_ref().unwrap().selected(), Some(0));
- assert_eq!(result.unwrap().offset(), 0);
- let result = app_data.get_log_title();
- assert_eq!(result, " 1/3 - container_1 - image_1");
- }
-
- // ********** //
- // Chart data //
- // ********** //
-
- #[test]
- /// Chart data returned correctly
- fn test_app_data_get_chart_data() {
- let (_ids, containers) = gen_containers();
- let mut app_data = gen_appdata(&containers);
-
- let result = app_data.get_chart_data();
- assert!(result.is_none());
-
- app_data.containers_start();
-
- let mut rx = NetworkBandwidth::new();
- rx.push(200);
- rx.push(100);
- rx.push(200);
-
- let mut tx = NetworkBandwidth::new();
- tx.push(300);
- tx.push(600);
- tx.push(900);
-
- if let Some(item) = app_data.get_container_by_id(&ContainerId::from("1")) {
- item.cpu_stats = VecDeque::from([CpuStats::new(1.2), CpuStats::new(1.2)]);
- item.mem_stats = VecDeque::from([ByteStats::new(1), ByteStats::new(2)]);
- item.rx = rx;
- item.tx = tx;
- }
-
- let result = app_data.get_chart_data();
- assert_eq!(
- result,
- Some(ChartsData {
- memory: ChartSeries {
- dataset: vec![(0.0, 1.0), (1.0, 2.0)],
- max: ByteStats::new(2),
- current: ByteStats::new(2)
- },
- cpu: ChartSeries {
- dataset: vec![(0.0, 1.2), (1.0, 1.2)],
- max: CpuStats::new(1.2),
- current: CpuStats::new(1.2)
- },
- rx: ChartSeries {
- dataset: vec![(0.0, 0.0), (1.0, 100.0)],
- max: BandwidthStat::new(100),
- current: BandwidthStat::new(100)
- },
- tx: ChartSeries {
- dataset: vec![(0.0, 300.0), (1.0, 300.0)],
- max: BandwidthStat::new(300),
- current: BandwidthStat::new(300)
- },
- state: State::Running(RunningState::Healthy)
- })
- );
- }
-
- // ************* //
- // Header Widths //
- // ************* //
-
- #[test]
- /// Header widths return correctly
- fn test_app_data_get_width() {
- let (_ids, containers) = gen_containers();
- let app_data = gen_appdata(&containers);
-
- let result = app_data.get_width();
- let expected = Columns {
- name: (Header::Name, 11),
- state: (Header::State, 9),
- status: (Header::Status, 9),
- cpu: (Header::Cpu, 6),
- mem: (Header::Memory, 7, 7),
- id: (Header::Id, 8),
- image: (Header::Image, 7),
- net_rx: (Header::Rx, 7),
- net_tx: (Header::Tx, 7),
- };
- assert_eq!(result, expected);
- }
-
- #[test]
- /// Header widths return correctly when some containers hidden
- fn test_app_data_get_width_filtered() {
- let (_ids, mut containers) = gen_containers();
- containers[0].name = ContainerName::from("some_longer_name_with_filter");
- let mut app_data = gen_appdata(&containers);
-
- let result = app_data.get_width();
- let expected = Columns {
- name: (Header::Name, 28),
- state: (Header::State, 9),
- status: (Header::Status, 9),
- cpu: (Header::Cpu, 6),
- mem: (Header::Memory, 7, 7),
- id: (Header::Id, 8),
- image: (Header::Image, 7),
- net_rx: (Header::Rx, 7),
- net_tx: (Header::Tx, 7),
- };
-
- assert_eq!(result, expected);
- app_data.filter_term_push('c');
- app_data.filter_containers();
- assert_eq!(result, expected);
- }
-
- // ***** //
- // Ports //
- // ***** //
-
- #[test]
- /// Returns selected containers ports ordered by private ip
- fn test_app_data_get_selected_ports() {
- let (_ids, containers) = gen_containers();
- let mut app_data = gen_appdata(&containers);
-
- app_data.containers.items[0].ports.push(ContainerPorts {
- ip: None,
- private: 10,
- public: Some(1),
- });
- app_data.containers.items[0].ports.push(ContainerPorts {
- ip: None,
- private: 11,
- public: Some(3),
- });
- app_data.containers.items[0].ports.push(ContainerPorts {
- ip: None,
- private: 4,
- public: Some(2),
- });
-
- // No containers selected
- let result = app_data.get_selected_ports();
- assert!(result.is_none());
-
- // Selected container & ports
- app_data.containers_start();
- let result = app_data.get_selected_ports();
-
- assert_eq!(
- result,
- Some((
- vec![
- ContainerPorts {
- ip: None,
- private: 4,
- public: Some(2)
- },
- ContainerPorts {
- ip: None,
- private: 10,
- public: Some(1)
- },
- ContainerPorts {
- ip: None,
- private: 11,
- public: Some(3)
- },
- ContainerPorts {
- ip: None,
- private: 8001,
- public: None
- }
- ],
- State::Running(RunningState::Healthy),
- ))
- );
-
- // Selected container & no ports
- app_data.containers_start();
- app_data.containers.items[0].ports = vec![];
- let result = app_data.get_selected_ports();
-
- assert_eq!(
- result,
- Some((vec![], State::Running(RunningState::Healthy)))
- );
- }
-
- // ************** //
- // Update mtehods //
- // ************** //
-
- #[test]
- /// Update stats functioning
- fn test_app_data_update_stats() {
- let (ids, containers) = gen_containers();
-
- let mut app_data = gen_appdata(&containers);
-
- let result = app_data.get_container_items();
- assert_eq!(result[0], containers[0]);
-
- app_data.update_stats_by_id(&ids[0], Some(10.0), Some(10), 10, 10, 10);
-
- let result = app_data.get_container_items();
- assert_ne!(result[0], containers[0]);
- assert_eq!(result[0].cpu_stats, VecDeque::from([CpuStats::new(10.0)]));
- assert_eq!(result[0].mem_stats, VecDeque::from([ByteStats::new(10)]));
- assert_eq!(result[0].mem_limit, ByteStats::new(10));
-
- let mut rx = NetworkBandwidth::new();
- rx.push(10);
- let mut tx = NetworkBandwidth::new();
- tx.push(10);
- assert_eq!(result[0].rx, rx);
- // VecDeque::from([ByteStats::new(10)]));
- assert_eq!(result[0].tx, tx);
- // VecDeque::from([ByteStats::new(10)]));
- }
-
- #[test]
- /// Update stats functioning
- fn test_app_data_update_containers() {
- let (_ids, containers) = gen_containers();
- let mut app_data = gen_appdata(&containers);
- let result_pre = app_data.get_container_items().to_owned();
- let input = vec![
- gen_container_summary(1, "paused"),
- gen_container_summary(2, "dead"),
- ];
-
- app_data.update_containers(input);
- let result_post = app_data.get_container_items().to_owned();
- assert_ne!(result_pre, result_post);
- assert_eq!(result_post[0].state, State::Paused);
- assert_eq!(result_post[1].state, State::Dead);
- }
-
- #[test]
- /// Update logs don't work if container is_oxker: true
- fn test_app_data_update_log_by_id_is_oxker() {
- let (ids, mut containers) = gen_containers();
- containers[0].is_oxker = true;
- let mut app_data = gen_appdata(&containers);
- let logs = (1..=3).map(|i| format!("{i} {i}")).collect::>();
-
- app_data.update_log_by_id(logs, &ids[0]);
- app_data.log_start();
-
- let result = app_data.get_log_state();
- assert!(result.is_none());
- }
-
- // *************** //
- // Get logs method //
- // *************** //
-
- #[test]
- /// get_logs() returns vec of item, but the items are empty unless they are in the *visible" zone, based on height, index, and padding
- fn test_app_data_update_get_logs() {
- let (ids, containers) = gen_containers();
-
- let mut app_data = gen_appdata(&containers);
-
- app_data.containers_start();
- let logs = (0..=999).map(|i| format!("{i} {i}")).collect::>();
-
- app_data.update_log_by_id(logs, &ids[0]);
-
- let result = app_data.get_logs(
- Size {
- width: 20,
- height: 10,
- },
- 10,
- );
- for (index, item) in result.iter().enumerate() {
- if index < 979 {
- assert_eq!(item, &Text::from(""));
- } else {
- assert_eq!(item, &Text::from(format!("{index}")));
- }
- }
-
- let result = app_data.get_logs(
- Size {
- width: 20,
- height: 100,
- },
- 20,
- );
- for (index, item) in result.iter().enumerate() {
- if index < 879 {
- assert_eq!(item, &Text::from(""));
- } else {
- assert_eq!(item, &Text::from(format!("{index}")));
- }
- }
-
- app_data.log_start();
-
- let result = app_data.get_logs(
- Size {
- width: 20,
- height: 10,
- },
- 10,
- );
- for (index, item) in result.iter().enumerate() {
- if index > 20 {
- assert_eq!(item, &Text::from(""));
- } else {
- assert_eq!(item, &Text::from(format!("{index}")));
- }
- }
-
- for _ in 0..=500 {
- app_data.log_scroll(&ScrollDirection::Down);
- }
- let result = app_data.get_logs(
- Size {
- width: 20,
- height: 10,
- },
- 10,
- );
- for (index, item) in result.iter().enumerate() {
- if (481..=521).contains(&index) {
- assert_eq!(item, &Text::from(format!("{index}")));
- } else {
- assert_eq!(item, &Text::from(""));
- }
- }
- }
-}
diff --git a/src/app_error.rs b/src/app_error.rs
deleted file mode 100644
index ce4b5f6..0000000
--- a/src/app_error.rs
+++ /dev/null
@@ -1,34 +0,0 @@
-use crate::app_data::DockerCommand;
-use std::fmt;
-
-/// app errors to set in global state
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
-pub enum AppError {
- DockerCommand(DockerCommand),
- DockerExec,
- DockerLogs,
- DockerConnect,
- IO(String),
- MouseCapture(bool),
- Parse(String),
- Terminal,
-}
-
-/// Convert errors into strings to display
-impl fmt::Display for AppError {
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- match self {
- Self::DockerCommand(s) => write!(f, "Unable to {s} container"),
- Self::DockerExec => write!(f, "Unable to exec into container"),
- Self::DockerLogs => write!(f, "Unable to save logs"),
- Self::DockerConnect => write!(f, "Unable to access docker daemon"),
- Self::IO(msg) => write!(f, "IO error with: {msg}"),
- Self::MouseCapture(x) => {
- let reason = if *x { "en" } else { "dis" };
- write!(f, "Unable to {reason}able mouse capture")
- }
- Self::Parse(msg) => write!(f, "Parsing error: {msg}"),
- Self::Terminal => write!(f, "Unable to fully render to terminal"),
- }
- }
-}
diff --git a/src/config/color_parser.rs b/src/config/color_parser.rs
deleted file mode 100644
index 8afded3..0000000
--- a/src/config/color_parser.rs
+++ /dev/null
@@ -1,551 +0,0 @@
-use ratatui::style::Color;
-
-static COLOR_RX: Color = Color::Rgb(255, 233, 193);
-static COLOR_TX: Color = Color::Rgb(205, 140, 140);
-
-/// The macro accepts a list of struct names with key names
-/// Returns a struct where every key name is an Option, with the correct derived attributes
-macro_rules! optional_config_struct {
- ($($struct_name:ident, $($key_name:ident),*);*) => {
- $(
- #[derive(Debug, serde::Deserialize, Clone, PartialEq, Eq)]
- struct $struct_name {
- $(
- $key_name: Option,
- )*
- }
- )*
- };
-}
-
-/// The macro accepts a list of struct names with key names
-macro_rules! config_struct {
- ($($struct_name:ident, $($key_name:ident),*);*) => {
- $(
- #[derive(Debug, Clone, PartialEq, Eq, Copy)]
- pub struct $struct_name {
- $(
- pub $key_name: Color,
- )*
- }
- )*
- };
-}
-
-impl AppColors {
- fn map_color(color_str: Option<&str>, setter: &mut Color) {
- color_str.map(|i| i.parse::().map(|i| *setter = i));
- }
-}
-
-impl From> for AppColors {
- #[allow(clippy::too_many_lines)]
- fn from(value: Option) -> Self {
- let mut app_colors = Self::new();
-
- if let Some(config_colors) = value {
- // Heading bar
- if let Some(hb) = config_colors.headers_bar {
- Self::map_color(
- hb.background.as_deref(),
- &mut app_colors.headers_bar.background,
- );
- Self::map_color(
- hb.loading_spinner.as_deref(),
- &mut app_colors.headers_bar.loading_spinner,
- );
- Self::map_color(hb.text.as_deref(), &mut app_colors.headers_bar.text);
- Self::map_color(
- hb.text_selected.as_deref(),
- &mut app_colors.headers_bar.text_selected,
- );
- }
-
- // Selectable panel borders
- if let Some(b) = config_colors.borders {
- Self::map_color(b.selected.as_deref(), &mut app_colors.borders.selected);
- Self::map_color(b.unselected.as_deref(), &mut app_colors.borders.unselected);
- }
-
- // Error Popup
- if let Some(ep) = config_colors.popup_error {
- Self::map_color(
- ep.background.as_deref(),
- &mut app_colors.popup_error.background,
- );
- Self::map_color(ep.text.as_deref(), &mut app_colors.popup_error.text);
- }
-
- // Filter panel
- if let Some(fc) = config_colors.filter {
- Self::map_color(fc.background.as_deref(), &mut app_colors.filter.background);
- Self::map_color(fc.highlight.as_deref(), &mut app_colors.filter.highlight);
-
- Self::map_color(
- fc.selected_filter_background.as_deref(),
- &mut app_colors.filter.selected_filter_background,
- );
- Self::map_color(
- fc.selected_filter_text.as_deref(),
- &mut app_colors.filter.selected_filter_text,
- );
- Self::map_color(fc.text.as_deref(), &mut app_colors.filter.text);
- }
-
- // Log search
- if let Some(ls) = config_colors.log_search {
- Self::map_color(
- ls.background.as_deref(),
- &mut app_colors.log_search.background,
- );
- Self::map_color(
- ls.highlight.as_deref(),
- &mut app_colors.log_search.highlight,
- );
-
- Self::map_color(
- ls.button_text.as_deref(),
- &mut app_colors.log_search.button_text,
- );
- Self::map_color(ls.text.as_deref(), &mut app_colors.log_search.text);
- }
-
- // Help Popup
- if let Some(hp) = config_colors.popup_help {
- Self::map_color(
- hp.background.as_deref(),
- &mut app_colors.popup_help.background,
- );
- Self::map_color(hp.text.as_deref(), &mut app_colors.popup_help.text);
- Self::map_color(
- hp.text_highlight.as_deref(),
- &mut app_colors.popup_help.text_highlight,
- );
- }
-
- // Info Popup
- if let Some(ip) = config_colors.popup_info {
- Self::map_color(
- ip.background.as_deref(),
- &mut app_colors.popup_info.background,
- );
- Self::map_color(ip.text.as_deref(), &mut app_colors.popup_info.text);
- }
-
- // Delete Popup
- if let Some(dp) = config_colors.popup_delete {
- Self::map_color(
- dp.background.as_deref(),
- &mut app_colors.popup_delete.background,
- );
- Self::map_color(dp.text.as_deref(), &mut app_colors.popup_delete.text);
- Self::map_color(
- dp.text_highlight.as_deref(),
- &mut app_colors.popup_delete.text_highlight,
- );
- }
-
- // Chart Cpu
- if let Some(cc) = config_colors.chart_cpu {
- Self::map_color(
- cc.background.as_deref(),
- &mut app_colors.chart_cpu.background,
- );
- Self::map_color(cc.border.as_deref(), &mut app_colors.chart_cpu.border);
- Self::map_color(cc.max.as_deref(), &mut app_colors.chart_cpu.max);
- Self::map_color(cc.points.as_deref(), &mut app_colors.chart_cpu.points);
- Self::map_color(cc.title.as_deref(), &mut app_colors.chart_cpu.title);
- Self::map_color(cc.y_axis.as_deref(), &mut app_colors.chart_cpu.y_axis);
- }
-
- // Chart Memory
- if let Some(cm) = config_colors.chart_memory {
- Self::map_color(
- cm.background.as_deref(),
- &mut app_colors.chart_memory.background,
- );
- Self::map_color(cm.border.as_deref(), &mut app_colors.chart_memory.border);
- Self::map_color(cm.max.as_deref(), &mut app_colors.chart_memory.max);
- Self::map_color(cm.points.as_deref(), &mut app_colors.chart_memory.points);
- Self::map_color(cm.title.as_deref(), &mut app_colors.chart_memory.title);
- Self::map_color(cm.y_axis.as_deref(), &mut app_colors.chart_memory.y_axis);
- }
-
- // Chart ports
- if let Some(cp) = config_colors.chart_ports {
- Self::map_color(
- cp.background.as_deref(),
- &mut app_colors.chart_ports.background,
- );
- Self::map_color(cp.border.as_deref(), &mut app_colors.chart_ports.border);
- Self::map_color(cp.headings.as_deref(), &mut app_colors.chart_ports.headings);
- Self::map_color(cp.text.as_deref(), &mut app_colors.chart_ports.text);
- Self::map_color(cp.title.as_deref(), &mut app_colors.chart_ports.title);
- }
-
- // Containers
- if let Some(c) = config_colors.containers {
- Self::map_color(
- c.background.as_deref(),
- &mut app_colors.containers.background,
- );
- Self::map_color(c.icon.as_deref(), &mut app_colors.containers.icon);
- Self::map_color(c.text.as_deref(), &mut app_colors.containers.text);
- Self::map_color(c.text_rx.as_deref(), &mut app_colors.containers.text_rx);
- Self::map_color(c.text_tx.as_deref(), &mut app_colors.containers.text_tx);
- }
-
- // Commands
- if let Some(cc) = config_colors.commands {
- Self::map_color(
- cc.background.as_deref(),
- &mut app_colors.commands.background,
- );
- Self::map_color(cc.pause.as_deref(), &mut app_colors.commands.pause);
- Self::map_color(cc.restart.as_deref(), &mut app_colors.commands.restart);
- Self::map_color(cc.stop.as_deref(), &mut app_colors.commands.stop);
- Self::map_color(cc.delete.as_deref(), &mut app_colors.commands.start);
- Self::map_color(cc.resume.as_deref(), &mut app_colors.commands.resume);
- Self::map_color(cc.start.as_deref(), &mut app_colors.commands.start);
- }
-
- // Logs panel
- if let Some(cl) = config_colors.logs {
- Self::map_color(cl.background.as_deref(), &mut app_colors.logs.background);
- Self::map_color(cl.text.as_deref(), &mut app_colors.logs.text);
- }
-
- // Container State
- if let Some(cs) = config_colors.container_state {
- Self::map_color(cs.dead.as_deref(), &mut app_colors.container_state.dead);
- Self::map_color(cs.exited.as_deref(), &mut app_colors.container_state.exited);
- Self::map_color(cs.paused.as_deref(), &mut app_colors.container_state.paused);
- Self::map_color(
- cs.removing.as_deref(),
- &mut app_colors.container_state.removing,
- );
- Self::map_color(
- cs.restarting.as_deref(),
- &mut app_colors.container_state.restarting,
- );
- Self::map_color(
- cs.running_healthy.as_deref(),
- &mut app_colors.container_state.running_healthy,
- );
- Self::map_color(
- cs.running_unhealthy.as_deref(),
- &mut app_colors.container_state.running_unhealthy,
- );
- Self::map_color(
- cs.unknown.as_deref(),
- &mut app_colors.container_state.unknown,
- );
- }
- }
- app_colors
- }
-}
-
-const ORANGE: Color = Color::Rgb(255, 178, 36);
-
-optional_config_struct!(
- ConfigBackgroundText, background, text;
- ConfigBackgroundTextHighlight, background, text, text_highlight;
- ConfigBorders, selected, unselected;
- ConfigChartBandwidth, background, border, max_rx, max_tx, title_tx, title_rx, points_rx, points_tx, y_axis;
-
- ConfigChartCpu, background, border, order, title, max, points,y_axis;
- ConfigChartMemory, background, border, title, max, points, y_axis;
- ConfigChartPorts, background, border, title, headings, text;
- ConfigCommands, background, pause, restart, stop, delete, resume, start;
- ConfigContainers, background, icon, text, text_rx, text_tx;
- ConfigContainerState, background, dead, exited, paused, removing, restarting, running_healthy, running_unhealthy, unknown;
- ConfigFilter, background, text, selected_filter_background, selected_filter_text, highlight;
- ConfigLogSearch, background, text, button_text, highlight;
- ConfigHeadersBar, background, loading_spinner, text, text_selected;
- ConfigLogs, background, text
-);
-
-config_struct!(
- Borders, selected, unselected;
- ChartCpu, background, border, title, max, points, y_axis;
- ChartMemory, background, border, title, max, points, y_axis;
- ChartBandwidth, background, border, max_rx, max_tx, title_rx, title_tx, points_rx, points_tx, y_axis;
-
- ChartPorts, background, border, title, headings, text;
- Commands, background, pause, restart, stop, delete, resume, start;
- Containers, background, icon, text, text_rx, text_tx;
- ContainerState, dead, exited, paused, removing, restarting, running_healthy, running_unhealthy, unknown;
- Filter, background, text, selected_filter_background, selected_filter_text, highlight;
- LogSearch, background, text, button_text, highlight;
- HeadersBar, background, text_selected, loading_spinner, text;
- Logs, background, text;
- PopupDelete, background, text, text_highlight;
- PopupError, background, text;
- PopupHelp, background, text, text_highlight;
- PopupInfo, background, text
-);
-
-#[derive(Debug, serde::Deserialize, Clone, PartialEq, Eq)]
-pub struct ConfigColors {
- borders: Option,
- chart_cpu: Option,
- chart_memory: Option,
- chart_bandwidth: Option,
- chart_ports: Option,
- commands: Option,
- container_state: Option,
- containers: Option,
- filter: Option,
- log_search: Option,
- headers_bar: Option,
- logs: Option,
- popup_delete: Option,
- popup_error: Option,
- popup_help: Option,
- popup_info: Option,
-}
-
-/// Default colours for the header bar
-impl HeadersBar {
- const fn new() -> Self {
- Self {
- background: Color::Magenta,
- loading_spinner: Color::White,
- text: Color::Black,
- text_selected: Color::Gray,
- }
- }
-}
-
-/// Default colours for the borders
-impl Borders {
- const fn new() -> Self {
- Self {
- selected: Color::LightCyan,
- unselected: Color::Gray,
- }
- }
-}
-
-/// Default colours for the delete popup
-impl Commands {
- const fn new() -> Self {
- Self {
- background: Color::Reset,
- pause: Color::Yellow,
- restart: Color::Magenta,
- stop: Color::Red,
- delete: Color::Gray,
- resume: Color::Blue,
- start: Color::Green,
- }
- }
-}
-
-/// Default colours for the Bandwidth chart
-impl ChartBandwidth {
- const fn new() -> Self {
- Self {
- background: Color::Reset,
- border: Color::White,
- max_rx: COLOR_RX,
- title_rx: COLOR_RX,
- title_tx: COLOR_TX,
- max_tx: COLOR_TX,
- points_rx: COLOR_RX,
- points_tx: COLOR_TX,
- y_axis: Color::White,
- }
- }
-}
-
-/// Default colours for the CPU chart
-impl ChartCpu {
- const fn new() -> Self {
- Self {
- background: Color::Reset,
- border: Color::White,
- title: Color::Green,
- max: ORANGE,
- points: Color::Magenta,
- y_axis: Color::White,
- }
- }
-}
-
-/// Default colours for the help popup
-impl ChartMemory {
- const fn new() -> Self {
- Self {
- background: Color::Reset,
- border: Color::White,
- title: Color::Green,
- max: ORANGE,
- points: Color::Cyan,
- y_axis: Color::White,
- }
- }
-}
-
-/// Default colours for the help popup
-impl ChartPorts {
- const fn new() -> Self {
- Self {
- background: Color::Reset,
- border: Color::White,
- title: Color::Green,
- headings: Color::Yellow,
- text: Color::White,
- }
- }
-}
-
-/// Default colours for the help popup
-impl Containers {
- const fn new() -> Self {
- Self {
- background: Color::Reset,
- icon: Color::White,
- text: Color::Blue,
- text_rx: COLOR_RX,
- text_tx: COLOR_TX,
- }
- }
-}
-
-/// Default colours for the help popup
-impl ContainerState {
- const fn new() -> Self {
- Self {
- paused: Color::Yellow,
- removing: Color::LightRed,
- restarting: Color::LightGreen,
- running_healthy: Color::Green,
- running_unhealthy: ORANGE,
- dead: Color::Red,
- exited: Color::Red,
- unknown: Color::Red,
- }
- }
-}
-
-/// Default colours for the filter panel
-impl Filter {
- const fn new() -> Self {
- Self {
- background: Color::Reset,
- highlight: Color::Magenta,
- selected_filter_background: Color::Gray,
- selected_filter_text: Color::Black,
- text: Color::Gray,
- }
- }
-}
-
-/// Default colours for the log search
-impl LogSearch {
- const fn new() -> Self {
- Self {
- background: Color::Reset,
- highlight: Color::Magenta,
- button_text: Color::Black,
- text: Color::Gray,
- }
- }
-}
-
-/// Default colours for the logs panel, only applied if color_logs is false
-impl Logs {
- const fn new() -> Self {
- Self {
- background: Color::Reset,
- text: Color::Reset,
- }
- }
-}
-
-/// Default colours for the Error popup
-impl PopupError {
- const fn new() -> Self {
- Self {
- background: Color::Red,
- text: Color::White,
- }
- }
-}
-
-/// Default colours for the info popup
-impl PopupInfo {
- const fn new() -> Self {
- Self {
- background: Color::Blue,
- text: Color::White,
- }
- }
-}
-
-/// Default colours for the help popup
-impl PopupHelp {
- const fn new() -> Self {
- Self {
- background: Color::Magenta,
- text: Color::Black,
- text_highlight: Color::White,
- }
- }
-}
-
-/// Default colours for the delete popup
-impl PopupDelete {
- const fn new() -> Self {
- Self {
- background: Color::White,
- text: Color::Black,
- text_highlight: Color::Red,
- }
- }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Copy)]
-pub struct AppColors {
- pub borders: Borders,
- pub chart_cpu: ChartCpu,
- pub chart_memory: ChartMemory,
- pub chart_bandwidth: ChartBandwidth,
- pub chart_ports: ChartPorts,
- pub commands: Commands,
- pub container_state: ContainerState,
- pub containers: Containers,
- pub log_search: LogSearch,
- pub filter: Filter,
- pub headers_bar: HeadersBar,
- pub logs: Logs,
- pub popup_delete: PopupDelete,
- pub popup_error: PopupError,
- pub popup_help: PopupHelp,
- pub popup_info: PopupInfo,
-}
-
-impl AppColors {
- pub const fn new() -> Self {
- Self {
- borders: Borders::new(),
- chart_cpu: ChartCpu::new(),
- chart_memory: ChartMemory::new(),
- chart_bandwidth: ChartBandwidth::new(),
- chart_ports: ChartPorts::new(),
- commands: Commands::new(),
- container_state: ContainerState::new(),
- containers: Containers::new(),
- log_search: LogSearch::new(),
- filter: Filter::new(),
- headers_bar: HeadersBar::new(),
- logs: Logs::new(),
- popup_delete: PopupDelete::new(),
- popup_error: PopupError::new(),
- popup_help: PopupHelp::new(),
- popup_info: PopupInfo::new(),
- }
- }
-}
diff --git a/src/config/config.toml b/src/config/config.toml
deleted file mode 100644
index f70c116..0000000
--- a/src/config/config.toml
+++ /dev/null
@@ -1,321 +0,0 @@
-# oxker config file
-# oxker will also read .jsonc and .json files which use the same key/value structure & format as this file
-# Every key is optional, with defaults that oxker will choose if missing or invalid
-# The `--config-file` cli argument can be used to load configuration files from any readable location
-
-# Docker update interval in ms, minimum effectively 1000
-docker_interval = 1000
-
-# Attempt to colorize the logs, conflicts with "raw"
-color_logs = false
-
-# Show raw logs, default is to remove ansi formatting, conflicts with "color"
-raw_logs = false
-
-# Show self (the oxker container) when running as a docker container
-show_self = false
-
-# Show std_err in logs
-show_std_err = true
-
-# Show a timestamp for every log entry
-show_timestamp = true
-
-# Don't draw gui - for debugging - mostly pointless
-gui = true
-
-# Docker host location. Will take priority over a DOCKER_HOST env.
-# host = "/var/run/docker.sock"
-
-# Display the container logs timestamp with a given timezone, if timezone is unknown, defaults to UTC
-timezone = "Etc/UTC"
-
-# Display the timestamp in a custom format, if given option is invalid, it will default to %Y-%m-%dT%H:%M:%S.%8f -> 2025-02-18T12:34:56.012345678Z
-# *Should* accept any valid strftime string up to 32 chars, see https://strftime.org/
-timestamp_format = "%Y-%m-%dT%H:%M:%S.%8f"
-
-# Directory for saving exported logs, defaults to `$HOME`, this is automatically *correctly* calculated for Linux, Mac, and Windows
-# save_dir = "$HOME"
-
-# Force use of docker cli when execing into containers, honestly mostly pointless
-use_cli = false
-
-# Show the logs section - this can be changed during operation with the log_section_toggle key
-show_logs = true
-
-# Use case-sensitive matching for logs
-log_search_case_sensitive = true
-
-#################
-# Custom Keymap #
-#################
-
-# Available keys are;
-# 1) a-z and A-Z
-# 2) 0-9
-# WARNING if using the \ key, it needs to be escaped, e.g. log_section_toggle = ["\\"]
-# 3) / \ , . # ' [ ] ; = -
-# 3) F1-F12
-# 4) backspace, tab, backtab, delete, end, esc, home, insert, pagedown, pageup, left, right, up, down
-
-# Each definition can have two keys associated with it
-
-# WARNING "scroll_many" only accepts control, alt, shift, with no secondary option
-
-# If any key clashes are found, oxker will revert to it's default keymap
-
-[keymap]
-# Clear any popup boxes, filter panel, or help panel
-clear = ["c", "esc"]
-# Cancel delete - clear also works here
-delete_deny = ["n"]
-# Confirm Delete
-delete_confirm = ["y"]
-# Exec into the selected container
-exec = ["e"]
-# Enter filter mode
-filter_mode = ["/", "F1"]
-
-# Enter log search mode
-log_search_mode = ["#"]
-
-# Quit at anytime
-quit = ["q"]
-# Save logs of selected container to file on disk
-save_logs = ["s"]
-# scroll down a list by one item
-scroll_down = ["down", "j"]
-
-# scroll down to the end of a list
-scroll_end = ["end"]
-# Modifier to scroll by 10 lines instead of one, used in conjunction with scroll_up/scroll_down
-scroll_many = ["control"]
-# scroll up to the start of a list
-scroll_start = ["home"]
-# scroll up a list by one item
-scroll_up = ["up", "k"]
-# Horizontal scroll of the logs
-scroll_forward = ["right"]
-scroll_back = ["left"]
-# Select next panel
-select_next_panel = ["tab"]
-# Select previous panel
-select_previous_panel = ["backtab"]
-# Sort the containers based on specific column
-sort_by_name = ["1"]
-sort_by_state = ["2"]
-sort_by_status = ["3"]
-sort_by_cpu = ["4"]
-sort_by_memory = ["5"]
-sort_by_id = ["6"]
-sort_by_image = ["7"]
-sort_by_rx = ["8"]
-sort_by_tx = ["9"]
-# Reset the sorted containers
-sort_reset = ["0"]
-# Toggle the help panel
-toggle_help = ["h"]
-# Toggle mouse capture
-toggle_mouse_capture = ["m"]
-# Reduce the height of the logs list section
-log_section_height_decrease = ["-"]
-log_section_height_increase = ["+"]
-# Toggle visibility of the log section
-log_section_toggle = ["\\"]
-# Toggle to inspect container screen
-inspect = ["i"]
-
-# Force a complete clear & redraw of the screen
-force_redraw = ["f"]
-
-#################
-# Custom Colors #
-#################
-
-# Colors be listed as either;
-# 1) named ANSI: 'red', case insensitive, see https://en.wikipedia.org/wiki/ANSI_escape_code#Colors
-# 2) Hex values: '#FF0000', case insensitive
-# 3) 'reset' for transparency
-
-# Some background/foreground combinations don't work, I *think* this is an issue/feature of ratatui - but I may have just made a mistake somewhere
-
-# The single line bar at the uppermost of the display. Contains name/state/status headings etc
-[colors.headers_bar]
-# Background color of the entire line
-background = "magenta"
-# Animated loading icon at the start of the bar
-loading_spinner = "white"
-# Text color
-text = "black"
-# Text color of a selected header
-text_selected = "gray"
-
-# The borders around the selectable panels - Containers, Commands, Logs
-[colors.borders]
-# Border when selected
-selected = "lightcyan"
-# Border when not selected
-unselected = "grey"
-
-# The containers sections, in the future more color customization options should be made available in this section
-[colors.containers]
-# The icon use to illustrate which container is currently selected - at the moment the TUI library, ratatui, doesn't seem allow changing the color of the highlight symbol
-icon = "white"
-# Background color of panel
-background = "reset"
-# At the moment, this will only change the color of the name, id, and image columns
-text = "blue"
-# Text color of the RX column
-text_rx = "#FFE9C1"
-# Text color of the TX column
-text_tx = "#CD8C8C"
-
-# The logs panel, will only be applied if color_logs is false
-[colors.logs]
-# Background color of panel
-background = "reset"
-# text color
-text = "reset"
-
-# Each state of a container has a color, which is used in multiple places, i.e. chart titles, state/status/cpu/memory columns in the container section
-[colors.container_state]
-dead = "red"
-exited = "red"
-paused = "yellow"
-removing = "lightred"
-restarting = "lightgreen"
-running_healthy = "green"
-running_unhealthy = "#FFB224"
-unknown = "red"
-
-# The filter panel
-[colors.filter]
-# Background color of panel
-background = "reset"
-# color of text
-text = "gray"
-# background color of the selected filter by item (Name/Image/Status/All)
-selected_filter_background = "gray"
-# text color of the selected filter by item (Name/Image/Status/All)
-selected_filter_text = "black"
-# Highlighted text color
-highlight = "magenta"
-
-
-# The log search panel
-[colors.log_search]
-# Background color of panel
-background = "reset"
-# color of text
-text = "gray"
-# text color of the buttons text
-button_text = "black"
-# Highlighted text color
-highlight = "magenta"
-
-# The color the of Docker commands available for each container
-[colors.commands]
-# Background color of panel
-background = "reset"
-pause = "yellow"
-restart = "magenta"
-stop = "red"
-delete = "gray"
-resume = "blue"
-start = "green"
-
-# The cpu chart
-[colors.chart_cpu]
-# Background color of panel
-background = "reset"
-# Border color
-border = "white"
-# Chart title - only whilst container is running, paused & stopped colors not yet customizable - or could just use state color?
-title = "green"
-# Maximum CPU percentage - again paused & stopped colors not yet customizable
-max = "#FFB224"
-# Points on the chart - again paused & stopped colors not yet customizable
-points = "magenta"
-# The charts y-axis
-y_axis = "white"
-
-# The memory chart
-[colors.chart_memory]
-# Background color of panel
-background = "reset"
-# Border color
-border = "white"
-# Chart title - only whilst container is running, paused & stopped will use colors.container_state
-title = "green"
-# Maximum memory use - again paused & stopped will use colors.container_state
-max = "#FFB224"
-# Points on the chart - again paused & stopped will use colors.container_state
-points = "cyan"
-# The charts y-axis
-y_axis = "white"
-
-# The bandwidth chart
-[colors.chart_bandwidth]
-# Background color of panel
-background = "reset"
-# Border color
-border = "white"
-# Maximum RX value - again paused & stopped colors not yet customizable
-max_rx = "#FFE9C1"
-# Maximum TX value - again paused & stopped colors not yet customizable
-max_tx = "#CD8C8C"
-# RX points on the chart - again paused & stopped colors not yet customizable
-points_rx = "#FFE9C1"
-# TX points on the chart - again paused & stopped colors not yet customizable
-points_tx = "#CD8C8C"
-# TX title color
-title_rx = "#FFE9C1"
-# RX title color
-title_tx = "#CD8C8C"
-# The charts y-axis
-y_axis = "white"
-
-# The ports chart
-[colors.chart_ports]
-# Background color of panel
-background = "reset"
-# Border color
-border = "white"
-# Chart title - only whilst container is running, paused & stopped will use colors.container_state
-title = "green"
-# Private/Public/IP headings
-headings = "yellow"
-# Ports & IP listing text
-text = "white"
-
-# The help popup
-[colors.popup_help]
-# Background color
-background = "magenta"
-# Text color
-text = "black"
-# Highlighted text color
-text_highlight = "white"
-
-# The info popup - used to display small messages - such as saving logs to disk, or change of mouse capture settings
-[colors.popup_info]
-# Background color
-background = "blue"
-# Text color
-text = "white"
-
-# The delete popup - used to display a confirmation warning when about to delete a container
-[colors.popup_delete]
-# Background color
-background = "white"
-# Text color
-text = "black"
-# Highlighted text color
-text_highlight = "red"
-
-# The error popup - hopefully you'll never have to see this
-[colors.popup_error]
-# Background color
-background = "red"
-# Text color
-text = "white"
diff --git a/src/config/keymap_parser.rs b/src/config/keymap_parser.rs
deleted file mode 100644
index 34fde03..0000000
--- a/src/config/keymap_parser.rs
+++ /dev/null
@@ -1,514 +0,0 @@
-use std::collections::HashSet;
-
-use crossterm::event::{KeyCode, KeyModifiers};
-
-/// The macro accepts a list of struct names with key names
-/// Returns a struct where every key name is an Option, with the correct derived attributes
-macro_rules! optional_config_struct {
- ($($struct_name:ident, $($key_name:ident),*);*) => {
- $(
- #[derive(Debug, serde::Deserialize, Clone, PartialEq, Eq)]
- pub struct $struct_name {
- $(
- $key_name: Option>,
- )*
- pub scroll_many: Option>,
- }
- )*
- };
-}
-
-/// The macro accepts a list of struct names with key names
-/// Similar to the optional_config_struct macro as above, but returns struct where every key name is Color
-macro_rules! config_struct {
- ($($struct_name:ident, $($key_name:ident),*);*) => {
- $(
- #[derive(Debug, Clone, PartialEq, Eq)]
- pub struct $struct_name {
- $(
- pub $key_name: (KeyCode, Option),
- )*
- pub scroll_many: KeyModifiers,
- }
- )*
- };
-}
-
-optional_config_struct!(
- ConfigKeymap,
- clear,
- delete_confirm,
- delete_deny,
- exec,
- filter_mode,
- force_redraw,
- inspect,
- scroll_back,
- scroll_forward,
- log_search_mode,
- log_section_height_decrease,
- log_section_height_increase,
- log_section_toggle,
- quit,
- save_logs,
- scroll_down,
- scroll_end,
- scroll_start,
- scroll_up,
- select_next_panel,
- select_previous_panel,
- sort_by_cpu,
- sort_by_id,
- sort_by_image,
- sort_by_memory,
- sort_by_name,
- sort_by_rx,
- sort_by_state,
- sort_by_status,
- sort_by_tx,
- sort_reset,
- toggle_help,
- toggle_mouse_capture
-);
-
-config_struct!(
- Keymap,
- clear,
- delete_confirm,
- delete_deny,
- exec,
- filter_mode,
- inspect,
- force_redraw,
- scroll_back,
- scroll_forward,
- log_search_mode,
- log_section_height_decrease,
- log_section_height_increase,
- log_section_toggle,
- quit,
- save_logs,
- scroll_down,
- scroll_end,
- scroll_start,
- scroll_up,
- select_next_panel,
- select_previous_panel,
- sort_by_cpu,
- sort_by_id,
- sort_by_image,
- sort_by_memory,
- sort_by_name,
- sort_by_rx,
- sort_by_state,
- sort_by_status,
- sort_by_tx,
- sort_reset,
- toggle_help,
- toggle_mouse_capture
-);
-
-impl Keymap {
- pub const fn new() -> Self {
- Self {
- clear: (KeyCode::Char('c'), Some(KeyCode::Esc)),
- delete_confirm: (KeyCode::Char('y'), None),
- delete_deny: (KeyCode::Char('n'), None),
- exec: (KeyCode::Char('e'), None),
- inspect: (KeyCode::Char('i'), None),
- filter_mode: (KeyCode::Char('/'), Some(KeyCode::F(1))),
- force_redraw: (KeyCode::Char('f'), None),
- scroll_back: (KeyCode::Left, None),
- scroll_forward: (KeyCode::Right, None),
- log_search_mode: (KeyCode::Char('#'), None),
- log_section_height_decrease: (KeyCode::Char('-'), None),
- log_section_height_increase: (KeyCode::Char('='), None),
- log_section_toggle: (KeyCode::Char('\\'), None),
- quit: (KeyCode::Char('q'), None),
- save_logs: (KeyCode::Char('s'), None),
- scroll_down: (KeyCode::Down, Some(KeyCode::Char('j'))),
- scroll_end: (KeyCode::End, None),
- scroll_many: KeyModifiers::CONTROL,
- scroll_start: (KeyCode::Home, None),
- scroll_up: (KeyCode::Up, Some(KeyCode::Char('k'))),
- select_next_panel: (KeyCode::Tab, None),
- select_previous_panel: (KeyCode::BackTab, None),
- sort_by_cpu: (KeyCode::Char('4'), None),
- sort_by_id: (KeyCode::Char('6'), None),
- sort_by_image: (KeyCode::Char('7'), None),
- sort_by_memory: (KeyCode::Char('5'), None),
- sort_by_name: (KeyCode::Char('1'), None),
- sort_by_rx: (KeyCode::Char('8'), None),
- sort_by_state: (KeyCode::Char('2'), None),
- sort_by_status: (KeyCode::Char('3'), None),
- sort_by_tx: (KeyCode::Char('9'), None),
- sort_reset: (KeyCode::Char('0'), None),
- toggle_help: (KeyCode::Char('h'), None),
- toggle_mouse_capture: (KeyCode::Char('m'), None),
- }
- }
-}
-
-impl From> for Keymap {
- /// Probably a better way to do this, but for now it works
- fn from(value: Option) -> Self {
- let mut keymap = Self::new();
-
- let mut clash = HashSet::new();
- let mut counter = 0;
-
- let mut update_keymap =
- |vec_str: Option>,
- keymap_field: &mut (KeyCode, Option),
- keymap_clash: &mut HashSet| {
- if let Some(vec_str) = vec_str
- && let Some(vec_keycode) = Self::try_parse_keycode(&vec_str)
- {
- if let Some(first) = vec_keycode.first() {
- keymap_clash.insert(*first);
- counter += 1;
- keymap_field.0 = *first;
- }
- if let Some(second) = vec_keycode.get(1) {
- keymap_clash.insert(*second);
- counter += 1;
- keymap_field.1 = Some(*second);
- } else {
- keymap_field.1 = None;
- }
- }
- };
-
- if let Some(ck) = value {
- update_keymap(ck.clear, &mut keymap.clear, &mut clash);
- update_keymap(ck.delete_deny, &mut keymap.delete_deny, &mut clash);
- update_keymap(ck.delete_confirm, &mut keymap.delete_confirm, &mut clash);
- update_keymap(
- ck.log_section_height_decrease,
- &mut keymap.log_section_height_decrease,
- &mut clash,
- );
- update_keymap(
- ck.log_section_height_increase,
- &mut keymap.log_section_height_increase,
- &mut clash,
- );
- update_keymap(
- ck.log_section_toggle,
- &mut keymap.log_section_toggle,
- &mut clash,
- );
-
- update_keymap(ck.exec, &mut keymap.exec, &mut clash);
- update_keymap(ck.filter_mode, &mut keymap.filter_mode, &mut clash);
- update_keymap(ck.force_redraw, &mut keymap.force_redraw, &mut clash);
- update_keymap(ck.quit, &mut keymap.quit, &mut clash);
- update_keymap(ck.save_logs, &mut keymap.save_logs, &mut clash);
- update_keymap(ck.scroll_down, &mut keymap.scroll_down, &mut clash);
- update_keymap(ck.scroll_end, &mut keymap.scroll_end, &mut clash);
- update_keymap(ck.scroll_start, &mut keymap.scroll_start, &mut clash);
- update_keymap(ck.scroll_up, &mut keymap.scroll_up, &mut clash);
- update_keymap(ck.log_search_mode, &mut keymap.log_search_mode, &mut clash);
- update_keymap(ck.scroll_forward, &mut keymap.scroll_forward, &mut clash);
- update_keymap(ck.scroll_back, &mut keymap.scroll_back, &mut clash);
- update_keymap(
- ck.select_next_panel,
- &mut keymap.select_next_panel,
- &mut clash,
- );
- update_keymap(
- ck.select_previous_panel,
- &mut keymap.select_previous_panel,
- &mut clash,
- );
- update_keymap(ck.sort_by_name, &mut keymap.sort_by_name, &mut clash);
- update_keymap(ck.sort_by_state, &mut keymap.sort_by_state, &mut clash);
- update_keymap(ck.sort_by_status, &mut keymap.sort_by_status, &mut clash);
- update_keymap(ck.sort_by_cpu, &mut keymap.sort_by_cpu, &mut clash);
- update_keymap(ck.sort_by_memory, &mut keymap.sort_by_memory, &mut clash);
- update_keymap(ck.sort_by_id, &mut keymap.sort_by_id, &mut clash);
- update_keymap(ck.sort_by_image, &mut keymap.sort_by_image, &mut clash);
- update_keymap(ck.sort_by_rx, &mut keymap.sort_by_rx, &mut clash);
- update_keymap(ck.sort_by_tx, &mut keymap.sort_by_tx, &mut clash);
- update_keymap(ck.sort_reset, &mut keymap.sort_reset, &mut clash);
- update_keymap(ck.toggle_help, &mut keymap.toggle_help, &mut clash);
- update_keymap(
- ck.toggle_mouse_capture,
- &mut keymap.toggle_mouse_capture,
- &mut clash,
- );
- // TODO need to check for clashes when using additional modifiers
- if let Some(scroll_many) = Self::try_parse_modifier(ck.scroll_many) {
- keymap.scroll_many = scroll_many;
- }
- }
- // A very basic clash check, every key has been inserted into a hashset, and a counter has been increased
- // if the counter and hashet length don't match, then there's a clash, and we just return the default keymap
- if counter == clash.len() {
- keymap
- } else {
- Self::new()
- }
- }
-}
-
-impl Keymap {
- // Allowable key modifiers are only `shift`, `control`, `alt`
- fn try_parse_modifier(input: Option>) -> Option {
- input.and_then(|input| {
- input
- .first()
- .and_then(|input| match input.to_lowercase().trim() {
- "control" => Some(KeyModifiers::CONTROL),
- "alt" => Some(KeyModifiers::ALT),
- "shift" => Some(KeyModifiers::SHIFT),
- _ => None,
- })
- })
- }
-
- /// Try to parse a &[String] into a Vec of keycodes, at most the output will have 2 entries
- /// This might fail on MacOS due to Backspace and Delete working in a different manner as to how they work on Linux & Windows
- /// I think that on MacOS `Del` becomes `Fwd Del`, and `Backspace` becomes `Delete`
- fn try_parse_keycode(input: &[String]) -> Option> {
- let mut output = vec![];
-
- for key in input.iter().take(2) {
- if key.chars().count() == 1 {
- if let Some(first_char) = key.chars().next()
- && let Some(first_char) = match first_char {
- x if x.is_ascii_alphabetic() || x.is_ascii_digit() => Some(first_char),
- '/' | '\\' | ',' | '.' | '#' | '\'' | '[' | ']' | ';' | '=' | '-' => {
- Some(first_char)
- }
- _ => None,
- }
- {
- output.push(KeyCode::Char(first_char));
- }
- } else {
- let keycode = match key.to_lowercase().as_str() {
- "f1" => Some(KeyCode::F(1)),
- "f2" => Some(KeyCode::F(2)),
- "f3" => Some(KeyCode::F(3)),
- "f4" => Some(KeyCode::F(4)),
- "f5" => Some(KeyCode::F(5)),
- "f6" => Some(KeyCode::F(6)),
- "f7" => Some(KeyCode::F(7)),
- "f8" => Some(KeyCode::F(8)),
- "f9" => Some(KeyCode::F(9)),
- "f10" => Some(KeyCode::F(10)),
- "f11" => Some(KeyCode::F(11)),
- "f12" => Some(KeyCode::F(12)),
- // Might fail on MacOS, see note above
- "backspace" => Some(KeyCode::Backspace),
- "backtab" => Some(KeyCode::BackTab),
- // Might fail on MacOS, see note above
- "delete" => Some(KeyCode::Delete),
- "down" => Some(KeyCode::Down),
- "end" => Some(KeyCode::End),
- "esc" => Some(KeyCode::Esc),
- "home" => Some(KeyCode::Home),
- "insert" => Some(KeyCode::Insert),
- "left" => Some(KeyCode::Left),
- "pagedown" => Some(KeyCode::PageDown),
- "pageup" => Some(KeyCode::PageUp),
- "right" => Some(KeyCode::Right),
- "tab" => Some(KeyCode::Tab),
- "up" => Some(KeyCode::Up),
- _ => None,
- };
- if let Some(a) = keycode {
- output.push(a);
- }
- }
- }
- if output.is_empty() {
- None
- } else {
- // Remove any duplicates for a single definition
- if output.first() == output.get(1) {
- output.pop();
- }
- Some(output)
- }
- }
-}
-
-#[cfg(test)]
-#[allow(clippy::unwrap_used)]
-mod tests {
- use crossterm::event::{KeyCode, KeyModifiers};
-
- use crate::config::keymap_parser::ConfigKeymap;
-
- use super::Keymap;
-
- #[test]
- /// Only allow two definitions to be parsed
- fn test_return_max_two() {
- let result = Keymap::try_parse_keycode(&["a".to_owned(), "b".to_owned(), "c".to_owned()]);
- assert_eq!(result, Some(vec![KeyCode::Char('a'), KeyCode::Char('b')]));
-
- let result = Keymap::try_parse_keycode(&["0".to_owned(), "1".to_owned(), "2".to_owned()]);
- assert_eq!(result, Some(vec![KeyCode::Char('0'), KeyCode::Char('1')]));
-
- let result =
- Keymap::try_parse_keycode(&["esc".to_owned(), "tab".to_owned(), "backtab".to_owned()]);
- assert_eq!(result, Some(vec![KeyCode::Esc, KeyCode::Tab]));
- }
-
- #[test]
- /// If a single definition has two identical entries, just return a single entry
- fn test_duplicate_definition() {
- let result = Keymap::try_parse_keycode(&["c".to_owned(), "c".to_owned()]);
- assert_eq!(result, Some(vec![KeyCode::Char('c')]));
-
- let result = Keymap::try_parse_keycode(&["0".to_owned(), "0".to_owned()]);
- assert_eq!(result, Some(vec![KeyCode::Char('0')]));
-
- let result = Keymap::try_parse_keycode(&["esc".to_owned(), "esc".to_owned()]);
- assert_eq!(result, Some(vec![KeyCode::Esc]));
- }
-
- #[test]
- /// Return None is invalid key definition is provided
- fn test_invalid_key() {
- let result = Keymap::try_parse_keycode(&["(".to_owned(), "*".to_owned()]);
- assert!(result.is_none());
-
- let result = Keymap::try_parse_keycode(&["enter".to_owned(), "shift".to_owned()]);
- assert!(result.is_none());
-
- let result = Keymap::try_parse_keycode(&["ö".to_owned(), "ä".to_owned()]);
- assert!(result.is_none());
- }
-
- #[test]
- /// If any key definitions clash, just return the default keymap
- fn test_clash_returns_default() {
- let input = ConfigKeymap {
- clear: Some(vec!["s".to_owned()]),
- delete_deny: Some(vec!["s".to_owned()]),
- delete_confirm: None,
- exec: None,
- filter_mode: None,
- force_redraw: None,
- inspect: None,
- scroll_back: None,
- log_search_mode: None,
- scroll_forward: None,
- log_section_height_decrease: None,
- log_section_height_increase: None,
- log_section_toggle: None,
- quit: None,
- save_logs: None,
- scroll_down: None,
- scroll_end: None,
- scroll_start: None,
- scroll_many: None,
- scroll_up: None,
- select_next_panel: None,
- select_previous_panel: None,
- sort_by_cpu: None,
- sort_by_id: None,
- sort_by_image: None,
- sort_by_memory: None,
- sort_by_name: None,
- sort_by_rx: None,
- sort_by_state: None,
- sort_by_status: None,
- sort_by_tx: None,
- sort_reset: None,
- toggle_help: None,
- toggle_mouse_capture: None,
- };
-
- let result = Keymap::from(Some(input));
-
- assert_eq!(result, Keymap::new());
- }
-
- #[test]
- /// Custom keymap definition creation
- fn test_valid_custom_keymap() {
- let gen_v = |a: (&str, &str)| Some(vec![a.0.to_owned(), a.1.to_owned()]);
-
- let input = ConfigKeymap {
- clear: gen_v(("a", "b")),
- delete_confirm: gen_v(("c", "d")),
- delete_deny: gen_v(("e", "f")),
- exec: gen_v(("g", "h")),
- filter_mode: gen_v(("i", "j")),
- force_redraw: gen_v(("k", "l")),
- inspect: gen_v(("m", "n")),
- scroll_back: gen_v(("s", "t")),
- scroll_forward: gen_v(("q", "r")),
- log_search_mode: gen_v(("1", "2")),
- log_section_height_decrease: gen_v(("m", "n")),
- log_section_height_increase: gen_v(("o", "p")),
- log_section_toggle: gen_v(("u", "v")),
- quit: gen_v(("w", "x")),
- save_logs: gen_v(("y", "z")),
- scroll_down: gen_v(("3", "4")),
- scroll_end: gen_v(("5", "6")),
- scroll_many: Some(vec!["alt".to_owned()]),
- scroll_start: gen_v(("7", "8")),
- scroll_up: gen_v(("F1", "F2")),
- select_next_panel: gen_v(("F3", "F4")),
- select_previous_panel: gen_v(("F5", "F6")),
- sort_by_cpu: gen_v(("F7", "F8")),
- sort_by_id: gen_v(("F9", "F10")),
- sort_by_image: gen_v(("F11", "F12")),
- sort_by_memory: gen_v(("HOME", "END")),
- sort_by_name: gen_v(("UP", "DOWN")),
- sort_by_rx: gen_v(("LEFT", "RIGHT")),
- sort_by_state: gen_v(("[", "]")),
- sort_by_status: gen_v(("INSERTt", "TAB")),
- sort_by_tx: gen_v(("PAGEDOWN", "PAGEUP")),
- sort_reset: gen_v((",", ".")),
- toggle_help: gen_v(("-", "=")),
- toggle_mouse_capture: gen_v(("\\", "/")),
- };
-
- let result = Keymap::from(Some(input));
-
- let expected = Keymap {
- clear: (KeyCode::Char('a'), Some(KeyCode::Char('b'))),
- delete_confirm: (KeyCode::Char('c'), Some(KeyCode::Char('d'))),
- delete_deny: (KeyCode::Char('e'), Some(KeyCode::Char('f'))),
- exec: (KeyCode::Char('g'), Some(KeyCode::Char('h'))),
- filter_mode: (KeyCode::Char('i'), Some(KeyCode::Char('j'))),
- force_redraw: (KeyCode::Char('k'), Some(KeyCode::Char('l'))),
- inspect: (KeyCode::Char('i'), None),
- scroll_back: (KeyCode::Char('s'), Some(KeyCode::Char('t'))),
- scroll_forward: (KeyCode::Char('q'), Some(KeyCode::Char('r'))),
- log_search_mode: (KeyCode::Char('1'), Some(KeyCode::Char('2'))),
- log_section_height_decrease: (KeyCode::Char('m'), Some(KeyCode::Char('n'))),
- log_section_height_increase: (KeyCode::Char('o'), Some(KeyCode::Char('p'))),
- log_section_toggle: (KeyCode::Char('u'), Some(KeyCode::Char('v'))),
- quit: (KeyCode::Char('w'), Some(KeyCode::Char('x'))),
- save_logs: (KeyCode::Char('y'), Some(KeyCode::Char('z'))),
- scroll_down: (KeyCode::Char('3'), Some(KeyCode::Char('4'))),
- scroll_end: (KeyCode::Char('5'), Some(KeyCode::Char('6'))),
- scroll_many: KeyModifiers::ALT,
- scroll_start: (KeyCode::Char('7'), Some(KeyCode::Char('8'))),
- scroll_up: (KeyCode::F(1), Some(KeyCode::F(2))),
- select_next_panel: (KeyCode::F(3), Some(KeyCode::F(4))),
- select_previous_panel: (KeyCode::F(5), Some(KeyCode::F(6))),
- sort_by_cpu: (KeyCode::F(7), Some(KeyCode::F(8))),
- sort_by_id: (KeyCode::F(9), Some(KeyCode::F(10))),
- sort_by_image: (KeyCode::F(11), Some(KeyCode::F(12))),
- sort_by_memory: (KeyCode::Home, Some(KeyCode::End)),
- sort_by_name: (KeyCode::Up, Some(KeyCode::Down)),
- sort_by_rx: (KeyCode::Left, Some(KeyCode::Right)),
- sort_by_state: (KeyCode::Char('['), Some(KeyCode::Char(']'))),
- sort_by_status: (KeyCode::Tab, None),
- sort_by_tx: (KeyCode::PageDown, Some(KeyCode::PageUp)),
- sort_reset: (KeyCode::Char(','), Some(KeyCode::Char('.'))),
- toggle_help: (KeyCode::Char('-'), Some(KeyCode::Char('='))),
- toggle_mouse_capture: (KeyCode::Char('\\'), Some(KeyCode::Char('/'))),
- };
- assert_eq!(expected, result);
- }
-}
diff --git a/src/config/mod.rs b/src/config/mod.rs
deleted file mode 100644
index db79281..0000000
--- a/src/config/mod.rs
+++ /dev/null
@@ -1,285 +0,0 @@
-use std::path::PathBuf;
-
-use clap::Parser;
-use jiff::tz::TimeZone;
-use parse_args::Args;
-use parse_config_file::ConfigFile;
-mod color_parser;
-mod keymap_parser;
-
-use crate::{ENV_KEY, ENV_VALUE};
-pub use {color_parser::AppColors, keymap_parser::Keymap};
-
-mod parse_args;
-mod parse_config_file;
-
-#[derive(Debug, Clone)]
-#[allow(clippy::struct_excessive_bools)]
-pub struct Config {
- pub app_colors: AppColors,
- pub color_logs: bool,
- pub docker_interval_ms: u32,
- pub gui: bool,
- pub host: Option,
- pub in_container: bool,
- pub keymap: Keymap,
- pub log_search_case_sensitive: bool,
- pub raw_logs: bool,
- pub dir_config: Option,
- pub dir_save: Option,
- pub show_logs: bool,
- pub show_self: bool,
- pub show_std_err: bool,
- pub show_timestamp: bool,
- pub timestamp_format: String,
- pub timezone: Option,
- pub use_cli: bool,
-}
-
-impl From<&Args> for Config {
- fn from(args: &Args) -> Self {
- Self {
- app_colors: AppColors::new(),
- color_logs: args.color,
- docker_interval_ms: args.docker_interval,
- gui: !args.gui,
- host: args.host.clone(),
- in_container: Self::check_if_in_container(),
- keymap: Keymap::new(),
- log_search_case_sensitive: true,
- raw_logs: args.raw,
- dir_save: Self::try_get_logs_dir(args.save_dir.as_ref()),
- dir_config: args.config_file.as_ref().map(|i| PathBuf::from(&i)),
- show_logs: true,
- show_self: !args.show_self,
- show_std_err: !args.no_std_err,
- show_timestamp: !args.timestamp,
- timestamp_format: Self::parse_timestamp_format(None),
- timezone: Self::parse_timezone(args.timezone.clone()),
- use_cli: args.use_cli,
- }
- }
-}
-
-impl From<(ConfigFile, Option)> for Config {
- fn from((config_file, dir): (ConfigFile, Option)) -> Self {
- Self {
- app_colors: AppColors::from(config_file.colors),
- color_logs: config_file.color_logs.unwrap_or(false),
- docker_interval_ms: config_file.docker_interval.unwrap_or(1000),
- dir_config: dir,
- gui: config_file.gui.unwrap_or(true),
- host: config_file.host,
- in_container: Self::check_if_in_container(),
- keymap: Keymap::from(config_file.keymap),
- log_search_case_sensitive: config_file.log_search_case_sensitive.unwrap_or(true),
- raw_logs: config_file.raw_logs.unwrap_or(false),
- dir_save: Self::try_get_logs_dir(config_file.save_dir.as_ref()),
- show_logs: config_file.show_logs.unwrap_or(true),
- show_self: config_file.show_self.unwrap_or(false),
- show_std_err: config_file.show_std_err.unwrap_or(true),
- show_timestamp: config_file.show_timestamp.unwrap_or(true),
- timestamp_format: Self::parse_timestamp_format(config_file.timestamp_format),
- timezone: Self::parse_timezone(config_file.timezone),
- use_cli: config_file.use_cli.unwrap_or(false),
- }
- }
-}
-
-impl Config {
- /// A basic timestampt format parser, will only take 32 chars, and checks if the parsed timestamp isn't identical to the given formatter
- fn parse_timestamp_format(input: Option) -> String {
- let default = || "%Y-%m-%dT%H:%M:%S.%8f".to_owned();
- input.map_or_else(default, |input| {
- if input.chars().count() >= 32
- || jiff::Timestamp::now().strftime(&input).to_string() == input
- {
- default()
- } else {
- input
- }
- })
- }
-
- /// Attempt to parse a timezone into a jiff::tz::TimeZone
- /// Also return a format to display the timesampt in
- fn parse_timezone(input: Option) -> Option {
- let timezone_str = input?;
- let Ok(tz) = jiff::tz::TimeZone::get(&timezone_str) else {
- return None;
- };
- let current_ts = jiff::Timestamp::now();
- let offset = tz.to_offset(current_ts);
- if jiff::tz::TimeZone::UTC.to_offset(current_ts) == offset {
- None
- } else {
- Some(tz)
- }
- }
- /// Check if oxker is running inside of a container
- fn check_if_in_container() -> bool {
- std::env::var(ENV_KEY).is_ok_and(|i| i == ENV_VALUE)
- }
-
- /// If a cli_arg is provided, create a pathbuf from it, else try to get home_dir automatically
- fn try_get_logs_dir(dir: Option<&String>) -> Option {
- dir.as_ref()
- .map_or_else(Self::try_get_home_dir, |home_dir| {
- Some(std::path::Path::new(&home_dir).to_owned())
- })
- }
-
- /// Try to get the home dir of the current user
- fn try_get_home_dir() -> Option {
- directories::BaseDirs::new().map(|base_dirs| base_dirs.home_dir().to_owned())
- }
-
- /// Combine config from CLI into config file, the cli take priority
- /// and also make sure color_logs and raw_logs can't clash
- fn merge_args(mut self, config_from_cli: Self) -> Self {
- let default_args = Args::default();
-
- if config_from_cli.color_logs != default_args.color {
- self.color_logs = config_from_cli.color_logs;
- self.raw_logs = !self.color_logs;
- }
-
- if config_from_cli.raw_logs != default_args.raw {
- self.raw_logs = config_from_cli.raw_logs;
- self.color_logs = !self.raw_logs;
- }
-
- if config_from_cli.gui != default_args.gui {
- self.gui = config_from_cli.gui;
- }
-
- if config_from_cli.docker_interval_ms != default_args.docker_interval {
- self.docker_interval_ms = config_from_cli.docker_interval_ms;
- }
-
- if config_from_cli.docker_interval_ms < 1000 {
- self.docker_interval_ms = default_args.docker_interval;
- }
-
- if config_from_cli.raw_logs != default_args.raw {
- self.raw_logs = config_from_cli.raw_logs;
- }
-
- if config_from_cli.show_self != default_args.show_self {
- self.show_self = config_from_cli.show_self;
- }
-
- if config_from_cli.show_std_err != default_args.no_std_err {
- self.show_std_err = config_from_cli.show_std_err;
- }
-
- if config_from_cli.show_timestamp != default_args.timestamp {
- self.show_timestamp = config_from_cli.show_timestamp;
- }
-
- if config_from_cli.use_cli != default_args.use_cli {
- self.use_cli = config_from_cli.use_cli;
- }
-
- if let Some(host) = config_from_cli.host {
- self.host = Some(host);
- }
-
- if let Some(x) = config_from_cli.dir_save {
- self.dir_save = Some(x);
- }
-
- if let Some(tz) = config_from_cli.timezone {
- self.timezone = Some(tz);
- }
-
- if self.color_logs && self.raw_logs {
- self.raw_logs = false;
- }
- self
- }
-
- /// Generate a new config file
- /// First check cli args,
- /// then if a config file location is given check then
- /// Else check the default location
- /// else just return the default config + the cli args
- /// cli args will take precedence over config settings
- pub fn new() -> Self {
- let in_container = Self::check_if_in_container();
-
- let args = Args::parse();
- let config_from_cli = Self::from(&args);
-
- if let Some(dir_config_file) = &args.config_file
- && let Some(config_file) =
- parse_config_file::ConfigFile::try_parse_from_file(dir_config_file)
- {
- return Self::from((config_file, Some(PathBuf::from(dir_config_file))))
- .merge_args(config_from_cli);
- }
-
- if let Some((config_file, dir)) = parse_config_file::ConfigFile::try_parse(in_container) {
- return Self::from((config_file, Some(dir))).merge_args(config_from_cli);
- }
- config_from_cli
- }
-}
-
-#[cfg(test)]
-#[allow(clippy::unwrap_used)]
-mod tests {
- use jiff::tz::TimeZone;
-
- /// Test the basic timestamp_format parsing/checker function
- #[test]
- fn test_config_parse_timestamp_format() {
- let default = "%Y-%m-%dT%H:%M:%S.%8f";
-
- let result = super::Config::parse_timestamp_format(None);
- assert_eq!(result, default);
-
- let result = super::Config::parse_timestamp_format(Some(String::new()));
- assert_eq!(result, default);
-
- let result = super::Config::parse_timestamp_format(Some(" ".to_owned()));
- assert_eq!(result, default);
-
- let result = super::Config::parse_timestamp_format(Some(" ".to_owned()));
- assert_eq!(result, default);
-
- let result =
- super::Config::parse_timestamp_format(Some("not a valid formatter".to_owned()));
- assert_eq!(result, default);
-
- let result = super::Config::parse_timestamp_format(Some(
- "%A, %B %d, %Y %I:%M %p %A, %B %d, %Y %I:%M %p".to_owned(),
- ));
- assert_eq!(result, default);
-
- let input = "%Y-%m-%d %H:%M:%S";
- let result = super::Config::parse_timestamp_format(Some(input.to_owned()));
- assert_eq!(result, input);
-
- let input = "%Y-%j";
- let result = super::Config::parse_timestamp_format(Some(input.to_owned()));
- assert_eq!(result, input);
- }
-
- #[test]
- /// Test various timezones get parsed correctly
- fn test_config_parse_timezone() {
- // Timezone with no offset just return None
- for i in [None, Some("UTC".to_owned())] {
- assert!(super::Config::parse_timezone(i).is_none());
- }
-
- let expected = Some(TimeZone::get("Asia/Tokyo").unwrap());
- // string case ignored
- for i in ["ASIA/TOKYO", "asia/tokyo", "aSiA/tOkYo"] {
- let result = super::Config::parse_timezone(Some(i.to_owned()));
- assert!(result.is_some());
- assert_eq!(result, expected);
- }
- }
-}
diff --git a/src/config/parse_args.rs b/src/config/parse_args.rs
deleted file mode 100644
index c79434f..0000000
--- a/src/config/parse_args.rs
+++ /dev/null
@@ -1,74 +0,0 @@
-use clap::Parser;
-use serde::Deserialize;
-
-#[derive(Parser, Debug, Clone, Deserialize)]
-#[allow(clippy::struct_excessive_bools)]
-#[command(version, about)]
-pub struct Args {
- /// Docker update interval in ms, minimum effectively 1000
- #[clap(short = 'd', value_name = "ms", default_value_t = 1000)]
- pub docker_interval: u32,
-
- /// Remove timestamps from Docker logs
- #[clap(short = 't')]
- pub timestamp: bool,
-
- /// Attempt to colorize the logs, conflicts with "-r"
- #[clap(short = 'c', conflicts_with = "raw")]
- pub color: bool,
-
- /// Show raw logs, default is to remove ansi formatting, conflicts with "-c"
- #[clap(short = 'r', conflicts_with = "color")]
- pub raw: bool,
-
- /// Show self when running as a docker container
- #[clap(short = 's')]
- pub show_self: bool,
-
- /// Don't draw gui - for debugging - mostly pointless
- #[clap(short = 'g')]
- pub gui: bool,
-
- /// Docker host, defaults to `/var/run/docker.sock`
- #[clap(long, short = None)]
- pub host: Option,
-
- /// Do not include stderr output in logs
- #[clap(long = "no-stderr")]
- pub no_std_err: bool,
-
- /// Display the container logs timestamp with a given timezone, default is UTC
- #[clap(long="timezone", short = None)]
- pub timezone: Option,
-
- /// Directory for saving exported logs, defaults to `$HOME`
- #[clap(long="save-dir", short = None)]
- pub save_dir: Option,
-
- /// Path to a config file, readable as TOML, JSONC, or JSON
- #[clap(long="config-file", short = None)]
- pub config_file: Option,
-
- /// Force use of docker cli when execing into containers
- #[clap(long="use-cli", short = None)]
- pub use_cli: bool,
-}
-
-impl Default for Args {
- fn default() -> Self {
- Self {
- docker_interval: 1000,
- timestamp: true,
- color: false,
- raw: false,
- show_self: false,
- gui: true,
- host: None,
- no_std_err: true,
- timezone: None,
- save_dir: None,
- config_file: None,
- use_cli: false,
- }
- }
-}
diff --git a/src/config/parse_config_file.rs b/src/config/parse_config_file.rs
deleted file mode 100644
index e685d57..0000000
--- a/src/config/parse_config_file.rs
+++ /dev/null
@@ -1,259 +0,0 @@
-use std::{
- io::{Read, Write},
- path::PathBuf,
-};
-
-use serde::Deserialize;
-
-use crate::app_error::AppError;
-
-use super::{color_parser::ConfigColors, keymap_parser::ConfigKeymap};
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-enum ConfigFileFormat {
- Toml,
- Jsonc,
- Json,
- JsoncAsJson,
-}
-
-impl TryFrom<&PathBuf> for ConfigFileFormat {
- type Error = AppError;
-
- /// Only allow toml, json, or jsonc files
- fn try_from(value: &PathBuf) -> Result {
- let err = || AppError::IO(format!("Can't parse give config file: {}", value.display()));
- let Some(ext) = value.extension() else {
- return Err(err());
- };
- let Some(ext) = ext.to_str() else {
- return Err(err());
- };
- match ext {
- "toml" => Ok(Self::Toml),
- "json" => Ok(Self::Json),
- "jsonc" => Ok(Self::Jsonc),
- _ => Err(err()),
- }
- }
-}
-
-impl ConfigFileFormat {
- /// Get the local config directory, to be used by default config parser
- fn get_config_dir(in_container: bool) -> Option {
- if in_container {
- Some(PathBuf::from("/"))
- } else {
- directories::BaseDirs::new()
- .map(|base_dirs| base_dirs.config_local_dir().join(env!("CARGO_PKG_NAME")))
- }
- }
- /// Return the default filename + path for a given fileformat
- fn get_default_path_name(self, in_container: bool) -> PathBuf {
- let suffix = match self {
- Self::Json | Self::JsoncAsJson => "config.json",
- Self::Jsonc => "config.jsonc",
- Self::Toml => "config.toml",
- };
- Self::get_config_dir(in_container).map_or_else(|| PathBuf::from(suffix), |i| i.join(suffix))
- }
-}
-
-#[derive(Debug, Deserialize, Clone, PartialEq, Eq)]
-pub struct ConfigFile {
- pub color_logs: Option,
- pub colors: Option,
- pub docker_interval: Option,
- pub gui: Option,
- pub host: Option,
- pub keymap: Option,
- pub log_search_case_sensitive: Option,
- pub raw_logs: Option,
- pub save_dir: Option,
- pub show_logs: Option,
- pub show_self: Option,
- pub show_std_err: Option,
- pub show_timestamp: Option,
- pub timestamp_format: Option,
- pub timezone: Option,
- pub use_cli: Option,
-}
-
-impl ConfigFile {
- /// Attempt to create a config.toml file, will attempt to recursively create the directories as well
- fn create_config_file(in_container: bool) -> Result<(), AppError> {
- if in_container {
- return Ok(());
- }
-
- let config_dir = ConfigFileFormat::get_config_dir(in_container)
- .ok_or_else(|| AppError::IO("config_dir".to_owned()))?;
- let file_name = config_dir.join("config.toml");
-
- if !std::fs::exists(&file_name).map_err(|i| AppError::IO(i.to_string()))? {
- if !std::fs::exists(&config_dir).map_err(|i| AppError::IO(i.to_string()))? {
- std::fs::DirBuilder::new()
- .recursive(true)
- .create(&config_dir)
- .map_err(|i| AppError::IO(i.to_string()))?;
- }
- let mut file =
- std::fs::File::create_new(&file_name).map_err(|i| AppError::IO(i.to_string()))?;
- file.write_all(include_bytes!("./config.toml"))
- .map_err(|i| AppError::IO(i.to_string()))?;
- file.flush().map_err(|i| AppError::IO(i.to_string()))?;
- }
- Ok(())
- }
-
- /// parse a given &str (read from the configfile) into Self
- fn parse(file_format: ConfigFileFormat, input: &str) -> Result {
- match file_format {
- ConfigFileFormat::Json => {
- serde_json::from_str::(input).map_err(|i| AppError::Parse(i.to_string()))
- }
- ConfigFileFormat::Jsonc | ConfigFileFormat::JsoncAsJson => {
- serde_jsonc::from_str::(input).map_err(|i| AppError::Parse(i.to_string()))
- }
- ConfigFileFormat::Toml => {
- toml::from_str::(input).map_err(|i| AppError::Parse(i.message().to_owned()))
- }
- }
- }
-
- /// Read the config file path to string, then attempt to parse
- fn parse_config_file(file_format: ConfigFileFormat, path: &PathBuf) -> Result {
- let mut file = std::fs::File::open(path).map_err(|_| {
- AppError::IO(
- path.to_str()
- .map_or_else(String::new, std::borrow::ToOwned::to_owned),
- )
- })?;
- let mut input = String::new();
- file.read_to_string(&mut input)
- .map_err(|i| AppError::IO(i.to_string()))?;
- Self::parse(file_format, &input)
- }
-
- /// Try to parse the config file when the path is user supplied via cliargs
- pub fn try_parse_from_file(path: &str) -> Option {
- let path = PathBuf::from(path);
- let Ok(file_format) = ConfigFileFormat::try_from(&path) else {
- return None;
- };
- Self::parse_config_file(file_format, &path).ok()
- }
-
- /// Parse a config file using default config_file location
- /// This is executed first, then the CLI args are read, and if they contain a "--config-file" entry, then Self::try_parse_from_file() is executed
- pub fn try_parse(in_container: bool) -> Option<(Self, PathBuf)> {
- let mut output = None;
- for file_format in [
- ConfigFileFormat::Toml,
- ConfigFileFormat::Jsonc,
- ConfigFileFormat::JsoncAsJson,
- ConfigFileFormat::Json,
- ] {
- let path = file_format.get_default_path_name(in_container);
- if let Ok(config_file) = Self::parse_config_file(file_format, &path) {
- output = Some((config_file, path));
- break;
- }
- }
-
- if output.is_none() {
- Self::create_config_file(in_container).ok();
- }
-
- output
- }
-}
-
-#[cfg(test)]
-#[allow(clippy::unwrap_used)]
-mod tests {
-
- use crate::config::{AppColors, Keymap};
-
- use super::ConfigFile;
-
- #[test]
- /// ./config.toml parses fine - as this is used to write a file on disk, it's vital that this is always valid
- fn test_parse_config_toml_valid() {
- let example_toml = include_str!("./config.toml");
- let result = ConfigFile::parse(super::ConfigFileFormat::Toml, example_toml);
- assert!(result.is_ok());
- }
-
- #[test]
- /// make sure config.toml matches the default keymap
- fn test_parse_config_keymap_toml() {
- let example_toml = include_str!("./config.toml");
- let result = ConfigFile::parse(super::ConfigFileFormat::Toml, example_toml).unwrap();
- assert!(result.keymap.is_some());
- assert_eq!(Keymap::from(result.keymap), Keymap::new());
- }
-
- #[test]
- /// make sure example.config.jsonc matches the default keymap
- fn test_parse_config_keymap_jsonc() {
- let example_jsonc = include_str!("../../example_config/example.config.jsonc");
- let result = ConfigFile::parse(super::ConfigFileFormat::Jsonc, example_jsonc).unwrap();
- assert!(result.keymap.is_some());
- assert_eq!(Keymap::from(result.keymap), Keymap::new());
- }
-
- #[test]
- /// All configs parsed and are equal
- fn test_parse_config_keymap_all() {
- let example_jsonc = include_str!("../../example_config/example.config.jsonc");
- let result_jsonc =
- ConfigFile::parse(super::ConfigFileFormat::Jsonc, example_jsonc).unwrap();
- assert!(result_jsonc.keymap.is_some());
- let result_jsonc = result_jsonc.keymap.unwrap();
-
- let example_toml = include_str!("./config.toml");
- let result_toml = ConfigFile::parse(super::ConfigFileFormat::Toml, example_toml).unwrap();
- assert!(result_toml.keymap.is_some());
- let result_toml = result_toml.keymap.unwrap();
-
- assert_eq!(Keymap::from(Some(result_toml.clone())), Keymap::new());
- assert_eq!(result_toml, result_jsonc);
- }
-
- #[test]
- /// make sure config.toml matches the default app colors
- fn test_parse_config_colors_toml() {
- let example_toml = include_str!("./config.toml");
- let result = ConfigFile::parse(super::ConfigFileFormat::Toml, example_toml).unwrap();
- assert!(result.colors.is_some());
- assert_eq!(AppColors::from(result.colors), AppColors::new());
- }
-
- #[test]
- /// make sure config.toml matches the default app colors
- fn test_parse_config_colors_jsonc() {
- let example_jsonc = include_str!("../../example_config/example.config.jsonc");
- let result = ConfigFile::parse(super::ConfigFileFormat::Jsonc, example_jsonc).unwrap();
- assert!(result.colors.is_some());
- assert_eq!(AppColors::from(result.colors), AppColors::new());
- }
-
- #[test]
- /// All configs parsed and are equal
- fn test_parse_config_colors_all() {
- let example_jsonc = include_str!("../../example_config/example.config.jsonc");
- let result_jsonc =
- ConfigFile::parse(super::ConfigFileFormat::Jsonc, example_jsonc).unwrap();
- assert!(result_jsonc.colors.is_some());
- let result_jsonc = result_jsonc.colors.unwrap();
-
- let example_toml = include_str!("./config.toml");
- let result_toml = ConfigFile::parse(super::ConfigFileFormat::Toml, example_toml).unwrap();
- assert!(result_toml.colors.is_some());
- let result_toml = result_toml.colors.unwrap();
-
- assert_eq!(AppColors::from(Some(result_toml.clone())), AppColors::new());
- assert_eq!(result_toml, result_jsonc);
- }
-}
diff --git a/src/docker_data/message.rs b/src/docker_data/message.rs
deleted file mode 100644
index 6030e29..0000000
--- a/src/docker_data/message.rs
+++ /dev/null
@@ -1,14 +0,0 @@
-use std::sync::Arc;
-
-use crate::app_data::{ContainerId, DockerCommand};
-use bollard::Docker;
-use tokio::sync::oneshot::Sender;
-
-#[derive(Debug)]
-pub enum DockerMessage {
- ConfirmDelete(ContainerId),
- Control((DockerCommand, ContainerId)),
- Exec(Sender>),
- Inspect(ContainerId),
- Update,
-}
diff --git a/src/docker_data/mod.rs b/src/docker_data/mod.rs
deleted file mode 100644
index 038dc6b..0000000
--- a/src/docker_data/mod.rs
+++ /dev/null
@@ -1,665 +0,0 @@
-use bollard::{
- Docker,
- query_parameters::{
- InspectContainerOptions, ListContainersOptions, LogsOptions, RemoveContainerOptions,
- RestartContainerOptions, StartContainerOptions, StatsOptions, StopContainerOptions,
- },
- secret::ContainerStatsResponse,
- service::ContainerSummary,
-};
-use futures_util::StreamExt;
-use parking_lot::Mutex;
-use std::{
- collections::HashSet,
- sync::{Arc, atomic::AtomicUsize},
-};
-use tokio::sync::mpsc::{Receiver, Sender};
-use uuid::Uuid;
-
-use crate::{
- ENTRY_POINT,
- app_data::{AppData, ContainerId, DockerCommand, State},
- app_error::AppError,
- config::Config,
- ui::{GuiState, Status},
-};
-mod message;
-pub use message::DockerMessage;
-
-#[derive(Debug, Clone, Eq, Hash, PartialEq)]
-enum SpawnId {
- Stats((ContainerId, Binate)),
- Log(ContainerId),
-}
-
-impl SpawnId {
- /// Extract the &ContainerId out of self
- const fn get_id(&self) -> &ContainerId {
- match self {
- Self::Log(id) | Self::Stats((id, _)) => id,
- }
- }
-}
-
-/// Cpu & Mem stats take twice as long as the update interval to get a value, so will have two being executed at the same time
-/// SpawnId::Stats takes container_id and binate value to enable both cycles of the same container_id to be inserted into the hashmap
-/// Binate value is toggled when all handles have been spawned off
-/// Also effectively means that the minimum docker_update interval will be 1000ms
-#[derive(Debug, Clone, Copy, Eq, Hash, PartialEq)]
-enum Binate {
- One,
- Two,
-}
-
-impl Binate {
- const fn toggle(self) -> Self {
- match self {
- Self::One => Self::Two,
- Self::Two => Self::One,
- }
- }
-}
-
-pub struct DockerData {
- app_data: Arc>,
- binate: Binate,
- config: Config,
- docker: Arc,
- gui_state: Arc>,
- receiver: Receiver,
- spawns: Arc>>,
-}
-
-impl DockerData {
- /// Use docker stats to calculate current cpu usage
- #[allow(clippy::cast_precision_loss)]
- fn calculate_usage(stats: &ContainerStatsResponse) -> f64 {
- let mut cpu_percentage = 0.0;
-
- let total_usage = stats.precpu_stats.as_ref().map_or(0, |i| {
- i.cpu_usage
- .as_ref()
- .map_or(0, |i| i.total_usage.unwrap_or_default())
- });
-
- let cpu_delta = stats.cpu_stats.as_ref().map_or(0, |i| {
- i.cpu_usage.as_ref().map_or(0, |i| {
- i.total_usage
- .unwrap_or_default()
- .saturating_sub(total_usage)
- })
- }) as f64;
-
- if let (Some(Some(cpu_stats_usage)), Some(Some(precpu_stats_usage))) = (
- stats.cpu_stats.as_ref().map(|i| i.system_cpu_usage),
- stats.precpu_stats.as_ref().map(|i| i.system_cpu_usage),
- ) {
- let system_delta = cpu_stats_usage.saturating_sub(precpu_stats_usage) as f64;
- let online_cpus = f64::from(stats.cpu_stats.as_ref().map_or(0, |i| {
- i.online_cpus.unwrap_or_else(|| {
- u32::try_from(
- stats
- .cpu_stats
- .clone()
- .unwrap_or_default()
- .cpu_usage
- .unwrap_or_default()
- .percpu_usage
- .as_ref()
- .map_or(0, std::vec::Vec::len),
- )
- .unwrap_or_default()
- })
- }));
- if system_delta > 0.0 && cpu_delta > 0.0 {
- cpu_percentage = (cpu_delta / system_delta) * online_cpus * 100.0;
- }
- }
- cpu_percentage
- }
-
- /// Get a single docker stat in order to update mem and cpu usage
- /// don't take &self, so that can tokio::spawn into it's own thread
- /// remove if from spawns hashmap when complete
- /// Get a single docker stat in order to update mem and cpu usage
- /// don't take &self, so that can tokio::spawn into it's own thread
- /// remove if from spawns hashmap when complete
- async fn update_container_stat(
- app_data: Arc>,
- docker: Arc,
- state: State,
- spawn_id: SpawnId,
- spawns: Arc>>,
- ) {
- let id = spawn_id.get_id();
- let mut stream = docker
- .stats(
- id.get(),
- Some(StatsOptions {
- stream: false,
- one_shot: false,
- }),
- )
- .take(1);
-
- while let Some(Ok(stats)) = stream.next().await {
- // Memory stats are only collected if the container is alive - is this the behaviour we want?
-
- let (mem_stat, cpu_stats) = if state.is_alive() {
- let mem_cache = stats.memory_stats.as_ref().map_or(&0, |i| {
- i.stats
- .as_ref()
- .map_or(&0, |i| i.get("inactive_file").unwrap_or(&0))
- });
- (
- Some(
- stats
- .memory_stats
- .as_ref()
- .map_or(0, |i| i.usage.unwrap_or_default())
- .saturating_sub(*mem_cache),
- ),
- Some(Self::calculate_usage(&stats)),
- )
- } else {
- (None, None)
- };
-
- // TODO is hardcoded eth0 a good idea here?
- let (rx, tx) = stats.networks.as_ref().map_or((0, 0), |i| {
- i.get("eth0").map_or((0, 0), |x| {
- (
- x.rx_bytes.unwrap_or_default(),
- x.tx_bytes.unwrap_or_default(),
- )
- })
- });
-
- app_data.lock().update_stats_by_id(
- id,
- cpu_stats,
- mem_stat,
- stats
- .memory_stats
- .unwrap_or_default()
- .limit
- .unwrap_or_default(),
- rx,
- tx,
- );
- }
- spawns.lock().remove(&spawn_id);
- }
-
- /// Update all stats, spawn each container into own tokio::spawn thread
- fn update_all_container_stats(&mut self) {
- let all_ids = self.app_data.lock().get_all_id_state();
- for (state, id) in all_ids {
- let spawn_id = SpawnId::Stats((id, self.binate));
-
- if !self.spawns.lock().contains(&spawn_id) {
- let app_data = Arc::clone(&self.app_data);
- let docker = Arc::clone(&self.docker);
- let spawns = Arc::clone(&self.spawns);
- tokio::spawn(Self::update_container_stat(
- app_data, docker, state, spawn_id, spawns,
- ));
- }
- }
- self.binate = self.binate.toggle();
- }
-
- /// Get all current containers, handle into ContainerItem in the app_data struct rather than here
- /// Just make sure that items sent are guaranteed to have an id
- /// If in a containerised runtime, will ignore any container that uses the `/app/oxker` as an entry point, unless the `-s` flag is set
- async fn update_all_containers(&self) {
- let containers = self
- .docker
- .list_containers(Some(ListContainersOptions {
- all: true,
- ..Default::default()
- }))
- .await
- .unwrap_or_default();
-
- let output = containers
- .into_iter()
- .filter_map(|f| match f.id {
- Some(_) => {
- if self.config.in_container
- && f.command
- .as_ref()
- .is_some_and(|c| c.starts_with(ENTRY_POINT))
- && self.config.show_self
- {
- None
- } else {
- Some(f)
- }
- }
- None => None,
- })
- .collect::>();
- self.app_data.lock().update_containers(output);
- }
-
- /// Update single container logs
- /// remove it from spawns hashmap when complete
- async fn update_log(
- app_data: Arc>,
- docker: Arc,
- id: ContainerId,
- since: u64,
- spawns: Arc>>,
- stderr: bool,
- ) {
- let options = Some(LogsOptions {
- stdout: true,
- stderr,
- timestamps: true,
- since: i32::try_from(since).unwrap_or_default(),
- ..Default::default()
- });
-
- let mut logs = docker.logs(id.get(), options);
- let mut output = vec![];
-
- while let Some(Ok(value)) = logs.next().await {
- let data = value.to_string();
- if !data.trim().is_empty() {
- output.push(data);
- }
- }
- app_data.lock().update_log_by_id(output, &id);
- spawns.lock().remove(&SpawnId::Log(id));
- }
-
- /// Update all logs, spawn each container into own tokio::spawn thread
- fn init_all_logs(&self, all_ids: Vec<(State, ContainerId)>) -> Arc {
- let init = Arc::new(AtomicUsize::new(0));
- for (_, id) in all_ids {
- let app_data: Arc> =
- Arc::clone(&self.app_data);
- let docker = Arc::clone(&self.docker);
- let spawns = Arc::clone(&self.spawns);
- let std_err = self.config.show_std_err;
- let init = Arc::clone(&init);
-
- self.spawns.lock().insert(SpawnId::Log(id.clone()));
-
- tokio::spawn(async move {
- Self::update_log(app_data, docker, id, 0, spawns, std_err).await;
- init.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
- });
- }
- init
- }
-
- /// Initialize docker container data, before any messages are received
- async fn initialise_container_data(&mut self) {
- self.gui_state.lock().status_push(Status::Init);
- let loading_uuid = Uuid::new_v4();
- GuiState::start_loading_animation(&self.gui_state, loading_uuid);
- self.update_all_containers().await;
- let all_ids = self.app_data.lock().get_all_id_state();
- let all_ids_len = all_ids.len();
- let init = self.init_all_logs(all_ids);
- self.update_all_container_stats();
-
- while init.load(std::sync::atomic::Ordering::SeqCst) != all_ids_len {
- self.app_data.lock().sort_containers();
- tokio::time::sleep(std::time::Duration::from_millis(10)).await;
- }
- self.gui_state.lock().stop_loading_animation(loading_uuid);
- self.gui_state.lock().status_del(Status::Init);
- }
-
- /// Update all cpu_mem, and selected container log (if a log update join_handle isn't currently being executed)
- async fn update_everything(&mut self) {
- self.update_all_containers().await;
- if let Some(container) = self.app_data.lock().get_selected_container() {
- let last_updated = container.last_updated;
- let spawn_id = SpawnId::Log(container.id.clone());
- // Only spawn if not already spawned with a given id/binate pair
- if !self.spawns.lock().contains(&spawn_id) {
- self.spawns.lock().insert(spawn_id.clone());
- tokio::spawn(Self::update_log(
- Arc::clone(&self.app_data),
- Arc::clone(&self.docker),
- container.id.clone(),
- last_updated,
- Arc::clone(&self.spawns),
- self.config.show_std_err,
- ));
- }
- }
- self.update_all_container_stats();
- self.app_data.lock().sort_containers();
- }
-
- /// Set the global error as the docker error, and set gui_state to error
- fn set_error(
- app_data: &Arc>,
- error: DockerCommand,
- gui_state: &Arc>,
- ) {
- app_data
- .lock()
- .set_error(AppError::DockerCommand(error), gui_state, Status::Error);
- }
-
- /// Execute docker commands (start, stop etc) on it's own tokio thread
- async fn execute_command(&mut self, control: DockerCommand, id: ContainerId) {
- let (app_data, docker, gui_state) = (
- Arc::clone(&self.app_data),
- Arc::clone(&self.docker),
- Arc::clone(&self.gui_state),
- );
- tokio::spawn(async move {
- let uuid = Uuid::new_v4();
- GuiState::start_loading_animation(&gui_state, uuid);
- if match control {
- DockerCommand::Delete => {
- gui_state.lock().set_delete_container(None);
- docker
- .remove_container(
- id.get(),
- Some(RemoveContainerOptions {
- v: false,
- force: true,
- link: false,
- }),
- )
- .await
- }
- DockerCommand::Pause => docker.pause_container(id.get()).await,
- DockerCommand::Restart => {
- docker
- .restart_container(id.get(), None::)
- .await
- }
- DockerCommand::Resume => docker.unpause_container(id.get()).await,
- DockerCommand::Start => {
- docker
- .start_container(id.get(), None::)
- .await
- }
- DockerCommand::Stop => {
- docker
- .stop_container(id.get(), None::)
- .await
- }
- }
- .is_err()
- {
- Self::set_error(&app_data, control, &gui_state);
- }
- gui_state.lock().stop_loading_animation(uuid);
- });
-
- self.update_everything().await;
- }
-
- /// Handle incoming messages, container controls & all container information update
- /// Spawn Docker commands off into own thread
- async fn message_handler(&mut self) {
- while let Some(message) = self.receiver.recv().await {
- match message {
- DockerMessage::ConfirmDelete(id) => {
- self.gui_state.lock().set_delete_container(Some(id));
- }
- DockerMessage::Control((command, id)) => self.execute_command(command, id).await,
- DockerMessage::Exec(docker_tx) => {
- docker_tx.send(Arc::clone(&self.docker)).ok();
- }
- DockerMessage::Update => self.update_everything().await,
- DockerMessage::Inspect(id) => {
- let t = self
- .docker
- .inspect_container(id.get(), Some(InspectContainerOptions { size: true }))
- .await;
- if let Ok(t) = t {
- self.app_data.lock().set_inspect_data(t);
- self.gui_state.lock().status_push(Status::Inspect);
- } else {
- // Set error here, can't inspect container
- }
- }
- }
- }
- }
-
- /// Send an update message every x ms, where x is the args.docker_interval
- fn heartbeat(config: &Config, docker_tx: Sender) {
- let update_duration =
- std::time::Duration::from_millis(u64::from(config.docker_interval_ms));
- let mut now = std::time::Instant::now();
- tokio::spawn(async move {
- loop {
- docker_tx.send(DockerMessage::Update).await.ok();
- if let Some(to_sleep) = update_duration.checked_sub(now.elapsed()) {
- tokio::time::sleep(to_sleep).await;
- }
- now = std::time::Instant::now();
- }
- });
- }
-
- /// Initialise self, and start the message receiving loop
- pub async fn start(
- app_data: Arc>,
- docker: Docker,
- docker_rx: Receiver,
- docker_tx: Sender,
- gui_state: Arc>,
- ) {
- let args = app_data.lock().config.clone();
- if app_data.lock().get_error().is_none() {
- let mut inner = Self {
- app_data,
- config: args,
- binate: Binate::One,
- docker: Arc::new(docker),
- gui_state,
- receiver: docker_rx,
- spawns: Arc::new(Mutex::new(HashSet::new())),
- };
- inner.initialise_container_data().await;
- Self::heartbeat(&inner.config, docker_tx);
- inner.message_handler().await;
- }
- }
-}
-
-// tests, use redis-test container, check logs exists, and selector of logs, and that it increases, and matches end, when you run restart on the docker containers
-#[cfg(test)]
-#[allow(clippy::float_cmp)]
-mod tests {
-
- use bollard::secret::{ContainerCpuStats, ContainerCpuUsage};
-
- use super::*;
-
- fn gen_stats() -> ContainerStatsResponse {
- ContainerStatsResponse {
- read: None,
- os_type: None,
- preread: None,
- num_procs: Some(1),
- pids_stats: None,
- networks: None,
- memory_stats: None,
- blkio_stats: None,
- cpu_stats: Some(ContainerCpuStats {
- cpu_usage: Some(ContainerCpuUsage {
- percpu_usage: Some(vec![50]),
- usage_in_usermode: Some(10),
- total_usage: Some(100),
- usage_in_kernelmode: Some(20),
- }),
- system_cpu_usage: Some(400),
- online_cpus: Some(1),
- throttling_data: None,
- }),
- precpu_stats: Some(ContainerCpuStats {
- cpu_usage: Some(ContainerCpuUsage {
- percpu_usage: Some(vec![50]),
- usage_in_usermode: Some(10),
- total_usage: Some(100),
- usage_in_kernelmode: Some(20),
- }),
- system_cpu_usage: Some(400),
- online_cpus: Some(1),
- throttling_data: None,
- }),
- storage_stats: None,
- name: None,
- id: None,
- }
- }
-
- #[test]
- fn test_calculate_usage_50() {
- let mut stats = gen_stats();
- stats.precpu_stats = Some(ContainerCpuStats {
- cpu_usage: Some(ContainerCpuUsage {
- percpu_usage: Some(vec![50]),
- usage_in_usermode: Some(10),
- total_usage: Some(100),
- usage_in_kernelmode: Some(20),
- }),
- system_cpu_usage: Some(400),
- online_cpus: Some(1),
- throttling_data: None,
- });
- stats.cpu_stats = Some(ContainerCpuStats {
- cpu_usage: Some(ContainerCpuUsage {
- percpu_usage: Some(vec![150]),
- usage_in_usermode: Some(20),
- total_usage: Some(150),
- usage_in_kernelmode: Some(30),
- }),
- system_cpu_usage: Some(500),
- online_cpus: Some(1),
- throttling_data: None,
- });
- let cpu_percentage = DockerData::calculate_usage(&stats);
- assert_eq!(50.0, cpu_percentage);
- }
-
- #[test]
- fn test_calculate_usage_25() {
- let mut stats = gen_stats();
- stats.precpu_stats = Some(ContainerCpuStats {
- cpu_usage: Some(ContainerCpuUsage {
- percpu_usage: Some(vec![50]),
- usage_in_usermode: Some(10),
- total_usage: Some(100),
- usage_in_kernelmode: Some(20),
- }),
- system_cpu_usage: Some(400),
- online_cpus: Some(1),
- throttling_data: None,
- });
- stats.cpu_stats = Some(ContainerCpuStats {
- cpu_usage: Some(ContainerCpuUsage {
- percpu_usage: Some(vec![75]),
- usage_in_usermode: Some(20),
- total_usage: Some(125),
- usage_in_kernelmode: Some(30),
- }),
- system_cpu_usage: Some(500),
- online_cpus: Some(1),
- throttling_data: None,
- });
- let cpu_percentage = DockerData::calculate_usage(&stats);
- assert_eq!(25.0, cpu_percentage);
- }
-
- #[test]
- fn test_calculate_usage_75() {
- let mut stats = gen_stats();
- stats.precpu_stats = Some(ContainerCpuStats {
- cpu_usage: Some(ContainerCpuUsage {
- percpu_usage: Some(vec![50]),
- usage_in_usermode: Some(10),
- total_usage: Some(100),
- usage_in_kernelmode: Some(20),
- }),
- system_cpu_usage: Some(400),
- online_cpus: Some(1),
- throttling_data: None,
- });
- stats.cpu_stats = Some(ContainerCpuStats {
- cpu_usage: Some(ContainerCpuUsage {
- percpu_usage: Some(vec![175]),
- usage_in_usermode: Some(20),
- total_usage: Some(175),
- usage_in_kernelmode: Some(30),
- }),
- system_cpu_usage: Some(500),
- online_cpus: Some(1),
- throttling_data: None,
- });
- let cpu_percentage = DockerData::calculate_usage(&stats);
- assert_eq!(75.0, cpu_percentage);
- }
-
- #[test]
- fn test_calculate_usage_100() {
- let mut stats = gen_stats();
- stats.precpu_stats = Some(ContainerCpuStats {
- cpu_usage: Some(ContainerCpuUsage {
- percpu_usage: Some(vec![50]),
- usage_in_usermode: Some(10),
- total_usage: Some(100),
- usage_in_kernelmode: Some(20),
- }),
- system_cpu_usage: Some(400),
- online_cpus: Some(1),
- throttling_data: None,
- });
- stats.cpu_stats = Some(ContainerCpuStats {
- cpu_usage: Some(ContainerCpuUsage {
- percpu_usage: Some(vec![200]),
- usage_in_usermode: Some(20),
- total_usage: Some(200),
- usage_in_kernelmode: Some(30),
- }),
- system_cpu_usage: Some(500),
- online_cpus: Some(1),
- throttling_data: None,
- });
- let cpu_percentage = DockerData::calculate_usage(&stats);
- assert_eq!(100.0, cpu_percentage);
- }
-
- #[test]
- fn test_calculate_usage_175() {
- let mut stats = gen_stats();
- stats.precpu_stats = Some(ContainerCpuStats {
- cpu_usage: Some(ContainerCpuUsage {
- percpu_usage: Some(vec![50]),
- usage_in_usermode: Some(10),
- total_usage: Some(100),
- usage_in_kernelmode: Some(20),
- }),
- system_cpu_usage: Some(400),
- online_cpus: Some(1),
- throttling_data: None,
- });
- stats.cpu_stats = Some(ContainerCpuStats {
- cpu_usage: Some(ContainerCpuUsage {
- percpu_usage: Some(vec![275]),
- usage_in_usermode: Some(20),
- total_usage: Some(275),
- usage_in_kernelmode: Some(30),
- }),
- system_cpu_usage: Some(500),
- online_cpus: Some(1),
- throttling_data: None,
- });
- let cpu_percentage = DockerData::calculate_usage(&stats);
- assert_eq!(175.0, cpu_percentage);
- }
-}
diff --git a/src/exec.rs b/src/exec.rs
deleted file mode 100644
index bc4444e..0000000
--- a/src/exec.rs
+++ /dev/null
@@ -1,360 +0,0 @@
-use std::{
- io::{Read, Write},
- sync::{Arc, atomic::AtomicBool, mpsc::Sender},
-};
-
-use bollard::{
- Docker,
- exec::{CreateExecOptions, ResizeExecOptions, StartExecOptions, StartExecResults},
-};
-use crossterm::terminal::enable_raw_mode;
-use futures_util::StreamExt;
-use parking_lot::Mutex;
-use ratatui::layout::Size;
-use tokio::{
- fs::File,
- io::{AsyncReadExt, AsyncWriteExt},
-};
-use tokio_util::sync::CancellationToken;
-
-use crate::{
- app_data::{AppData, ContainerId, RunningState, State},
- app_error::AppError,
-};
-
-/// TTY location
-const TTY: &str = "/dev/tty";
-
-/// This will be the start of a docker exec message if one is unable to actually exec into the container
-const OCI_ERROR: &str = "OCI runtime exec failed";
-
-/// Set the cursor position on the screen to (0,0)
-const CURSOR_POS: &str = "\x1B[J\x1B[H";
-
-/// This needs to be written to stdout when exiting the exec mode, else the input handler thread gets confused,
-/// see https://sw.kovidgoyal.net/kitty/keyboard-protocol/#progressive-enhancement
-const KEYBOARD_PROTO: &str = "\x1B[?u\x1B[c";
-
-mod command {
- pub const PWD: &str = "pwd";
- pub const DOCKER: &str = "docker";
- pub const EXEC: &str = "exec";
- pub const SH: &str = "sh";
- pub const IT: &str = "-it";
-}
-
-/// Currently known byte output after writing KEYBOARD_PROTO to stdout
-/// valid arm: [91, 63, 54, 49, 59, 54, 59, 55, 59, 50, 50, 59, 50, 51, 59, 50, 52, 59, 50, 56, 59, 51, 50, 59,52, 50] => [?61;6;7;22;23;24;28;32;2
-/// valid x86: [91, 63, 49, 59, 50, 99] => [?1;2c
-/// invalid x86: [91, 63, 49, 59, 48, 99] => [?1;0c
-enum ByteOutput {
- Arm,
- X86,
-}
-
-impl ByteOutput {
- const fn len(&self) -> usize {
- match self {
- Self::Arm => 26,
- Self::X86 => 6,
- }
- }
- const fn last(&self) -> &[u8] {
- match self {
- Self::Arm => &[50],
- Self::X86 => &[99],
- }
- }
-}
-
-/// Check the output from tty to see if it matches known sequence.
-/// At the moment we only need to check the length and end digit, as x86 valid and invalid match in these two regards
-fn byte_sequence_valid(bytes: &[u8]) -> bool {
- [ByteOutput::Arm, ByteOutput::X86]
- .iter()
- .any(|i| i.len() == bytes.len() && bytes.ends_with(i.last()))
-}
-
-/// Check if tty is able to be written to, aka not windows
-pub fn tty_readable() -> bool {
- std::fs::OpenOptions::new()
- .read(true)
- .write(false)
- .open(TTY)
- .is_ok()
-}
-
-struct AsyncTTY {
- rx: std::sync::mpsc::Receiver,
-}
-
-impl AsyncTTY {
- /// Use an async timeout to read data from the file, and send to the "main" thread
- async fn read_loop(mut f: File, tx: Sender) {
- loop {
- let mut buf = [0];
- if tokio::time::timeout(std::time::Duration::from_millis(10), f.read_exact(&mut buf))
- .await
- .is_ok()
- && tx.send(buf[0]).is_err()
- {
- break;
- }
- }
- }
-
- /// Async tty reading, spawned into its own tokio thread
- fn get(cancel_token: &CancellationToken) -> Option {
- if tty_readable() {
- let (tx, rx) = std::sync::mpsc::channel();
- let cancel_token = cancel_token.to_owned();
- tokio::spawn(async move {
- if let Ok(f) = tokio::fs::File::open(TTY).await {
- tokio::select! {
- () = cancel_token.cancelled() => (),
- () = Self::read_loop(f, tx) => cancel_token.cancel(),
- }
- }
- });
- Some(Self { rx })
- } else {
- None
- }
- }
-}
-
-// impl TryFrom<&Terminal>> for HWU16 {
-// type Error = None;
-// fn try_from(terminal: &Terminal>) -> Option {
-// terminal.size().map_or(None, |i| {
-// Some(Self {
-// width: i.width,
-// height: i.height,
-// })
-// })
-// }
-
-// }
-
-// impl TerminalSize {
-// pub fn new(terminal: &Terminal>) -> Option {
-// terminal.size().map_or(None, |i| {
-// Some(Self {
-// width: i.width,
-// height: i.height,
-// })
-// })
-// }
-// }
-
-#[derive(Debug, Clone)]
-pub enum ExecMode {
- // use Bollard Rust library
- Internal((Arc, Arc)),
- // use the external `docker-cli`
- External(Arc),
-}
-
-impl ExecMode {
- /// Test if we can exec into the selected container, first via the Internal methods, then by the External
- /// If the container is oxker, it will always return None
- pub async fn new(app_data: &Arc>, docker: &Arc) -> Option {
- let is_oxker = app_data.lock().is_oxker();
- if is_oxker {
- return None;
- }
-
- let use_cli = app_data.lock().config.use_cli;
- let container = app_data.lock().get_selected_container_id_state_name();
-
- if let Some((id, state, _)) = container
- && [
- State::Running(RunningState::Healthy),
- State::Running(RunningState::Unhealthy),
- ]
- .contains(&state)
- {
- if tty_readable()
- && !use_cli
- && let Ok(exec) = docker
- .create_exec(
- id.get(),
- CreateExecOptions {
- attach_stdout: Some(true),
- attach_stderr: Some(true),
- cmd: Some(vec![command::PWD]),
- ..Default::default()
- },
- )
- .await
- && let Ok(StartExecResults::Attached { mut output, .. }) =
- docker.start_exec(&exec.id, None).await
- && let Some(Ok(msg)) = output.next().await
- && !msg.to_string().starts_with(OCI_ERROR)
- {
- return Some(Self::Internal((Arc::new(id), Arc::clone(docker))));
- }
-
- if let Ok(output) = std::process::Command::new(command::DOCKER)
- .args([command::EXEC, id.get(), command::PWD])
- .output()
- && let Ok(output) = String::from_utf8(output.stdout)
- && !output.starts_with(OCI_ERROR)
- {
- return Some(Self::External(Arc::new(id)));
- }
- }
- None
- }
-
- /// exec into the container using the external docker cli, the result it just piped into oxker
- fn exec_external(id: &ContainerId) {
- let mut stdout = std::io::stdout();
- stdout.write_all(CURSOR_POS.as_bytes()).ok();
- if let Ok(mut child) = std::process::Command::new(command::DOCKER)
- .args([command::EXEC, command::IT, id.get(), command::SH])
- .stdin(std::process::Stdio::inherit())
- .stdout(std::process::Stdio::inherit())
- .stderr(std::process::Stdio::inherit())
- .spawn()
- {
- child.wait().ok();
- if child.kill().is_err() {
- std::process::exit(1)
- }
- }
- }
-
- /// Exec into the container via the Bollard library, stdout & stdin on different threads
- /// Have to deal with strange output once dropped, hence the use of internal_cleanup() method
- async fn exec_internal(
- &self,
- id: &ContainerId,
- docker: &Arc,
- terminal_size: Option,
- ) -> Result<(), AppError> {
- let cancel_token = CancellationToken::new();
-
- if let Ok(exec_result) = docker
- .create_exec(
- id.get(),
- CreateExecOptions {
- attach_stdout: Some(true),
- attach_stderr: Some(true),
- attach_stdin: Some(true),
- tty: Some(true),
- cmd: Some(vec![command::SH]),
- ..Default::default()
- },
- )
- .await
- {
- match docker
- .start_exec(
- &exec_result.id,
- Some(StartExecOptions {
- detach: false,
- ..Default::default()
- }),
- )
- .await
- {
- Ok(StartExecResults::Attached {
- mut output,
- mut input,
- }) => {
- if let Some(tty) = AsyncTTY::get(&cancel_token) {
- tokio::spawn(async move {
- enable_raw_mode().ok();
- let mut stdout = std::io::stdout();
- stdout.write_all(CURSOR_POS.as_bytes()).ok();
- stdout.flush().ok();
- while let Some(Ok(x)) = output.next().await {
- stdout.write_all(&x.into_bytes()).ok();
- stdout.flush().ok();
- }
- cancel_token.cancel();
- });
-
- if let Some(terminal_size) = terminal_size {
- docker
- .resize_exec(
- &exec_result.id,
- ResizeExecOptions {
- height: terminal_size.height,
- width: terminal_size.width,
- },
- )
- .await
- .ok();
- }
-
- while let Ok(x) = tty.rx.recv() {
- input.write_all(&[x]).await.ok();
- }
-
- self.internal_cleanup()?;
- }
- }
- _ => {
- return Err(AppError::Terminal);
- }
- }
- }
- Ok(())
- }
-
- /// This is the fix for key pressed not being handled correctly on quit
- /// It writes a special message to the stdout, and then listens out for a valid response
- /// afterwhich it's assumes that we're completely done with TTY
- fn internal_cleanup(&self) -> Result<(), AppError> {
- match self {
- Self::External(_) => Ok(()),
- Self::Internal(_) => {
- let waiting = Arc::new(AtomicBool::new(true));
- let waiting_thread = Arc::clone(&waiting);
-
- std::thread::spawn(move || {
- let mut bytes = Vec::with_capacity(26);
- while waiting_thread.load(std::sync::atomic::Ordering::SeqCst) {
- let mut buf = [0];
- if let Ok(mut f) = std::fs::File::open(TTY) {
- if f.read_exact(&mut buf).is_err() {
- waiting_thread.store(false, std::sync::atomic::Ordering::SeqCst);
- }
- bytes.push(buf[0]);
- if byte_sequence_valid(&bytes) {
- waiting_thread.store(false, std::sync::atomic::Ordering::SeqCst);
- }
- }
- }
- });
-
- let mut stdout = std::io::stdout();
- stdout.write_all(KEYBOARD_PROTO.as_bytes()).ok();
- stdout.flush().ok();
-
- let start = std::time::Instant::now();
- while waiting.load(std::sync::atomic::Ordering::SeqCst) {
- if start.elapsed().as_millis() > 1500 {
- waiting.store(false, std::sync::atomic::Ordering::SeqCst);
- return Err(AppError::Terminal);
- }
- std::thread::sleep(std::time::Duration::from_millis(10));
- }
- Ok(())
- }
- }
- }
-
- pub async fn run(&self, tty_size: Option) -> Result<(), AppError> {
- match self {
- Self::External(id) => {
- Self::exec_external(id);
- Ok(())
- }
-
- Self::Internal((id, docker)) => self.exec_internal(id, docker, tty_size).await,
- }
- }
-}
diff --git a/src/input_handler/message.rs b/src/input_handler/message.rs
deleted file mode 100644
index 1d5ab4a..0000000
--- a/src/input_handler/message.rs
+++ /dev/null
@@ -1,7 +0,0 @@
-use crossterm::event::{KeyCode, KeyModifiers, MouseEvent};
-
-#[derive(Debug, Clone, Copy)]
-pub enum InputMessages {
- ButtonPress((KeyCode, KeyModifiers)),
- MouseEvent((MouseEvent, KeyModifiers)),
-}
diff --git a/src/input_handler/mod.rs b/src/input_handler/mod.rs
deleted file mode 100644
index 4dd5ae3..0000000
--- a/src/input_handler/mod.rs
+++ /dev/null
@@ -1,871 +0,0 @@
-use std::{
- fs::OpenOptions,
- io::{BufWriter, Write},
- sync::{Arc, atomic::AtomicBool},
- time::SystemTime,
-};
-
-use bollard::query_parameters::LogsOptions;
-use cansi::v3::categorise_text;
-use crossterm::{
- event::{DisableMouseCapture, KeyCode, KeyModifiers, MouseButton, MouseEvent, MouseEventKind},
- execute,
-};
-use futures_util::StreamExt;
-use parking_lot::Mutex;
-use ratatui::layout::Rect;
-use tokio::sync::mpsc::{Receiver, Sender};
-use uuid::Uuid;
-
-mod message;
-use crate::{
- app_data::{AppData, DockerCommand, Header, ScrollDirection},
- app_error::AppError,
- config,
- docker_data::DockerMessage,
- exec::{ExecMode, tty_readable},
- ui::{DeleteButton, GuiState, SelectablePanel, Status, Ui},
-};
-pub use message::InputMessages;
-
-/// Handle all input events
-#[derive(Debug)]
-pub struct InputHandler {
- app_data: Arc>,
- docker_tx: Sender,
- keymap: config::Keymap,
- gui_state: Arc>,
- is_running: Arc,
- mouse_capture: bool,
- rx: Receiver,
-}
-
-impl InputHandler {
- /// Initialize self, and running the message handling loop
- pub async fn start(
- app_data: Arc>,
- docker_tx: Sender,
- gui_state: Arc>,
- is_running: Arc,
- rx: Receiver,
- ) {
- let keymap = app_data.lock().config.keymap.clone();
- let mut inner = Self {
- app_data,
- docker_tx,
- gui_state,
- is_running,
- keymap,
- rx,
- mouse_capture: true,
- };
- inner.message_handler().await;
- }
-
- /// check for incoming messages
- async fn message_handler(&mut self) {
- while let Some(message) = self.rx.recv().await {
- match message {
- InputMessages::ButtonPress(key) => self.button_press(key.0, key.1).await,
- InputMessages::MouseEvent((mouse_event, modifider)) => {
- let status = self.gui_state.lock().get_status();
- let contains = |s: Status| status.contains(&s);
-
- if contains(Status::DeleteConfirm) {
- self.button_intersect(mouse_event).await;
- } else if !contains(Status::Error)
- && !contains(Status::Help)
- && !contains(Status::DeleteConfirm)
- && !contains(Status::Filter)
- && !contains(Status::SearchLogs)
- {
- // TODO handle state where you want to scroll log search results with the mouse wheel
- self.mouse_press(mouse_event, modifider);
- }
- }
- }
- }
- }
-
- /// Sort the containers by a given header
- fn sort(&self, selected_header: Header) {
- self.app_data.lock().set_sort_by_header(selected_header);
- }
-
- /// Send a quit message to docker, to abort all spawns, if an error is returned, set is_running to false here instead
- /// If gui_status is Error or Init, then just set the is_running to false immediately, for a quicker exit
- fn quit(&self) {
- let status = self.gui_state.lock().get_status();
- let contains = |s: Status| status.contains(&s);
- if !contains(Status::Error) | !contains(Status::Init) {
- self.is_running
- .store(false, std::sync::atomic::Ordering::SeqCst);
- }
- }
-
- /// This is executed from the Delete Confirm dialog, and will send an internal message to actually remove the given container
- async fn confirm_delete(&self) {
- let id = self.gui_state.lock().get_delete_container();
- if let Some(id) = id {
- self.docker_tx
- .send(DockerMessage::Control((DockerCommand::Delete, id)))
- .await
- .ok();
- }
- }
-
- /// This is executed from the Delete Confirm dialog, and will clear the delete_container information (removes id and closes panel)
- fn clear_delete(&self) {
- self.gui_state.lock().set_delete_container(None);
- }
-
- async fn inspect_key(&self) {
- self.app_data.lock().clear_inspect_data();
- let selected = self.app_data.lock().get_selected_container().cloned();
- if let Some(g) = selected {
- self.docker_tx.send(DockerMessage::Inspect(g.id)).await.ok();
- }
- }
-
- /// Validate that one can exec into a Docker container
- async fn exec_key(&self) {
- let is_oxker = self.app_data.lock().is_oxker();
- if !is_oxker && tty_readable() {
- let uuid = Uuid::new_v4();
- GuiState::start_loading_animation(&self.gui_state, uuid);
- let (sx, rx) = tokio::sync::oneshot::channel();
- self.docker_tx.send(DockerMessage::Exec(sx)).await.ok();
-
- if let Ok(docker) = rx.await {
- (ExecMode::new(&self.app_data, &docker).await).map_or_else(
- || {
- self.app_data.lock().set_error(
- AppError::DockerExec,
- &self.gui_state,
- Status::Error,
- );
- },
- |mode| {
- self.gui_state.lock().set_exec_mode(mode);
- },
- );
- }
- self.gui_state.lock().stop_loading_animation(uuid);
- }
- }
-
- /// Toggle the mouse capture (via input of the 'm' key)
- fn mouse_capture_key(&mut self) {
- let err = || {
- self.app_data.lock().set_error(
- AppError::MouseCapture(!self.mouse_capture),
- &self.gui_state,
- Status::Error,
- );
- };
- if self.mouse_capture {
- if execute!(std::io::stdout(), DisableMouseCapture).is_ok() {
- self.gui_state
- .lock()
- .set_info_box("✖ mouse capture disabled");
- } else {
- err();
- }
- } else if Ui::enable_mouse_capture().is_ok() {
- self.gui_state
- .lock()
- .set_info_box("✓ mouse capture enabled");
- } else {
- err();
- }
-
- self.mouse_capture = !self.mouse_capture;
- }
-
- /// Save the currently selected containers logs into a `[container_name]_[timestamp].log` file
- async fn save_logs(&self) -> Result<(), Box> {
- let args = self.app_data.lock().config.clone();
- let container = self.app_data.lock().get_selected_container_id_state_name();
- if let Some((id, _, name)) = container
- && let Some(log_path) = args.dir_save
- {
- let (sx, rx) = tokio::sync::oneshot::channel();
- self.docker_tx.send(DockerMessage::Exec(sx)).await?;
-
- let now = SystemTime::now()
- .duration_since(SystemTime::UNIX_EPOCH)
- .map_or(0, |i| i.as_secs());
-
- let path = log_path.join(format!("{name}_{now}.log"));
-
- let options = Some(LogsOptions {
- stderr: true,
- stdout: true,
- timestamps: args.show_timestamp,
- since: 0,
- ..Default::default()
- });
- let mut logs = rx.await?.logs(id.get(), options);
- let mut output = vec![];
-
- while let Some(Ok(value)) = logs.next().await {
- let data = value.to_string();
- if !data.trim().is_empty() {
- output.push(
- categorise_text(&data)
- .into_iter()
- .map(|i| i.text)
- .collect::(),
- );
- }
- }
- if !output.is_empty() {
- let mut stream = BufWriter::new(
- OpenOptions::new()
- .read(true)
- .write(true)
- .create(true)
- .truncate(true)
- .open(&path)?,
- );
-
- for line in &output {
- stream.write_all(line.as_bytes())?;
- }
- stream.flush()?;
-
- self.gui_state
- .lock()
- .set_info_box(&format!("saved to {}", path.display()));
- }
- }
- Ok(())
- }
-
- /// Attempt to save the currently selected container logs to a file
- async fn save_key(&self) {
- let status = self.gui_state.lock().get_status();
- let contains = |s: Status| status.contains(&s);
-
- if !contains(Status::Logs) {
- self.gui_state.lock().status_push(Status::Logs);
- let uuid = Uuid::new_v4();
- GuiState::start_loading_animation(&self.gui_state, uuid);
- if self.save_logs().await.is_err() {
- self.app_data.lock().set_error(
- AppError::DockerLogs,
- &self.gui_state,
- Status::Error,
- );
- }
- self.gui_state.lock().status_del(Status::Logs);
- self.gui_state.lock().stop_loading_animation(uuid);
- }
- }
-
- /// Send docker command, if the Commands panel is selected
- async fn enter_key(&self) {
- // This isn't great, just means you can't send docker commands before full initialization of the program
- let panel = self.gui_state.lock().get_selected_panel();
- if panel == SelectablePanel::Commands {
- let option_command = self.app_data.lock().selected_docker_controls();
-
- if let Some(command) = option_command {
- // Poor way of disallowing commands to be sent to a containerised okxer
- if self.app_data.lock().is_oxker_in_container() {
- return;
- }
- let option_id = self.app_data.lock().get_selected_container_id();
- if let Some(id) = option_id {
- match command {
- DockerCommand::Delete => self
- .docker_tx
- .send(DockerMessage::ConfirmDelete(id))
- .await
- .ok(),
-
- _ => self
- .docker_tx
- .send(DockerMessage::Control((command, id)))
- .await
- .ok(),
- };
- }
- }
- }
- }
-
- /// If keymap.scroll_modifier is pressed, return 10, else return 1, to speed up scrolling
- fn get_modifier_total(&self, modifier: KeyModifiers) -> u8 {
- if modifier == self.keymap.scroll_many {
- 10
- } else {
- 1
- }
- }
-
- fn inspect_scroll(&self, modifier: KeyModifiers, sd: &ScrollDirection) {
- for _ in 0..self.get_modifier_total(modifier) {
- self.gui_state.lock().set_inspect_offset(sd);
- }
- }
-
- // fn inspect_scroll(&self, modifier: KeyModifiers, sd: &ScrollDirection) {
- // for _ in 0..self.get_modifier_total(modifier) {
- // self.gui_state.lock().set_inspect_offset(sd);
- // }
- // }
-
- fn logs_horizontal_scroll(&self, modifier: KeyModifiers, sd: &ScrollDirection) {
- let panel = self.gui_state.lock().get_selected_panel();
- if panel == SelectablePanel::Logs {
- for _ in 0..self.get_modifier_total(modifier) {
- let width = self.gui_state.lock().get_screen_width();
- self.app_data.lock().logs_horizontal_scroll(sd, width);
- }
- }
- }
-
- /// Change the the "next" selectable panel
- /// If no containers, and on Commands panel, skip to next panel, as Commands panel isn't visible in this state
- fn next_panel_key(&self) {
- self.gui_state.lock().selectable_panel_next(&self.app_data);
- }
-
- /// Change to previously selected panel
- /// Need to skip the commands planel if there no are current containers running
- fn previous_panel_key(&self) {
- self.gui_state
- .lock()
- .selectable_panel_previous(&self.app_data);
- }
-
- fn scroll_start_key(&self) {
- let selected_panel = self.gui_state.lock().get_selected_panel();
- match selected_panel {
- SelectablePanel::Containers => self.app_data.lock().containers_start(),
- SelectablePanel::Logs => self.app_data.lock().log_start(),
- SelectablePanel::Commands => self.app_data.lock().docker_controls_start(),
- }
- }
-
- /// Go to end of the list of the currently selected panel
- fn scroll_end_key(&self) {
- let selected_panel = self.gui_state.lock().get_selected_panel();
- match selected_panel {
- SelectablePanel::Containers => self.app_data.lock().containers_end(),
- SelectablePanel::Logs => self.app_data.lock().log_end(),
- SelectablePanel::Commands => self.app_data.lock().docker_controls_end(),
- }
- }
-
- /// Actions to take when in Help status active
- fn handle_help(&mut self, key_code: KeyCode) {
- if self.keymap.clear.0 == key_code
- || self.keymap.clear.1 == Some(key_code)
- || self.keymap.toggle_help.0 == key_code
- || self.keymap.toggle_help.1 == Some(key_code)
- {
- self.gui_state.lock().status_del(Status::Help);
- }
-
- if self.keymap.toggle_mouse_capture.0 == key_code
- || self.keymap.toggle_mouse_capture.1 == Some(key_code)
- {
- self.mouse_capture_key();
- }
- }
-
- /// Actions to take when Error status active
- fn handle_error(&self, key_code: KeyCode) {
- if self.keymap.clear.0 == key_code || self.keymap.clear.1 == Some(key_code) {
- self.app_data.lock().remove_error();
- self.gui_state.lock().status_del(Status::Error);
- }
- }
-
- /// Actions to take when Delete status active
- async fn handle_delete(&self, key_code: KeyCode) {
- if self.keymap.delete_confirm.0 == key_code
- || self.keymap.delete_confirm.1 == Some(key_code)
- {
- self.confirm_delete().await;
- } else if self.keymap.delete_deny.0 == key_code
- || self.keymap.delete_deny.1 == Some(key_code)
- || self.keymap.clear.0 == key_code
- || self.keymap.clear.1 == Some(key_code)
- {
- self.clear_delete();
- }
- }
-
- /// Actions to take when Filter status active
- fn handle_search_logs(&self, key_code: KeyCode, modifier: KeyModifiers) {
- match key_code {
- KeyCode::Esc => {
- self.app_data.lock().logs_search_clear();
- self.gui_state.lock().status_del(Status::SearchLogs);
- }
- _ if KeyCode::Enter == key_code
- || self.keymap.log_search_mode.0 == key_code
- || self.keymap.log_search_mode.1 == Some(key_code) =>
- {
- self.gui_state.lock().status_del(Status::SearchLogs);
- }
-
- _ if self.keymap.scroll_back.0 == key_code
- || self.keymap.scroll_back.1 == Some(key_code) =>
- {
- self.logs_horizontal_scroll(modifier, &ScrollDirection::Up);
- }
-
- _ if self.keymap.scroll_forward.0 == key_code
- || self.keymap.scroll_forward.1 == Some(key_code) =>
- {
- self.logs_horizontal_scroll(modifier, &ScrollDirection::Down);
- }
-
- _ if self.keymap.scroll_down.0 == key_code => {
- self.app_data
- .lock()
- .log_search_scroll(&ScrollDirection::Down);
- // TODO should only do this is log_search_scroll returns some
- // Need to wait til app_data and gui_data is combined
- self.gui_state
- .lock()
- .set_logs_panel_selected(&self.app_data);
- //
- }
-
- _ if self.keymap.scroll_up.0 == key_code => {
- self.app_data.lock().log_search_scroll(&ScrollDirection::Up);
- // TODO should only do this is log_search_scroll returns some
- // Need to wait til app_data and gui_data is combined
- self.gui_state
- .lock()
- .set_logs_panel_selected(&self.app_data);
- }
-
- // handle up and down keys
- KeyCode::Backspace => {
- self.app_data.lock().log_search_pop();
- }
- KeyCode::Char(x) => {
- self.app_data.lock().log_search_push(x);
- }
- _ => (),
- }
- }
-
- /// Actions to take when Filter status active
- fn handle_inspect(&mut self, key_code: KeyCode, modifier: KeyModifiers) {
- match key_code {
- _ if self.keymap.inspect.0 == key_code
- || self.keymap.inspect.1 == Some(key_code)
- || self.keymap.clear.0 == key_code
- || self.keymap.clear.1 == Some(key_code) =>
- {
- self.app_data.lock().clear_inspect_data();
- self.gui_state.lock().clear_inspect_offset();
- self.gui_state.lock().status_del(Status::Inspect);
- }
-
- _ if self.keymap.scroll_down.0 == key_code
- || self.keymap.scroll_down.1 == Some(key_code) =>
- {
- self.inspect_scroll(modifier, &ScrollDirection::Down);
- }
-
- _ if self.keymap.scroll_up.0 == key_code
- || self.keymap.scroll_up.1 == Some(key_code) =>
- {
- self.inspect_scroll(modifier, &ScrollDirection::Up);
- }
-
- _ if self.keymap.scroll_forward.0 == key_code
- || self.keymap.scroll_forward.1 == Some(key_code) =>
- {
- self.inspect_scroll(modifier, &ScrollDirection::Right);
- }
-
- _ if self.keymap.scroll_back.0 == key_code
- || self.keymap.scroll_back.1 == Some(key_code) =>
- {
- self.inspect_scroll(modifier, &ScrollDirection::Left);
- }
-
- _ if self.keymap.toggle_mouse_capture.0 == key_code
- || self.keymap.toggle_mouse_capture.1 == Some(key_code) =>
- {
- self.mouse_capture_key();
- }
- _ if self.keymap.scroll_start.0 == key_code
- || self.keymap.scroll_start.1 == Some(key_code) =>
- {
- self.gui_state.lock().clear_inspect_offset();
- }
- _ if self.keymap.scroll_end.0 == key_code
- || self.keymap.scroll_end.1 == Some(key_code) =>
- {
- self.gui_state.lock().set_inspect_offset_y_to_max();
- }
- _ => (),
- }
- }
-
- /// Actions to take when Filter status active
- fn handle_filter(&self, key_code: KeyCode) {
- match key_code {
- KeyCode::Esc => {
- self.app_data.lock().filter_term_clear();
- self.gui_state.lock().status_del(Status::Filter);
- }
- _ if KeyCode::Enter == key_code
- || self.keymap.filter_mode.0 == key_code
- || self.keymap.filter_mode.1 == Some(key_code) =>
- {
- self.gui_state.lock().status_del(Status::Filter);
- }
- KeyCode::Backspace => {
- self.app_data.lock().filter_term_pop();
- }
- KeyCode::Char(x) => {
- self.app_data.lock().filter_term_push(x);
- }
- KeyCode::Right => {
- self.app_data.lock().filter_by_next();
- }
- KeyCode::Left => {
- self.app_data.lock().filter_by_prev();
- }
- _ => (),
- }
- }
-
- /// Handle input that refers to the sorting of columns
- fn handle_sort(&self, key_code: KeyCode) {
- match key_code {
- _ if self.keymap.force_redraw.0 == key_code
- || self.keymap.force_redraw.1 == Some(key_code) =>
- {
- self.gui_state.lock().set_clear();
- }
- _ if self.keymap.sort_reset.0 == key_code
- || self.keymap.sort_reset.1 == Some(key_code) =>
- {
- self.app_data.lock().reset_sorted();
- }
-
- _ if self.keymap.sort_by_name.0 == key_code
- || self.keymap.sort_by_name.1 == Some(key_code) =>
- {
- self.sort(Header::Name);
- }
-
- _ if self.keymap.sort_by_state.0 == key_code
- || self.keymap.sort_by_state.1 == Some(key_code) =>
- {
- self.sort(Header::State);
- }
-
- _ if self.keymap.sort_by_status.0 == key_code
- || self.keymap.sort_by_status.1 == Some(key_code) =>
- {
- self.sort(Header::Status);
- }
-
- _ if self.keymap.sort_by_cpu.0 == key_code
- || self.keymap.sort_by_cpu.1 == Some(key_code) =>
- {
- self.sort(Header::Cpu);
- }
- _ if self.keymap.sort_by_memory.0 == key_code
- || self.keymap.sort_by_memory.1 == Some(key_code) =>
- {
- self.sort(Header::Memory);
- }
- _ if self.keymap.sort_by_id.0 == key_code
- || self.keymap.sort_by_id.1 == Some(key_code) =>
- {
- self.sort(Header::Id);
- }
- _ if self.keymap.sort_by_image.0 == key_code
- || self.keymap.sort_by_image.1 == Some(key_code) =>
- {
- self.sort(Header::Image);
- }
-
- _ if self.keymap.sort_by_rx.0 == key_code
- || self.keymap.sort_by_rx.1 == Some(key_code) =>
- {
- self.sort(Header::Rx);
- }
-
- _ if self.keymap.sort_by_tx.0 == key_code
- || self.keymap.sort_by_tx.1 == Some(key_code) =>
- {
- self.sort(Header::Tx);
- }
- _ => (),
- }
- }
-
- // Increase the log panel height
- fn log_panel_height_increase(&self) {
- self.gui_state.lock().log_height_increase();
- }
-
- // Decrease the log panel height
- fn log_panel_height_decrease(&self) {
- self.gui_state.lock().log_height_decrease();
- }
-
- // Toggle visibility of the log panel
- fn log_panel_toggle(&self) {
- self.gui_state.lock().toggle_show_logs();
- }
-
- /// Handle button presses in all other scenarios
- #[allow(clippy::cognitive_complexity)]
- async fn handle_others(&mut self, key_code: KeyCode, modifier: KeyModifiers) {
- self.handle_sort(key_code);
- // shift key plus arrows
- match key_code {
- _ if self.keymap.exec.0 == key_code || self.keymap.exec.1 == Some(key_code) => {
- self.exec_key().await;
- }
-
- _ if self.keymap.toggle_help.0 == key_code
- || self.keymap.toggle_help.1 == Some(key_code) =>
- {
- self.gui_state.lock().status_push(Status::Help);
- }
-
- _ if self.keymap.toggle_mouse_capture.0 == key_code
- || self.keymap.toggle_mouse_capture.1 == Some(key_code) =>
- {
- self.mouse_capture_key();
- }
- _ if self.keymap.log_section_height_decrease.0 == key_code
- || self.keymap.log_section_height_decrease.1 == Some(key_code) =>
- {
- self.log_panel_height_decrease();
- }
-
- _ if self.keymap.log_section_height_increase.0 == key_code
- || self.keymap.log_section_height_increase.1 == Some(key_code) =>
- {
- self.log_panel_height_increase();
- }
-
- _ if self.keymap.log_section_toggle.0 == key_code
- || self.keymap.log_section_toggle.1 == Some(key_code) =>
- {
- self.log_panel_toggle();
- }
-
- _ if self.keymap.save_logs.0 == key_code
- || self.keymap.save_logs.1 == Some(key_code) =>
- {
- self.save_key().await;
- }
-
- _ if self.keymap.inspect.0 == key_code || self.keymap.inspect.1 == Some(key_code) => {
- self.inspect_key().await;
- }
-
- _ if self.keymap.select_next_panel.0 == key_code
- || self.keymap.select_next_panel.1 == Some(key_code) =>
- {
- self.next_panel_key();
- }
-
- _ if self.keymap.select_previous_panel.0 == key_code
- || self.keymap.select_previous_panel.1 == Some(key_code) =>
- {
- self.previous_panel_key();
- }
-
- _ if self.keymap.scroll_start.0 == key_code
- || self.keymap.scroll_start.1 == Some(key_code) =>
- {
- self.scroll_start_key();
- }
-
- _ if self.keymap.scroll_end.0 == key_code
- || self.keymap.scroll_end.1 == Some(key_code) =>
- {
- self.scroll_end_key();
- }
-
- _ if self.keymap.scroll_up.0 == key_code
- || self.keymap.scroll_up.1 == Some(key_code) =>
- {
- self.scroll(modifier, &ScrollDirection::Up);
- }
-
- _ if self.keymap.scroll_down.0 == key_code
- || self.keymap.scroll_down.1 == Some(key_code) =>
- {
- self.scroll(modifier, &ScrollDirection::Down);
- }
-
- _ if self.keymap.filter_mode.0 == key_code
- || self.keymap.filter_mode.1 == Some(key_code) =>
- {
- self.gui_state.lock().status_push(Status::Filter);
- self.docker_tx.send(DockerMessage::Update).await.ok();
- }
-
- _ if self.keymap.log_search_mode.0 == key_code
- || self.keymap.log_search_mode.1 == Some(key_code) =>
- {
- if !self.gui_state.lock().get_show_logs() {
- self.gui_state.lock().toggle_show_logs();
- }
- self.gui_state.lock().status_push(Status::SearchLogs);
- }
-
- _ if self.keymap.scroll_back.0 == key_code
- || self.keymap.scroll_back.1 == Some(key_code) =>
- {
- self.logs_horizontal_scroll(modifier, &ScrollDirection::Up);
- // self.logs_back(modifier);
- }
-
- _ if self.keymap.scroll_forward.0 == key_code
- || self.keymap.scroll_forward.1 == Some(key_code) =>
- {
- self.logs_horizontal_scroll(modifier, &ScrollDirection::Down);
- }
-
- KeyCode::Enter => self.enter_key().await,
- _ => (),
- }
- }
-
- /// Handle keyboard button events
- async fn button_press(&mut self, key_code: KeyCode, key_modifier: KeyModifiers) {
- let status = self.gui_state.lock().get_status();
- let contains = |s: Status| status.contains(&s);
-
- let contains_error = contains(Status::Error);
- let contains_help = contains(Status::Help);
- let contains_exec = contains(Status::Exec);
- let contains_filter = contains(Status::Filter);
- let contains_delete = contains(Status::DeleteConfirm);
- let contains_search_logs = contains(Status::SearchLogs);
- let contains_inspect = contains(Status::Inspect);
-
- if !contains_exec {
- let is_q = || key_code == self.keymap.quit.0 || Some(key_code) == self.keymap.quit.1;
- if key_modifier == KeyModifiers::CONTROL && key_code == KeyCode::Char('c')
- || is_q() && !contains_filter && !contains_search_logs
- {
- // Always just quit on Ctrl + c/C or q/Q, unless in filter/search_logs mode, i.e. when user inmput can include the q key
- self.quit();
- }
-
- if contains_error {
- self.handle_error(key_code);
- } else if contains_help {
- self.handle_help(key_code);
- } else if contains_filter {
- self.handle_filter(key_code);
- } else if contains_search_logs {
- self.handle_search_logs(key_code, key_modifier);
- } else if contains_delete {
- self.handle_delete(key_code).await;
- } else if contains_inspect {
- self.handle_inspect(key_code, key_modifier);
- } else {
- self.handle_others(key_code, key_modifier).await;
- }
- }
- }
-
- /// Check if a button press interacts with either the yes or no buttons in the delete container confirm window
- async fn button_intersect(&self, mouse_event: MouseEvent) {
- if mouse_event.kind == MouseEventKind::Down(MouseButton::Left) {
- let intersect = self.gui_state.lock().get_intersect_button(Rect::new(
- mouse_event.column,
- mouse_event.row,
- 1,
- 1,
- ));
-
- if let Some(button) = intersect {
- match button {
- DeleteButton::Confirm => self.confirm_delete().await,
- DeleteButton::Cancel => self.clear_delete(),
- }
- }
- }
- }
-
- /// Handle mouse button events
- fn mouse_press(&self, mouse_event: MouseEvent, modifier: KeyModifiers) {
- let status = self.gui_state.lock().get_status();
-
- if status.contains(&Status::Inspect) {
- match mouse_event.kind {
- MouseEventKind::ScrollDown => self.inspect_scroll(modifier, &ScrollDirection::Down),
- MouseEventKind::ScrollUp => self.inspect_scroll(modifier, &ScrollDirection::Up),
- MouseEventKind::ScrollRight => {
- self.inspect_scroll(modifier, &ScrollDirection::Right)
- }
- MouseEventKind::ScrollLeft => self.inspect_scroll(modifier, &ScrollDirection::Left),
- _ => (),
- }
- } else if status.contains(&Status::Help) {
- let mouse_point = Rect::new(mouse_event.column, mouse_event.row, 1, 1);
- let help_intersect = self.gui_state.lock().get_intersect_help(mouse_point);
- if help_intersect {
- self.gui_state.lock().status_del(Status::Help);
- }
- } else {
- match mouse_event.kind {
- MouseEventKind::ScrollUp => self.scroll(modifier, &ScrollDirection::Up),
- MouseEventKind::ScrollDown => self.scroll(modifier, &ScrollDirection::Down),
- // TODO left and right for log offsets
- MouseEventKind::Down(MouseButton::Left) => {
- let mouse_point = Rect::new(mouse_event.column, mouse_event.row, 1, 1);
- let header = self.gui_state.lock().get_intersect_header(mouse_point);
- if let Some(header) = header {
- self.sort(header);
- }
- let help_intersect = self.gui_state.lock().get_intersect_help(mouse_point);
- if help_intersect {
- self.gui_state.lock().status_push(Status::Help);
- }
-
- self.gui_state.lock().check_panel_intersect(mouse_point);
- }
- _ => (),
- }
- }
- }
-
- /// Change state to next, depending which panel is currently in focus
- fn scroll(&self, modifier: KeyModifiers, scroll: &ScrollDirection) {
- let status = self.gui_state.lock().get_status();
- if status.contains(&Status::SearchLogs) {
- self.app_data.lock().log_search_scroll(scroll);
- } else {
- let selected_panel = self.gui_state.lock().get_selected_panel();
- match selected_panel {
- SelectablePanel::Containers => {
- for _ in 0..self.get_modifier_total(modifier) {
- self.app_data.lock().containers_scroll(scroll);
- }
- }
- SelectablePanel::Logs => {
- for _ in 0..self.get_modifier_total(modifier) {
- self.app_data.lock().log_scroll(scroll);
- }
- }
- SelectablePanel::Commands => self.app_data.lock().docker_controls_scroll(scroll),
- }
- }
- }
-}
diff --git a/src/main.rs b/src/main.rs
deleted file mode 100644
index 8ad73f5..0000000
--- a/src/main.rs
+++ /dev/null
@@ -1,269 +0,0 @@
-// #![allow(unused)]
-// Zigbuild is stuck on 1.87.0, which means Mac builds won't work when using collapsible ifs
-
-use app_data::AppData;
-use app_error::AppError;
-use bollard::{API_DEFAULT_VERSION, Docker};
-use config::Config;
-use docker_data::DockerData;
-use input_handler::InputMessages;
-use parking_lot::Mutex;
-use std::{
- process,
- sync::{
- Arc,
- atomic::{AtomicBool, Ordering},
- },
-};
-use tokio::sync::mpsc::{Receiver, Sender};
-use tracing::{Level, error, info};
-
-mod app_data;
-mod app_error;
-mod config;
-mod docker_data;
-mod exec;
-mod input_handler;
-mod ui;
-
-use ui::{GuiState, Rerender, Status, Ui};
-
-use crate::docker_data::DockerMessage;
-
-/// This is the entry point when running as a Docker Container, and is used, in conjunction with the `CONTAINER_ENV` ENV, to check if we are running as a Docker Container
-const ENTRY_POINT: &str = "/app/oxker";
-const ENV_KEY: &str = "OXKER_RUNTIME";
-const ENV_VALUE: &str = "container";
-const DOCKER_HOST: &str = "DOCKER_HOST";
-
-/// Enable tracing, only really used in debug mode, for now
-/// write to file if `-g` is set?
-fn setup_tracing() {
- tracing_subscriber::fmt().with_max_level(Level::INFO).init();
-}
-
-/// Read the optional docker_host path
-/// Bollard will use DOCKER_HOST env, so might be pointless here, although it will fix it's priority over any config setting
-fn read_docker_host(config: &Config) -> Option {
- if let Some(x) = &config.host {
- Some(x.to_string())
- } else if let Ok(env) = std::env::var(DOCKER_HOST)
- && !env.trim().is_empty()
- {
- Some(env)
- } else {
- None
- }
-}
-
-/// Create docker daemon handler, and only spawn up the docker data handler if a ping returns non-error
-async fn docker_init(
- app_data: &Arc>,
- docker_rx: Receiver,
- docker_tx: Sender,
- gui_state: &Arc>,
-) {
- let host = read_docker_host(&app_data.lock().config);
-
- if let Ok(docker) = host
- .as_ref()
- .map_or_else(Docker::connect_with_defaults, |host| {
- Docker::connect_with_socket(host, 120, API_DEFAULT_VERSION)
- })
- && docker.ping().await.is_ok()
- {
- tokio::spawn(DockerData::start(
- Arc::clone(app_data),
- docker,
- docker_rx,
- docker_tx,
- Arc::clone(gui_state),
- ));
- } else {
- app_data.lock().set_error(
- AppError::DockerConnect,
- gui_state,
- Status::DockerConnect(host),
- );
- }
-}
-
-/// Create data for, and then spawn a tokio thread, for the input handler
-fn handler_init(
- app_data: &Arc>,
- docker_sx: &Sender,
- gui_state: &Arc>,
- input_rx: Receiver,
- is_running: &Arc,
-) {
- tokio::spawn(input_handler::InputHandler::start(
- Arc::clone(app_data),
- docker_sx.clone(),
- Arc::clone(gui_state),
- Arc::clone(is_running),
- input_rx,
- ));
-}
-
-#[tokio::main]
-async fn main() {
- setup_tracing();
- let config = config::Config::new();
- let redraw = Arc::new(Rerender::new());
-
- let app_data = Arc::new(Mutex::new(AppData::new(config.clone(), &redraw)));
- let gui_state = Arc::new(Mutex::new(GuiState::new(&redraw, config.show_logs)));
- let is_running = Arc::new(AtomicBool::new(true));
- let (docker_tx, docker_rx) = tokio::sync::mpsc::channel(32);
-
- docker_init(&app_data, docker_rx, docker_tx.clone(), &gui_state).await;
-
- if config.gui {
- let (input_tx, input_rx) = tokio::sync::mpsc::channel(32);
- handler_init(&app_data, &docker_tx, &gui_state, input_rx, &is_running);
- Ui::start(app_data, gui_state, input_tx, is_running, redraw).await;
- } else {
- info!("in debug mode\n");
- let mut now = std::time::Instant::now();
- // Debug mode for testing, less pointless now, will display some basic information
- while is_running.load(Ordering::SeqCst) {
- let err = app_data.lock().get_error();
- if let Some(err) = err {
- error!("{}", err);
- process::exit(1);
- }
- if let Some(Ok(to_sleep)) = u128::from(config.docker_interval_ms)
- .checked_sub(now.elapsed().as_millis())
- .map(u64::try_from)
- {
- tokio::time::sleep(std::time::Duration::from_millis(to_sleep)).await;
- }
- let containers = app_data
- .lock()
- .get_container_items()
- .iter()
- .map(|i| format!("{i}"))
- .collect::>();
-
- if !containers.is_empty() {
- for item in containers {
- info!("{item}");
- }
- println!();
- }
- now = std::time::Instant::now();
- }
- }
-}
-
-#[cfg(test)]
-#[allow(clippy::unwrap_used)]
-mod tests {
-
- use std::{str::FromStr, sync::Arc};
-
- use bollard::service::{ContainerSummary, PortSummary};
-
- use crate::{
- app_data::{
- AppData, ContainerId, ContainerItem, ContainerPorts, ContainerStatus, Filter,
- RunningState, State, StatefulList,
- },
- config::{AppColors, Config, Keymap},
- ui::Rerender,
- };
-
- /// Default test config, has timestamps turned off
- pub fn gen_config() -> Config {
- Config {
- app_colors: AppColors::new(),
- color_logs: false,
- dir_save: None,
- dir_config: None,
- docker_interval_ms: 1000,
- gui: true,
- host: None,
- in_container: false,
- keymap: Keymap::new(),
- log_search_case_sensitive: true,
- raw_logs: false,
- show_logs: true,
- show_self: false,
- show_std_err: false,
- show_timestamp: false,
- timestamp_format: "HH:MM:SS.NNNNN dd-mm-yyyy".to_owned(),
- timezone: None,
- use_cli: false,
- }
- }
-
- pub fn gen_item(id: &ContainerId, index: usize) -> ContainerItem {
- ContainerItem::new(
- u64::try_from(index).unwrap(),
- id.clone(),
- format!("image_{index}"),
- false,
- format!("container_{index}"),
- vec![ContainerPorts {
- ip: None,
- private: u16::try_from(index).unwrap_or(1) + 8000,
- public: None,
- }],
- State::Running(RunningState::Healthy),
- ContainerStatus::from(format!("Up {index} hour")),
- )
- }
-
- pub fn gen_appdata(containers: &[ContainerItem]) -> AppData {
- AppData {
- containers: StatefulList::new(containers.to_vec()),
- hidden_containers: vec![],
- current_sorted_id: vec![],
- inspect_data: None,
- error: None,
- sorted_by: None,
- rerender: Arc::new(Rerender::new()),
- filter: Filter::new(),
- config: gen_config(),
- }
- }
-
- pub fn gen_containers() -> (Vec, Vec) {
- let ids = (1..=3)
- .map(|i| ContainerId::from(format!("{i}").as_str()))
- .collect::>();
- let containers = ids
- .iter()
- .enumerate()
- .map(|(index, id)| gen_item(id, index + 1))
- .collect::>();
- (ids, containers)
- }
-
- pub fn gen_container_summary(index: usize, state: &str) -> ContainerSummary {
- ContainerSummary {
- image_manifest_descriptor: None,
- health: None,
- id: Some(format!("{index}")),
- names: Some(vec![format!("container_{}", index)]),
- image: Some(format!("image_{index}")),
- image_id: Some(format!("{index}")),
- command: None,
- created: Some(i64::try_from(index).unwrap()),
- ports: Some(vec![PortSummary {
- ip: None,
- private_port: u16::try_from(index).unwrap_or(1) + 8000,
- public_port: None,
- typ: None,
- }]),
- size_rw: None,
- size_root_fs: None,
- labels: None,
- state: Some(bollard::secret::ContainerSummaryStateEnum::from_str(state).unwrap()),
- status: Some(format!("Up {index} hour")),
- host_config: None,
- network_settings: None,
- mounts: None,
- }
- }
-}
diff --git a/src/ui/color_match.rs b/src/ui/color_match.rs
deleted file mode 100644
index b54d63a..0000000
--- a/src/ui/color_match.rs
+++ /dev/null
@@ -1,157 +0,0 @@
-pub mod log_sanitizer {
-
- use cansi::{Color as CansiColor, Intensity, v3::categorise_text};
- use ratatui::{
- style::{Color, Modifier, Style},
- text::{Line, Span},
- };
-
- /// Attempt to colorize the given string to ratatui standards
- pub fn colorize_logs<'a>(input: &str) -> Vec> {
- vec![Line::from(
- categorise_text(input)
- .iter()
- .map(|i| {
- let mut style = Style::default()
- .bg(color_ansi_to_tui(i.bg.unwrap_or(CansiColor::Black)))
- .fg(color_ansi_to_tui(i.fg.unwrap_or(CansiColor::White)));
- if i.blink.is_some() {
- style = style.add_modifier(Modifier::SLOW_BLINK);
- }
- if i.underline.is_some() {
- style = style.add_modifier(Modifier::UNDERLINED);
- }
- if i.reversed.is_some() {
- style = style.add_modifier(Modifier::REVERSED);
- }
- if i.intensity == Some(Intensity::Bold) {
- style = style.add_modifier(Modifier::BOLD);
- }
- if i.hidden.is_some() {
- style = style.add_modifier(Modifier::HIDDEN);
- }
- if i.strikethrough.is_some() {
- style = style.add_modifier(Modifier::CROSSED_OUT);
- }
- Span::styled(i.text.to_owned(), style)
- })
- .collect::>(),
- )]
- }
-
- /// Remove all ansi formatting from a given string and create ratatui Lines
- pub fn remove_ansi<'a>(input: &str) -> Vec> {
- vec
-
-