jpmschweitzerandClaude
7b80e30691
Non-interactive equivalent of system-admin-toj's prune-docker.sh, which prompts per stage and so cannot run from cron. Only the stages that discard regenerable data run by default: build cache and dangling images. Unused images and volumes are opt-in, because docker volume prune removes volumes belonging to merely-stopped containers rather than only orphaned ones, which on this host is a plausible way to lose a database. A failing stage is reported and the remaining stages still run, since a partial reclaim beats none, but the task still ends up failed so the error is not swallowed. Co-Authored-By: Claude <noreply@anthropic.com>
110 lines
4.1 KiB
Python
110 lines
4.1 KiB
Python
"""
|
|
Docker Prune Executor
|
|
|
|
Scheduled, non-interactive reclaim of Docker disk usage. The host equivalent is
|
|
system-admin-toj's scripts/disk/prune-docker.sh, which prompts per stage; a cron
|
|
task cannot prompt, so the destructive stages are opt-in instead.
|
|
|
|
Runs the docker CLI against the socket already mounted into this container.
|
|
|
|
Config schema:
|
|
{
|
|
"build_cache": true, # safe: cache is rebuilt on demand
|
|
"dangling_images": true, # safe: untagged layers nothing references
|
|
"unused_images": false, # re-pull on next deploy; costs bandwidth
|
|
"volumes": false, # DESTRUCTIVE - see below
|
|
"build_cache_until_hours": 168,
|
|
"dry_run": false
|
|
}
|
|
|
|
`volumes` is off by default and should stay off unless you have checked what is
|
|
actually unattached. `docker volume prune` removes every volume not bound to a
|
|
*running* container, which includes the data volume of anything merely stopped.
|
|
On this host that is a plausible way to lose a database.
|
|
|
|
Defaults are the two stages that only ever discard regenerable data.
|
|
"""
|
|
import asyncio
|
|
import logging
|
|
from typing import Any, Dict, List, Tuple
|
|
|
|
from src.config import Settings
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
COMMAND_TIMEOUT = 900
|
|
|
|
|
|
async def _run(args: List[str]) -> Tuple[int, str, str]:
|
|
proc = await asyncio.create_subprocess_exec(
|
|
*args,
|
|
stdout=asyncio.subprocess.PIPE,
|
|
stderr=asyncio.subprocess.PIPE,
|
|
)
|
|
try:
|
|
stdout, stderr = await asyncio.wait_for(proc.communicate(), timeout=COMMAND_TIMEOUT)
|
|
except asyncio.TimeoutError:
|
|
proc.kill()
|
|
await proc.wait()
|
|
raise Exception(f"timed out after {COMMAND_TIMEOUT}s: {' '.join(args)}")
|
|
return proc.returncode, stdout.decode().strip(), stderr.decode().strip()
|
|
|
|
|
|
def _reclaimed(output: str) -> str:
|
|
"""Pull the 'Total reclaimed space: X' line out of docker's prune output."""
|
|
for line in output.splitlines():
|
|
if "reclaimed space" in line.lower():
|
|
return line.split(":", 1)[1].strip()
|
|
return "0B"
|
|
|
|
|
|
async def execute(config: Dict[str, Any], settings: Settings) -> str:
|
|
dry_run = bool(config.get("dry_run", False))
|
|
until_hours = int(config.get("build_cache_until_hours", 168))
|
|
|
|
stages: List[Tuple[str, List[str]]] = []
|
|
if config.get("build_cache", True):
|
|
stages.append(
|
|
("build cache", ["docker", "builder", "prune", "-f", "--filter", f"until={until_hours}h"])
|
|
)
|
|
if config.get("dangling_images", True):
|
|
stages.append(("dangling images", ["docker", "image", "prune", "-f"]))
|
|
if config.get("unused_images", False):
|
|
stages.append(("unused images", ["docker", "image", "prune", "-a", "-f"]))
|
|
if config.get("volumes", False):
|
|
logger.warning(
|
|
"volume pruning is enabled; this removes volumes belonging to stopped "
|
|
"containers, not just orphaned ones"
|
|
)
|
|
stages.append(("volumes", ["docker", "volume", "prune", "-f"]))
|
|
|
|
if not stages:
|
|
return "no prune stages enabled; nothing to do"
|
|
|
|
rc, out, err = await _run(["docker", "system", "df"])
|
|
if rc != 0:
|
|
raise Exception(f"docker unavailable: {err or out}")
|
|
before = out
|
|
|
|
if dry_run:
|
|
planned = ", ".join(name for name, _ in stages)
|
|
logger.info("dry run; would prune: %s", planned)
|
|
return f"dry run - would prune: {planned}\n{before}"
|
|
|
|
results = []
|
|
for name, args in stages:
|
|
rc, out, err = await _run(args)
|
|
if rc != 0:
|
|
# Report rather than abort: a later stage may still reclaim space, and
|
|
# a partial reclaim is more useful than none.
|
|
logger.error("prune stage %r failed: %s", name, err or out)
|
|
results.append(f"{name}: FAILED ({(err or out).splitlines()[0] if (err or out) else 'unknown'})")
|
|
continue
|
|
results.append(f"{name}: {_reclaimed(out)}")
|
|
logger.info("pruned %s -> %s", name, _reclaimed(out))
|
|
|
|
summary = "; ".join(results)
|
|
if any("FAILED" in r for r in results):
|
|
raise Exception(f"one or more prune stages failed: {summary}")
|
|
return f"reclaimed - {summary}"
|