Files
komodo/bin/periphery/src/api/image.rs
T
Maxwell Becker 5fc0a87dea 1.14 - Rename to Komodo - Docker Management (#56)
* setup network page

* add Network, Image, Container

* Docker ListItems and Inspects

* frontend build

* dev0

* network info working

* fix cargo lock

* dev1

* pages for the things

* implement Active in dashboard

* RunBuild update trigger list refresh

* rename deployment executions to StartDeployment etc

* add server level container control

* dev2

* add Config field to Image

* can get image labels from Config.Labels

* mount container page

* server show resource count

* add GetContainerLog api

* add _AllContainers api

* dev3

* move ResourceTarget to entities mod

* GetResourceMatchingContainer api

* connect container to resource

* dev4 add volume names to container list items

* ts types

* volume / image / network unused management

* add image history to image page

* fix PruneContainers incorret Operation

* update cache for server for server after server actions

* dev5

* add singapore to Hetzner

* implement delete single network / image / volume api

* dev6

* include "in use" on Docker Lists

* add docker resource delete buttons

* is nice

* fix volume all in use

* remove google font dependency

* use host networking in test compose

* implement Secret Variables (hidden in logs)

* remove unneeded borrow

* interpolate variables / secrets into extra args / onclone / onpull / command etc

* validate empty strings before SelectItem

* rename everything to Komodo

* rename workspace to komodo

* rc1
2024-09-01 15:38:40 -07:00

64 lines
1.4 KiB
Rust

use command::run_komodo_command;
use komodo_client::entities::{
docker::image::{Image, ImageHistoryResponseItem},
update::Log,
};
use periphery_client::api::image::*;
use resolver_api::Resolve;
use crate::{docker::docker_client, State};
//
impl Resolve<InspectImage> for State {
#[instrument(name = "InspectImage", level = "debug", skip(self))]
async fn resolve(
&self,
InspectImage { name }: InspectImage,
_: (),
) -> anyhow::Result<Image> {
docker_client().inspect_image(&name).await
}
}
//
impl Resolve<ImageHistory> for State {
#[instrument(name = "ImageHistory", level = "debug", skip(self))]
async fn resolve(
&self,
ImageHistory { name }: ImageHistory,
_: (),
) -> anyhow::Result<Vec<ImageHistoryResponseItem>> {
docker_client().image_history(&name).await
}
}
//
impl Resolve<DeleteImage> for State {
#[instrument(name = "DeleteImage", skip(self))]
async fn resolve(
&self,
DeleteImage { name }: DeleteImage,
_: (),
) -> anyhow::Result<Log> {
let command = format!("docker image rm {name}");
Ok(run_komodo_command("delete image", command).await)
}
}
//
impl Resolve<PruneImages> for State {
#[instrument(name = "PruneImages", skip(self))]
async fn resolve(
&self,
_: PruneImages,
_: (),
) -> anyhow::Result<Log> {
let command = String::from("docker image prune -a -f");
Ok(run_komodo_command("prune images", command).await)
}
}