127 lines
8.1 KiB
Python
127 lines
8.1 KiB
Python
#!/usr/bin/env python3
|
|
"""Root-owned local helper. Only inventory and fresh Docker install; no generic RPC."""
|
|
import argparse
|
|
import json
|
|
import os
|
|
from pathlib import Path
|
|
import shutil
|
|
import socket
|
|
import socketserver
|
|
import struct
|
|
import subprocess
|
|
import threading
|
|
import time
|
|
|
|
MANAGED_LABEL='io.athena-deck.managed=true'
|
|
ROLE_LABEL='io.athena-deck.role=application'
|
|
PACKAGES=['docker-ce','docker-ce-cli','containerd.io','docker-buildx-plugin','docker-compose-plugin']
|
|
CONFLICTS=['docker.io','docker-compose','docker-doc','docker-buildx','podman-docker','containerd','runc']
|
|
ENV={'PATH':'/usr/sbin:/usr/bin:/sbin:/bin','HOME':'/var/lib/athena-deck-docker','LANG':'C.UTF-8','DEBIAN_FRONTEND':'noninteractive','NEEDRESTART_MODE':'l'}
|
|
|
|
def run(args,timeout=15):
|
|
return subprocess.run(args,capture_output=True,text=True,timeout=timeout,env=ENV)
|
|
|
|
def release():
|
|
return dict(line.split('=',1) for line in Path('/etc/os-release').read_text().replace('"','').splitlines() if '=' in line)
|
|
|
|
class Manager:
|
|
def __init__(self,state,allow_install=False):
|
|
self.state=Path(state);self.allow_install=allow_install;self.lock=threading.RLock();self.job=None
|
|
if (self.state/'job.json').exists():
|
|
self.job=json.loads((self.state/'job.json').read_text())
|
|
if self.job['state']=='running':self.job.update(state='interrupted',phase='Installation unterbrochen. Hostzustand prüfen; vorhandene Pakete werden nicht automatisch ersetzt.')
|
|
def inventory(self):
|
|
# Filter at the daemon before retrieving rows. No inspect, env, mounts or logs.
|
|
result=run(['/usr/bin/docker','ps','-a','--no-trunc','--filter','label='+MANAGED_LABEL,'--filter','label='+ROLE_LABEL,'--format','{{.ID}}\t{{.Names}}\t{{.Image}}\t{{.State}}\t{{.Status}}'])
|
|
if result.returncode:raise ValueError('Docker-Daemon nicht erreichbar.')
|
|
rows=[]
|
|
for line in result.stdout.splitlines()[:500]:
|
|
fields=line.split('\t')
|
|
if len(fields)==5:rows.append(dict(zip(('id','name','image','state','status'),fields)))
|
|
return rows
|
|
def preflight(self):
|
|
info=release()
|
|
if info.get('ID')!='debian' or info.get('VERSION_ID') not in ('12','13'):return False,'Unterstützt werden Debian 12 und 13.'
|
|
if Path('/usr/bin/docker').exists() or Path('/var/run/docker.sock').exists():return False,'Docker ist vorhanden. Keine automatische Neuinstallation oder Aktualisierung.'
|
|
if not self.allow_install:return False,'Docker-Erstinstallation ist für diesen Helfer nicht freigegeben.'
|
|
if any(Path(p).exists() for p in ('/var/lib/docker','/var/lib/containerd','/etc/docker')):return False,'Vorhandene Containerdaten oder Konfiguration erkannt. Manuelle Prüfung erforderlich.'
|
|
for package in CONFLICTS+PACKAGES:
|
|
value=run(['/usr/bin/dpkg-query','-W','-f=${Status}',package])
|
|
if value.returncode==0 and 'install ok installed' in value.stdout:return False,'Vorhandene Containerpakete erkannt. Keine automatische Entfernung oder Ersetzung.'
|
|
if shutil.disk_usage('/var').free<3*1024**3:return False,'Mindestens 3 GiB freier Speicher erforderlich.'
|
|
return True,'Docker Engine, Compose und Buildx aus dem offiziellen Docker-Repository installieren. Docker richtet einen Systemdienst sowie eigene Netzwerk-/Firewallregeln ein. Keine NVIDIA-Treiberinstallation und kein Host-Neustart.'
|
|
def status(self):
|
|
installed=Path('/usr/bin/docker').exists();reachable=False;version=None;services=[]
|
|
if installed:
|
|
try:
|
|
version_result=run(['/usr/bin/docker','version','--format','{{.Server.Version}}'])
|
|
if version_result.returncode==0:version=version_result.stdout.strip();services=self.inventory();reachable=True
|
|
except (OSError,ValueError,subprocess.SubprocessError):pass
|
|
supported,message=self.preflight()
|
|
with self.lock:job=dict(self.job) if self.job else None
|
|
return dict(installed=installed,reachable=reachable,version=version,services=services,install_supported=supported,message=message,job=job,labels=[MANAGED_LABEL,ROLE_LABEL])
|
|
def _phase(self,text,state='running'):
|
|
with self.lock:
|
|
self.job.update(state=state,phase=text);self.state.mkdir(parents=True,exist_ok=True,mode=0o700)
|
|
temp=self.state/'job.tmp';temp.write_text(json.dumps(self.job));temp.replace(self.state/'job.json')
|
|
def install(self):
|
|
with self.lock:
|
|
if self.job and self.job['state']=='running':raise ValueError('Docker-Installation läuft bereits.')
|
|
allowed,message=self.preflight()
|
|
if not allowed:raise ValueError(message)
|
|
self.job=dict(state='running',phase='Docker-Erstinstallation wird vorbereitet',started_at=time.time())
|
|
self._phase(self.job['phase']);threading.Thread(target=self._install,daemon=True).start()
|
|
return {'started':True}
|
|
def _checked(self,args):
|
|
result=run(args,timeout=1200)
|
|
if result.returncode:raise ValueError('Installationsschritt fehlgeschlagen. Paketverwaltung und Internetverbindung auf dem Host prüfen.')
|
|
def _install(self):
|
|
try:
|
|
info=release();codename={'12':'bookworm','13':'trixie'}[info['VERSION_ID']]
|
|
arch=run(['/usr/bin/dpkg','--print-architecture']).stdout.strip()
|
|
if arch not in ('amd64','arm64'):raise ValueError('Diese Architektur wird vom Deck-Installer noch nicht unterstützt.')
|
|
self._phase('Paketquellen prüfen und Download-Werkzeuge installieren')
|
|
self._checked(['/usr/bin/apt-get','update'])
|
|
self._checked(['/usr/bin/apt-get','install','-y','--no-remove','ca-certificates','curl'])
|
|
key=Path('/etc/apt/keyrings/athena-deck-docker.asc');source=Path('/etc/apt/sources.list.d/athena-deck-docker.sources')
|
|
key.parent.mkdir(mode=0o755,exist_ok=True)
|
|
self._checked(['/usr/bin/curl','--fail','--silent','--show-error','--proto','=https','--tlsv1.2','--max-time','60','https://download.docker.com/linux/debian/gpg','-o',str(key)])
|
|
key.chmod(0o644)
|
|
source.write_text(f'Types: deb\nURIs: https://download.docker.com/linux/debian\nSuites: {codename}\nComponents: stable\nArchitectures: {arch}\nSigned-By: {key}\n');source.chmod(0o644)
|
|
self._phase('Docker Engine, Compose und Buildx installieren')
|
|
self._checked(['/usr/bin/apt-get','update'])
|
|
self._checked(['/usr/bin/apt-get','install','-y','--no-remove',*PACKAGES])
|
|
self._phase('Docker-Systemdienst starten und Erreichbarkeit prüfen')
|
|
self._checked(['/usr/bin/systemctl','enable','--now','docker.service'])
|
|
self._checked(['/usr/bin/docker','version','--format','{{.Server.Version}}'])
|
|
self._checked(['/usr/bin/docker','compose','version','--short'])
|
|
self._phase('Docker bereit. Keine Anwendungen oder Modelle installiert.','complete')
|
|
except Exception as exc:self._phase(str(exc) if isinstance(exc,ValueError) else 'Docker-Installation fehlgeschlagen. Hostzustand vor erneutem Versuch prüfen.','failed')
|
|
def dispatch(self,data):
|
|
if not isinstance(data,dict) or set(data)!={'action'}:raise ValueError('Ungültige Helferanfrage.')
|
|
if data['action']=='status':return self.status()
|
|
if data['action']=='install':return self.install()
|
|
raise ValueError('Aktion nicht erlaubt.')
|
|
|
|
class Handler(socketserver.StreamRequestHandler):
|
|
def handle(self):
|
|
self.connection.settimeout(20)
|
|
try:
|
|
_,uid,_=struct.unpack('3i',self.connection.getsockopt(socket.SOL_SOCKET,socket.SO_PEERCRED,12))
|
|
if uid not in (0,self.server.client_uid):raise ValueError('Client nicht erlaubt.')
|
|
raw=self.rfile.readline(4097)
|
|
if len(raw)>4096:raise ValueError('Anfrage zu groß.')
|
|
result=self.server.manager.dispatch(json.loads(raw))
|
|
except Exception as exc:result={'error':str(exc) if isinstance(exc,ValueError) else 'Docker-Systemhelfer nicht verfügbar.'}
|
|
self.wfile.write(json.dumps(result).encode()+b'\n')
|
|
|
|
class Server(socketserver.ThreadingUnixStreamServer):
|
|
daemon_threads=True
|
|
|
|
def main():
|
|
parser=argparse.ArgumentParser();parser.add_argument('--client-uid',type=int,required=True);parser.add_argument('--client-gid',type=int,required=True);parser.add_argument('--allow-install',action='store_true');parser.add_argument('--state',default='/var/lib/athena-deck-docker');args=parser.parse_args()
|
|
socket_path=Path('/run/athena-deck-docker/control.sock');socket_path.parent.mkdir(mode=0o755,exist_ok=True);socket_path.unlink(missing_ok=True)
|
|
with Server(str(socket_path),Handler) as server:
|
|
os.chown(socket_path,0,args.client_gid);socket_path.chmod(0o660);server.client_uid=args.client_uid;server.manager=Manager(args.state,args.allow_install);server.serve_forever()
|
|
if __name__=='__main__':main()
|