Zum Hauptinhalt springen
Auf dieser Seite

Diagramme

Diagramme mit einem Flussdiagramm aus LosOS Cloud: die Ansichten und die Dateiauswahl, die Zeichenfläche mit Karten und Pfeilen und die Leiste zu diesem Diagramm.

LosOS Diagrams ist ein Diagrammeditor: Flussdiagramme, Pläne, Mindmaps, Boards und Netzwerkzeichnungen, geschrieben als Karten auf einer Zeichenfläche. Seine Dateien sind JSON Canvas, das Format von Obsidian Canvas, sodass eine .canvas-Datei zwischen beiden wandert, ohne etwas zu verlieren. Es kennt auch LosOS. Ein Netzwerk, das du zeichnest, hat seinen eigenen Verkehr, und eine Karte kann für eine Maschine stehen, die du im Mesh bestellt hast. Es ist ein Bildschirm der Administrationsoberfläche unter /diagrams, in der Seitenleiste unter Diagramme, aufgebaut wie LosOS Mail: die Überschrift mit Neues Diagramm daneben, eine Reihe Schaltflächen für die Ansichten mit der Aufbauauswahl am Ende und eine Karte mit den Werkzeugen, der Zeichenfläche, der Ablage und dem Inspektor. Wie die übrige Administrationsoberfläche antwortet es nur im lokalen Netz. Die alte Adresse /lab/ leitet zur neuen weiter.

Die Reihe unter der Überschrift wechselt zwischen drei Ansichten eines Dokuments: Diagramm, die Zeichenfläche, und Logisch und Physisch, das Netzwerk darin, wie der Simulator es zeichnet.

