init commit
This commit is contained in:
Jack Wills
@@ -0,0 +1,9 @@
|
|||||||
|
# See here for image contents: https://github.com/microsoft/vscode-dev-containers/tree/v0.217.4/containers/rust/.devcontainer/base.Dockerfile
|
||||||
|
|
||||||
|
# [Choice] Debian OS version (use bullseye on local arm64/Apple Silicon): buster, bullseye
|
||||||
|
ARG VARIANT="buster"
|
||||||
|
FROM mcr.microsoft.com/vscode/devcontainers/rust:0-${VARIANT}
|
||||||
|
|
||||||
|
RUN printf "alias cls='clear'\nalias ll='ls -l --human-readable --color=auto --group-directories-first --classify --time-style=long-iso -all'" >> /etc/bash.bashrc
|
||||||
|
|
||||||
|
RUN apt-get update && apt-get -y install upx-ucl
|
||||||
@@ -0,0 +1,58 @@
|
|||||||
|
// For format details, see https://aka.ms/devcontainer.json. For config options, see the README at:
|
||||||
|
// https://github.com/microsoft/vscode-dev-containers/tree/v0.217.4/containers/rust
|
||||||
|
{
|
||||||
|
"name": "Rust",
|
||||||
|
"build": {
|
||||||
|
"dockerfile": "Dockerfile",
|
||||||
|
"args": {
|
||||||
|
// Use the VARIANT arg to pick a Debian OS version: buster, bullseye
|
||||||
|
// Use bullseye when on local on arm64/Apple Silicon.
|
||||||
|
"VARIANT": "bullseye"
|
||||||
|
}
|
||||||
|
},
|
||||||
|
"runArgs": [
|
||||||
|
"--cap-add=SYS_PTRACE",
|
||||||
|
"--security-opt",
|
||||||
|
"seccomp=unconfined",
|
||||||
|
],
|
||||||
|
|
||||||
|
"mounts": [
|
||||||
|
"source=/etc/timezone,target=/etc/timezone,type=bind,readonly",
|
||||||
|
"source=/ramdrive,target=/ramdrive,type=bind",
|
||||||
|
"source=${localEnv:HOME}/.ssh,target=/home/vscode/.ssh,type=bind,readonly",
|
||||||
|
"source=${localEnv:HOME}/.cargo/bin/cargo-watch,target=/usr/local/cargo/bin/cargo-watch,type=bind,readonly",
|
||||||
|
"source=${localEnv:HOME}/.cargo/bin/cross,target=/usr/local/cargo/bin/cross,type=bind,readonly",
|
||||||
|
],
|
||||||
|
|
||||||
|
// Set *default* container specific settings.json values on container create.
|
||||||
|
"settings": {
|
||||||
|
"lldb.executable": "/usr/bin/lldb",
|
||||||
|
// VS Code don't watch files under ./target
|
||||||
|
"files.watcherExclude": {
|
||||||
|
"**/target/**": true
|
||||||
|
},
|
||||||
|
"rust-analyzer.checkOnSave.command": "clippy"
|
||||||
|
},
|
||||||
|
|
||||||
|
// Add the IDs of extensions you want installed when the container is created.
|
||||||
|
"extensions": [
|
||||||
|
"vadimcn.vscode-lldb",
|
||||||
|
"mutantdino.resourcemonitor",
|
||||||
|
"matklad.rust-analyzer",
|
||||||
|
"tamasfe.even-better-toml",
|
||||||
|
"serayuzgur.crates",
|
||||||
|
"christian-kohler.path-intellisense",
|
||||||
|
"timonwong.shellcheck",
|
||||||
|
"ms-vscode.live-server",
|
||||||
|
"rangav.vscode-thunder-client",
|
||||||
|
"bmuskalla.vscode-tldr"
|
||||||
|
],
|
||||||
|
|
||||||
|
|
||||||
|
// Comment out to connect as root instead. More info: https://aka.ms/vscode-remote/containers/non-root.
|
||||||
|
"remoteUser": "vscode",
|
||||||
|
"features": {
|
||||||
|
"docker-in-docker": "latest",
|
||||||
|
"git": "os-provided"
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,4 @@
|
|||||||
|
*.sh eol=lf
|
||||||
|
*.md eol=CRLF
|
||||||
|
*.txt eol=lf
|
||||||
|
|
||||||
@@ -0,0 +1,30 @@
|
|||||||
|
---
|
||||||
|
name: Bug report
|
||||||
|
about: Create a report to help us improve
|
||||||
|
title: "[BUG] "
|
||||||
|
labels: bug
|
||||||
|
assignees: ''
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
**Describe the bug**
|
||||||
|
A clear and concise description of what the bug is.
|
||||||
|
|
||||||
|
**To Reproduce**
|
||||||
|
Steps to reproduce the behavior:
|
||||||
|
1. Go to '...'
|
||||||
|
2. Click on '....'
|
||||||
|
3. Scroll down to '....'
|
||||||
|
4. See error
|
||||||
|
|
||||||
|
**Expected behavior**
|
||||||
|
A clear and concise description of what you expected to happen.
|
||||||
|
|
||||||
|
**Screenshots**
|
||||||
|
If applicable, add screenshots to help explain your problem.
|
||||||
|
|
||||||
|
**Desktop (please complete the following information):**
|
||||||
|
- OS: [e.g. windows 11]
|
||||||
|
|
||||||
|
**Additional context**
|
||||||
|
Add any other context about the problem here.
|
||||||
@@ -0,0 +1,20 @@
|
|||||||
|
---
|
||||||
|
name: New Feature
|
||||||
|
about: Suggest an idea for this project
|
||||||
|
title: "[NEW FEATURE] "
|
||||||
|
labels: 'new feature'
|
||||||
|
assignees: ''
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
**Is your feature request related to a problem? Please describe.**
|
||||||
|
A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
|
||||||
|
|
||||||
|
**Describe the solution you'd like**
|
||||||
|
A clear and concise description of what you want to happen.
|
||||||
|
|
||||||
|
**Describe alternatives you've considered**
|
||||||
|
A clear and concise description of any alternative solutions or features you've considered.
|
||||||
|
|
||||||
|
**Additional context**
|
||||||
|
Add any other context or screenshots about the feature request here.
|
||||||
@@ -0,0 +1,20 @@
|
|||||||
|
---
|
||||||
|
name: Refactor
|
||||||
|
about: Refactor a component
|
||||||
|
title: "[REFACTOR] "
|
||||||
|
labels: 'refactor'
|
||||||
|
assignees: ''
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
**Component to refactor.**
|
||||||
|
What component(s) needs to be refactored?
|
||||||
|
|
||||||
|
**Describe the solution you'd like**
|
||||||
|
A clear and concise description of what you want to happen.
|
||||||
|
|
||||||
|
**Describe alternatives you've considered**
|
||||||
|
A clear and concise description of any alternative solutions or features you've considered.
|
||||||
|
|
||||||
|
**Additional context**
|
||||||
|
Add any other context or screenshots about the feature request here.
|
||||||
File diff suppressed because one or more lines are too long
|
After Width: | Height: | Size: 19 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 179 KiB |
@@ -0,0 +1,88 @@
|
|||||||
|
name: Release CI
|
||||||
|
on:
|
||||||
|
push:
|
||||||
|
tags:
|
||||||
|
- 'v*.*.*'
|
||||||
|
jobs:
|
||||||
|
deploy:
|
||||||
|
runs-on: ubuntu-18.04
|
||||||
|
steps:
|
||||||
|
- uses: actions/checkout@master
|
||||||
|
|
||||||
|
# cache some rust data?
|
||||||
|
- uses: actions/cache@v2
|
||||||
|
with:
|
||||||
|
path: |
|
||||||
|
~/.cargo/registry
|
||||||
|
~/.cargo/git
|
||||||
|
target
|
||||||
|
key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
|
||||||
|
|
||||||
|
# Build for linux x86_64
|
||||||
|
- name: build release linux_x86_64
|
||||||
|
uses: actions-rs/cargo@v1
|
||||||
|
with:
|
||||||
|
command: build
|
||||||
|
args: --release
|
||||||
|
- name: compress oxker_linux_x86_64 binary
|
||||||
|
run: tar -C target/release -czf ./oxker_linux_x86_64.tar.gz oxker
|
||||||
|
|
||||||
|
# Build for linux aarch64, aka 64 bit pi 4
|
||||||
|
- name: build release armv7
|
||||||
|
uses: actions-rs/toolchain@v1
|
||||||
|
with:
|
||||||
|
toolchain: stable
|
||||||
|
target: aarch64-unknown-linux-musl
|
||||||
|
override: true
|
||||||
|
- uses: actions-rs/cargo@v1
|
||||||
|
with:
|
||||||
|
use-cross: true
|
||||||
|
command: build
|
||||||
|
args: --target aarch64-unknown-linux-musl --release
|
||||||
|
- name: compress aarch64 binary
|
||||||
|
run: tar -C target/aarch64-unknown-linux-musl/release -czf ./oxker_linux_aarch64.tar.gz oxker
|
||||||
|
|
||||||
|
# Build for linux armv6, aka 32 bit pi zero w
|
||||||
|
- name: build release armv6
|
||||||
|
uses: actions-rs/toolchain@v1
|
||||||
|
with:
|
||||||
|
toolchain: stable
|
||||||
|
target: arm-unknown-linux-musleabihf
|
||||||
|
override: true
|
||||||
|
- uses: actions-rs/cargo@v1
|
||||||
|
with:
|
||||||
|
use-cross: true
|
||||||
|
command: build
|
||||||
|
args: --target arm-unknown-linux-musleabihf --release
|
||||||
|
- name: compress armv6 binary
|
||||||
|
run: tar -C target/arm-unknown-linux-musleabihf/release -czf ./oxker_linux_armv6.tar.gz oxker
|
||||||
|
|
||||||
|
# Build for windows
|
||||||
|
- name: build release windows_x86_64
|
||||||
|
uses: actions-rs/toolchain@v1
|
||||||
|
with:
|
||||||
|
toolchain: stable
|
||||||
|
target: x86_64-pc-windows-gnu
|
||||||
|
override: true
|
||||||
|
- uses: actions-rs/cargo@v1
|
||||||
|
with:
|
||||||
|
use-cross: true
|
||||||
|
command: build
|
||||||
|
args: --target x86_64-pc-windows-gnu --release
|
||||||
|
- name: compress windows_x86_64 binary
|
||||||
|
run: zip -j ./oxker_windows_x86_64.zip target/x86_64-pc-windows-gnu/release/oxker.exe
|
||||||
|
|
||||||
|
- name: Release
|
||||||
|
uses: softprops/action-gh-release@v1
|
||||||
|
with:
|
||||||
|
tag_name: ${{ github.ref }}
|
||||||
|
name: ${{ github.ref_name }}
|
||||||
|
body_path: ".github/release-body.md"
|
||||||
|
draft: false
|
||||||
|
files: |
|
||||||
|
oxker_linux_x86_64.tar.gz
|
||||||
|
oxker_linux_aarch64.tar.gz
|
||||||
|
oxker_linux_armv6.tar.gz
|
||||||
|
oxker_windows_x86_64.zip
|
||||||
|
env:
|
||||||
|
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
|
||||||
@@ -0,0 +1,3 @@
|
|||||||
|
/target
|
||||||
|
/releases
|
||||||
|
Cargo.lock
|
||||||
@@ -0,0 +1 @@
|
|||||||
|
+ init commit
|
||||||
+33
@@ -0,0 +1,33 @@
|
|||||||
|
[package]
|
||||||
|
name = "oxker"
|
||||||
|
version = "0.0.1"
|
||||||
|
edition = "2021"
|
||||||
|
authors = ["Jack Wills <email@mrjackwills.com>"]
|
||||||
|
description = "a simple tui to view & control docker containers"
|
||||||
|
repository = "https://github.com/mrjackwills/oxker"
|
||||||
|
license = "MIT"
|
||||||
|
readme = "README.md"
|
||||||
|
|
||||||
|
[dependencies]
|
||||||
|
anyhow = "1.0"
|
||||||
|
bollard = "0.12.0"
|
||||||
|
cansi = "2.1.1"
|
||||||
|
clap={version="3.1.0", features = ["derive", "unicode"] }
|
||||||
|
crossterm = "0.23.2"
|
||||||
|
futures-util = "0.3.21"
|
||||||
|
parking_lot = {version= "0.12.0"}
|
||||||
|
tokio = {version = "1.17.0", features=["full"]}
|
||||||
|
tracing = "0.1.32"
|
||||||
|
tracing-subscriber = "0.3.9"
|
||||||
|
tui = "0.17"
|
||||||
|
|
||||||
|
[dev-dependencies]
|
||||||
|
|
||||||
|
[profile.release]
|
||||||
|
lto = true
|
||||||
|
codegen-units = 1
|
||||||
|
panic = 'abort'
|
||||||
|
strip=true
|
||||||
|
debug = false
|
||||||
|
|
||||||
|
|
||||||
@@ -0,0 +1,21 @@
|
|||||||
|
MIT License
|
||||||
|
|
||||||
|
Copyright (c) 2022 Jack Wills
|
||||||
|
|
||||||
|
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||||
|
of this software and associated documentation files (the "Software"), to deal
|
||||||
|
in the Software without restriction, including without limitation the rights
|
||||||
|
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||||
|
copies of the Software, and to permit persons to whom the Software is
|
||||||
|
furnished to do so, subject to the following conditions:
|
||||||
|
|
||||||
|
The above copyright notice and this permission notice shall be included in all
|
||||||
|
copies or substantial portions of the Software.
|
||||||
|
|
||||||
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||||
|
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||||
|
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||||
|
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||||
|
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||||
|
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||||
|
SOFTWARE.
|
||||||
@@ -0,0 +1,91 @@
|
|||||||
|
<p align="center">
|
||||||
|
<img src='./.github/logo.svg' width='200px'/>
|
||||||
|
</p>
|
||||||
|
|
||||||
|
<p align="center">
|
||||||
|
<h1 align="center">oxker</h1>
|
||||||
|
</p>
|
||||||
|
|
||||||
|
<p align="center">
|
||||||
|
A simple tui to view and control docker containers"
|
||||||
|
</p>
|
||||||
|
|
||||||
|
<p align="center">
|
||||||
|
Built in <a href='https://www.rust-lang.org/' target='_blank' rel='noopener noreferrer'>Rust</a>, making heavy use of <a href='https://github.com/fdehau/tui-rs' target='_blank' rel='noopener noreferrer'>tui-rs</a> & <a href='https://github.com/fussybeaver/bollard' target='_blank' rel='noopener noreferrer'>Bollard</a>
|
||||||
|
</p>
|
||||||
|
|
||||||
|
<p align="center">
|
||||||
|
<a href="https://raw.githubusercontent.com/mrjackwills/oxker/main/.github/screenshot_01.jpg" target='_blank' rel='noopener noreferrer'>
|
||||||
|
<img src='./.github/screenshot_01.jpg' width='100%'/>
|
||||||
|
</a>
|
||||||
|
</p>
|
||||||
|
|
||||||
|
|
||||||
|
## Download
|
||||||
|
|
||||||
|
See <a href="https://github.com/mrjackwills/oxker/releases" target='_blank' rel='noopener noreferrer'>releases</a>
|
||||||
|
|
||||||
|
|
||||||
|
## Run
|
||||||
|
|
||||||
|
```./oxker```
|
||||||
|
|
||||||
|
available command line arguments
|
||||||
|
| argument|result|
|
||||||
|
|--|--|
|
||||||
|
|```-d [number > 0]```| set the update interval for docker information, is ms |
|
||||||
|
|```-r```| Show raw logs, by default oxker will remove ANSI formatting (conflicts with -c) |
|
||||||
|
|```-c```| Attempt to color the logs (conflicts with -r) |
|
||||||
|
|```-t```| Remove timestamps from each log entry |
|
||||||
|
|```-g```| No tui, basically a pointless debugging mode, for now |
|
||||||
|
|
||||||
|
## Build step
|
||||||
|
|
||||||
|
### x86_64
|
||||||
|
|
||||||
|
```cargo build --release```
|
||||||
|
|
||||||
|
### Raspberry pi
|
||||||
|
|
||||||
|
requires docker & <a href='https://github.com/cross-rs/cross' target='_blank' rel='noopener noreferrer'>cross-rs</a>
|
||||||
|
|
||||||
|
|
||||||
|
#### 64bit pi (pi 4, pi zero w 2)
|
||||||
|
|
||||||
|
```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
|
||||||
|
|
||||||
|
```cross build --target arm-unknown-linux-musleabihf --release```
|
||||||
|
|
||||||
|
If no memory information available, try appending ```/boot/cmdline.txt``` with
|
||||||
|
|
||||||
|
```cgroup_enable=cpuset cgroup_enable=memory```
|
||||||
|
|
||||||
|
see <a href="https://forums.raspberrypi.com/viewtopic.php?t=203128" target='_blank' rel='noopener noreferrer'>https://forums.raspberrypi.com/viewtopic.php?t=203128</a> and <a href="https://github.com/docker/for-linux/issues/1112" target='_blank' rel='noopener noreferrer'>https://github.com/docker/for-linux/issues/1112</a>
|
||||||
|
|
||||||
|
### Compress executable
|
||||||
|
|
||||||
|
compress output from \~3mb to ~1mb
|
||||||
|
|
||||||
|
```upx --best --lzma target/release/oxker -o ./oxker```
|
||||||
|
|
||||||
|
### Untested on other platforms
|
||||||
|
|
||||||
|
## Tests
|
||||||
|
|
||||||
|
As of yet untested, needs work
|
||||||
|
|
||||||
|
```cargo test -- --test-threads=1```
|
||||||
|
|
||||||
|
Run some example docker images
|
||||||
|
|
||||||
|
```docker run --name redis -d redis:alpine3.15```
|
||||||
|
|
||||||
|
```docker run --name postgres -e POSTGRES_PASSWORD=never_use_this_password_in_production -d postgres:alpine```
|
||||||
|
|
||||||
|
```docker run -d --hostname my-rabbit --name rabbitmq rabbitmq:3```
|
||||||
|
|
||||||
|
|
||||||
Executable
+248
@@ -0,0 +1,248 @@
|
|||||||
|
#!/bin/bash
|
||||||
|
|
||||||
|
# rust create_release
|
||||||
|
# v0.0.14
|
||||||
|
|
||||||
|
PACKAGE_NAME='oxker'
|
||||||
|
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
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
if [ -z "$PACKAGE_NAME" ]
|
||||||
|
then
|
||||||
|
error_close "No package name"
|
||||||
|
fi
|
||||||
|
|
||||||
|
# $1 string - question to ask
|
||||||
|
ask_yn () {
|
||||||
|
printf "%b%s? [y/N]:%b " "${GREEN}" "$1" "${RESET}"
|
||||||
|
}
|
||||||
|
|
||||||
|
# return user input
|
||||||
|
user_input() {
|
||||||
|
read -r data
|
||||||
|
echo "$data"
|
||||||
|
}
|
||||||
|
|
||||||
|
update_major () {
|
||||||
|
local bumped_major
|
||||||
|
bumped_major=$((MAJOR + 1))
|
||||||
|
echo "${bumped_major}.0.0"
|
||||||
|
}
|
||||||
|
|
||||||
|
update_minor () {
|
||||||
|
local bumped_minor
|
||||||
|
bumped_minor=$((MINOR + 1))
|
||||||
|
echo "${MAJOR}.${bumped_minor}.0"
|
||||||
|
}
|
||||||
|
|
||||||
|
update_patch () {
|
||||||
|
local bumped_patch
|
||||||
|
bumped_patch=$((PATCH + 1))
|
||||||
|
echo "${MAJOR}.${MINOR}.${bumped_patch}"
|
||||||
|
}
|
||||||
|
|
||||||
|
# Get the url of the github repo, strip .git from the end of it
|
||||||
|
get_git_remote_url() {
|
||||||
|
REMOTE_ORIGIN=$(git config --get remote.origin.url)
|
||||||
|
TO_REMOVE=".git"
|
||||||
|
GIT_REPO_URL="${REMOTE_ORIGIN//$TO_REMOVE}"
|
||||||
|
}
|
||||||
|
|
||||||
|
# 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 '/# <a href=/Q' CHANGELOG.md)
|
||||||
|
printf "%s" "$RELEASE_BODY_TEXT"
|
||||||
|
printf "\n%s\n" "${STAR_LINE}"
|
||||||
|
ask_yn "accept release body"
|
||||||
|
if [[ "$(user_input)" =~ ^y$ ]]
|
||||||
|
then
|
||||||
|
update_release_body_and_changelog "$RELEASE_BODY_TEXT"
|
||||||
|
else
|
||||||
|
exit
|
||||||
|
fi
|
||||||
|
}
|
||||||
|
|
||||||
|
# Edit the release-body to include new liens from changelog
|
||||||
|
# add commit urls to changelog
|
||||||
|
# $1 RELEASE_BODY
|
||||||
|
update_release_body_and_changelog () {
|
||||||
|
echo -e
|
||||||
|
DATE_SUBHEADING="### $(date +'%Y-%m-%d')\n\n"
|
||||||
|
RELEASE_BODY_ADDITION="${DATE_SUBHEADING}$1"
|
||||||
|
echo -e "${RELEASE_BODY_ADDITION}\n\nsee <a href='${GIT_REPO_URL}/blob/main/CHANGELOG.md'>CHANGELOG.md</a> for more details" > .github/release-body.md
|
||||||
|
echo -e "# <a href='${GIT_REPO_URL}/releases/tag/${NEW_TAG_VERSION}'>${NEW_TAG_VERSION}</a>\n${DATE_SUBHEADING}${CHANGELOG_ADDITION}$(cat CHANGELOG.md)" > CHANGELOG.md
|
||||||
|
sed -i -E "s=(\s)\[([0-9a-f]{40})\](\n|\s|\,|\r)= [\2](${GIT_REPO_URL}/commit/\2),=g" ./CHANGELOG.md
|
||||||
|
}
|
||||||
|
|
||||||
|
# update version in cargo.toml, to match selected current version/tag
|
||||||
|
update_cargo_toml () {
|
||||||
|
sed -i "s|^version = .*|version = \"${NEW_TAG_VERSION:1}\"|" Cargo.toml
|
||||||
|
}
|
||||||
|
|
||||||
|
# Work out the current version, based on git tags
|
||||||
|
# create new semver version based on user input
|
||||||
|
check_tag () {
|
||||||
|
LATEST_TAG=$(git describe --tags --abbrev=0 --always)
|
||||||
|
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
|
||||||
|
MAJOR_TAG=v$(update_major)
|
||||||
|
MINOR_TAG=v$(update_minor)
|
||||||
|
PATCH_TAG=v$(update_patch)
|
||||||
|
OP_MAJOR="major___$MAJOR_TAG"
|
||||||
|
OP_MINOR="minor___$MINOR_TAG"
|
||||||
|
OP_PATCH="patch___$PATCH_TAG"
|
||||||
|
OPTIONS=("$OP_MAJOR" "$OP_MINOR" "$OP_PATCH")
|
||||||
|
select choice in "${OPTIONS[@]}"
|
||||||
|
do
|
||||||
|
case $choice in
|
||||||
|
"$OP_MAJOR" )
|
||||||
|
NEW_TAG_VERSION="$MAJOR_TAG"
|
||||||
|
break;;
|
||||||
|
"$OP_MINOR")
|
||||||
|
NEW_TAG_VERSION="$MINOR_TAG"
|
||||||
|
break;;
|
||||||
|
"$OP_PATCH")
|
||||||
|
NEW_TAG_VERSION="$PATCH_TAG"
|
||||||
|
break;;
|
||||||
|
*)
|
||||||
|
error_close "invalid option $REPLY"
|
||||||
|
break;;
|
||||||
|
esac
|
||||||
|
done
|
||||||
|
}
|
||||||
|
|
||||||
|
# ask continue, or quit
|
||||||
|
ask_continue () {
|
||||||
|
ask_yn "continue"
|
||||||
|
if [[ ! "$(user_input)" =~ ^y$ ]]
|
||||||
|
then
|
||||||
|
exit
|
||||||
|
fi
|
||||||
|
}
|
||||||
|
|
||||||
|
# run all tests
|
||||||
|
cargo_test () {
|
||||||
|
cargo test -- --test-threads=1
|
||||||
|
ask_continue
|
||||||
|
}
|
||||||
|
|
||||||
|
# Build for linux, pi 32, pi 64, and windows
|
||||||
|
cargo_build_all() {
|
||||||
|
cargo build --release
|
||||||
|
cross build --target aarch64-unknown-linux-musl --release
|
||||||
|
cross build --target arm-unknown-linux-musleabihf --release
|
||||||
|
cross build --target x86_64-pc-windows-gnu --release
|
||||||
|
tar -C target/arm-unknown-linux-musleabihf/release -czf ./releases/oxker_linux_armv6.tar.gz oxker
|
||||||
|
tar -C target/aarch64-unknown-linux-musl/release -czf ./releases/oxker_linux_aarch64.tar.gz oxker
|
||||||
|
zip -j ./releases/oxker_windows_x86_64.zip target/x86_64-pc-windows-gnu/release/oxker.exe
|
||||||
|
tar -C target/release -czf ./releases/oxker_linux_x86_64.tar.gz oxker
|
||||||
|
}
|
||||||
|
|
||||||
|
# Full flow to create a new release
|
||||||
|
release_flow() {
|
||||||
|
check_git
|
||||||
|
get_git_remote_url
|
||||||
|
cargo_test
|
||||||
|
cd "${CWD}" || error_close "Can't find ${CWD}"
|
||||||
|
check_tag
|
||||||
|
printf "\nnew tag chosen: %s\n\n" "${NEW_TAG_VERSION}"
|
||||||
|
RELEASE_BRANCH=release-$NEW_TAG_VERSION
|
||||||
|
echo -e
|
||||||
|
ask_changelog_update
|
||||||
|
git checkout -b "$RELEASE_BRANCH"
|
||||||
|
update_cargo_toml
|
||||||
|
git add .
|
||||||
|
git commit -m "chore: release $NEW_TAG_VERSION"
|
||||||
|
git checkout main
|
||||||
|
git merge --no-ff "$RELEASE_BRANCH" -m "chore: merge ${RELEASE_BRANCH} into main"
|
||||||
|
git tag -am "${RELEASE_BRANCH}" "$NEW_TAG_VERSION"
|
||||||
|
echo "git tag -am \"${RELEASE_BRANCH}\" \"$NEW_TAG_VERSION\""
|
||||||
|
git push --atomic origin main "$NEW_TAG_VERSION"
|
||||||
|
git checkout dev
|
||||||
|
git merge --no-ff main -m 'chore: merge main into dev'
|
||||||
|
git branch -d "$RELEASE_BRANCH"
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
main() {
|
||||||
|
cmd=(dialog --backtitle "Choose build option" --radiolist "choose" 14 80 16)
|
||||||
|
options=(
|
||||||
|
1 "fmt" off
|
||||||
|
2 "build" off
|
||||||
|
3 "test" off
|
||||||
|
4 "release" off
|
||||||
|
)
|
||||||
|
choices=$("${cmd[@]}" "${options[@]}" 2>&1 >/dev/tty)
|
||||||
|
exitStatus=$?
|
||||||
|
clear
|
||||||
|
if [ $exitStatus -ne 0 ]; then
|
||||||
|
exit
|
||||||
|
fi
|
||||||
|
for choice in $choices
|
||||||
|
do
|
||||||
|
case $choice in
|
||||||
|
0)
|
||||||
|
exit
|
||||||
|
break;;
|
||||||
|
1)
|
||||||
|
cargo fmt
|
||||||
|
main
|
||||||
|
break;;
|
||||||
|
2)
|
||||||
|
cargo_build_all
|
||||||
|
main
|
||||||
|
break;;
|
||||||
|
3)
|
||||||
|
npm_test
|
||||||
|
main
|
||||||
|
break;;
|
||||||
|
4)
|
||||||
|
release_flow
|
||||||
|
break;;
|
||||||
|
esac
|
||||||
|
done
|
||||||
|
}
|
||||||
|
|
||||||
|
main
|
||||||
@@ -0,0 +1,425 @@
|
|||||||
|
use std::{cmp::Ordering, collections::VecDeque, fmt};
|
||||||
|
|
||||||
|
use tui::{
|
||||||
|
style::Color,
|
||||||
|
widgets::{ListItem, ListState},
|
||||||
|
};
|
||||||
|
|
||||||
|
#[derive(Debug, Clone)]
|
||||||
|
pub struct StatefulList<T> {
|
||||||
|
pub state: ListState,
|
||||||
|
pub items: Vec<T>,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<T> StatefulList<T> {
|
||||||
|
pub fn new(items: Vec<T>) -> 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 next(&mut self) {
|
||||||
|
if !self.items.is_empty() {
|
||||||
|
let i = match self.state.selected() {
|
||||||
|
Some(i) => {
|
||||||
|
if i < self.items.len() - 1 {
|
||||||
|
i + 1
|
||||||
|
} else {
|
||||||
|
i
|
||||||
|
}
|
||||||
|
}
|
||||||
|
None => 0,
|
||||||
|
};
|
||||||
|
self.state.select(Some(i));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn previous(&mut self) {
|
||||||
|
if !self.items.is_empty() {
|
||||||
|
let i = match self.state.selected() {
|
||||||
|
Some(i) => {
|
||||||
|
if i == 0 {
|
||||||
|
0
|
||||||
|
} else {
|
||||||
|
i - 1
|
||||||
|
}
|
||||||
|
}
|
||||||
|
None => 0,
|
||||||
|
};
|
||||||
|
self.state.select(Some(i));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn get_state_title(&self) -> String {
|
||||||
|
if self.items.is_empty() {
|
||||||
|
String::from("")
|
||||||
|
} else {
|
||||||
|
let len = self.items.len();
|
||||||
|
let c = if let Some(value) = self.state.selected() {
|
||||||
|
if len > 0 {
|
||||||
|
value + 1
|
||||||
|
} else {
|
||||||
|
value
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
0
|
||||||
|
};
|
||||||
|
format!("{}/{}", c, self.items.len())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// States of the container
|
||||||
|
#[derive(Clone, Debug, PartialEq, PartialOrd)]
|
||||||
|
pub enum State {
|
||||||
|
Dead,
|
||||||
|
Exited,
|
||||||
|
Paused,
|
||||||
|
Removing,
|
||||||
|
Restarting,
|
||||||
|
Running,
|
||||||
|
Unknown,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl State {
|
||||||
|
pub fn get_color(&self) -> Color {
|
||||||
|
match self {
|
||||||
|
Self::Running => Color::Green,
|
||||||
|
Self::Removing => Color::LightRed,
|
||||||
|
Self::Restarting => Color::LightGreen,
|
||||||
|
Self::Paused => Color::Yellow,
|
||||||
|
_ => Color::Red,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl From<&str> for State {
|
||||||
|
fn from(input: &str) -> Self {
|
||||||
|
match input {
|
||||||
|
"dead" => Self::Dead,
|
||||||
|
"exited" => Self::Exited,
|
||||||
|
"paused" => Self::Paused,
|
||||||
|
"removing" => Self::Removing,
|
||||||
|
"restarting" => Self::Restarting,
|
||||||
|
"running" => Self::Running,
|
||||||
|
_ => Self::Unknown,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
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 => "✓ running",
|
||||||
|
Self::Unknown => "? unknown",
|
||||||
|
};
|
||||||
|
write!(f, "{}", disp)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Items for the container control list
|
||||||
|
/// Should probably have a vec for each container
|
||||||
|
/// so that can remove Pause if container currently Paused etc
|
||||||
|
#[derive(Debug, Clone)]
|
||||||
|
pub enum DockerControls {
|
||||||
|
Pause,
|
||||||
|
Unpause,
|
||||||
|
Restart,
|
||||||
|
Stop,
|
||||||
|
Start,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl DockerControls {
|
||||||
|
pub fn get_color(&self) -> Color {
|
||||||
|
match self {
|
||||||
|
Self::Start => Color::Green,
|
||||||
|
Self::Stop => Color::Red,
|
||||||
|
Self::Restart => Color::Magenta,
|
||||||
|
Self::Pause => Color::Yellow,
|
||||||
|
Self::Unpause => Color::Blue,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn gen_vec(state: &State) -> Vec<Self> {
|
||||||
|
match state {
|
||||||
|
State::Dead | State::Exited => vec![Self::Start, Self::Restart],
|
||||||
|
State::Paused => vec![Self::Unpause, Self::Stop],
|
||||||
|
State::Running => vec![Self::Pause, Self::Restart, Self::Stop],
|
||||||
|
_ => vec![],
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl fmt::Display for DockerControls {
|
||||||
|
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
||||||
|
let disp = match self {
|
||||||
|
Self::Pause => "pause",
|
||||||
|
Self::Unpause => "unpause",
|
||||||
|
Self::Restart => "restart",
|
||||||
|
Self::Stop => "stop",
|
||||||
|
Self::Start => "start",
|
||||||
|
};
|
||||||
|
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(Clone, Debug)]
|
||||||
|
pub struct CpuStats {
|
||||||
|
value: f64,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl CpuStats {
|
||||||
|
pub fn new(value: f64) -> Self {
|
||||||
|
Self { value }
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Eq for CpuStats {}
|
||||||
|
|
||||||
|
impl PartialEq for CpuStats {
|
||||||
|
fn eq(&self, other: &Self) -> bool {
|
||||||
|
self.value == other.value
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl PartialOrd for CpuStats {
|
||||||
|
fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
|
||||||
|
self.value.partial_cmp(&other.value)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Ord for CpuStats {
|
||||||
|
fn cmp(&self, other: &Self) -> Ordering {
|
||||||
|
if self.value > other.value {
|
||||||
|
Ordering::Greater
|
||||||
|
} else if self.value == other.value {
|
||||||
|
Ordering::Equal
|
||||||
|
} else {
|
||||||
|
Ordering::Less
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Stats for CpuStats {
|
||||||
|
fn get_value(&self) -> f64 {
|
||||||
|
self.value
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl fmt::Display for CpuStats {
|
||||||
|
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
||||||
|
let disp = format!("{:05.2}%", self.value);
|
||||||
|
write!(f, "{:>x$}", disp, 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(Clone, Debug, Eq)]
|
||||||
|
pub struct ByteStats {
|
||||||
|
value: u64,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl PartialEq for ByteStats {
|
||||||
|
fn eq(&self, other: &Self) -> bool {
|
||||||
|
self.value == other.value
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl PartialOrd for ByteStats {
|
||||||
|
fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
|
||||||
|
self.value.partial_cmp(&other.value)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Ord for ByteStats {
|
||||||
|
fn cmp(&self, other: &Self) -> Ordering {
|
||||||
|
self.value.cmp(&other.value)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl ByteStats {
|
||||||
|
pub fn new(value: u64) -> Self {
|
||||||
|
Self { value }
|
||||||
|
}
|
||||||
|
pub fn update(&mut self, value: u64) {
|
||||||
|
self.value = value;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl Stats for ByteStats {
|
||||||
|
fn get_value(&self) -> f64 {
|
||||||
|
self.value 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 one_kb = 1000.0;
|
||||||
|
let one_mb = one_kb * one_kb;
|
||||||
|
let one_gb = one_mb * 1000.0;
|
||||||
|
let as_f64 = self.value as f64;
|
||||||
|
let p = match as_f64 {
|
||||||
|
x if x >= one_gb => format!("{y:.2} GB", y = as_f64 / one_gb),
|
||||||
|
x if x >= one_kb => format!("{y:.2} MB", y = as_f64 / one_mb),
|
||||||
|
x if x >= one_mb => format!("{y:.2} kB", y = as_f64 / one_kb),
|
||||||
|
_ => format!("{} B", self.value),
|
||||||
|
};
|
||||||
|
write!(f, "{:>x$}", p, x = f.width().unwrap_or(1))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Info for each container
|
||||||
|
#[derive(Debug, Clone)]
|
||||||
|
pub struct ContainerItem {
|
||||||
|
pub cpu_stats: VecDeque<CpuStats>,
|
||||||
|
pub docker_controls: StatefulList<DockerControls>,
|
||||||
|
pub id: String,
|
||||||
|
pub image: String,
|
||||||
|
pub last_updated: u64,
|
||||||
|
pub logs: StatefulList<ListItem<'static>>,
|
||||||
|
pub mem_limit: ByteStats,
|
||||||
|
pub mem_stats: VecDeque<ByteStats>,
|
||||||
|
pub name: String,
|
||||||
|
pub net_rx: ByteStats,
|
||||||
|
pub net_tx: ByteStats,
|
||||||
|
pub state: State,
|
||||||
|
pub status: String,
|
||||||
|
}
|
||||||
|
|
||||||
|
pub type MemTuple = (Vec<(f64, f64)>, ByteStats, State);
|
||||||
|
pub type CpuTuple = (Vec<(f64, f64)>, CpuStats, State);
|
||||||
|
|
||||||
|
impl ContainerItem {
|
||||||
|
/// Create a new container item
|
||||||
|
pub fn new(id: String, status: String, image: String, state: State, name: String) -> Self {
|
||||||
|
let mut docker_controls = StatefulList::new(DockerControls::gen_vec(&state));
|
||||||
|
docker_controls.start();
|
||||||
|
Self {
|
||||||
|
cpu_stats: VecDeque::with_capacity(60),
|
||||||
|
docker_controls,
|
||||||
|
id,
|
||||||
|
image,
|
||||||
|
last_updated: 0,
|
||||||
|
logs: StatefulList::new(vec![]),
|
||||||
|
mem_limit: ByteStats::new(0),
|
||||||
|
mem_stats: VecDeque::with_capacity(60),
|
||||||
|
name,
|
||||||
|
net_rx: ByteStats::new(0),
|
||||||
|
net_tx: ByteStats::new(0),
|
||||||
|
state,
|
||||||
|
status,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Find the max value in the last 30 items in the cpu stats vec
|
||||||
|
fn max_cpu_stats(&self) -> CpuStats {
|
||||||
|
match self.cpu_stats.iter().max() {
|
||||||
|
Some(value) => value.to_owned(),
|
||||||
|
None => CpuStats::new(0.0),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Find the max value in the last 30 items in the mem stats vec
|
||||||
|
fn max_mem_stats(&self) -> ByteStats {
|
||||||
|
match self.mem_stats.iter().max() {
|
||||||
|
Some(value) => value.to_owned(),
|
||||||
|
None => ByteStats::new(0),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Convert cpu stats into a vec for the charts function
|
||||||
|
fn get_cpu_dataset(&self) -> Vec<(f64, f64)> {
|
||||||
|
self.cpu_stats
|
||||||
|
.iter()
|
||||||
|
.enumerate()
|
||||||
|
.map(|i| (i.0 as f64, i.1.value))
|
||||||
|
.collect::<Vec<_>>()
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Convert mem stats into a vec for the charts function
|
||||||
|
fn get_mem_dataset(&self) -> Vec<(f64, f64)> {
|
||||||
|
self.mem_stats
|
||||||
|
.iter()
|
||||||
|
.enumerate()
|
||||||
|
.map(|i| (i.0 as f64, i.1.value as f64))
|
||||||
|
.collect::<Vec<_>>()
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Get all cpu chart data
|
||||||
|
fn get_cpu_chart_data(&self) -> CpuTuple {
|
||||||
|
(
|
||||||
|
self.get_cpu_dataset(),
|
||||||
|
self.max_cpu_stats(),
|
||||||
|
self.state.clone(),
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Get all mem chart data
|
||||||
|
fn get_mem_chart_data(&self) -> MemTuple {
|
||||||
|
(
|
||||||
|
self.get_mem_dataset(),
|
||||||
|
self.max_mem_stats(),
|
||||||
|
self.state.clone(),
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Get chart info for cpu & memory in one function
|
||||||
|
/// So only need to call .lock() once
|
||||||
|
pub fn get_chart_data(&self) -> (CpuTuple, MemTuple) {
|
||||||
|
(self.get_cpu_chart_data(), self.get_mem_chart_data())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Container information panel headings + widths, for nice pretty formatting
|
||||||
|
#[derive(Debug)]
|
||||||
|
pub struct Columns {
|
||||||
|
pub cpu: (String, usize),
|
||||||
|
pub image: (String, usize),
|
||||||
|
pub name: (String, usize),
|
||||||
|
pub state: (String, usize),
|
||||||
|
pub status: (String, usize),
|
||||||
|
pub mem: (String, usize),
|
||||||
|
pub net_rx: (String, usize),
|
||||||
|
pub net_tx: (String, usize),
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Columns {
|
||||||
|
pub fn new() -> Self {
|
||||||
|
Self {
|
||||||
|
// 7 to allow for 100.00%
|
||||||
|
cpu: (String::from("cpu"), 7),
|
||||||
|
image: (String::from("image"), 5),
|
||||||
|
name: (String::from("name"), 4),
|
||||||
|
state: (String::from("state"), 11),
|
||||||
|
status: (String::from("status"), 16),
|
||||||
|
mem: (String::from("mem/limit"), 9),
|
||||||
|
net_rx: (String::from("↓ rx"), 5),
|
||||||
|
net_tx: (String::from("↑ tx"), 5),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,397 @@
|
|||||||
|
use bollard::models::ContainerSummary;
|
||||||
|
use std::time::{SystemTime, UNIX_EPOCH};
|
||||||
|
use tui::widgets::ListItem;
|
||||||
|
|
||||||
|
mod container_state;
|
||||||
|
|
||||||
|
use crate::{app_error::AppError, parse_args::CliArgs, ui::log_sanitizer};
|
||||||
|
pub use container_state::*;
|
||||||
|
|
||||||
|
/// Global app_state, stored in an Arc<Mutex>
|
||||||
|
#[derive(Debug)]
|
||||||
|
pub struct AppData {
|
||||||
|
args: CliArgs,
|
||||||
|
error: Option<AppError>,
|
||||||
|
logs_parsed: bool,
|
||||||
|
pub containers: StatefulList<ContainerItem>,
|
||||||
|
pub init: bool,
|
||||||
|
pub show_error: bool,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl AppData {
|
||||||
|
/// Generate a default app_state
|
||||||
|
pub fn default(args: CliArgs) -> Self {
|
||||||
|
Self {
|
||||||
|
args,
|
||||||
|
containers: StatefulList::new(vec![]),
|
||||||
|
error: None,
|
||||||
|
init: false,
|
||||||
|
logs_parsed: false,
|
||||||
|
show_error: false,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
// Current time as unix timestamp
|
||||||
|
fn get_systemtime(&self) -> u64 {
|
||||||
|
SystemTime::now()
|
||||||
|
.duration_since(UNIX_EPOCH)
|
||||||
|
.expect("In our known reality, this error should never occur")
|
||||||
|
.as_secs()
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
/// Get the current select docker command
|
||||||
|
/// So know which command to execute
|
||||||
|
pub fn get_docker_command(&self) -> Option<DockerControls> {
|
||||||
|
let mut output = None;
|
||||||
|
if let Some(index) = self.containers.state.selected() {
|
||||||
|
if let Some(control_index) = self.containers.items[index]
|
||||||
|
.docker_controls
|
||||||
|
.state
|
||||||
|
.selected()
|
||||||
|
{
|
||||||
|
output =
|
||||||
|
Some(self.containers.items[index].docker_controls.items[control_index].clone())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
output
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Change selected choice of docker commands of selected container
|
||||||
|
pub fn docker_command_next(&mut self) {
|
||||||
|
if let Some(index) = self.containers.state.selected() {
|
||||||
|
self.containers.items[index].docker_controls.next()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Change selected choice of docker commands of selected container
|
||||||
|
pub fn docker_command_previous(&mut self) {
|
||||||
|
if let Some(index) = self.containers.state.selected() {
|
||||||
|
self.containers.items[index].docker_controls.previous()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Change selected choice of docker commands of selected container
|
||||||
|
pub fn docker_command_start(&mut self) {
|
||||||
|
if let Some(index) = self.containers.state.selected() {
|
||||||
|
self.containers.items[index].docker_controls.start()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Change selected choice of docker commands of selected container
|
||||||
|
pub fn docker_command_end(&mut self) {
|
||||||
|
if let Some(index) = self.containers.state.selected() {
|
||||||
|
self.containers.items[index].docker_controls.end()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// return single app_state error
|
||||||
|
pub fn get_error(&self) -> Option<AppError> {
|
||||||
|
self.error.clone()
|
||||||
|
}
|
||||||
|
|
||||||
|
/// remove single app_state error
|
||||||
|
pub fn remove_error(&mut self) {
|
||||||
|
self.error = None;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// insert single app_state error
|
||||||
|
pub fn set_error(&mut self, error: AppError) {
|
||||||
|
self.error = Some(error);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Find the if of the currently selected container
|
||||||
|
/// If any containers on system, will always return
|
||||||
|
/// Only returns None when no containers found
|
||||||
|
pub fn get_selected_container_id(&self) -> Option<String> {
|
||||||
|
let mut output = None;
|
||||||
|
if let Some(index) = self.containers.state.selected() {
|
||||||
|
let id = self
|
||||||
|
.containers
|
||||||
|
.items
|
||||||
|
.iter()
|
||||||
|
.skip(index)
|
||||||
|
.take(1)
|
||||||
|
.map(|i| i.id.to_owned())
|
||||||
|
.collect::<String>();
|
||||||
|
output = Some(id)
|
||||||
|
}
|
||||||
|
output
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Find the index of the currently selected single log line
|
||||||
|
pub fn get_selected_log_index(&self) -> Option<usize> {
|
||||||
|
let mut output = None;
|
||||||
|
if let Some(id) = self.get_selected_container_id() {
|
||||||
|
if let Some(index) = self.containers.items.iter().position(|i| i.id == id) {
|
||||||
|
output = Some(index);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
output
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Get the title for log panel for selected container
|
||||||
|
/// will be "logs x/x"
|
||||||
|
pub fn get_log_title(&self) -> String {
|
||||||
|
if let Some(index) = self.get_selected_log_index() {
|
||||||
|
self.containers.items[index].logs.get_state_title()
|
||||||
|
} else {
|
||||||
|
String::from("")
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// select next selected log line
|
||||||
|
pub fn log_next(&mut self) {
|
||||||
|
if let Some(index) = self.get_selected_log_index() {
|
||||||
|
self.containers.items[index].logs.next()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// select previous selected log line
|
||||||
|
pub fn log_previous(&mut self) {
|
||||||
|
if let Some(index) = self.get_selected_log_index() {
|
||||||
|
self.containers.items[index].logs.previous()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// select last selected log line
|
||||||
|
pub fn log_end(&mut self) {
|
||||||
|
if let Some(index) = self.get_selected_log_index() {
|
||||||
|
self.containers.items[index].logs.end()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// select first selected log line
|
||||||
|
pub fn log_start(&mut self) {
|
||||||
|
if let Some(index) = self.get_selected_log_index() {
|
||||||
|
self.containers.items[index].logs.start()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn initialised(&mut self, all_ids: &[(bool, String)]) -> bool {
|
||||||
|
let count_is_running = all_ids.iter().filter(|i| i.0).count();
|
||||||
|
let number_with_cpu_status = self
|
||||||
|
.containers
|
||||||
|
.items
|
||||||
|
.iter()
|
||||||
|
.filter(|i| !i.cpu_stats.is_empty())
|
||||||
|
.count();
|
||||||
|
self.logs_parsed && count_is_running == number_with_cpu_status
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Just get the total number of containers
|
||||||
|
pub fn get_container_len(&self) -> usize {
|
||||||
|
self.containers.items.len()
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Find the widths for the strings in the containers panel
|
||||||
|
/// So can display nicely and evenly
|
||||||
|
pub fn get_width(&self) -> Columns {
|
||||||
|
let mut output = Columns::new();
|
||||||
|
let count = |x: &String| x.chars().count();
|
||||||
|
|
||||||
|
for container in self.containers.items.iter() {
|
||||||
|
let cpu_count = count(
|
||||||
|
&container
|
||||||
|
.cpu_stats
|
||||||
|
.back()
|
||||||
|
.unwrap_or(&CpuStats::new(0.0))
|
||||||
|
.to_string(),
|
||||||
|
);
|
||||||
|
let mem_count = count(&format!(
|
||||||
|
"{} / {}",
|
||||||
|
container.mem_stats.back().unwrap_or(&ByteStats::new(0)),
|
||||||
|
container.mem_limit
|
||||||
|
));
|
||||||
|
|
||||||
|
let net_rx_count = count(&container.net_rx.to_string());
|
||||||
|
let net_tx_count = count(&container.net_tx.to_string());
|
||||||
|
let image_count = count(&container.image);
|
||||||
|
let name_count = count(&container.name);
|
||||||
|
let state_count = count(&container.state.to_string());
|
||||||
|
let status_count = count(&container.status);
|
||||||
|
|
||||||
|
if cpu_count > output.cpu.1 {
|
||||||
|
output.cpu.1 = cpu_count;
|
||||||
|
};
|
||||||
|
if image_count > output.image.1 {
|
||||||
|
output.image.1 = image_count;
|
||||||
|
};
|
||||||
|
if mem_count > output.mem.1 {
|
||||||
|
output.mem.1 = mem_count;
|
||||||
|
};
|
||||||
|
if name_count > output.name.1 {
|
||||||
|
output.name.1 = name_count;
|
||||||
|
};
|
||||||
|
if state_count > output.state.1 {
|
||||||
|
output.state.1 = state_count;
|
||||||
|
};
|
||||||
|
if status_count > output.status.1 {
|
||||||
|
output.status.1 = status_count;
|
||||||
|
};
|
||||||
|
|
||||||
|
if net_rx_count > output.net_rx.1 {
|
||||||
|
output.net_rx.1 = net_rx_count;
|
||||||
|
};
|
||||||
|
|
||||||
|
if net_tx_count > output.net_tx.1 {
|
||||||
|
output.net_tx.1 = net_tx_count;
|
||||||
|
};
|
||||||
|
}
|
||||||
|
output
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Get all containers ids
|
||||||
|
pub fn get_all_ids(&self) -> Vec<String> {
|
||||||
|
self.containers
|
||||||
|
.items
|
||||||
|
.iter()
|
||||||
|
.map(|i| i.id.to_owned())
|
||||||
|
.collect::<Vec<_>>()
|
||||||
|
}
|
||||||
|
|
||||||
|
/// find container given id
|
||||||
|
fn get_container_by_id(&mut self, id: &str) -> Option<&mut ContainerItem> {
|
||||||
|
self.containers.items.iter_mut().find(|i| i.id == id)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Update container mem + cpu stats, in single function so only need to call .lock() once
|
||||||
|
pub fn update_stats(
|
||||||
|
&mut self,
|
||||||
|
id: String,
|
||||||
|
cpu_stat: Option<f64>,
|
||||||
|
mem_stat: Option<u64>,
|
||||||
|
mem_limit: u64,
|
||||||
|
rx: u64,
|
||||||
|
tx: u64,
|
||||||
|
) {
|
||||||
|
if let Some(container) = self.get_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));
|
||||||
|
}
|
||||||
|
|
||||||
|
container.net_rx.update(rx);
|
||||||
|
container.net_tx.update(tx);
|
||||||
|
container.mem_limit.update(mem_limit);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Update, or insert, containers
|
||||||
|
pub fn update_containers(&mut self, containers: &[ContainerSummary]) {
|
||||||
|
let all_ids = self.get_all_ids();
|
||||||
|
|
||||||
|
if !containers.is_empty() && self.containers.state.selected().is_none() {
|
||||||
|
self.containers.start();
|
||||||
|
}
|
||||||
|
|
||||||
|
for (index, id) in all_ids.iter().enumerate() {
|
||||||
|
if !containers
|
||||||
|
.iter()
|
||||||
|
.map(|i| i.id.as_ref().unwrap())
|
||||||
|
.any(|x| x == id)
|
||||||
|
{
|
||||||
|
// 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.previous();
|
||||||
|
}
|
||||||
|
self.containers.items.remove(index);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
for i in containers.iter() {
|
||||||
|
let id = i.id.as_ref().unwrap().to_owned();
|
||||||
|
let mut name = i
|
||||||
|
.names
|
||||||
|
.as_ref()
|
||||||
|
.unwrap_or(&vec!["".to_owned()])
|
||||||
|
.get(0)
|
||||||
|
.unwrap()
|
||||||
|
.to_owned();
|
||||||
|
if let Some(c) = name.chars().next() {
|
||||||
|
if c == '/' {
|
||||||
|
name.remove(0);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
let state = State::from(i.state.as_ref().unwrap_or(&"dead".to_owned()).trim());
|
||||||
|
let status = i
|
||||||
|
.status
|
||||||
|
.as_ref()
|
||||||
|
.unwrap_or(&"".to_owned())
|
||||||
|
.trim()
|
||||||
|
.to_owned();
|
||||||
|
let image = i.image.as_ref().unwrap_or(&"".to_owned()).trim().to_owned();
|
||||||
|
if let Some(current_container) = self.get_container_by_id(&id) {
|
||||||
|
if current_container.name != name {
|
||||||
|
current_container.name = name
|
||||||
|
};
|
||||||
|
if current_container.status != status {
|
||||||
|
current_container.status = status
|
||||||
|
};
|
||||||
|
if current_container.state != state {
|
||||||
|
current_container.docker_controls.items = DockerControls::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 => {
|
||||||
|
current_container.docker_controls.state.select(None)
|
||||||
|
}
|
||||||
|
_ => current_container.docker_controls.start(),
|
||||||
|
};
|
||||||
|
current_container.state = state;
|
||||||
|
};
|
||||||
|
if current_container.image != image {
|
||||||
|
current_container.image = image
|
||||||
|
};
|
||||||
|
} else {
|
||||||
|
let mut container = ContainerItem::new(id, status, image, state, name);
|
||||||
|
container.logs.end();
|
||||||
|
self.containers.items.push(container);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// update logs of a given container, based on index not id
|
||||||
|
pub fn update_log_by_index(&mut self, output: Vec<String>, index: usize) {
|
||||||
|
let tz = self.get_systemtime();
|
||||||
|
if let Some(container) = self.containers.items.get_mut(index) {
|
||||||
|
container.last_updated = tz;
|
||||||
|
let current_len = container.logs.items.len();
|
||||||
|
output.iter().for_each(|i| {
|
||||||
|
let lines = if self.args.color {
|
||||||
|
log_sanitizer::colorize_logs(i.to_owned())
|
||||||
|
} else if self.args.raw {
|
||||||
|
log_sanitizer::raw(i.to_owned())
|
||||||
|
} else {
|
||||||
|
log_sanitizer::remove_ansi(i.to_owned())
|
||||||
|
};
|
||||||
|
container.logs.items.push(ListItem::new(lines));
|
||||||
|
});
|
||||||
|
if container.logs.state.selected().is_none()
|
||||||
|
|| container.logs.state.selected().unwrap() + 1 == current_len
|
||||||
|
{
|
||||||
|
container.logs.end();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
self.logs_parsed = true;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
pub fn update_all_logs(&mut self, all_logs: Vec<Vec<String>>) {
|
||||||
|
for (index, output) in all_logs.into_iter().enumerate() {
|
||||||
|
self.update_log_by_index(output, index);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,45 @@
|
|||||||
|
use core::fmt;
|
||||||
|
use tracing::error;
|
||||||
|
|
||||||
|
use crate::app_data::DockerControls;
|
||||||
|
|
||||||
|
/// app errors to set in global state
|
||||||
|
#[allow(unused)]
|
||||||
|
#[derive(Debug, Clone)]
|
||||||
|
pub enum AppError {
|
||||||
|
DockerConnect,
|
||||||
|
DockerInterval,
|
||||||
|
InputPoll,
|
||||||
|
DockerCommand(DockerControls),
|
||||||
|
Terminal,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl AppError {
|
||||||
|
/// for handling errors from terminal
|
||||||
|
pub fn disp(&self) {
|
||||||
|
match self {
|
||||||
|
Self::DockerConnect => error!("Unable to access docker daemon"),
|
||||||
|
Self::DockerInterval => error!("Docker update interval needs to be greater than 0"),
|
||||||
|
Self::InputPoll => error!("Unable to poll user input"),
|
||||||
|
Self::Terminal => error!("Unable to draw to terminal"),
|
||||||
|
Self::DockerCommand(s) => {
|
||||||
|
let error = format!("Unable to {} container", s);
|
||||||
|
error!(%error);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Convert errors into strings to display
|
||||||
|
impl fmt::Display for AppError {
|
||||||
|
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
||||||
|
let disp = match self {
|
||||||
|
Self::DockerConnect => "Unable to access docker daemon".to_owned(),
|
||||||
|
Self::DockerInterval => "Docker update interval needs to be greater than 0".to_owned(),
|
||||||
|
Self::InputPoll => "Unable to poll user input".to_owned(),
|
||||||
|
Self::Terminal => "Unable to draw to terminal".to_owned(),
|
||||||
|
Self::DockerCommand(s) => format!("Unable to {} container", s),
|
||||||
|
};
|
||||||
|
write!(f, "{}", disp)
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,277 @@
|
|||||||
|
use bollard::{
|
||||||
|
container::{ListContainersOptions, LogsOptions, Stats, StatsOptions},
|
||||||
|
Docker,
|
||||||
|
};
|
||||||
|
use futures_util::{future::join_all, StreamExt};
|
||||||
|
use parking_lot::Mutex;
|
||||||
|
use std::{
|
||||||
|
sync::Arc,
|
||||||
|
time::{Duration, Instant},
|
||||||
|
};
|
||||||
|
|
||||||
|
use crate::{app_data::AppData, parse_args::CliArgs, ui::GuiState};
|
||||||
|
|
||||||
|
pub struct DockerData {
|
||||||
|
app_data: Arc<Mutex<AppData>>,
|
||||||
|
docker: Arc<Docker>,
|
||||||
|
gui_state: Arc<Mutex<GuiState>>,
|
||||||
|
initialised: bool,
|
||||||
|
sleep_duration: Duration,
|
||||||
|
timestamps: bool,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl DockerData {
|
||||||
|
/// Use docker stats for work out current cpu usage
|
||||||
|
fn calculate_usage(stats: &Stats) -> f64 {
|
||||||
|
let mut cpu_percentage = 0.0;
|
||||||
|
let previous_cpu = stats.precpu_stats.cpu_usage.total_usage;
|
||||||
|
let cpu_delta = stats.cpu_stats.cpu_usage.total_usage as f64 - previous_cpu as f64;
|
||||||
|
if stats.cpu_stats.system_cpu_usage.is_some()
|
||||||
|
&& stats.precpu_stats.system_cpu_usage.is_some()
|
||||||
|
{
|
||||||
|
let system_delta = (stats.cpu_stats.system_cpu_usage.unwrap()
|
||||||
|
- stats.precpu_stats.system_cpu_usage.unwrap())
|
||||||
|
as f64;
|
||||||
|
let online_cpus = stats.cpu_stats.online_cpus.unwrap_or_else(|| {
|
||||||
|
stats
|
||||||
|
.cpu_stats
|
||||||
|
.cpu_usage
|
||||||
|
.percpu_usage
|
||||||
|
.clone()
|
||||||
|
.unwrap_or_default()
|
||||||
|
.len() as u64
|
||||||
|
}) as f64;
|
||||||
|
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 on thread
|
||||||
|
async fn update_container_stat(
|
||||||
|
docker: Arc<Docker>,
|
||||||
|
id: String,
|
||||||
|
app_data: Arc<Mutex<AppData>>,
|
||||||
|
is_running: bool,
|
||||||
|
) {
|
||||||
|
let mut stream = docker
|
||||||
|
.stats(
|
||||||
|
&id,
|
||||||
|
Some(StatsOptions {
|
||||||
|
stream: false,
|
||||||
|
one_shot: !is_running,
|
||||||
|
}),
|
||||||
|
)
|
||||||
|
.take(1);
|
||||||
|
|
||||||
|
while let Some(Ok(stats)) = stream.next().await {
|
||||||
|
let mem_stat = stats.memory_stats.usage.unwrap_or(0);
|
||||||
|
let mem_limit = stats.memory_stats.limit.unwrap_or(0);
|
||||||
|
|
||||||
|
let key = if let Some(networks) = &stats.networks {
|
||||||
|
networks.keys().next().map(|x| x.to_owned())
|
||||||
|
} else {
|
||||||
|
None
|
||||||
|
};
|
||||||
|
|
||||||
|
let cpu_stats = Self::calculate_usage(&stats);
|
||||||
|
|
||||||
|
let (rx, tx) = if let Some(k) = key {
|
||||||
|
let ii = stats.networks.unwrap();
|
||||||
|
let v = ii.get(&k).unwrap();
|
||||||
|
(v.rx_bytes.to_owned(), v.tx_bytes.to_owned())
|
||||||
|
} else {
|
||||||
|
(0, 0)
|
||||||
|
};
|
||||||
|
|
||||||
|
if is_running {
|
||||||
|
app_data.lock().update_stats(
|
||||||
|
id.clone(),
|
||||||
|
Some(cpu_stats),
|
||||||
|
Some(mem_stat),
|
||||||
|
mem_limit,
|
||||||
|
rx,
|
||||||
|
tx,
|
||||||
|
);
|
||||||
|
} else {
|
||||||
|
app_data
|
||||||
|
.lock()
|
||||||
|
.update_stats(id.clone(), None, None, mem_limit, rx, tx);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Update all stats, spawn each container into own tokio::spawn thread
|
||||||
|
async fn update_all_container_stats(&mut self, all_ids: &[(bool, String)]) {
|
||||||
|
for (is_running, id) in all_ids.iter() {
|
||||||
|
let docker = Arc::clone(&self.docker);
|
||||||
|
let app_data = Arc::clone(&self.app_data);
|
||||||
|
let is_running = *is_running;
|
||||||
|
let id = id.to_owned();
|
||||||
|
tokio::spawn(async move {
|
||||||
|
Self::update_container_stat(docker, id, app_data, is_running).await
|
||||||
|
});
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// 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
|
||||||
|
pub async fn update_all_containers(&mut self) -> Vec<(bool, String)> {
|
||||||
|
let containers = self
|
||||||
|
.docker
|
||||||
|
.list_containers(Some(ListContainersOptions::<String> {
|
||||||
|
all: true,
|
||||||
|
..Default::default()
|
||||||
|
}))
|
||||||
|
.await
|
||||||
|
.unwrap();
|
||||||
|
|
||||||
|
let mut output = vec![];
|
||||||
|
// iter over containers, to only send ones which have an id, as use ID for extensivley!
|
||||||
|
// alternative is to create my own container struct, and will out with details
|
||||||
|
containers.iter().filter(|i| i.id.is_some()).for_each(|c| {
|
||||||
|
output.push(c.to_owned());
|
||||||
|
});
|
||||||
|
|
||||||
|
self.app_data.lock().update_containers(&output);
|
||||||
|
output
|
||||||
|
.iter()
|
||||||
|
.map(|i| {
|
||||||
|
(
|
||||||
|
i.state.as_ref().unwrap() == "running",
|
||||||
|
i.id.as_ref().unwrap().to_owned(),
|
||||||
|
)
|
||||||
|
})
|
||||||
|
.collect::<Vec<_>>()
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Update single container logs
|
||||||
|
/// don't take &self, so that can tokio::spawn into it's on thread
|
||||||
|
async fn update_log(
|
||||||
|
docker: Arc<Docker>,
|
||||||
|
id: String,
|
||||||
|
timestamps: bool,
|
||||||
|
since: i64,
|
||||||
|
) -> Vec<String> {
|
||||||
|
let options = Some(LogsOptions::<String> {
|
||||||
|
stdout: true,
|
||||||
|
timestamps,
|
||||||
|
since,
|
||||||
|
..Default::default()
|
||||||
|
});
|
||||||
|
|
||||||
|
let mut logs = docker.logs(&id, options);
|
||||||
|
|
||||||
|
let mut output = vec![];
|
||||||
|
|
||||||
|
while let Some(value) = logs.next().await {
|
||||||
|
if let Ok(data) = value {
|
||||||
|
let log_string = data.to_string();
|
||||||
|
if !log_string.trim().is_empty() {
|
||||||
|
output.push(log_string);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
output
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Update all logs, spawn each container into own tokio::spawn thread
|
||||||
|
// rename init all logs, as only gets run once
|
||||||
|
async fn update_all_logs(&mut self, all_ids: &[(bool, String)]) {
|
||||||
|
let mut handles = vec![];
|
||||||
|
|
||||||
|
for (_, id) in all_ids.iter() {
|
||||||
|
let docker = Arc::clone(&self.docker);
|
||||||
|
let timestamps = self.timestamps;
|
||||||
|
let id = id.to_owned();
|
||||||
|
handles.push(Self::update_log(docker, id, timestamps, 0));
|
||||||
|
}
|
||||||
|
let all_logs = join_all(handles).await;
|
||||||
|
self.app_data.lock().update_all_logs(all_logs);
|
||||||
|
}
|
||||||
|
|
||||||
|
async fn update_everything(&mut self) {
|
||||||
|
let all_ids = self.update_all_containers().await;
|
||||||
|
let op_index = self.app_data.lock().get_selected_log_index();
|
||||||
|
if let Some(index) = op_index {
|
||||||
|
let docker = Arc::clone(&self.docker);
|
||||||
|
let since = self.app_data.lock().containers.items[index].last_updated as i64;
|
||||||
|
let timestamps = self.timestamps;
|
||||||
|
let id = self.app_data.lock().containers.items[index].id.to_owned();
|
||||||
|
let logs = Self::update_log(docker, id, timestamps, since).await;
|
||||||
|
self.app_data.lock().update_log_by_index(logs, index);
|
||||||
|
};
|
||||||
|
|
||||||
|
self.update_all_container_stats(&all_ids).await;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Initialise self, and start the updated loop
|
||||||
|
pub async fn init(
|
||||||
|
args: CliArgs,
|
||||||
|
app_data: Arc<Mutex<AppData>>,
|
||||||
|
docker: Arc<Docker>,
|
||||||
|
gui_state: Arc<Mutex<GuiState>>,
|
||||||
|
) {
|
||||||
|
if app_data.lock().get_error().is_none() {
|
||||||
|
let mut inner = Self {
|
||||||
|
app_data,
|
||||||
|
docker,
|
||||||
|
gui_state,
|
||||||
|
initialised: false,
|
||||||
|
sleep_duration: Duration::from_millis(args.docker as u64),
|
||||||
|
timestamps: args.timestamp,
|
||||||
|
};
|
||||||
|
inner.initialise_container_data().await;
|
||||||
|
inner.update_loop().await;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
async fn initialise_container_data(&mut self) {
|
||||||
|
let gui_state = Arc::clone(&self.gui_state);
|
||||||
|
// could also just loop while init is false, would need to move an arc mutex into here
|
||||||
|
// so instead just abort at end of function
|
||||||
|
let loading_spin = tokio::spawn(async move {
|
||||||
|
loop {
|
||||||
|
tokio::time::sleep(std::time::Duration::from_millis(100)).await;
|
||||||
|
gui_state.lock().next_loading();
|
||||||
|
}
|
||||||
|
});
|
||||||
|
|
||||||
|
let all_ids = self.update_all_containers().await;
|
||||||
|
self.update_all_container_stats(&all_ids).await;
|
||||||
|
|
||||||
|
// Maybe only do a single one at first?
|
||||||
|
self.update_all_logs(&all_ids).await;
|
||||||
|
|
||||||
|
if all_ids.is_empty() {
|
||||||
|
self.initialised = true;
|
||||||
|
}
|
||||||
|
|
||||||
|
// wait until all logs have initialised
|
||||||
|
while !self.initialised {
|
||||||
|
tokio::time::sleep(std::time::Duration::from_millis(100)).await;
|
||||||
|
self.initialised = self.app_data.lock().initialised(&all_ids);
|
||||||
|
}
|
||||||
|
self.app_data.lock().init = true;
|
||||||
|
loading_spin.abort();
|
||||||
|
self.gui_state.lock().reset_loading();
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Update all items, wait until all complete
|
||||||
|
/// sleep for CliArgs.docker ms before updating next
|
||||||
|
async fn update_loop(&mut self) {
|
||||||
|
loop {
|
||||||
|
let start = Instant::now();
|
||||||
|
self.update_everything().await;
|
||||||
|
|
||||||
|
let elapsed = start.elapsed();
|
||||||
|
if elapsed < self.sleep_duration {
|
||||||
|
tokio::time::sleep(self.sleep_duration - elapsed).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
|
||||||
@@ -0,0 +1,7 @@
|
|||||||
|
use crossterm::event::{KeyCode, MouseEvent};
|
||||||
|
|
||||||
|
#[derive(Debug, Clone)]
|
||||||
|
pub enum InputMessages {
|
||||||
|
ButtonPress(KeyCode),
|
||||||
|
MouseEvent(MouseEvent),
|
||||||
|
}
|
||||||
@@ -0,0 +1,262 @@
|
|||||||
|
use std::sync::{
|
||||||
|
atomic::{AtomicBool, Ordering},
|
||||||
|
Arc,
|
||||||
|
};
|
||||||
|
|
||||||
|
use bollard::{container::StartContainerOptions, Docker};
|
||||||
|
use crossterm::event::{KeyCode, MouseButton, MouseEvent, MouseEventKind};
|
||||||
|
use parking_lot::Mutex;
|
||||||
|
use tokio::sync::broadcast::Receiver;
|
||||||
|
use tui::layout::Rect;
|
||||||
|
|
||||||
|
mod message;
|
||||||
|
use crate::{
|
||||||
|
app_data::{AppData, DockerControls},
|
||||||
|
app_error::AppError,
|
||||||
|
ui::{GuiState, SelectablePanel},
|
||||||
|
};
|
||||||
|
pub use message::InputMessages;
|
||||||
|
|
||||||
|
/// Handle all input events
|
||||||
|
#[derive(Debug)]
|
||||||
|
pub struct InputHandler {
|
||||||
|
app_data: Arc<Mutex<AppData>>,
|
||||||
|
docker: Arc<Docker>,
|
||||||
|
gui_state: Arc<Mutex<GuiState>>,
|
||||||
|
is_running: Arc<AtomicBool>,
|
||||||
|
rec: Receiver<InputMessages>,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl InputHandler {
|
||||||
|
/// Initialize self, and running the message handling loop
|
||||||
|
pub async fn init(
|
||||||
|
app_data: Arc<Mutex<AppData>>,
|
||||||
|
rec: Receiver<InputMessages>,
|
||||||
|
docker: Arc<Docker>,
|
||||||
|
gui_state: Arc<Mutex<GuiState>>,
|
||||||
|
is_running: Arc<AtomicBool>,
|
||||||
|
) {
|
||||||
|
let mut inner = Self {
|
||||||
|
app_data,
|
||||||
|
docker,
|
||||||
|
gui_state,
|
||||||
|
is_running,
|
||||||
|
rec,
|
||||||
|
};
|
||||||
|
inner.start().await;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// check for incoming messages
|
||||||
|
async fn start(&mut self) {
|
||||||
|
while let Ok(message) = self.rec.recv().await {
|
||||||
|
match message {
|
||||||
|
InputMessages::ButtonPress(key_code) => self.button_press(key_code).await,
|
||||||
|
InputMessages::MouseEvent(mouse_event) => {
|
||||||
|
let show_error = self.app_data.lock().show_error;
|
||||||
|
let show_info = self.gui_state.lock().show_help;
|
||||||
|
if !show_error && !show_info {
|
||||||
|
self.mouse_press(mouse_event);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if !self.is_running.load(Ordering::SeqCst) {
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Handle any keyboard button events
|
||||||
|
async fn button_press(&mut self, key_code: KeyCode) {
|
||||||
|
let show_error = self.app_data.lock().show_error;
|
||||||
|
let show_info = self.gui_state.lock().show_help;
|
||||||
|
if show_error {
|
||||||
|
match key_code {
|
||||||
|
KeyCode::Char('q') => {
|
||||||
|
self.is_running.store(false, Ordering::SeqCst);
|
||||||
|
}
|
||||||
|
KeyCode::Char('c') => {
|
||||||
|
self.app_data.lock().show_error = false;
|
||||||
|
self.app_data.lock().remove_error();
|
||||||
|
}
|
||||||
|
_ => (),
|
||||||
|
}
|
||||||
|
} else if show_info {
|
||||||
|
match key_code {
|
||||||
|
KeyCode::Char('q') => {
|
||||||
|
self.is_running.store(false, Ordering::SeqCst);
|
||||||
|
}
|
||||||
|
KeyCode::Char('h') => {
|
||||||
|
self.gui_state.lock().show_help = false;
|
||||||
|
}
|
||||||
|
_ => (),
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
match key_code {
|
||||||
|
KeyCode::Char('q') => {
|
||||||
|
self.is_running.store(false, Ordering::SeqCst);
|
||||||
|
}
|
||||||
|
KeyCode::Char('h') => {
|
||||||
|
self.gui_state.lock().show_help = true;
|
||||||
|
}
|
||||||
|
KeyCode::Tab => self.gui_state.lock().next_panel(),
|
||||||
|
KeyCode::BackTab => self.gui_state.lock().previous_panel(),
|
||||||
|
KeyCode::Home => {
|
||||||
|
let mut locked_data = self.app_data.lock();
|
||||||
|
match self.gui_state.lock().selected_panel {
|
||||||
|
SelectablePanel::Containers => locked_data.containers.start(),
|
||||||
|
SelectablePanel::Logs => locked_data.log_start(),
|
||||||
|
SelectablePanel::Commands => locked_data.docker_command_start(),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
KeyCode::End => {
|
||||||
|
let mut locked_data = self.app_data.lock();
|
||||||
|
match self.gui_state.lock().selected_panel {
|
||||||
|
SelectablePanel::Containers => locked_data.containers.end(),
|
||||||
|
SelectablePanel::Logs => locked_data.log_end(),
|
||||||
|
SelectablePanel::Commands => locked_data.docker_command_end(),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
KeyCode::Up => self.previous(),
|
||||||
|
KeyCode::PageUp => {
|
||||||
|
for _ in 0..=6 {
|
||||||
|
self.previous()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
KeyCode::Down => self.next(),
|
||||||
|
KeyCode::PageDown => {
|
||||||
|
for _ in 0..=6 {
|
||||||
|
self.next()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
KeyCode::Enter => {
|
||||||
|
// Does is matter though?
|
||||||
|
// This isn't great, just means you can't send docker commands before full initialization of the program
|
||||||
|
// could change to to if loading = true, although at the moment don't have a loading bool
|
||||||
|
let panel = self.gui_state.lock().selected_panel;
|
||||||
|
if panel == SelectablePanel::Commands {
|
||||||
|
let command = self.app_data.lock().get_docker_command();
|
||||||
|
|
||||||
|
if command.is_some() {
|
||||||
|
let id = self.app_data.lock().get_selected_container_id();
|
||||||
|
let app_data = Arc::clone(&self.app_data);
|
||||||
|
let docker = Arc::clone(&self.docker);
|
||||||
|
if id.is_some() {
|
||||||
|
let id = id.unwrap();
|
||||||
|
match command.unwrap() {
|
||||||
|
DockerControls::Pause => {
|
||||||
|
tokio::spawn(async move {
|
||||||
|
docker.pause_container(&id).await.unwrap_or_else(
|
||||||
|
|_| {
|
||||||
|
app_data.lock().set_error(
|
||||||
|
AppError::DockerCommand(
|
||||||
|
DockerControls::Pause,
|
||||||
|
),
|
||||||
|
)
|
||||||
|
},
|
||||||
|
);
|
||||||
|
});
|
||||||
|
}
|
||||||
|
DockerControls::Unpause => {
|
||||||
|
tokio::spawn(async move {
|
||||||
|
docker.unpause_container(&id).await.unwrap_or_else(
|
||||||
|
|_| {
|
||||||
|
app_data.lock().set_error(
|
||||||
|
AppError::DockerCommand(
|
||||||
|
DockerControls::Unpause,
|
||||||
|
),
|
||||||
|
)
|
||||||
|
},
|
||||||
|
);
|
||||||
|
});
|
||||||
|
}
|
||||||
|
DockerControls::Start => {
|
||||||
|
tokio::spawn(async move {
|
||||||
|
docker
|
||||||
|
.start_container(
|
||||||
|
&id,
|
||||||
|
None::<StartContainerOptions<String>>,
|
||||||
|
)
|
||||||
|
.await
|
||||||
|
.unwrap_or_else(|_| {
|
||||||
|
app_data.lock().set_error(
|
||||||
|
AppError::DockerCommand(
|
||||||
|
DockerControls::Start,
|
||||||
|
),
|
||||||
|
)
|
||||||
|
});
|
||||||
|
});
|
||||||
|
}
|
||||||
|
DockerControls::Stop => {
|
||||||
|
tokio::spawn(async move {
|
||||||
|
docker.stop_container(&id, None).await.unwrap_or_else(
|
||||||
|
|_| {
|
||||||
|
app_data.lock().set_error(
|
||||||
|
AppError::DockerCommand(
|
||||||
|
DockerControls::Stop,
|
||||||
|
),
|
||||||
|
)
|
||||||
|
},
|
||||||
|
);
|
||||||
|
});
|
||||||
|
}
|
||||||
|
DockerControls::Restart => {
|
||||||
|
tokio::spawn(async move {
|
||||||
|
docker
|
||||||
|
.restart_container(&id, None)
|
||||||
|
.await
|
||||||
|
.unwrap_or_else(|_| {
|
||||||
|
app_data.lock().set_error(
|
||||||
|
AppError::DockerCommand(
|
||||||
|
DockerControls::Restart,
|
||||||
|
),
|
||||||
|
)
|
||||||
|
});
|
||||||
|
});
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
_ => (),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Handle mouse button events
|
||||||
|
fn mouse_press(&mut self, mouse_event: MouseEvent) {
|
||||||
|
match mouse_event.kind {
|
||||||
|
MouseEventKind::ScrollUp => self.previous(),
|
||||||
|
MouseEventKind::ScrollDown => self.next(),
|
||||||
|
MouseEventKind::Down(MouseButton::Left) => {
|
||||||
|
self.gui_state.lock().rect_insersects(Rect::new(
|
||||||
|
mouse_event.column,
|
||||||
|
mouse_event.row,
|
||||||
|
1,
|
||||||
|
1,
|
||||||
|
));
|
||||||
|
}
|
||||||
|
_ => (),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Change state of selected container
|
||||||
|
fn next(&mut self) {
|
||||||
|
let mut locked_data = self.app_data.lock();
|
||||||
|
match self.gui_state.lock().selected_panel {
|
||||||
|
SelectablePanel::Containers => locked_data.containers.next(),
|
||||||
|
SelectablePanel::Logs => locked_data.log_next(),
|
||||||
|
SelectablePanel::Commands => locked_data.docker_command_next(),
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Change state of selected container
|
||||||
|
fn previous(&mut self) {
|
||||||
|
let mut locked_data = self.app_data.lock();
|
||||||
|
match self.gui_state.lock().selected_panel {
|
||||||
|
SelectablePanel::Containers => locked_data.containers.previous(),
|
||||||
|
SelectablePanel::Logs => locked_data.log_previous(),
|
||||||
|
SelectablePanel::Commands => locked_data.docker_command_previous(),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
+76
@@ -0,0 +1,76 @@
|
|||||||
|
use app_data::AppData;
|
||||||
|
use app_error::AppError;
|
||||||
|
use bollard::Docker;
|
||||||
|
use docker_data::DockerData;
|
||||||
|
use parking_lot::Mutex;
|
||||||
|
use parse_args::CliArgs;
|
||||||
|
use std::sync::{atomic::AtomicBool, Arc};
|
||||||
|
use tracing::{info, Level};
|
||||||
|
|
||||||
|
mod app_data;
|
||||||
|
mod app_error;
|
||||||
|
mod docker_data;
|
||||||
|
mod input_handler;
|
||||||
|
mod parse_args;
|
||||||
|
mod ui;
|
||||||
|
|
||||||
|
use ui::{create_ui, GuiState};
|
||||||
|
|
||||||
|
fn setup_tracing() {
|
||||||
|
tracing_subscriber::fmt().with_max_level(Level::INFO).init();
|
||||||
|
}
|
||||||
|
|
||||||
|
#[tokio::main]
|
||||||
|
async fn main() {
|
||||||
|
setup_tracing();
|
||||||
|
let args = CliArgs::new();
|
||||||
|
let app_data = Arc::new(Mutex::new(AppData::default(args.clone())));
|
||||||
|
let gui_state = Arc::new(Mutex::new(GuiState::default()));
|
||||||
|
|
||||||
|
let docker_args = args.clone();
|
||||||
|
let docker_app_data = Arc::clone(&app_data);
|
||||||
|
let docker_gui_state = Arc::clone(&gui_state);
|
||||||
|
|
||||||
|
// Create docker daemon handler, and only spawn up the docker data handler if ping returns non-error
|
||||||
|
let docker = Arc::new(Docker::connect_with_socket_defaults().unwrap());
|
||||||
|
match docker.ping().await {
|
||||||
|
Ok(_) => {
|
||||||
|
let docker = Arc::clone(&docker);
|
||||||
|
tokio::spawn(async move {
|
||||||
|
DockerData::init(docker_args, docker_app_data, docker, docker_gui_state).await;
|
||||||
|
});
|
||||||
|
}
|
||||||
|
Err(_) => app_data.lock().set_error(AppError::DockerConnect),
|
||||||
|
}
|
||||||
|
|
||||||
|
let input_app_data = Arc::clone(&app_data);
|
||||||
|
|
||||||
|
let (s, r) = tokio::sync::broadcast::channel(16);
|
||||||
|
|
||||||
|
let input_docker = Arc::clone(&docker);
|
||||||
|
let is_running = Arc::new(AtomicBool::new(true));
|
||||||
|
let input_is_running = Arc::clone(&is_running);
|
||||||
|
let input_gui_state = Arc::clone(&gui_state);
|
||||||
|
|
||||||
|
// Spawn input handling into own tokio thread
|
||||||
|
tokio::spawn(async {
|
||||||
|
input_handler::InputHandler::init(
|
||||||
|
input_app_data,
|
||||||
|
r,
|
||||||
|
input_docker,
|
||||||
|
input_gui_state,
|
||||||
|
input_is_running,
|
||||||
|
)
|
||||||
|
.await;
|
||||||
|
});
|
||||||
|
|
||||||
|
// Debug mode for testing, mostly pointless, doesn't take terminal nor draw gui
|
||||||
|
if !args.gui {
|
||||||
|
loop {
|
||||||
|
info!("in debug mode");
|
||||||
|
tokio::time::sleep(std::time::Duration::from_millis(5000)).await;
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
create_ui(app_data, s, is_running, gui_state).await.unwrap();
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,50 @@
|
|||||||
|
use std::process;
|
||||||
|
|
||||||
|
use clap::Parser;
|
||||||
|
use tracing::error;
|
||||||
|
|
||||||
|
#[derive(Parser, Debug, Clone)]
|
||||||
|
#[clap(about, version, author)]
|
||||||
|
|
||||||
|
pub struct CliArgs {
|
||||||
|
/// Docker update interval in ms, minimum 1, reccomended 500+
|
||||||
|
#[clap(short = 'd', default_value_t = 1000)]
|
||||||
|
pub docker: u32,
|
||||||
|
|
||||||
|
/// Don't draw gui - for debugging - mostly pointless
|
||||||
|
#[clap(short = 'g')]
|
||||||
|
pub gui: bool,
|
||||||
|
|
||||||
|
/// Remove timestamps from Docker logs
|
||||||
|
#[clap(short = 't')]
|
||||||
|
pub timestamp: bool,
|
||||||
|
|
||||||
|
/// Show raw logs, default is to remove ansi formatting
|
||||||
|
#[clap(short = 'r', conflicts_with = "color")]
|
||||||
|
pub raw: bool,
|
||||||
|
|
||||||
|
/// Attempt to colorize the logs
|
||||||
|
#[clap(short = 'c', conflicts_with = "raw")]
|
||||||
|
pub color: bool,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl CliArgs {
|
||||||
|
/// Parse cli arguments
|
||||||
|
pub fn new() -> Self {
|
||||||
|
let args = CliArgs::parse();
|
||||||
|
|
||||||
|
// Quit the program if the docker update argument is 0
|
||||||
|
// Should maybe change it to check if less than 100
|
||||||
|
if args.docker == 0 {
|
||||||
|
error!("docker args needs to be greater than 0");
|
||||||
|
process::exit(1)
|
||||||
|
}
|
||||||
|
Self {
|
||||||
|
color: args.color,
|
||||||
|
docker: args.docker,
|
||||||
|
gui: !args.gui,
|
||||||
|
raw: args.raw,
|
||||||
|
timestamp: !args.timestamp,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,77 @@
|
|||||||
|
pub mod log_sanitizer {
|
||||||
|
|
||||||
|
use cansi::{categorise_text, Color as CansiColor, Intensity};
|
||||||
|
use tui::{
|
||||||
|
style::{Color, Modifier, Style},
|
||||||
|
text::{Span, Spans},
|
||||||
|
};
|
||||||
|
|
||||||
|
/// Attempt to colorize the given string to tui-rs standars
|
||||||
|
pub fn colorize_logs(input: String) -> Vec<Spans<'static>> {
|
||||||
|
vec![Spans::from(
|
||||||
|
categorise_text(&input)
|
||||||
|
.into_iter()
|
||||||
|
.map(|i| {
|
||||||
|
let fg_color = color_ansi_to_tui(i.fg_colour);
|
||||||
|
let bg_color = color_ansi_to_tui(i.bg_colour);
|
||||||
|
let style = Style::default().bg(bg_color).fg(fg_color);
|
||||||
|
if i.blink {
|
||||||
|
style.add_modifier(Modifier::SLOW_BLINK);
|
||||||
|
}
|
||||||
|
if i.underline {
|
||||||
|
style.add_modifier(Modifier::UNDERLINED);
|
||||||
|
}
|
||||||
|
if i.reversed {
|
||||||
|
style.add_modifier(Modifier::REVERSED);
|
||||||
|
}
|
||||||
|
if i.intensity == Intensity::Bold {
|
||||||
|
style.add_modifier(Modifier::BOLD);
|
||||||
|
}
|
||||||
|
if i.hidden {
|
||||||
|
style.add_modifier(Modifier::HIDDEN);
|
||||||
|
}
|
||||||
|
if i.strikethrough {
|
||||||
|
style.add_modifier(Modifier::CROSSED_OUT);
|
||||||
|
}
|
||||||
|
Span::styled(i.text.to_owned(), style)
|
||||||
|
})
|
||||||
|
.collect::<Vec<_>>(),
|
||||||
|
)]
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Remove all ansi formatting from a given string and create tui-rs spans
|
||||||
|
pub fn remove_ansi(input: String) -> Vec<Spans<'static>> {
|
||||||
|
let mut output = String::from("");
|
||||||
|
for i in categorise_text(&input) {
|
||||||
|
output.push_str(i.text)
|
||||||
|
}
|
||||||
|
raw(output)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// create tui-rs spans that exactly match the given strings
|
||||||
|
pub fn raw(input: String) -> Vec<Spans<'static>> {
|
||||||
|
vec![Spans::from(Span::raw(input))]
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Change from ansi to tui colors
|
||||||
|
fn color_ansi_to_tui(color: CansiColor) -> Color {
|
||||||
|
match color {
|
||||||
|
CansiColor::Black => Color::Black,
|
||||||
|
CansiColor::Red => Color::Red,
|
||||||
|
CansiColor::Green => Color::Green,
|
||||||
|
CansiColor::Yellow => Color::Yellow,
|
||||||
|
CansiColor::Blue => Color::Blue,
|
||||||
|
CansiColor::Magenta => Color::Magenta,
|
||||||
|
CansiColor::Cyan => Color::Cyan,
|
||||||
|
CansiColor::White => Color::White,
|
||||||
|
CansiColor::BrightBlack => Color::Black,
|
||||||
|
CansiColor::BrightRed => Color::LightRed,
|
||||||
|
CansiColor::BrightGreen => Color::LightGreen,
|
||||||
|
CansiColor::BrightYellow => Color::LightYellow,
|
||||||
|
CansiColor::BrightBlue => Color::LightBlue,
|
||||||
|
CansiColor::BrightMagenta => Color::LightMagenta,
|
||||||
|
CansiColor::BrightCyan => Color::LightCyan,
|
||||||
|
CansiColor::BrightWhite => Color::White,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,598 @@
|
|||||||
|
use parking_lot::Mutex;
|
||||||
|
use std::default::Default;
|
||||||
|
use std::{fmt::Display, sync::Arc};
|
||||||
|
use tui::{
|
||||||
|
backend::Backend,
|
||||||
|
layout::{Alignment, Constraint, Direction, Layout, Rect},
|
||||||
|
style::{Color, Modifier, Style},
|
||||||
|
symbols,
|
||||||
|
text::{Span, Spans},
|
||||||
|
widgets::{
|
||||||
|
Axis, Block, BorderType, Borders, Chart, Clear, Dataset, GraphType, List, ListItem,
|
||||||
|
Paragraph,
|
||||||
|
},
|
||||||
|
Frame,
|
||||||
|
};
|
||||||
|
|
||||||
|
use crate::{
|
||||||
|
app_data::{AppData, ByteStats, Columns, CpuStats, State, Stats},
|
||||||
|
app_error::AppError,
|
||||||
|
};
|
||||||
|
|
||||||
|
use super::{GuiState, SelectablePanel};
|
||||||
|
|
||||||
|
const NAME_TEXT: &str = r#"
|
||||||
|
88
|
||||||
|
88
|
||||||
|
88
|
||||||
|
,adPPYba, 8b, ,d8 88 ,d8 ,adPPYba, 8b,dPPYba,
|
||||||
|
a8" "8a `Y8, ,8P' 88 ,a8" a8P_____88 88P' "Y8
|
||||||
|
8b d8 )888( 8888[ 8PP""""""" 88
|
||||||
|
"8a, ,a8" ,d8" "8b, 88`"Yba, "8b, ,aa 88
|
||||||
|
`"YbbdP"' 8P' `Y8 88 `Y8a `"Ybbd8"' 88 "#;
|
||||||
|
|
||||||
|
const NAME: &str = env!("CARGO_PKG_NAME");
|
||||||
|
const VERSION: &str = env!("CARGO_PKG_VERSION");
|
||||||
|
const REPO: &str = env!("CARGO_PKG_REPOSITORY");
|
||||||
|
const ORANGE: Color = Color::Rgb(255, 178, 36);
|
||||||
|
const MARGIN: &str = " ";
|
||||||
|
|
||||||
|
/// Generate block, add a bored if is the selected panel,
|
||||||
|
/// add custom title based on state of each panel
|
||||||
|
fn generate_block<'a>(
|
||||||
|
selectable_panel: Option<SelectablePanel>,
|
||||||
|
app_data: &Arc<Mutex<AppData>>,
|
||||||
|
selected_panel: &SelectablePanel,
|
||||||
|
) -> Block<'a> {
|
||||||
|
let mut block = Block::default().borders(Borders::ALL);
|
||||||
|
|
||||||
|
if let Some(panel) = selectable_panel {
|
||||||
|
let title = match panel {
|
||||||
|
SelectablePanel::Containers => {
|
||||||
|
format!(
|
||||||
|
" {} {} ",
|
||||||
|
panel.title(),
|
||||||
|
app_data.lock().containers.get_state_title()
|
||||||
|
)
|
||||||
|
}
|
||||||
|
SelectablePanel::Logs => {
|
||||||
|
format!(" {} {} ", panel.title(), app_data.lock().get_log_title())
|
||||||
|
}
|
||||||
|
_ => String::from(""),
|
||||||
|
};
|
||||||
|
block = block.title(title);
|
||||||
|
if selected_panel == &panel {
|
||||||
|
let selected_style = Style::default().fg(Color::LightCyan);
|
||||||
|
let selected_border = BorderType::Plain;
|
||||||
|
block = block
|
||||||
|
.border_style(selected_style)
|
||||||
|
.border_type(selected_border);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
block
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Draw the selectable panels
|
||||||
|
pub fn draw_commands<B: Backend>(
|
||||||
|
app_data: &Arc<Mutex<AppData>>,
|
||||||
|
area: Rect,
|
||||||
|
f: &mut Frame<'_, B>,
|
||||||
|
gui_state: &Arc<Mutex<GuiState>>,
|
||||||
|
index: Option<usize>,
|
||||||
|
selected_panel: &SelectablePanel,
|
||||||
|
) {
|
||||||
|
let panel = SelectablePanel::Commands;
|
||||||
|
let block = generate_block(Some(panel), app_data, selected_panel);
|
||||||
|
|
||||||
|
gui_state.lock().insert_into_area_map(panel, area);
|
||||||
|
|
||||||
|
if let Some(i) = index {
|
||||||
|
let items = app_data.lock().containers.items[i]
|
||||||
|
.docker_controls
|
||||||
|
.items
|
||||||
|
.iter()
|
||||||
|
.map(|i| {
|
||||||
|
let lines = Spans::from(vec![Span::styled(
|
||||||
|
i.to_string(),
|
||||||
|
Style::default().fg(i.get_color()),
|
||||||
|
)]);
|
||||||
|
ListItem::new(lines)
|
||||||
|
})
|
||||||
|
.collect::<Vec<_>>();
|
||||||
|
|
||||||
|
let items = List::new(items)
|
||||||
|
.block(block)
|
||||||
|
.highlight_style(Style::default().add_modifier(Modifier::BOLD))
|
||||||
|
.highlight_symbol("▶ ");
|
||||||
|
|
||||||
|
f.render_stateful_widget(
|
||||||
|
items,
|
||||||
|
area,
|
||||||
|
&mut app_data.lock().containers.items[i].docker_controls.state,
|
||||||
|
);
|
||||||
|
} else {
|
||||||
|
let debug_text = String::from("");
|
||||||
|
let paragraph = Paragraph::new(debug_text)
|
||||||
|
.block(block)
|
||||||
|
.alignment(Alignment::Center);
|
||||||
|
f.render_widget(paragraph, area)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Draw the selectable panels
|
||||||
|
pub fn draw_containers<B: Backend>(
|
||||||
|
app_data: &Arc<Mutex<AppData>>,
|
||||||
|
area: Rect,
|
||||||
|
f: &mut Frame<'_, B>,
|
||||||
|
gui_state: &Arc<Mutex<GuiState>>,
|
||||||
|
selected_panel: &SelectablePanel,
|
||||||
|
widths: &Columns,
|
||||||
|
) {
|
||||||
|
let panel = SelectablePanel::Containers;
|
||||||
|
let block = generate_block(Some(panel), app_data, selected_panel);
|
||||||
|
|
||||||
|
gui_state.lock().insert_into_area_map(panel, area);
|
||||||
|
|
||||||
|
let items = app_data
|
||||||
|
.lock()
|
||||||
|
.containers
|
||||||
|
.items
|
||||||
|
.iter()
|
||||||
|
.map(|i| {
|
||||||
|
let state_style = Style::default().fg(i.state.get_color());
|
||||||
|
let blue = Style::default().fg(Color::Blue);
|
||||||
|
|
||||||
|
let mems = format!(
|
||||||
|
"{:>1} / {:>1}",
|
||||||
|
i.mem_stats.back().unwrap_or(&ByteStats::new(0)),
|
||||||
|
i.mem_limit
|
||||||
|
);
|
||||||
|
|
||||||
|
let lines = Spans::from(vec![
|
||||||
|
Span::styled(
|
||||||
|
format!("{:<width$}", i.state.to_string(), width = widths.state.1),
|
||||||
|
state_style,
|
||||||
|
),
|
||||||
|
Span::styled(
|
||||||
|
format!("{}{:>width$}", MARGIN, i.status, width = widths.status.1),
|
||||||
|
state_style,
|
||||||
|
),
|
||||||
|
Span::styled(
|
||||||
|
format!(
|
||||||
|
"{}{:>width$}",
|
||||||
|
MARGIN,
|
||||||
|
i.cpu_stats.back().unwrap_or(&CpuStats::new(0.0)),
|
||||||
|
width = widths.cpu.1
|
||||||
|
),
|
||||||
|
state_style,
|
||||||
|
),
|
||||||
|
Span::styled(
|
||||||
|
format!("{}{:>width$}", MARGIN, mems, width = widths.mem.1),
|
||||||
|
state_style,
|
||||||
|
),
|
||||||
|
Span::styled(
|
||||||
|
format!("{}{:>width$}", MARGIN, i.name, width = widths.name.1),
|
||||||
|
blue,
|
||||||
|
),
|
||||||
|
Span::styled(
|
||||||
|
format!("{}{:>width$}", MARGIN, i.image, width = widths.image.1),
|
||||||
|
blue,
|
||||||
|
),
|
||||||
|
Span::styled(
|
||||||
|
format!("{}{:>width$}", MARGIN, i.net_rx, width = widths.net_rx.1),
|
||||||
|
Style::default().fg(Color::Rgb(255, 233, 193)),
|
||||||
|
),
|
||||||
|
Span::styled(
|
||||||
|
format!("{}{:>width$}", MARGIN, i.net_tx, width = widths.net_tx.1),
|
||||||
|
Style::default().fg(Color::Rgb(205, 140, 140)),
|
||||||
|
),
|
||||||
|
]);
|
||||||
|
ListItem::new(lines)
|
||||||
|
})
|
||||||
|
.collect::<Vec<_>>();
|
||||||
|
|
||||||
|
if items.is_empty() {
|
||||||
|
let debug_text = String::from("no containers running");
|
||||||
|
let paragraph = Paragraph::new(debug_text)
|
||||||
|
.block(block)
|
||||||
|
.alignment(Alignment::Center);
|
||||||
|
f.render_widget(paragraph, area)
|
||||||
|
} else {
|
||||||
|
let items = List::new(items)
|
||||||
|
.block(block)
|
||||||
|
.highlight_style(Style::default().add_modifier(Modifier::BOLD))
|
||||||
|
.highlight_symbol("⚪ ");
|
||||||
|
|
||||||
|
f.render_stateful_widget(items, area, &mut app_data.lock().containers.state);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Draw the selectable panels
|
||||||
|
pub fn draw_logs<B: Backend>(
|
||||||
|
app_data: &Arc<Mutex<AppData>>,
|
||||||
|
area: Rect,
|
||||||
|
f: &mut Frame<'_, B>,
|
||||||
|
gui_state: &Arc<Mutex<GuiState>>,
|
||||||
|
index: Option<usize>,
|
||||||
|
selected_panel: &SelectablePanel,
|
||||||
|
) {
|
||||||
|
let panel = SelectablePanel::Logs;
|
||||||
|
|
||||||
|
gui_state.lock().insert_into_area_map(panel, area);
|
||||||
|
|
||||||
|
let block = generate_block(Some(panel), app_data, selected_panel);
|
||||||
|
|
||||||
|
let init = app_data.lock().init;
|
||||||
|
if !init {
|
||||||
|
let icon = gui_state.lock().get_loading();
|
||||||
|
let parsing_logs = format!("parsing logs {}", icon);
|
||||||
|
let paragraph = Paragraph::new(parsing_logs)
|
||||||
|
.style(Style::default())
|
||||||
|
.block(block)
|
||||||
|
.alignment(Alignment::Center);
|
||||||
|
f.render_widget(paragraph, area)
|
||||||
|
|
||||||
|
} else if let Some(index) = index {
|
||||||
|
let items = app_data.lock().containers.items[index]
|
||||||
|
.logs
|
||||||
|
.items
|
||||||
|
.iter()
|
||||||
|
.enumerate()
|
||||||
|
.map(|i| i.1.to_owned())
|
||||||
|
.collect::<Vec<_>>();
|
||||||
|
|
||||||
|
let items = List::new(items)
|
||||||
|
.block(block)
|
||||||
|
.highlight_symbol("▶ ")
|
||||||
|
.highlight_style(Style::default().add_modifier(Modifier::BOLD));
|
||||||
|
f.render_stateful_widget(
|
||||||
|
items,
|
||||||
|
area,
|
||||||
|
&mut app_data.lock().containers.items[index].logs.state,
|
||||||
|
);
|
||||||
|
} else {
|
||||||
|
let debug_text = String::from("no logs found");
|
||||||
|
let paragraph = Paragraph::new(debug_text)
|
||||||
|
.block(block)
|
||||||
|
.alignment(Alignment::Center);
|
||||||
|
f.render_widget(paragraph, area)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Draw the cpu + mem charts
|
||||||
|
pub fn draw_chart<B: Backend>(
|
||||||
|
f: &mut Frame<'_, B>,
|
||||||
|
area: Rect,
|
||||||
|
app_data: &Arc<Mutex<AppData>>,
|
||||||
|
index: Option<usize>,
|
||||||
|
) {
|
||||||
|
if let Some(index) = index {
|
||||||
|
let area = Layout::default()
|
||||||
|
.direction(Direction::Horizontal)
|
||||||
|
.constraints([Constraint::Percentage(50), Constraint::Percentage(50)].as_ref())
|
||||||
|
.split(area);
|
||||||
|
let (cpu, mem) = app_data.lock().containers.items[index].get_chart_data();
|
||||||
|
|
||||||
|
let cpu_dataset = vec![Dataset::default()
|
||||||
|
.marker(symbols::Marker::Dot)
|
||||||
|
.style(Style::default().fg(Color::Magenta))
|
||||||
|
.graph_type(GraphType::Line)
|
||||||
|
.data(&cpu.0)];
|
||||||
|
|
||||||
|
let mem_dataset = vec![Dataset::default()
|
||||||
|
.marker(symbols::Marker::Dot)
|
||||||
|
.style(Style::default().fg(Color::Cyan))
|
||||||
|
.graph_type(GraphType::Line)
|
||||||
|
.data(&mem.0)];
|
||||||
|
let cpu_chart = make_chart(
|
||||||
|
cpu.2,
|
||||||
|
String::from("cpu"),
|
||||||
|
cpu_dataset,
|
||||||
|
CpuStats::new(cpu.0.last().unwrap_or(&(0.00, 0.00)).1),
|
||||||
|
cpu.1,
|
||||||
|
);
|
||||||
|
let mem_chart = make_chart(
|
||||||
|
mem.2,
|
||||||
|
String::from("memory"),
|
||||||
|
mem_dataset,
|
||||||
|
ByteStats::new(mem.0.last().unwrap_or(&(0.0, 0.0)).1 as u64),
|
||||||
|
mem.1,
|
||||||
|
);
|
||||||
|
|
||||||
|
f.render_widget(cpu_chart, area[0]);
|
||||||
|
f.render_widget(mem_chart, area[1]);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Create charts
|
||||||
|
fn make_chart<T: Stats + Display>(
|
||||||
|
state: State,
|
||||||
|
name: String,
|
||||||
|
dataset: Vec<Dataset>,
|
||||||
|
current: T,
|
||||||
|
max: T,
|
||||||
|
) -> Chart {
|
||||||
|
let title_color = match state {
|
||||||
|
State::Running => Color::Green,
|
||||||
|
_ => state.get_color(),
|
||||||
|
};
|
||||||
|
let label_color = match state {
|
||||||
|
State::Running => ORANGE,
|
||||||
|
_ => state.get_color(),
|
||||||
|
};
|
||||||
|
Chart::new(dataset)
|
||||||
|
.block(
|
||||||
|
Block::default()
|
||||||
|
.title_alignment(Alignment::Center)
|
||||||
|
.title(Span::styled(
|
||||||
|
format!(" {} {} ", name, current),
|
||||||
|
Style::default()
|
||||||
|
.fg(title_color)
|
||||||
|
.add_modifier(Modifier::BOLD),
|
||||||
|
))
|
||||||
|
.borders(Borders::ALL)
|
||||||
|
.border_type(BorderType::Plain),
|
||||||
|
)
|
||||||
|
.x_axis(
|
||||||
|
Axis::default()
|
||||||
|
.style(Style::default().fg(title_color))
|
||||||
|
.bounds([0.00, 60.0]),
|
||||||
|
)
|
||||||
|
.y_axis(
|
||||||
|
Axis::default()
|
||||||
|
.labels(vec![
|
||||||
|
Span::styled("", Style::default().fg(label_color)),
|
||||||
|
Span::styled(
|
||||||
|
format!("{}", max),
|
||||||
|
Style::default()
|
||||||
|
.add_modifier(Modifier::BOLD)
|
||||||
|
.fg(label_color),
|
||||||
|
),
|
||||||
|
])
|
||||||
|
// add 0.01, for cases when the value is 0
|
||||||
|
.bounds([0.0, max.get_value() +0.01]),
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Show error popup over whole screen
|
||||||
|
pub fn draw_info_bar<B: Backend>(
|
||||||
|
area: Rect,
|
||||||
|
columns: &Columns,
|
||||||
|
f: &mut Frame<'_, B>,
|
||||||
|
has_containers: bool,
|
||||||
|
info_visible: bool,
|
||||||
|
) {
|
||||||
|
let block = || Block::default().style(Style::default().bg(Color::Magenta).fg(Color::Black));
|
||||||
|
|
||||||
|
f.render_widget(block(), area);
|
||||||
|
|
||||||
|
let mut column_headings = format!(" {:>width$}", columns.state.0, width = columns.state.1);
|
||||||
|
column_headings.push_str(
|
||||||
|
format!(
|
||||||
|
"{} {:>width$}",
|
||||||
|
MARGIN,
|
||||||
|
columns.status.0,
|
||||||
|
width = columns.status.1
|
||||||
|
)
|
||||||
|
.as_str(),
|
||||||
|
);
|
||||||
|
column_headings
|
||||||
|
.push_str(format!("{}{:>width$}", MARGIN, columns.cpu.0, width = columns.cpu.1).as_str());
|
||||||
|
column_headings
|
||||||
|
.push_str(format!("{}{:>width$}", MARGIN, columns.mem.0, width = columns.mem.1).as_str());
|
||||||
|
column_headings.push_str(
|
||||||
|
format!(
|
||||||
|
"{}{:>width$}",
|
||||||
|
MARGIN,
|
||||||
|
columns.name.0,
|
||||||
|
width = columns.name.1
|
||||||
|
)
|
||||||
|
.as_str(),
|
||||||
|
);
|
||||||
|
column_headings.push_str(
|
||||||
|
format!(
|
||||||
|
"{}{:>width$}",
|
||||||
|
MARGIN,
|
||||||
|
columns.image.0,
|
||||||
|
width = columns.image.1
|
||||||
|
)
|
||||||
|
.as_str(),
|
||||||
|
);
|
||||||
|
column_headings.push_str(
|
||||||
|
format!(
|
||||||
|
"{}{:>width$}",
|
||||||
|
MARGIN,
|
||||||
|
columns.net_rx.0,
|
||||||
|
width = columns.net_rx.1
|
||||||
|
)
|
||||||
|
.as_str(),
|
||||||
|
);
|
||||||
|
column_headings.push_str(
|
||||||
|
format!(
|
||||||
|
"{}{:>width$}",
|
||||||
|
MARGIN,
|
||||||
|
columns.net_tx.0,
|
||||||
|
width = columns.net_tx.1
|
||||||
|
)
|
||||||
|
.as_str(),
|
||||||
|
);
|
||||||
|
|
||||||
|
let suffix = if info_visible { "exit" } else { "show" };
|
||||||
|
let info_text = format!("( h ) to {} help {}", suffix, MARGIN);
|
||||||
|
let info_width = info_text.chars().count();
|
||||||
|
|
||||||
|
let column_width = column_headings.chars().count();
|
||||||
|
|
||||||
|
let splits = if has_containers {
|
||||||
|
vec![
|
||||||
|
Constraint::Min(column_width as u16),
|
||||||
|
Constraint::Min(info_width as u16),
|
||||||
|
]
|
||||||
|
} else {
|
||||||
|
vec![Constraint::Percentage(100)]
|
||||||
|
};
|
||||||
|
|
||||||
|
let split_bar = Layout::default()
|
||||||
|
.direction(Direction::Horizontal)
|
||||||
|
.constraints(splits.as_ref())
|
||||||
|
.split(area);
|
||||||
|
|
||||||
|
if has_containers {
|
||||||
|
let paragraph = Paragraph::new(column_headings)
|
||||||
|
.block(block())
|
||||||
|
.alignment(Alignment::Left);
|
||||||
|
f.render_widget(paragraph, split_bar[0]);
|
||||||
|
}
|
||||||
|
|
||||||
|
let paragraph = Paragraph::new(info_text)
|
||||||
|
.block(block())
|
||||||
|
.alignment(Alignment::Right);
|
||||||
|
|
||||||
|
let index = if has_containers { 1 } else { 0 };
|
||||||
|
f.render_widget(paragraph, split_bar[index]);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Show error popup over whole screen
|
||||||
|
pub fn draw_help_box<B: Backend>(f: &mut Frame<'_, B>) {
|
||||||
|
let title = format!(" {} ", VERSION);
|
||||||
|
|
||||||
|
let mut description_text =
|
||||||
|
String::from("\n A basic docker container information viewer and controller.");
|
||||||
|
description_text.push_str("\n Tab or Alt+Tab to change panels, arrows to change lines, enter to send docker container commands.");
|
||||||
|
description_text.push_str("\n Mouse input also available.");
|
||||||
|
description_text.push_str("\n ( q ) to quit at any time.");
|
||||||
|
description_text
|
||||||
|
.push_str("\n\n currenty an early work in progress, all and any input appreciated");
|
||||||
|
description_text.push_str(format!("\n {}", REPO.trim()).as_str());
|
||||||
|
|
||||||
|
let mut max_line_width = 0;
|
||||||
|
|
||||||
|
let all_text = format!("{}{}", NAME_TEXT, description_text);
|
||||||
|
|
||||||
|
all_text.lines().into_iter().for_each(|line| {
|
||||||
|
let width = line.chars().count();
|
||||||
|
if width > max_line_width {
|
||||||
|
max_line_width = width;
|
||||||
|
}
|
||||||
|
});
|
||||||
|
|
||||||
|
let mut lines = all_text.lines().count();
|
||||||
|
|
||||||
|
// Add some vertical and horizontal padding to the info box
|
||||||
|
lines += 3;
|
||||||
|
max_line_width += 4;
|
||||||
|
|
||||||
|
let name_paragraph = Paragraph::new(NAME_TEXT)
|
||||||
|
.style(Style::default().bg(Color::Magenta).fg(Color::White))
|
||||||
|
.block(Block::default())
|
||||||
|
.alignment(Alignment::Center);
|
||||||
|
|
||||||
|
let description_paragraph = Paragraph::new(description_text.as_str())
|
||||||
|
.style(Style::default().bg(Color::Magenta).fg(Color::Black))
|
||||||
|
.block(Block::default())
|
||||||
|
.alignment(Alignment::Left);
|
||||||
|
|
||||||
|
let block = Block::default()
|
||||||
|
.title(title)
|
||||||
|
.borders(Borders::ALL)
|
||||||
|
.border_type(BorderType::Rounded)
|
||||||
|
.border_style(Style::default().fg(Color::Black));
|
||||||
|
|
||||||
|
let area = centered_info(lines as u16, max_line_width as u16, f.size());
|
||||||
|
|
||||||
|
let split_popup = Layout::default()
|
||||||
|
.direction(Direction::Vertical)
|
||||||
|
.constraints(
|
||||||
|
[
|
||||||
|
Constraint::Max(NAME_TEXT.lines().count() as u16),
|
||||||
|
Constraint::Max(description_text.lines().count() as u16),
|
||||||
|
]
|
||||||
|
.as_ref(),
|
||||||
|
)
|
||||||
|
.split(area);
|
||||||
|
|
||||||
|
// Order is important here
|
||||||
|
f.render_widget(Clear, area);
|
||||||
|
f.render_widget(name_paragraph, split_popup[0]);
|
||||||
|
f.render_widget(description_paragraph, split_popup[1]);
|
||||||
|
f.render_widget(block, area);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Show error popup over whole screen
|
||||||
|
pub fn draw_error<B: Backend>(f: &mut Frame<'_, B>, error: AppError, seconds: Option<u8>) {
|
||||||
|
let block = Block::default()
|
||||||
|
.title(" Error ")
|
||||||
|
.border_type(BorderType::Rounded)
|
||||||
|
.title_alignment(Alignment::Center)
|
||||||
|
.borders(Borders::ALL);
|
||||||
|
|
||||||
|
let to_push = match error {
|
||||||
|
AppError::DockerConnect => {
|
||||||
|
format!(
|
||||||
|
"\n\n {}::v{} closing in {:02} seconds",
|
||||||
|
NAME,
|
||||||
|
VERSION,
|
||||||
|
seconds.unwrap_or(5)
|
||||||
|
)
|
||||||
|
}
|
||||||
|
_ => String::from("\n\n ( c ) to clear error\n ( q ) to quit oxker"),
|
||||||
|
};
|
||||||
|
|
||||||
|
let mut text = format!("\n{}", error);
|
||||||
|
|
||||||
|
text.push_str(to_push.as_str());
|
||||||
|
|
||||||
|
let mut max_line_width = 0;
|
||||||
|
text.lines().into_iter().for_each(|line| {
|
||||||
|
let width = line.chars().count();
|
||||||
|
if width > max_line_width {
|
||||||
|
max_line_width = width;
|
||||||
|
}
|
||||||
|
});
|
||||||
|
|
||||||
|
let mut lines = text.lines().count();
|
||||||
|
|
||||||
|
// Add some horizontal & vertical margins
|
||||||
|
max_line_width += 8;
|
||||||
|
lines += 3;
|
||||||
|
|
||||||
|
let paragraph = Paragraph::new(text)
|
||||||
|
.style(Style::default().bg(Color::Red).fg(Color::White))
|
||||||
|
.block(block)
|
||||||
|
.alignment(Alignment::Center);
|
||||||
|
|
||||||
|
let area = centered_info(lines as u16, max_line_width as u16, f.size());
|
||||||
|
f.render_widget(Clear, area);
|
||||||
|
f.render_widget(paragraph, area);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// draw a box in the center of the screen, based on max line width + number of lines
|
||||||
|
fn centered_info(number_lines: u16, max_line_width: u16, r: Rect) -> Rect {
|
||||||
|
// This can panic if number_lines or max_line_width is larger than r.height or r.width
|
||||||
|
let blank_vertical = (r.height - number_lines) / 2;
|
||||||
|
let blank_horizontal = (r.width - max_line_width) / 2;
|
||||||
|
|
||||||
|
let popup_layout = Layout::default()
|
||||||
|
.direction(Direction::Vertical)
|
||||||
|
.constraints(
|
||||||
|
[
|
||||||
|
Constraint::Max(blank_vertical),
|
||||||
|
Constraint::Max(number_lines),
|
||||||
|
Constraint::Max(blank_vertical),
|
||||||
|
]
|
||||||
|
.as_ref(),
|
||||||
|
)
|
||||||
|
.split(r);
|
||||||
|
|
||||||
|
Layout::default()
|
||||||
|
.direction(Direction::Horizontal)
|
||||||
|
.constraints(
|
||||||
|
[
|
||||||
|
Constraint::Max(blank_horizontal),
|
||||||
|
Constraint::Max(max_line_width),
|
||||||
|
Constraint::Max(blank_horizontal),
|
||||||
|
]
|
||||||
|
.as_ref(),
|
||||||
|
)
|
||||||
|
.split(popup_layout[1])[1]
|
||||||
|
}
|
||||||
@@ -0,0 +1,161 @@
|
|||||||
|
use std::{collections::HashMap, fmt};
|
||||||
|
use tui::layout::Rect;
|
||||||
|
|
||||||
|
#[derive(Debug, PartialEq, std::hash::Hash, std::cmp::Eq, Clone, Copy)]
|
||||||
|
pub enum SelectablePanel {
|
||||||
|
Containers,
|
||||||
|
Commands,
|
||||||
|
Logs,
|
||||||
|
}
|
||||||
|
#[derive(Debug)]
|
||||||
|
pub enum Loading {
|
||||||
|
One,
|
||||||
|
Two,
|
||||||
|
Three,
|
||||||
|
Four,
|
||||||
|
Five,
|
||||||
|
Six,
|
||||||
|
Seven,
|
||||||
|
Eight,
|
||||||
|
Nine,
|
||||||
|
Ten,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Loading {
|
||||||
|
pub fn next(&self) -> Self {
|
||||||
|
match self {
|
||||||
|
Self::One => Self::Two,
|
||||||
|
Self::Two => Self::Three,
|
||||||
|
Self::Three => Self::Four,
|
||||||
|
Self::Four => Self::Five,
|
||||||
|
Self::Five => Self::Six,
|
||||||
|
Self::Six => Self::Seven,
|
||||||
|
Self::Seven => Self::Eight,
|
||||||
|
Self::Eight => Self::Nine,
|
||||||
|
Self::Nine => Self::Ten,
|
||||||
|
Self::Ten => Self::One,
|
||||||
|
// Self::Five => Self::One
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
// "⠋",
|
||||||
|
// "⠙",
|
||||||
|
// "⠹",
|
||||||
|
// "⠸",
|
||||||
|
// "⠼",
|
||||||
|
// "⠴",
|
||||||
|
// "⠦",
|
||||||
|
// "⠧",
|
||||||
|
// "⠇",
|
||||||
|
// "⠏"
|
||||||
|
|
||||||
|
impl fmt::Display for Loading {
|
||||||
|
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
||||||
|
let disp = match self {
|
||||||
|
Self::One => "⠋",
|
||||||
|
Self::Two => "⠙",
|
||||||
|
Self::Three => "⠹",
|
||||||
|
Self::Four => "⠸",
|
||||||
|
Self::Five => "⠼",
|
||||||
|
Self::Six => "⠴",
|
||||||
|
Self::Seven => "⠦",
|
||||||
|
Self::Eight => "⠧",
|
||||||
|
Self::Nine => "⠇",
|
||||||
|
Self::Ten => "⠏",
|
||||||
|
};
|
||||||
|
write!(f, "{}", disp)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl SelectablePanel {
|
||||||
|
pub fn title(self) -> &'static str {
|
||||||
|
match self {
|
||||||
|
Self::Containers => "Containers",
|
||||||
|
Self::Logs => "Logs",
|
||||||
|
_ => "",
|
||||||
|
}
|
||||||
|
}
|
||||||
|
pub fn next(self) -> Self {
|
||||||
|
match self {
|
||||||
|
Self::Containers => Self::Commands,
|
||||||
|
Self::Commands => Self::Logs,
|
||||||
|
Self::Logs => Self::Containers,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
pub fn prev(self) -> Self {
|
||||||
|
match self {
|
||||||
|
Self::Containers => Self::Logs,
|
||||||
|
Self::Commands => Self::Containers,
|
||||||
|
Self::Logs => Self::Commands,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Global gui_state, stored in an Arc<Mutex>
|
||||||
|
#[derive(Debug)]
|
||||||
|
pub struct GuiState {
|
||||||
|
// Think this should be a BMapTree, so can define order when iterating over potential intersects
|
||||||
|
// Is an issue if two panels are in the same space, sush as a smaller panel embedded, yet infront of, a larger panel
|
||||||
|
// If a BMapTree think it would mean have to implement ordering for SelectablePanel
|
||||||
|
area_map: HashMap<SelectablePanel, Rect>,
|
||||||
|
loading: Loading,
|
||||||
|
pub selected_panel: SelectablePanel,
|
||||||
|
pub show_help: bool,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl GuiState {
|
||||||
|
/// Generate a default gui_state
|
||||||
|
pub fn default() -> Self {
|
||||||
|
Self {
|
||||||
|
area_map: HashMap::new(),
|
||||||
|
loading: Loading::One,
|
||||||
|
selected_panel: SelectablePanel::Containers,
|
||||||
|
show_help: false,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// clear panels hash map, so on resize can fix the sizes for mouse clicks
|
||||||
|
pub fn clear_area_map(&mut self) {
|
||||||
|
self.area_map.clear();
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Check if a given Rect (a clicked area of 1x1), interacts with any known panels
|
||||||
|
pub fn rect_insersects(&mut self, rect: Rect) {
|
||||||
|
if let Some(data) = self
|
||||||
|
.area_map
|
||||||
|
.iter()
|
||||||
|
.filter(|i| i.1.intersects(rect))
|
||||||
|
.collect::<Vec<_>>()
|
||||||
|
.get(0)
|
||||||
|
{
|
||||||
|
self.selected_panel = *data.0;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Insert selectable gui panel into area map
|
||||||
|
pub fn insert_into_area_map(&mut self, panel: SelectablePanel, area: Rect) {
|
||||||
|
self.area_map.entry(panel).or_insert(area);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Change to next selectable panel
|
||||||
|
pub fn next_panel(&mut self) {
|
||||||
|
self.selected_panel = self.selected_panel.next();
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Change to previous selectable panel
|
||||||
|
pub fn previous_panel(&mut self) {
|
||||||
|
self.selected_panel = self.selected_panel.prev();
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn next_loading(&mut self) {
|
||||||
|
self.loading = self.loading.next()
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn get_loading(&mut self) -> String {
|
||||||
|
self.loading.to_string()
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn reset_loading(&mut self) {
|
||||||
|
self.loading = Loading::One;
|
||||||
|
}
|
||||||
|
}
|
||||||
+215
@@ -0,0 +1,215 @@
|
|||||||
|
use anyhow::Result;
|
||||||
|
use crossterm::{
|
||||||
|
event::{self, DisableMouseCapture, EnableMouseCapture, Event},
|
||||||
|
execute,
|
||||||
|
terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
|
||||||
|
};
|
||||||
|
use parking_lot::Mutex;
|
||||||
|
use std::sync::atomic::AtomicBool;
|
||||||
|
use std::{
|
||||||
|
io,
|
||||||
|
sync::{atomic::Ordering, Arc},
|
||||||
|
};
|
||||||
|
use tokio::sync::broadcast::Sender;
|
||||||
|
use tui::{
|
||||||
|
backend::{Backend, CrosstermBackend},
|
||||||
|
layout::{Constraint, Direction, Layout},
|
||||||
|
Frame, Terminal,
|
||||||
|
};
|
||||||
|
|
||||||
|
mod color_match;
|
||||||
|
mod draw_blocks;
|
||||||
|
mod gui_state;
|
||||||
|
|
||||||
|
pub use self::color_match::*;
|
||||||
|
pub use self::gui_state::{GuiState, SelectablePanel};
|
||||||
|
use crate::{app_data::AppData, app_error::AppError, input_handler::InputMessages};
|
||||||
|
use draw_blocks::*;
|
||||||
|
|
||||||
|
/// Take control of the terminal in order to draw gui
|
||||||
|
pub async fn create_ui(
|
||||||
|
app_data: Arc<Mutex<AppData>>,
|
||||||
|
sender: Sender<InputMessages>,
|
||||||
|
is_running: Arc<AtomicBool>,
|
||||||
|
gui_state: Arc<Mutex<GuiState>>,
|
||||||
|
) -> Result<()> {
|
||||||
|
enable_raw_mode()?;
|
||||||
|
let mut stdout = io::stdout();
|
||||||
|
execute!(stdout, EnterAlternateScreen, EnableMouseCapture)?;
|
||||||
|
let backend = CrosstermBackend::new(stdout);
|
||||||
|
let mut terminal = Terminal::new(backend)?;
|
||||||
|
|
||||||
|
let res = run_app(&mut terminal, app_data, sender, is_running, gui_state).await;
|
||||||
|
|
||||||
|
disable_raw_mode().unwrap();
|
||||||
|
execute!(
|
||||||
|
terminal.backend_mut(),
|
||||||
|
LeaveAlternateScreen,
|
||||||
|
DisableMouseCapture
|
||||||
|
)?;
|
||||||
|
terminal.show_cursor().unwrap();
|
||||||
|
|
||||||
|
if let Err(err) = res {
|
||||||
|
err.disp()
|
||||||
|
}
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Run a loop to draw the gui
|
||||||
|
async fn run_app<B: Backend>(
|
||||||
|
terminal: &mut Terminal<B>,
|
||||||
|
app_data: Arc<Mutex<AppData>>,
|
||||||
|
sender: Sender<InputMessages>,
|
||||||
|
is_running: Arc<AtomicBool>,
|
||||||
|
gui_state: Arc<Mutex<GuiState>>,
|
||||||
|
) -> Result<(), AppError> {
|
||||||
|
let input_poll_rate = std::time::Duration::from_millis(75);
|
||||||
|
|
||||||
|
// Check for docker connect errors before attempting to draw the gui
|
||||||
|
let e = app_data.lock().get_error();
|
||||||
|
if let Some(error) = e {
|
||||||
|
if let AppError::DockerConnect = error {
|
||||||
|
let mut seconds = 5;
|
||||||
|
loop {
|
||||||
|
if seconds < 1 {
|
||||||
|
is_running.store(false, Ordering::SeqCst);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
terminal
|
||||||
|
.draw(|f| draw_error(f, AppError::DockerConnect, Some(seconds)))
|
||||||
|
.unwrap();
|
||||||
|
tokio::time::sleep(std::time::Duration::from_secs(1)).await;
|
||||||
|
seconds -= 1;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
loop {
|
||||||
|
terminal.draw(|f| ui(f, &app_data, &gui_state)).unwrap();
|
||||||
|
if crossterm::event::poll(input_poll_rate).unwrap() {
|
||||||
|
let event = event::read().unwrap();
|
||||||
|
if let Event::Key(key) = event {
|
||||||
|
sender
|
||||||
|
.send(InputMessages::ButtonPress(key.code))
|
||||||
|
.unwrap_or(0);
|
||||||
|
} else if let Event::Mouse(m) = event {
|
||||||
|
sender.send(InputMessages::MouseEvent(m)).unwrap_or(0);
|
||||||
|
} else if let Event::Resize(_, _) = event {
|
||||||
|
gui_state.lock().clear_area_map();
|
||||||
|
terminal.autoresize().unwrap_or(());
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
if !is_running.load(Ordering::SeqCst) {
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
|
||||||
|
fn ui<B: Backend>(
|
||||||
|
f: &mut Frame<'_, B>,
|
||||||
|
app_data: &Arc<Mutex<AppData>>,
|
||||||
|
gui_state: &Arc<Mutex<GuiState>>,
|
||||||
|
) {
|
||||||
|
// set max height for container section, needs +4 to deal with docker commands list and borders
|
||||||
|
let mut height = app_data.lock().get_container_len();
|
||||||
|
if height < 12 {
|
||||||
|
height += 4;
|
||||||
|
} else {
|
||||||
|
height = 12
|
||||||
|
}
|
||||||
|
|
||||||
|
let column_widths = app_data.lock().get_width();
|
||||||
|
let has_containers = !app_data.lock().containers.items.is_empty();
|
||||||
|
let has_error = app_data.lock().get_error();
|
||||||
|
let log_index = app_data.lock().get_selected_log_index();
|
||||||
|
let selected_panel = gui_state.lock().selected_panel;
|
||||||
|
let show_help = gui_state.lock().show_help;
|
||||||
|
|
||||||
|
let whole_layout = Layout::default()
|
||||||
|
.direction(Direction::Vertical)
|
||||||
|
.constraints([Constraint::Min(1), Constraint::Min(100)].as_ref())
|
||||||
|
.split(f.size());
|
||||||
|
|
||||||
|
// Split into 3, containers+controls, logs, then graphs
|
||||||
|
let upper_main = Layout::default()
|
||||||
|
.direction(Direction::Vertical)
|
||||||
|
.constraints([Constraint::Max(height as u16), Constraint::Percentage(50)].as_ref())
|
||||||
|
.split(whole_layout[1]);
|
||||||
|
|
||||||
|
let top_split = if has_containers {
|
||||||
|
vec![Constraint::Percentage(90), Constraint::Percentage(10)]
|
||||||
|
} else {
|
||||||
|
vec![Constraint::Percentage(100)]
|
||||||
|
};
|
||||||
|
// Containers + docker commands
|
||||||
|
let top_panel = Layout::default()
|
||||||
|
.direction(Direction::Horizontal)
|
||||||
|
.constraints(top_split.as_ref())
|
||||||
|
.split(upper_main[0]);
|
||||||
|
|
||||||
|
let lower_split = if has_containers {
|
||||||
|
vec![Constraint::Percentage(75), Constraint::Percentage(25)]
|
||||||
|
} else {
|
||||||
|
vec![Constraint::Percentage(100)]
|
||||||
|
};
|
||||||
|
|
||||||
|
// Split into 3, containers+controls, logs, then graphs
|
||||||
|
let lower_main = Layout::default()
|
||||||
|
.direction(Direction::Vertical)
|
||||||
|
.constraints(lower_split.as_ref())
|
||||||
|
.split(upper_main[1]);
|
||||||
|
|
||||||
|
draw_containers(
|
||||||
|
app_data,
|
||||||
|
top_panel[0],
|
||||||
|
f,
|
||||||
|
gui_state,
|
||||||
|
&selected_panel,
|
||||||
|
&column_widths,
|
||||||
|
);
|
||||||
|
|
||||||
|
if has_containers {
|
||||||
|
draw_commands(
|
||||||
|
app_data,
|
||||||
|
top_panel[1],
|
||||||
|
f,
|
||||||
|
gui_state,
|
||||||
|
log_index,
|
||||||
|
&selected_panel,
|
||||||
|
);
|
||||||
|
}
|
||||||
|
|
||||||
|
draw_logs(
|
||||||
|
app_data,
|
||||||
|
lower_main[0],
|
||||||
|
f,
|
||||||
|
gui_state,
|
||||||
|
log_index,
|
||||||
|
&selected_panel,
|
||||||
|
);
|
||||||
|
|
||||||
|
draw_info_bar(
|
||||||
|
whole_layout[0],
|
||||||
|
&column_widths,
|
||||||
|
f,
|
||||||
|
has_containers,
|
||||||
|
show_help,
|
||||||
|
);
|
||||||
|
|
||||||
|
// only draw charts if there are containers
|
||||||
|
if has_containers {
|
||||||
|
draw_chart(f, lower_main[1], app_data, log_index);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Check if error, and show popup if so
|
||||||
|
if show_help {
|
||||||
|
draw_help_box(f);
|
||||||
|
}
|
||||||
|
|
||||||
|
if let Some(error) = has_error {
|
||||||
|
app_data.lock().show_error = true;
|
||||||
|
draw_error(f, error, None);
|
||||||
|
}
|
||||||
|
}
|
||||||
Reference in New Issue
Block a user