Das Diagramm​

  • Karten. Ein Doppelklick auf die Fläche legt eine Textkarte an, oder nimm eine aus der Leiste: Text, Notiz, Gruppe, Webseite und die Formen Pille, Raute, Kreis, Parallelogramm, Sechseck, Datenbank, Dokument, Prozess und Wolke. Der Text einer Karte ist Markdown: Überschriften, Listen und Aufgabenlisten, Zitate und Hinweise, Code, Links, **fett**, *kursiv*, ~~durchgestrichen~~ und ==markiert==. Ein Doppelklick auf eine Karte bearbeitet sie; Escape oder ein Klick daneben beendet die Bearbeitung.
  • @-Markierungen. Tippe @ in eine Karte, und du bekommst eine Liste der Personen auf der Box und der Dateien in deiner LosOS Cloud. Eine Person kommt als ihr Anmeldename hinein, @eva, und die Karte zeigt sie mit ihrem Bild. Eine Datei kommt als Link hinein, [@plan.canvas](/diagrams?file=…), der ein Diagramm in Diagrams öffnet und jede andere Datei in ihrem Ordner in LosOS Cloud. Obsidian liest beides als einfachen Text und Link.
  • Pfeile. Zieh von einem der vier Griffe an den Seiten einer Karte auf eine andere Karte, oder auf leere Fläche für eine neue Karte dort. Ein Pfeil hat eine Beschriftung, einen Verlauf (gerade, rechtwinklig oder um die Karten herum), eine gepunktete oder gestrichelte Linie und eine Spitze an jedem Ende. Zwischen zwei Geräten ist der Pfeil ein Kabel, es sei denn, in der Leiste ist Pfeil gewählt.
  • Gruppen, Farben und Anordnung. Eine Gruppe ist ein beschrifteter Rahmen; Karten darin bewegen sich mit ihr. Sechs Farben folgen dem hellen und dem dunklen Thema, oder wähle eine beliebige Farbe. Der Inspektor ordnet, richtet aus, gruppiert, dupliziert und löscht die Auswahl, und dasselbe tut eine Leiste, die über der Auswahl erscheint (siehe die Leiste über einer Auswahl), die außerdem einen Pfeil zwischen zwei ausgewählten Karten zieht. Rückgängig und Wiederholen decken jede Änderung ab.
  • Vorlagen. Ein Flussdiagramm, eine Dienstarchitektur, eine Mindmap, ein Board und ein Heimnetz, abgelegt, wo du klickst.
  • Dateien. Datei speichert das Diagramm als .canvas-Datei und öffnet eine. Läuft LosOS Cloud auf der Box, öffnet und speichert es Diagramme auch dort, und eine .canvas-Datei in LosOS Cloud öffnet sich in Diagramme. Das Zurückspeichern nennt die Version, die es gelesen hat: Hat sich die Datei inzwischen geändert, wird das Speichern abgelehnt und nichts überschrieben. Strg+S speichert dorthin, woher das Diagramm kam. Das Bild lässt sich als SVG oder PNG exportieren.
  • Gemeinsam bearbeiten. Ein aus LosOS Cloud geöffnetes Diagramm ist live: Öffne dieselbe Datei in einem anderen Tab oder auf einem anderen Computer, und beide bearbeiten ein Diagramm. LosOS Cloud hält es im selben Live-Raum wie eine Textdatei und schreibt jede Änderung einen Moment später in die Datei, es gibt also nichts zu speichern. In der Werkzeugreihe über der Zeichenfläche sind die Gesichter aller, die es offen haben, und Zeiger, Name und Auswahl jeder Person erscheinen auf der Zeichenfläche der anderen in ihrer Farbe. Rückgängig nimmt deine eigenen Änderungen zurück, nicht die von anderen. Teile eine .canvas-Datei mit jemandem auf einer anderen Box, und sie öffnet sich dort aus Mit dir geteilt in Diagramme, im selben Raum; eine Freigabe nur zum Ansehen zeigt das Diagramm und nimmt keine Änderung an. Ändern zwei Personen die Datei im selben Moment, bleiben beide Änderungen erhalten.
  • Maschinen. Maschinen in der Leiste listet die virtuellen Maschinen, die diese Box im Mesh bestellt hat. Leg eine ab, und ihre Karte zeigt jede Kopie und was sie gerade tut, alle 20 Sekunden neu gelesen. Eine Karte kann eine Maschine auch aus einem Image planen; ihr Link Bestellen öffnet die Seite Maschinen mit Image und Namen ausgefüllt. Eine Box, die ihre Platte nicht mit dem Mesh teilt, bekommt keine Maschinen angeboten, und die Leiste sagt, warum.

Formen, Rahmen, Textausrichtung, Linienarten und Pfeilspitzen werden als styleAttributes mit den Namen geschrieben, die das Plugin Advanced Canvas für Obsidian verwendet. Schlüssel, die Diagramme nicht kennt, am Dokument, an einer Karte oder an einem Pfeil, bleiben beim nächsten Speichern, wie sie waren. Ältere .llf-Dateien des Netzwerksimulators öffnen sich weiterhin.

Das Netzwerk​

Ein Gerät aus der Leiste (eine Box, eine Edge, ein Router, ein Switch, ein Laptop) ist eine Karte, die der Simulator betreibt, und ein Pfeil zwischen zweien davon ist ein Kabel. Die Seite öffnet mit This box (diese Box): Sie liest die Einstellungen der Box und die Edges, die sie gefunden hat, über dieselben drei Administrationsrouten wie die anderen Seiten, und zeichnet die Box daraus: ihren Router, die erreichbaren Edges, die offizielle Edge, sofern eine konfiguriert ist, und einen Laptop. Router, Kabel und Laptop sind angenommen, weil die Box sie nicht sehen kann. Diagramme schreibt nie auf die Box. Ist niemand angemeldet, sagt die Seite das und öffnet die eingebauten Setups.

  • Logisch und Physisch. Die logische Ansicht zeigt Subnetze, die Edge-Pfade und das Mesh. Die physische Ansicht zeigt Racks, Schreibtische und die Kabel dazwischen.
  • Modi Echtzeit und Simulation. Echtzeit spielt den Verkehr ab, wie er geschieht. Es hat eine Uhr, die du beschleunigen kannst (1×, 10×, 60×, 10 min/s, 1 h/s), und eine Schaltfläche, die zum nächsten Timer springt: dem Neustart um 00:07, dem Upgrade um 03:00, der Garbage Collection um 04:30 sowie Beginn und Ende des Rechenfensters. Simulation hält jedes Paket an, bis du Abspielen oder Schritt drückst, und listet jeden Hop mit seinem Protokoll auf.
  • Eigene Setups. Beginne mit einem neuen Diagramm oder einem beliebigen eingebauten Setup, zieh Geräte aus der Leiste und zieh Kupfer, Glasfaser oder WLAN zwischen ihren Ports. Das zuletzt geänderte Diagramm wird im Browser gespeichert und in der Auswahl als "Letztes Diagramm" aufgeführt. Eine geöffnete Datei wird mit denselben Werkzeugen wie die Leiste neu aufgebaut; ein Gerät oder Kabel darin, das die Leiste nicht erzeugen könnte, bleibt also weg, und die Seite sagt, wie viele Teile sie verworfen hat.
  • Eingebaute Setups. Zwei Standorte hinter einer offiziellen Edge, eine einzelne Box zu Hause, eine Firma mit eigenem Gateway, ein LAN ohne Internet und drei Lehrbuchformen: Stern, Bus und vermaschtes Netz. Sie sind nur Ausgangspunkte, gebaut mit derselben Leiste.
  • Ein Laptop mit LosOS Desktop. Er hat den Anmeldebildschirm, die Übersicht und den Browser, den du auf jede Box und jede Edge im Diagramm richten kannst.
  • Netzwerkgeräte (Router, Switches, WLAN-Access-Points und ein Koax-Bus) laufen mit einem eigenen kleinen System namens Netzgeräte Betriebssystem. Seine Konsole kennt show interfaces, show ip route, show arp und show dhcp.

Das Netzwerk folgt denselben Regeln wie die echte Software. Beispiele: Eine Box ohne erreichbare Edge startet keinen Tunnel; ein Wechsel zum Mesh wird mit edgeRequired abgelehnt; der Markt öffnet nur neben einer offiziellen Edge (einer, die die Gateway-Prüfung besteht); ein LAN-Gateway mit offener Registrierung nimmt unbekannte Boxen bei der ersten Nutzung auf; und die Administrationsrouten lehnen Loopback ab.

Die zwei Kopien​

Auf der Box (/diagrams/)Gehostet
Gebaut vonnix build .#losos-admin-ui (Diagramme ist ein Bildschirm davon)admin-ui/lab/engine/build.ts in lab.yml
Konsolensimuliert, oder echte Gäste unter libvirt, wenn die Box den Helfer ausführtechte x86_64-Gäste unter libvirt auf deinem Rechner, sonst qemu-wasm
Brauchtnichts außer der Boxeinen Cross-Origin-isolierten Host (COOP + COEP)

Diagramme ist Teil der Administrationsoberfläche: src/lab/app.tsx ist der Bildschirm unter /diagrams, ein eigener Teil des Codes, der beim ersten Öffnen geladen wird, gebaut aus denselben Komponenten, derselben Palette, denselben Icons und Sprachen wie jeder Bereich. Alles, was nicht Zeichnen ist, läuft in WebAssembly: Modell, Simulator, Uhr, Konsolen und Seiten sind ein Rust-Crate, admin-ui/lab/core (losos-lab-core), das nix vor dem eigentlichen Build der Administrationsoberfläche für wasm32 baut. Die Content Security Policy der Administrationsseite enthält 'wasm-unsafe-eval', damit der Browser den Kern kompilieren darf; eine Seite darf damit WebAssembly kompilieren und nichts weiter, und Skripte kommen weiterhin nur aus den eigenen Dateien der Box.

Die gehostete Kopie ist derselbe Bildschirm auf einer eigenen Seite (admin-ui/app/diagrams/index.html, nur mit LOSOS_LAB_HOSTED=1 gebaut), plus qemu-wasm: QEMU nach WebAssembly kompiliert, sodass jede Konsole ein echter Linux-Gast im Browser-Tab ist. Boxen und Edges booten ein busybox als Ersatz für LosOS, und die Netzwerkgeräte booten Netzgeräte Betriebssystem, das nix aus admin-ui/lab/engine/gear/netzgeraete.nix baut. Das Lab verbindet die Netzwerkkarten der Gäste mit dem Diagramm, sodass DHCP, ARP, Ping und HTTP zwischen Gästen über die Kabel laufen, die du gezogen hast. Ein Router-Gast vergibt Leases mit seinem eigenen udhcpd. Ein Tab führt höchstens drei Gäste gleichzeitig aus. Mit einem vierten gingen den Gästen die Kerne aus und sie blieben hängen, deshalb weigert sich die Seite, einen weiteren zu booten. qemu-wasm führt die Threads von QEMU als Web Worker mit gemeinsamem Speicher aus, und Browser erlauben das nur auf einer Seite, die mit Cross-Origin-Opener-Policy: same-origin und Cross-Origin-Embedder-Policy: require-corp ausgeliefert wird. vercel.json setzt beide Header auf Vercel, und serve.json tut dasselbe für serve auf deinem eigenen Rechner:

admin-ui/lab/engine/build.ts /tmp/lab # docker, nix, bun
bunx serve@14.2.4 -l 8080 /tmp/lab # then open http://localhost:8080/diagrams/

lab.yml baut die gehostete Kopie für jeden Pull Request, der admin-ui/lab/ oder die Seite von Diagramme in admin-ui/app/ berührt, und lädt sie als Artefakt losos-lab-hosted hoch. Bei einem Push auf main deployt es die Kopie außerdem auf Vercel, sofern das Repository die Secrets VERCEL_TOKEN, VERCEL_ORG_ID und VERCEL_PROJECT_ID hat.

Die GPU-Zeichenfläche​

Die Ansichten Logisch und Physisch haben zwei Zeichenflächen (die Ansicht Diagramm zeichnet die Seite immer selbst). Die Seite beginnt immer mit der SVG-Fläche, sodass das Setup auf dem Bildschirm steht, sobald der Kern geladen ist. Dann fragt sie den Browser, was er bietet. Mit WebGPU lädt sie den WebGPU-Build von admin-ui/lab/render (losos-lab-render). Ohne WebGPU, aber mit WebGL2 lädt sie den WebGL2-Build. Ohne beides bleibt sie bei SVG.

Jeder Build ist Bevy 0.19.1, zusammen mit dem Kern der Seite nach WebAssembly kompiliert. Die Seite überträgt das Setup in den eigenen Kern des Moduls, indem sie jede Änderung wiederholt, die sie am ersten vorgenommen hat, und macht nur weiter, wenn beide danach dasselbe Setup beschreiben. Die Bevy-Fläche nimmt dann den Platz der SVG-Fläche ein und behält Auswahl, Werkzeug und Kamera.

Die Szene ist 3D. Jeder Raum, jede WLAN-Reichweite, jedes Kabel und jedes Gerät ist ein eigenes flaches Mesh auf einer Grundebene, und eine orthografische Kamera blickt senkrecht von oben darauf, sodass beide Ansichten so aussehen wie in SVG. Namen und Adressen sind Text im Bildschirmraum über der Szene. Klicks sind Raycasts von der Kamera in die Szene.

Die Seite kehrt zu SVG zurück und sagt das einmal, wenn das Modul nicht lädt, wenn innerhalb von 20 Sekunden kein Frame ankommt oder wenn das GPU-Gerät später verloren geht. Ein verlorenes WebGPU-Gerät merkt sich der Browser, und der nächste Besuch beginnt mit WebGL2.

Jeder Build umfasst etwa 16 MB WebAssembly, mit brotli 3,4 MB für WebGPU und 3,6 MB für WebGL2. Der Browser lädt nur den, den er verwendet, und zwar nachdem die SVG-Fläche gezeichnet ist. Die Content Security Policy der Seite braucht keine Änderung, weil 'wasm-unsafe-eval' dem Browser bereits erlaubt, den Kern zu kompilieren.

Zeichenfläche selbst wählen

Um eine Zeichenfläche zu wählen, häng ?canvas=svg, ?canvas=webgpu oder ?canvas=webgl2 an die Adresse an. Der Local-Storage-Schlüssel losos-lab-canvas nimmt dieselben Werte an und behält die Wahl in diesem Browser. Das Engine-Abzeichen in der Werkzeugreihe nennt die Zeichenfläche in seinem Tooltip.

Gäste unter libvirt​

qemu-wasm ist langsam: Es emuliert jede Instruktion ohne KVM, jeder Gast kostet den Tab etwa 450 MB, und ein Tab führt drei aus. Hat der Rechner, auf dem Diagramme geöffnet ist, libvirt (das, was virt-manager steuert), kann die Seite ihre Gäste stattdessen dort ausführen, unter KVM, wenn die CPU es hat. Sie booten in wenigen Sekunden, und bis zu acht laufen gleichzeitig.

Ein Gast kann auf drei Arten laufen, in der Reihenfolge der Präferenz:

  1. Der Helfer steuert libvirt über virsh. Der Helfer ist ein Unterbefehl des Edge-Registrars, losos-registrar lab, und läuft auf demselben Rechner wie libvirt. Er braucht dort libvirt, QEMU und den Befehl virsh sowie die Gast-Images in einem Ordner, den der Helfer lesen kann.
  2. Die Seite steuert libvirt selbst, über das Relay des Helfers. Der Helfer bietet außerdem einen WebSocket an, den er Byte für Byte auf den eigenen Socket von libvirt kopiert. Die Seite bringt den WebAssembly-Client für libvirt mit (admin-ui/lab/virt-rpc, das Paket losos-lab-virt) und spricht darüber das Protokoll von libvirt; dieser Weg braucht also den Helfer und einen laufenden libvirt-Daemon, aber weder virsh noch eine libvirt-Client-Bibliothek auf dem Rechner. Die Seite nutzt ihn, wenn dem Helfer virsh fehlt, und für jeden Gast, den der erste Weg nicht starten konnte.
  3. qemu-wasm im Tab. Gar nichts auf dem Rechner, nur die Engine der gehosteten Kopie. Das ist der langsame Weg und der Fallback für jeden Gast, den die ersten beiden nicht starten können.

Der Helfer und virsh​

Der Helfer startet jeden Gast als transiente Domain namens losos-lab-... mit virsh create. Transient bedeutet, dass libvirt sie nie speichert, sodass nichts den Helfer überdauert: Ctrl-C oder SIGTERM zerstört jeden Gast, den er gestartet hat, ein Gast, den eine Minute lang keine Seite beobachtet hat, wird ebenfalls zerstört, und beim Start entfernt er jede losos-lab--Domain, die ein abgeschossener Helfer hinterlassen hat. Ein Gast hängt an keinem libvirt-Netzwerk und keiner Bridge. Seine serielle Konsole und seine Netzwerkkarte sind mit dem Helfer auf 127.0.0.1 verbunden, und der Helfer reicht beide über WebSockets an die Seite weiter. Die Seite ist weiterhin der Switch, sodass ein libvirt-Gast und ein qemu-wasm-Gast sich ein Kabel teilen können und DHCP, ARP und Ping zwischen ihnen wie bisher funktionieren.

So nutzt du ihn neben virt-manager auf deinem eigenen PC:

  1. Installiere libvirt und QEMU (auf den meisten Distributionen die Pakete, die virt-manager bereits mitgebracht hat) und das Binary losos-registrar (nix build .#losos-registrar).

  2. Leg die Gast-Images in einen Ordner namens guest: bzImage, rootfs.bin und, für Router, Switches und Access Points, gear.bin. admin-ui/lab/engine/build.ts erzeugt alle drei, und die gehostete Kopie liefert sie unter /diagrams/guest/ aus, sodass du sie von dort herunterladen kannst.

  3. Starte den Helfer im Ordner oberhalb von guest:

    losos-registrar lab --origin https://your-lab.example.org

    Er lauscht auf 127.0.0.1:8095 und verwendet qemu:///session, das kein root braucht. Gib --connect qemu:///system an, damit die Gäste in virt-manager neben deinen anderen VMs erscheinen (dein Benutzer muss in der Gruppe libvirt sein, und der eigene qemu-Benutzer von libvirt muss den Image-Ordner lesen können). --origin nennt die Adresse der Seite von Diagramme, die du öffnest; eine Kopie, die wie oben unter localhost:8080 ausgeliefert wird, ist auch ohne erlaubt. Die übrigen Flags sind --images DIR, --max-guests N (8), --memory MiB (96), --virt-type auto|kvm|qemu, --idle 60s, --virsh PATH und --token-file FILE. Ohne Token-Datei weigert sich der Helfer, auf etwas anderem als Loopback zu lauschen, und beantwortet nur Anfragen, die an 127.0.0.1 oder localhost adressiert sind.

  4. Öffne Diagramme. Eine Kopie auf localhost sucht den Helfer von selbst. Eine gehostete Kopie sucht erst, wenn du sie mit ?libvirt am Ende der Adresse öffnest, weil Chrome jeden Besucher einer öffentlichen Seite in dem Moment um Zugriff aufs lokale Netz bittet, in dem sie 127.0.0.1 berührt. Die Seite merkt sich die Wahl; ?libvirt=0 vergisst sie.

Das Abzeichen in der Werkzeugreihe zeigt dann "KVM via libvirt" (oder "QEMU via libvirt (no KVM)" auf einem Rechner ohne KVM), und jede Konsole sagt, was ihren Gast ausführt: libvirt oder "QEMU in this tab". Läuft der Helfer nicht oder lehnt libvirt einen Gast ab, bootet dieser Gast wie bisher unter qemu-wasm, und die Seite sagt das einmal. Die eigene Kopie der Box hat kein qemu-wasm, dort bleibt es also bei der simulierten Konsole.

Der WebAssembly-Client und das Relay​

Eine Webseite kann den Socket von libvirt nicht öffnen: Browser bieten einer normalen Seite weder rohes TCP noch Unix-Sockets, und libvirt hat keinen eigenen WebSocket-Listener. Deshalb übernimmt der Helfer das Relay. Die Seite fordert mit POST /lab/v1/virt-ticket ein Ticket an und öffnet dann den WebSocket /lab/v1/virt mit den Subprotokollen losos-lab und ticket.<ticket>. Das Ticket gilt einmal, für 30 Sekunden. Der Helfer verbindet sich mit dem Socket seiner --connect-URI und kopiert Bytes in beide Richtungen, ohne sie zu lesen. Für qemu:///session ist dieser Socket $XDG_RUNTIME_DIR/libvirt/virtqemud-sock, oder libvirt-sock daneben für ein monolithisches libvirtd. Für qemu:///system ist es /run/libvirt/virtqemud-sock, danach /run/libvirt/libvirt-sock. Ein ?socket=PATH in der URI benennt den Socket direkt, wie bei virsh. Der Helfer hält höchstens --max-guests weitergeleitete Sockets gleichzeitig offen.

GET /lab/v1/hello meldet diesen Weg gesondert, als virt: {available, socket}. available ist true, wenn der Socket gerade jetzt eine Verbindung annimmt, und kann daher true sein, während virsh fehlt. Der Helfer startet keinen Session-Daemon, wie virsh es tut; bei qemu:///session muss der Daemon also bereits laufen oder von seinem systemd-Socket gestartet werden.

Die Seite nutzt diesen Weg von selbst (engine/virt-rpc.ts). Für jeden Gast fordert sie ein Ticket an, öffnet eine weitergeleitete Verbindung, legt die Domain pausiert an, öffnet ihre Konsole und setzt sie dann fort, sodass die Konsole das erste Byte sieht, das der Gast ausgibt. Die Domain ist dieselbe, die der Helfer für virsh geschrieben hätte, nur dass der serielle Port ein Pseudoterminal ist, das der Client als Konsole der Domain liest. Das Modul des Clients, etwa 220 KB, wird erst geladen, wenn der erste Gast auf diesem Weg startet. Der Konsolenkopf zeigt "KVM via libvirt from WebAssembly" oder "QEMU via libvirt from WebAssembly (no KVM)". Ohne KVM wird die erste Domain abgelehnt, und die Seite fragt erneut nach einfachem QEMU.

Zu jedem Ticket gehört auch eine Netzwerkkarte: Der Helfer bindet dieselbe Art UDP-Tunnel, die er seinen eigenen Gästen gibt, und antwortet mit dessen zwei Ports, einem Namen für die Domain (losos-lab-virt-...) und einem zweiten Ticket. Die Seite schreibt den Tunnel in die Domain und öffnet die Karte unter guests/<key>/nic/0, sodass diese Gäste wie die anderen an den Kabeln des Diagramms hängen und ein Gast des einen Wegs einen des anderen anpingen kann. Die Karte zählt gegen --max-guests; ein voller Helfer gibt weiterhin das Relay-Ticket aus, aber keine Karte, und der Gast bootet dann ohne Netzwerk, was sein Konsolenkopf anzeigt.

Der Client legt seine Gäste mit dem autodestroy-Flag von libvirt an, sodass sie enden, wenn die Verbindung endet: wenn der Tab geschlossen wird und wenn der Helfer stoppt, weil der Helfer bei Ctrl-C oder SIGTERM jeden weitergeleiteten Socket schließt. Schaltet die Seite einen Gast aus, zerstört sie die Domain selbst und gibt die Karte mit DELETE guests/<key> zurück. Eine Karte, die keine Seite beobachtet, wird nach --idle beendet, wie ein Gast des Helfers selbst, und weil die Seite ihre Domain so benennt wie der Helfer, erreichen das Aufräumen und die Leerlaufprüfung des Helfers auch diese Domain. admin-ui/lab/virt-rpc/README.md zeigt den Client für sich, über seine Demo-Seite.

Sicherheit​

Auf dem eigenen PC die System-Instanz meiden

Wer einen weitergeleiteten Socket hält, hat libvirt mit den Rechten des Helfers. libvirt erkennt die Gegenseite eines Sockets an ihrer User-ID, sieht also den Helfer und nie die Seite, und auch polkit fragt nach dem Helfer. Mit qemu:///system ist das so gut wie root auf dem Rechner, denn eine Seite kann eine Domain anlegen, die jede beliebige Datei oder Festplatte des Hosts einbindet, und das Relay kann eine solche Domain nicht ablehnen, ohne das Protokoll von libvirt zu parsen. Bevorzuge auf deinem eigenen PC qemu:///session: Dann sind im schlimmsten Fall die Dateien deines eigenen Benutzers betroffen. Die Gäste von Diagramme brauchen nichts von der System-Instanz.

Der Helfer lässt den Relay-Socket deshalb nur mit einem Ticket zu, und ein Ticket kostet dasselbe wie das Starten eines Gastes: das Bearer-Token, wenn der Helfer --token-file hat, und sonst eine an 127.0.0.1 oder localhost adressierte Anfrage von einer erlaubten Seite. Die --origin-Liste ist hier am wichtigsten. Ein WebSocket unterliegt nicht CORS, sodass jede im selben Browser geöffnete Website versuchen kann, ws://127.0.0.1:8095 zu erreichen, und der Helfer lehnt jede Anfrage ab, deren Origin weder auf der Liste steht noch die eigene Adresse des Helfers ist.

Auf einer Box​

losos.lab.libvirt.enable (standardmäßig aus) schaltet libvirtd ein und führt denselben Helfer als Dienst aus, mit qemu:///system. lososd leitet die Anfragen des Labs unter /api/lab/ mit dem Admin-Schlüssel an ihn weiter, einschließlich POST /api/lab/virt-ticket. Die Konsolen und Netzwerkkarten der Gäste (/api/lab/ws/) und das libvirt-Relay (/api/lab/virt) gehen über nginx direkt zum Helfer, nur aus dem lokalen Netz, und jedes braucht ein Ticket, das nur dieser Schlüssel bekommen kann. Das Relay gibt libvirt als Benutzer des Helfers heraus, der in der Gruppe libvirtd ist; es ist auf der Box also root-äquivalent. Der Admin-Schlüssel kann ohnehin schon das ganze System neu bauen, er gibt also nichts preis, was der Schlüssel nicht schon hatte. Leg die drei Images in /var/lib/losos-lab/images ab (losos.lab.libvirt.images).

Was nicht echt ist​

Die Gäste sind Platzhalter: busybox und ein 4-MiB-Image, nicht NixOS. Die Edges, der Tunnel, das Mesh und der Markt sind im Rust-Kern nach den obigen Regeln modelliert; sie sind kein laufender Code. Der Desktop des Laptops ist ein Bild von LosOS Desktop, nicht der Desktop selbst.

Änderungen vornehmen​

  • Die Seite und ihre Teile liegen in admin-ui/app/src/lab/. bun run lab:core baut den Kern nach src/lab/core-pkg/ und bun run lab:virt den libvirt-Client nach src/lab/virt-pkg/ (beide in gitignore; sie brauchen cargo mit dem Target wasm32-unknown-unknown und wasm-bindgen 0.2.127), und danach liefert bun run dev die Seite unter /diagrams/ aus. bun run lab:render baut die zwei Module der GPU-Fläche auf dieselbe Weise nach src/lab/render-pkg/ und führt wasm-opt darauf aus, wenn WASM_OPT es benennt. Ohne sie baut die Seite nicht, und ihr Build dauert etwa 13 Minuten. tests/lab.browser.ts prüft die Netzwerkansichten unter der eigenen Policy der Seite, den Relay-Weg gegen einen gefälschten libvirt-Daemon, und tests/diagrams.browser.ts das Diagramm: Karten, Pfeile, eine Obsidian-Datei, die Bilder, LosOS Cloud, das gemeinsame Bearbeiten und die Maschinenkarten. nix/tests/diagrams-together.nix startet zwei Boxen, teilt ein Diagramm von einer zur anderen und lässt beide Personen darin zeichnen.
  • Der Vertrag des Kerns ist admin-ui/lab/core/README.md. Seine Tests vergleichen jedes eingebaute Setup mit dem Verhalten des JavaScript-Simulators, den er ersetzt hat. Die Zeichenfläche, ihr Dateiformat und ihr Rückgängig liegen in admin-ui/lab/core/src/canvas/, die React-Teile des Diagramms in admin-ui/app/src/lab/canvas/.
  • Gäste: admin-ui/app/src/lab/engine/ versucht libvirt über das virsh des Helfers, dann libvirt über den eigenen Client der Seite und das Relay des Helfers, dann qemu-wasm, in dieser Reihenfolge.