boban
/
CluPilotCloud
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
CluPilotCloud/tests/Feature/Provisioning/BridgeScriptTest.php

1107 lines
45 KiB
PHP
Raw Blame History

<?php
use Illuminate\Support\Facades\Process;
/*
|--------------------------------------------------------------------------
| bridge.sh, gegen eine echte Shell gefahren
|--------------------------------------------------------------------------
|
| Der Rest der Testsuite liest die Befehle dieses Schritts als Zeichenketten —
| FakeRemoteShell führt keinen davon aus. Die Strophe, die diese Bibliothek
| schreibt, ist aber genau das, was eine Maschine umbringt, wenn sie falsch
| ist. Deshalb wird bridge.sh hier mit `sh` wirklich ausgeführt, gegen
| aufgezeichnete Ausgaben von `ip` statt gegen einen Host.
|
| `CLUPILOT_IP` zeigt dabei auf ein Attrappen-Skript, `CLUPILOT_SYS_NET` auf
| einen Baum aus Textdateien. Beides ist die einzige Berührung mit dem System,
| die die Bibliothek hat.
*/
/**
* Legt eine `ip`-Attrappe an, die auf feste Argumentmuster feste Ausgaben gibt.
*
* @param array<string, string> $answers Argumentmuster => Ausgabe
*/
function fakeIp(string $dir, array $answers): string
{
$cases = '';
foreach ($answers as $pattern => $output) {
$cases .= " '{$pattern}') cat <<'OUT'\n{$output}\nOUT\n ;;\n";
}
$script = "#!/bin/sh\ncase \"\$*\" in\n{$cases} *) exit 1 ;;\nesac\n";
file_put_contents("{$dir}/ip", $script);
chmod("{$dir}/ip", 0o755);
return "{$dir}/ip";
}
/**
* Fährt eine Zeile Shell mit bridge.sh im Rücken und gibt stdout zurück.
*
* `$pre` läuft VOR dem Sourcen. Damit kann ein Test `log` oder `http_get` selbst
* definieren — bridge.sh legt beide unter einem `command -v`-Schutz an, wer
* zuerst da ist, behält recht. Das ist zugleich die Probe auf diesen Schutz und
* spart dem Test eine Abhängigkeit von curl im Container.
*/
function runBridgeSh(string $body, array $env = [], string $pre = ''): string
{
$lib = base_path('deploy/bootstrap/lib/bridge.sh');
$exports = '';
foreach ($env as $key => $value) {
$exports .= "export {$key}=".escapeshellarg($value)."\n";
}
$result = Process::input("{$exports}{$pre}\n. '{$lib}'\n{$body}\n")->run('sh');
return trim($result->output());
}
/**
* Baut einen Testrumpf, der JA oder NEIN meldet — und FEHLT, wenn es die
* Funktion gar nicht gibt.
*
* Ohne diese Unterscheidung ist jeder Test, der NEIN erwartet, grün, SOLANGE die
* Funktion fehlt: `if gibtsnicht; then … else echo NEIN; fi` ist in sh schlicht
* unwahr. Die rote Phase wäre dann aus dem falschen Grund rot und die grüne
* bewiese nichts — genau die Sorte Attrappe, die hier schon einmal vier echte
* Fehler durchgelassen hat.
*
* Die Ausgabe der Funktion selbst wird verworfen, damit `log`-Zeilen das Urteil
* nicht verwässern und `toBe` statt `toContain` geprüft werden kann.
*/
function verdictBody(string $call): string
{
$function = strtok($call, ' ');
return "command -v {$function} >/dev/null 2>&1 || { echo FEHLT; exit 1; }\n"
."if {$call} >/dev/null 2>&1; then echo JA; else echo NEIN; fi";
}
/**
* Ruft eine Funktion, die etwas ausgibt — und meldet FEHLT, wenn es sie nicht
* gibt. Dieselbe Begründung wie bei verdictBody(): eine leere Ausgabe und eine
* fehlende Funktion sind von außen nicht zu unterscheiden.
*/
function callBridgeFn(string $call, array $env = [], string $pre = ''): string
{
$function = strtok($call, ' ');
return runBridgeSh(
"command -v {$function} >/dev/null 2>&1 || { echo FEHLT; exit 1; }\n{$call}",
$env,
$pre
);
}
/** Ein /sys/class/net-Baum aus Textdateien. */
function fakeSysNet(string $dir, string $iface, string $mac, bool $physical = true): string
{
$root = "{$dir}/sys";
mkdir("{$root}/{$iface}", 0o755, true);
file_put_contents("{$root}/{$iface}/address", $mac."\n");
if ($physical) {
mkdir("{$root}/{$iface}/device", 0o755, true);
}
return $root;
}
beforeEach(function () {
$this->dir = sys_get_temp_dir().'/bridge-'.bin2hex(random_bytes(6));
mkdir($this->dir, 0o755, true);
});
it('nimmt die Karte, über die die Standardroute geht — nicht die erste beste', function () {
// Eine Maschine mit zwei Karten hat oft eine angeschlossene und eine nicht.
$ip = fakeIp($this->dir, [
'-4 route show default' => 'default via 49.12.121.65 dev enp0s31f6 proto static',
]);
expect(runBridgeSh('detect_primary_interface', ['CLUPILOT_IP' => $ip]))
->toBe('enp0s31f6');
});
it('erkennt eine geroutete Einzeladresse an der /32', function () {
// Hetzner dediziert. Das eigene Subnetz besteht aus der eigenen Adresse —
// ein Gateway darin kann es nicht geben, es braucht pointopoint.
$ip = fakeIp($this->dir, [
'-4 route show default' => 'default via 49.12.121.65 dev enp0s31f6',
'-4 -o addr show dev enp0s31f6 scope global' => '2: enp0s31f6 inet 49.12.121.79/32 scope global enp0s31f6\ valid_lft forever preferred_lft forever',
]);
expect(runBridgeSh('detect_network_style enp0s31f6', ['CLUPILOT_IP' => $ip]))
->toBe('routed');
});
it('erkennt DHCP am laufenden Zustand, nicht an der Datei des Anbieters', function () {
// Der Kernel markiert eine geleaste Adresse als `dynamic`. Das steht bei
// jedem Anbieter gleich da — anders als die Datei, in die er es geschrieben
// hat.
$ip = fakeIp($this->dir, [
'-4 route show default' => 'default via 10.0.0.1 dev ens3',
'-4 -o addr show dev ens3 scope global' => '2: ens3 inet 10.0.0.7/24 brd 10.0.0.255 scope global dynamic ens3\ valid_lft 3521sec preferred_lft 3521sec',
]);
expect(runBridgeSh('detect_network_style ens3', [
'CLUPILOT_IP' => $ip,
// Absichtlich auf eine Datei zeigen, die es nicht gibt: die Antwort darf
// nicht davon abhängen.
'CLUPILOT_INTERFACES_FILE' => $this->dir.'/gibtesnicht',
]))->toBe('dhcp');
});
it('hält eine Bridge und einen Bond für keine physische Karte', function () {
// bridge_ports auf einem Bond oder einer bestehenden Bridge ist falsch: die
// Brücke nähme sich ihren eigenen Unterbau als Port.
$sys = fakeSysNet($this->dir, 'bond0', 'aa:bb:cc:dd:ee:ff', physical: false);
mkdir("{$sys}/bond0/bonding", 0o755, true);
$out = runBridgeSh(
verdictBody('interface_is_physical bond0'),
['CLUPILOT_SYS_NET' => $sys]
);
expect($out)->toBe('NEIN');
});
it('hält eine gewöhnliche Karte für eine physische', function () {
$sys = fakeSysNet($this->dir, 'enp0s31f6', 'a8:a1:59:00:11:22');
$out = runBridgeSh(
verdictBody('interface_is_physical enp0s31f6'),
['CLUPILOT_SYS_NET' => $sys]
);
expect($out)->toBe('JA');
});
it('sagt nur dann „Brücke steht", wenn sie Route UND Adresse trägt', function () {
// Eine vmbr0 ohne Adresse und ohne Standardroute ist eine Brücke im Sinne
// von `ip link show` und sonst nichts. Der alte Schritt prüfte genau das
// und warf das Ergebnis weg; sein Kommentar behauptete, er halte die
// Abwesenheit fest, und er hielt nichts fest.
$ip = fakeIp($this->dir, [
'link show vmbr0' => '5: vmbr0: <BROADCAST,MULTICAST,UP> mtu 1500',
'-4 route show default' => 'default via 49.12.121.65 dev enp0s31f6',
'-4 -o addr show dev vmbr0 scope global' => '',
]);
$out = runBridgeSh(
verdictBody('bridge_is_up'),
['CLUPILOT_IP' => $ip]
);
expect($out)->toBe('NEIN');
});
it('liest kein Gateway aus einer Standardroute, die keins hat', function () {
// `default dev ens3 scope link` — kein `via`. Ein `awk '{print $3}'` liefert
// dort den KARTENNAMEN, und daraus würde `gateway ens3` in der Strophe.
// Der Zeitgeber finge das ab, aber der Host wäre umsonst gescheitert.
$ip = fakeIp($this->dir, [
'-4 route show default' => 'default dev ens3 scope link',
]);
expect(runBridgeSh('default_gateway', ['CLUPILOT_IP' => $ip]))->toBe('');
});
it('liest das Gateway hinter dem via, nicht an fester Feldnummer', function () {
$ip = fakeIp($this->dir, [
'-4 route show default' => 'default via 10.0.0.1 dev ens3 proto dhcp src 10.0.0.7 metric 100',
]);
expect(runBridgeSh('default_gateway', ['CLUPILOT_IP' => $ip]))->toBe('10.0.0.1');
});
it('hält eine gatewaylose Karte nicht für eine geroutete Einzeladresse', function () {
// Ohne Gateway gibt es weder eins im eigenen Subnetz noch eines ausserhalb.
// `routed` zu melden hiesse `pointopoint` auf nichts.
$ip = fakeIp($this->dir, [
'-4 route show default' => 'default dev ens3 scope link',
'-4 -o addr show dev ens3 scope global' => '2: ens3 inet 10.0.0.7/24 scope global ens3',
]);
expect(runBridgeSh('detect_network_style ens3', ['CLUPILOT_IP' => $ip]))
->toBe('subnet');
});
it('schreibt ohne Gateway auch keine gateway-Zeile', function () {
$ip = fakeIp($this->dir, [
'-4 route show dev ens3' => '',
'-6 -o addr show dev ens3 scope global' => '',
'-6 route show default' => '',
]);
$sys = fakeSysNet($this->dir, 'ens3', 'de:ad:be:ef:00:07');
$out = $this->dir.'/interfaces';
runBridgeSh('write_bridge_stanza ens3 subnet 10.0.0.7/24 ""', [
'CLUPILOT_IP' => $ip,
'CLUPILOT_SYS_NET' => $sys,
'CLUPILOT_INTERFACES_FILE' => $out,
]);
expect(file_get_contents($out))
->toContain('address 10.0.0.7/24')
->not->toContain('gateway')
->not->toContain('pointopoint');
});
it('hält jede Brückenfunktion an genau einer Stelle im Repo', function () {
// Zwei Fassungen wären zwei Installationen, die bei jeder Proxmox-Version
// nachgezogen werden müssten — und die zweite fiele erst auf, wenn jemand
// sie benutzt. Genau die Entscheidung, die den Rettungssystem-Weg
// stillgelegt hat.
//
// Die Liste wächst mit bridge.sh mit: wer eine Funktion hierher zieht und
// die alte Fassung stehen lässt, fällt hier auf und nicht auf einem Host.
//
// array_merge, NICHT `+`: bei numerischen Schlüsseln behält der
// Vereinigungsoperator die linke Seite und wirft die rechte still weg. Und
// PHPs glob() kennt kein rekursives `**`, also zwei Muster.
$files = array_merge(
glob(base_path('deploy/bootstrap/lib/*.sh')) ?: [],
glob(base_path('deploy/bootstrap/*.sh')) ?: [],
);
$functions = [
'detect_primary_interface',
'detect_network_style',
'bridge_exists',
'bridge_carries_default_route',
'bridge_has_address',
'build_bridge',
'write_bridge_stanza',
'backup_network_config',
'schedule_network_rollback',
'cancel_network_rollback',
];
foreach ($functions as $function) {
$hits = [];
foreach ($files as $file) {
if (preg_match('/^'.$function.'\(\)/m', (string) file_get_contents($file))) {
$hits[] = str_replace(base_path().'/', '', $file);
}
}
expect($hits)->toBe(['deploy/bootstrap/lib/bridge.sh'], $function.' steht nicht genau einmal im Repo');
}
});
/*
|--------------------------------------------------------------------------
| Die Strophe
|--------------------------------------------------------------------------
|
| Vier Anbieterfälle, und sie unterscheiden sich in genau der Zeile, die
| entscheidet, ob die Maschine danach noch da ist.
*/
it('schreibt für eine geroutete /32 eine pointopoint-Strophe', function () {
// Hetzner dediziert. Ohne `pointopoint` findet der Kernel keinen Weg zum
// Gateway: die Route zeigte auf ein Netz, in dem das Gateway nicht liegt,
// und die Maschine wäre still weg.
$ip = fakeIp($this->dir, [
'-4 route show dev enp0s31f6' => "49.12.121.65 scope link\ndefault via 49.12.121.65",
'-6 -o addr show dev enp0s31f6 scope global' => '',
'-6 route show default' => '',
]);
$sys = fakeSysNet($this->dir, 'enp0s31f6', 'a8:a1:59:00:11:22');
$out = $this->dir.'/interfaces';
runBridgeSh('write_bridge_stanza enp0s31f6 routed 49.12.121.79/32 49.12.121.65', [
'CLUPILOT_IP' => $ip,
'CLUPILOT_SYS_NET' => $sys,
'CLUPILOT_INTERFACES_FILE' => $out,
]);
expect(file_get_contents($out))
->toContain('address 49.12.121.79/32')
->toContain('pointopoint 49.12.121.65')
->toContain('gateway 49.12.121.65')
->toContain('bridge-ports enp0s31f6')
->toContain('iface enp0s31f6 inet manual')
// Festgenagelt, damit die Brücke nicht irgendeine MAC wählt: manche
// Anbieter binden den Switchport an die der Karte.
->toContain('hwaddress ether a8:a1:59:00:11:22')
->toContain('auto vmbr0');
});
it('schreibt für ein gewöhnliches Subnetz Adresse und Gateway ohne pointopoint', function () {
// netcup und die meisten anderen. `pointopoint` wäre hier falsch.
$ip = fakeIp($this->dir, [
'-4 route show dev ens3' => '192.168.10.0/24 proto kernel scope link src 192.168.10.7',
'-6 -o addr show dev ens3 scope global' => '',
'-6 route show default' => '',
]);
$sys = fakeSysNet($this->dir, 'ens3', 'de:ad:be:ef:00:01');
$out = $this->dir.'/interfaces';
runBridgeSh('write_bridge_stanza ens3 subnet 192.168.10.7/24 192.168.10.1', [
'CLUPILOT_IP' => $ip,
'CLUPILOT_SYS_NET' => $sys,
'CLUPILOT_INTERFACES_FILE' => $out,
]);
expect(file_get_contents($out))
->toContain('address 192.168.10.7/24')
->toContain('gateway 192.168.10.1')
->not->toContain('pointopoint')
// Die Route zum eigenen Subnetz gehört NICHT in die Zusatzrouten: die
// legt der Kernel selbst an, sobald die Adresse steht. Ein zweites Mal
// hinzufügen scheitert — und ein gescheitertes `up` nimmt bei
// `ifreload` die ganze Strophe mit.
->not->toContain('up ip route add 192.168.10.0/24');
});
it('schreibt für DHCP keine Adresse in die Strophe', function () {
$ip = fakeIp($this->dir, [
'-4 route show dev ens3' => '',
'-6 -o addr show dev ens3 scope global' => '',
'-6 route show default' => '',
]);
$sys = fakeSysNet($this->dir, 'ens3', 'de:ad:be:ef:00:02');
$out = $this->dir.'/interfaces';
runBridgeSh('write_bridge_stanza ens3 dhcp 10.0.0.7/24 10.0.0.1', [
'CLUPILOT_IP' => $ip,
'CLUPILOT_SYS_NET' => $sys,
'CLUPILOT_INTERFACES_FILE' => $out,
]);
expect(file_get_contents($out))
->toContain('iface vmbr0 inet dhcp')
->not->toContain('address 10.0.0.7')
->toContain('bridge-ports ens3');
});
it('nimmt eine statische globale IPv6 samt link-local Gateway mit', function () {
// Hetzners Form: 2a01:…::2/64 mit fe80::1. Statisch, also derselbe Dreisatz
// wie bei v4 — und damit der Fall, der laut Entwurf nichts kostet.
$ip = fakeIp($this->dir, [
'-4 route show dev enp0s31f6' => '',
'-6 -o addr show dev enp0s31f6 scope global' => '2: enp0s31f6 inet6 2a01:4f8:1c1c::2/64 scope global \ valid_lft forever preferred_lft forever',
'-6 route show default' => 'default via fe80::1 dev enp0s31f6 metric 1024',
]);
$sys = fakeSysNet($this->dir, 'enp0s31f6', 'a8:a1:59:00:11:22');
$out = $this->dir.'/interfaces';
runBridgeSh('write_bridge_stanza enp0s31f6 routed 49.12.121.79/32 49.12.121.65', [
'CLUPILOT_IP' => $ip,
'CLUPILOT_SYS_NET' => $sys,
'CLUPILOT_INTERFACES_FILE' => $out,
]);
expect(file_get_contents($out))
->toContain('iface vmbr0 inet6 static')
->toContain('address 2a01:4f8:1c1c::2/64')
->toContain('gateway fe80::1');
});
it('lässt SLAAC-IPv6 liegen und sagt es ins Protokoll', function () {
// Proxmox setzt forwarding=1, und der Kernel verwirft
// Router-Advertisements dann ohne accept_ra=2. Das sauber hinzubekommen
// wäre ein zweiter Satz Fehlerfälle in genau dem Fenster, das diese
// Konstruktion zu überleben versucht — und v6 trägt hier keinen Verkehr.
// Still verlieren gilt trotzdem nicht.
$ip = fakeIp($this->dir, [
'-4 route show dev ens3' => '',
'-6 -o addr show dev ens3 scope global' => '2: ens3 inet6 2a01:4f8:aaaa::17/64 scope global dynamic \ valid_lft 86000sec preferred_lft 14000sec',
'-6 route show default' => 'default via fe80::1 dev ens3',
]);
$sys = fakeSysNet($this->dir, 'ens3', 'de:ad:be:ef:00:03');
$out = $this->dir.'/interfaces';
$log = runBridgeSh('write_bridge_stanza ens3 subnet 10.0.0.7/24 10.0.0.1', [
'CLUPILOT_IP' => $ip,
'CLUPILOT_SYS_NET' => $sys,
'CLUPILOT_INTERFACES_FILE' => $out,
]);
expect(file_get_contents($out))->not->toContain('inet6 static')
->and($log)->toContain('IPv6');
});
it('nimmt die Zusatzrouten des Anbieters mit auf die Brücke', function () {
// Was der Anbieter extra eingetragen hat, verliert der Host sonst — und es
// fällt erst auf, wenn jemand das Ziel dahinter braucht.
$ip = fakeIp($this->dir, [
'-4 route show dev enp0s31f6' => "49.12.121.65 scope link\n10.128.0.0/16 via 49.12.121.65\n49.12.121.64/26 proto kernel scope link src 49.12.121.79",
'-6 -o addr show dev enp0s31f6 scope global' => '',
'-6 route show default' => '',
]);
$sys = fakeSysNet($this->dir, 'enp0s31f6', 'a8:a1:59:00:11:22');
$out = $this->dir.'/interfaces';
runBridgeSh('write_bridge_stanza enp0s31f6 subnet 49.12.121.79/26 49.12.121.65', [
'CLUPILOT_IP' => $ip,
'CLUPILOT_SYS_NET' => $sys,
'CLUPILOT_INTERFACES_FILE' => $out,
]);
expect(file_get_contents($out))
->toContain('up ip route add 10.128.0.0/16 via 49.12.121.65 dev vmbr0')
// Weder die Link-Route zum Gateway noch die Kernel-Route zum eigenen
// Subnetz: beide entstehen von selbst, und ein zweiter Versuch
// scheitert und nimmt die Strophe mit.
->not->toContain('up ip route add 49.12.121.65 ')
->not->toContain('up ip route add 49.12.121.64/26');
});
it('schreibt eine Strophe, die ein Mensch als von CluPilot erkennt', function () {
// Wer in sechs Monaten in diese Datei sieht, muss wissen, wer sie
// geschrieben hat und woraus.
$ip = fakeIp($this->dir, [
'-4 route show dev ens3' => '',
'-6 -o addr show dev ens3 scope global' => '',
'-6 route show default' => '',
]);
$sys = fakeSysNet($this->dir, 'ens3', 'de:ad:be:ef:00:04');
$out = $this->dir.'/interfaces';
runBridgeSh('write_bridge_stanza ens3 subnet 10.0.0.7/24 10.0.0.1', [
'CLUPILOT_IP' => $ip,
'CLUPILOT_SYS_NET' => $sys,
'CLUPILOT_INTERFACES_FILE' => $out,
]);
expect(file_get_contents($out))
->toContain('Von CluPilot geschrieben')
->toContain('EnsureNetworkBridge');
});
/*
|--------------------------------------------------------------------------
| Die Rückfahrkarte
|--------------------------------------------------------------------------
*/
it('schreibt ein Rücknahme-Skript, das den Grund festhält BEVOR es zurückspielt', function () {
// Ohne diese zwei Zeilen liest der Schritt nach dem Wiederverbinden
// `running` und pollt gegen einen Lauf, den es nicht mehr gibt — der
// Zeitgeber beendet den Treiber ja gerade nicht. Und zuerst schreiben, nicht
// zuletzt: ein halb geglücktes Zurückspielen soll das Urteil trotzdem
// hinterlassen.
$script = runBridgeSh('render_rollback_script 5', [
'CLUPILOT_WORK_DIR' => '/var/lib/clupilot/bridge',
]);
$stateAt = strpos($script, "printf 'failed'");
$restoreAt = strpos($script, 'tar xzf');
$doneAt = strpos($script, 'rolled-back');
expect($stateAt)->not->toBeFalse()
->and($restoreAt)->not->toBeFalse()
->and($doneAt)->not->toBeFalse()
->and($stateAt)->toBeLessThan($restoreAt)
->and($script)->toContain('/var/lib/clupilot/bridge/note')
// Das Signal, auf das CluPilot wartet: erst wenn das da ist, ist der
// alte Zustand wirklich zurück.
->and($doneAt)->toBeGreaterThan($restoreAt);
});
it('legt die Marke NICHT an, wenn das Zurückspielen scheitert', function () {
// Ohne diese Prüfung laufen tar und ifreload ins Leere, das Skript macht
// weiter und setzt `rolled-back` — CluPilot meldet dann „der alte Zustand
// ist zurück" und gibt auf, während der Host auf einer kaputten
// Konfiguration steht. Das ursprüngliche network.sh hatte dafür `set -e`;
// beim Umbau ist es verlorengegangen.
$work = $this->dir.'/work';
mkdir($work, 0o755, true);
$script = runBridgeSh('render_rollback_script 5', [
'CLUPILOT_WORK_DIR' => $work,
// Ein Archiv, das es nicht gibt: tar scheitert.
'CLUPILOT_NET_BACKUP' => $this->dir.'/gibtesnicht',
'CLUPILOT_UNIT_DIR' => $this->dir.'/units',
]);
file_put_contents($this->dir.'/rollback.sh', $script);
$result = Process::run('sh '.$this->dir.'/rollback.sh');
expect($result->exitCode())->not->toBe(0)
->and(file_exists($work.'/rolled-back'))->toBeFalse()
// Das Urteil steht trotzdem — es wird VOR dem Zurückspielen geschrieben.
->and(file_get_contents($work.'/state'))->toBe('failed');
});
it('schaltet die Rücknahme den entmachteten Netzverwalter wieder ein', function () {
// Sonst spielt sie eine /etc/network/interfaces zurück, die diese Maschine
// nie getragen hat, während der Verwalter, der es tat, abgeschaltet bleibt.
// Genau der tote Host, den der Zeitgeber verhindern soll.
$work = $this->dir.'/work';
$etc = $this->dir.'/etc';
mkdir($work, 0o755, true);
mkdir("{$etc}/cloud/cloud.cfg.d", 0o755, true);
file_put_contents("{$etc}/cloud/cloud.cfg", "datasource_list: [ Hetzner ]\n");
$env = [
'CLUPILOT_WORK_DIR' => $work,
'CLUPILOT_ETC' => $etc,
'CLUPILOT_NET_BACKUP' => $this->dir.'/sicherung',
'CLUPILOT_UNIT_DIR' => $this->dir.'/units',
'CLUPILOT_INTERFACES_D' => $this->dir.'/interfaces.d',
];
// Erst entmachten, dann das Skript fahren, das der Zeitgeber gestellt hat.
runBridgeSh('disown_network_manager cloud-init ens3', $env);
expect(file_exists("{$etc}/cloud/cloud.cfg.d/99-clupilot-disable-network.cfg"))->toBeTrue();
// Eine Sicherung, damit tar nicht vorher scheitert.
file_put_contents($this->dir.'/leer', "x\n");
Process::run('tar czf '.$this->dir.'/sicherung.tar.gz -C '.$this->dir.' leer');
$script = runBridgeSh('render_rollback_script 5', $env);
file_put_contents($this->dir.'/rollback.sh', $script);
Process::run('sh '.$this->dir.'/rollback.sh');
expect(file_exists("{$etc}/cloud/cloud.cfg.d/99-clupilot-disable-network.cfg"))->toBeFalse();
});
it('nimmt eine verdrängte Strophe aus dem Quellverzeichnis heraus', function () {
// `source /etc/network/interfaces.d/*` fasst auch eine umbenannte Datei —
// der Stern nimmt sie mit. Umbenennen allein löst die Kollision also nicht.
$etc = $this->dir.'/etc';
$d = $this->dir.'/interfaces.d';
$work = $this->dir.'/work';
mkdir($etc, 0o755, true);
mkdir($d, 0o755, true);
mkdir($work, 0o755, true);
file_put_contents("{$d}/50-cloud-init", "auto ens3\niface ens3 inet static\n address 10.0.0.7/24\n");
file_put_contents("{$d}/99-egal", "iface eth9 inet manual\n");
runBridgeSh('disown_network_manager "" ens3', [
'CLUPILOT_ETC' => $etc,
'CLUPILOT_INTERFACES_D' => $d,
'CLUPILOT_WORK_DIR' => $work,
]);
// Nichts, was der Stern noch fassen könnte.
expect(glob("{$d}/*"))->toBe(["{$d}/99-egal"])
->and(file_exists("{$work}/verdraengt/50-cloud-init"))->toBeTrue()
// Und die Rücknahme muss wissen, wohin damit.
->and(file_get_contents("{$work}/moved-aside"))->toContain("{$d}/50-cloud-init");
});
it('stellt die Rücknahme eine verdrängte Strophe zurück', function () {
$etc = $this->dir.'/etc';
$d = $this->dir.'/interfaces.d';
$work = $this->dir.'/work';
mkdir($etc, 0o755, true);
mkdir($d, 0o755, true);
mkdir($work, 0o755, true);
file_put_contents("{$d}/50-cloud-init", "iface ens3 inet static\n");
$env = [
'CLUPILOT_ETC' => $etc,
'CLUPILOT_INTERFACES_D' => $d,
'CLUPILOT_WORK_DIR' => $work,
'CLUPILOT_NET_BACKUP' => $this->dir.'/sicherung',
'CLUPILOT_UNIT_DIR' => $this->dir.'/units',
];
runBridgeSh('disown_network_manager "" ens3', $env);
expect(file_exists("{$d}/50-cloud-init"))->toBeFalse();
file_put_contents($this->dir.'/leer', "x\n");
Process::run('tar czf '.$this->dir.'/sicherung.tar.gz -C '.$this->dir.' leer');
$script = runBridgeSh('render_rollback_script 5', $env);
file_put_contents($this->dir.'/rollback.sh', $script);
Process::run('sh '.$this->dir.'/rollback.sh');
expect(file_exists("{$d}/50-cloud-init"))->toBeTrue();
});
it('räumt der Zeitgeber sich nach dem Feuern selbst weg', function () {
// Sonst liegen Unit-Dateien herum, die aussehen, als stünde noch eine
// Rücknahme aus.
expect(runBridgeSh('render_rollback_script 5'))
->toContain('clupilot-network-rollback.timer');
});
it('stellt den Zeitgeber, bevor irgendetwas verändert wird', function () {
// Die tragende Zusicherung des ganzen Entwurfs, geprüft an der Reihenfolge
// der Aufrufe. Umgekehrt wäre es die Reihenfolge, die einen Host dauerhaft
// unerreichbar macht.
$bin = $this->dir.'/bin';
mkdir($bin, 0o755, true);
file_put_contents("{$bin}/systemctl", "#!/bin/sh\necho \"systemctl \$*\" >> '{$this->dir}/calls'\n");
file_put_contents("{$bin}/ifreload", "#!/bin/sh\necho 'ifreload' >> '{$this->dir}/calls'\n");
chmod("{$bin}/systemctl", 0o755);
chmod("{$bin}/ifreload", 0o755);
$ip = fakeIp($this->dir, [
'-4 route show dev ens3' => '',
'-6 -o addr show dev ens3 scope global' => '',
'-6 route show default' => '',
]);
$sys = fakeSysNet($this->dir, 'ens3', 'de:ad:be:ef:00:05');
file_put_contents($this->dir.'/interfaces', "# alt\n");
runBridgeSh(
"backup_network_config\nschedule_network_rollback 5\nbuild_bridge ens3 subnet 10.0.0.7/24 10.0.0.1",
[
'CLUPILOT_IP' => $ip,
'CLUPILOT_SYS_NET' => $sys,
'CLUPILOT_INTERFACES_FILE' => $this->dir.'/interfaces',
'CLUPILOT_INTERFACES_D' => $this->dir.'/interfaces.d',
'CLUPILOT_NET_BACKUP' => $this->dir.'/sicherung',
'CLUPILOT_SYSTEMCTL' => "{$bin}/systemctl",
'CLUPILOT_IFRELOAD' => "{$bin}/ifreload",
'CLUPILOT_UNIT_DIR' => $this->dir.'/units',
'CLUPILOT_SBIN_DIR' => $this->dir.'/sbin',
'CLUPILOT_WORK_DIR' => $this->dir,
]
);
$calls = file_get_contents($this->dir.'/calls');
expect(strpos($calls, 'start clupilot-network-rollback.timer'))->not->toBeFalse()
->and(strpos($calls, 'ifreload'))->not->toBeFalse()
->and(strpos($calls, 'start clupilot-network-rollback.timer'))
->toBeLessThan(strpos($calls, 'ifreload'))
// Und die Sicherung muss existieren, bevor der Zeitgeber sie
// überhaupt zurückspielen könnte.
->and(file_exists($this->dir.'/sicherung.tar.gz'))->toBeTrue();
});
it('bestellt beim Abbestellen alles ab, was gestellt wurde', function () {
// Ein Zeitgeber, dessen Unit-Dateien liegen bleiben, sieht beim nächsten
// Hinsehen aus wie eine ausstehende Rücknahme.
$bin = $this->dir.'/bin';
mkdir($bin, 0o755, true);
file_put_contents("{$bin}/systemctl", "#!/bin/sh\necho \"systemctl \$*\" >> '{$this->dir}/calls'\n");
chmod("{$bin}/systemctl", 0o755);
runBridgeSh(
"schedule_network_rollback 5\ncancel_network_rollback",
[
'CLUPILOT_SYSTEMCTL' => "{$bin}/systemctl",
'CLUPILOT_UNIT_DIR' => $this->dir.'/units',
'CLUPILOT_SBIN_DIR' => $this->dir.'/sbin',
'CLUPILOT_WORK_DIR' => $this->dir,
]
);
expect(file_get_contents($this->dir.'/calls'))->toContain('stop clupilot-network-rollback.timer')
->and(file_exists($this->dir.'/units/clupilot-network-rollback.timer'))->toBeFalse()
->and(file_exists($this->dir.'/units/clupilot-network-rollback.service'))->toBeFalse()
->and(file_exists($this->dir.'/sbin/clupilot-network-rollback.sh'))->toBeFalse();
});
/*
|--------------------------------------------------------------------------
| Nachsehen — beide Richtungen
|--------------------------------------------------------------------------
*/
/** Eine `wg`-Attrappe, die einen Handshake von genau einem Peer meldet. */
function fakeWg(string $dir, string $peer, int $secondsAgo): string
{
$when = time() - $secondsAgo;
file_put_contents("{$dir}/wg", "#!/bin/sh\nprintf '%s\\t%s\\n' '{$peer}' '{$when}'\n");
chmod("{$dir}/wg", 0o755);
return "{$dir}/wg";
}
/** Eine Brücke, die steht und trägt. */
function fakeUpBridge(string $dir): string
{
return fakeIp($dir, [
'link show vmbr0' => '5: vmbr0: <BROADCAST,MULTICAST,UP> mtu 1500',
'-4 route show default' => 'default via 10.0.0.1 dev vmbr0',
'-4 -o addr show dev vmbr0 scope global' => '5: vmbr0 inet 10.0.0.7/24 scope global vmbr0',
]);
}
it('bestellt nicht ab, wenn der Tunnel steht, aber das Internet nicht erreichbar ist', function () {
$ip = fakeUpBridge($this->dir);
$wg = fakeWg($this->dir, 'HUBKEY=', 5);
$out = runBridgeSh(
verdictBody('bridge_proven'),
[
'CLUPILOT_IP' => $ip,
'CLUPILOT_WG' => $wg,
'CLUPILOT_WG_HUB_PUBKEY' => 'HUBKEY=',
],
// Kein Weg nach draußen — als Funktion gesetzt statt über eine Adresse,
// damit der Test nicht davon abhängt, ob im Container curl liegt.
pre: 'http_get() { return 1; }'
);
expect($out)->toBe('NEIN');
});
it('bestellt NICHT ab, wenn das Internet erreichbar ist, der Tunnel aber schal', function () {
// Der Fehlerfall, für den diese Prüfung existiert: ifreload bringt vmbr0
// sauber hoch, die Maschine erreicht das Internet, der Treiber wäre
// zufrieden — aber wg0 kommt nicht zurück. Dann lebt der Host öffentlich,
// CluPilot ist ausgesperrt, und wer hier abbestellt, hat die Rückfahrkarte
// weggeworfen.
$ip = fakeUpBridge($this->dir);
$wg = fakeWg($this->dir, 'HUBKEY=', 3600); // eine Stunde alt
$bin = $this->dir.'/bin';
mkdir($bin, 0o755, true);
file_put_contents("{$bin}/systemctl", "#!/bin/sh\necho \"systemctl \$*\" >> '{$this->dir}/calls'\n");
chmod("{$bin}/systemctl", 0o755);
$out = runBridgeSh(
verdictBody('bridge_proven'),
[
'CLUPILOT_IP' => $ip,
'CLUPILOT_WG' => $wg,
'CLUPILOT_WG_HUB_PUBKEY' => 'HUBKEY=',
'CLUPILOT_SYSTEMCTL' => "{$bin}/systemctl",
'CLUPILOT_HANDSHAKE_TRIES' => '1',
'CLUPILOT_HANDSHAKE_WAIT' => '0',
],
pre: 'http_get() { return 0; }'
);
expect($out)->toBe('NEIN')
// Einmal nachhelfen gehört dazu: das ist zu diesem Zeitpunkt gefahrlos,
// weil ifreload die SSH-Sitzung ohnehin schon mitgenommen hat, und
// verwandelt einen hängenden Tunnel in einen laufenden statt in eine
// Rücknahme.
->and(file_get_contents($this->dir.'/calls'))
->toContain('restart wg-quick@wg0');
});
it('bestellt ab, wenn beide Richtungen stimmen', function () {
$ip = fakeUpBridge($this->dir);
$wg = fakeWg($this->dir, 'HUBKEY=', 5);
$out = runBridgeSh(
verdictBody('bridge_proven'),
[
'CLUPILOT_IP' => $ip,
'CLUPILOT_WG' => $wg,
'CLUPILOT_WG_HUB_PUBKEY' => 'HUBKEY=',
],
pre: 'http_get() { return 0; }'
);
expect($out)->toBe('JA');
});
it('erkennt einen Handshake von einem FREMDEN Peer nicht als den des Hubs', function () {
// Auf demselben Hub liegen auch Mitarbeiter-Zugänge. Deren Handshake sagt
// nichts über CluPilots eigenen Weg hierher.
$wg = fakeWg($this->dir, 'IRGENDWER=', 5);
$out = runBridgeSh(
verdictBody('tunnel_handshake_fresh'),
['CLUPILOT_WG' => $wg, 'CLUPILOT_WG_HUB_PUBKEY' => 'HUBKEY=']
);
expect($out)->toBe('NEIN');
});
it('hält einen Handshake, der nie stattgefunden hat, nicht für frisch', function () {
// WireGuard meldet 0 für einen Peer, mit dem noch nie gesprochen wurde.
// Als Sekunden gelesen ist das 1970 — uralt, aber `0` ist auch der Wert,
// den eine naive Prüfung für „vorhanden" hält.
$wg = fakeWg($this->dir, 'HUBKEY=', 0);
file_put_contents($this->dir.'/wg', "#!/bin/sh\nprintf '%s\\t%s\\n' 'HUBKEY=' '0'\n");
$out = runBridgeSh(
verdictBody('tunnel_handshake_fresh'),
['CLUPILOT_WG' => $this->dir.'/wg', 'CLUPILOT_WG_HUB_PUBKEY' => 'HUBKEY=']
);
expect($out)->toBe('NEIN');
});
it('benutzt an keiner Stelle ping', function () {
// Hetzners Debian-Basis hat kein iputils-ping, und PrepareBaseSystem
// installiert es nicht (curl, gnupg, ifupdown2, chrony). Eine Prüfung damit
// sagte IMMER „nicht erreichbar", der Zeitgeber spielte IMMER zurück, der
// Schritt käme nie durch — dieselbe Falle, die ConfigureWireguard schon
// einmal erwischt hat.
expect(file_get_contents(base_path('deploy/bootstrap/lib/bridge.sh')))
->not->toMatch('/(^|[^-\w])ping\s/m');
});
/*
|--------------------------------------------------------------------------
| Der Treiber
|--------------------------------------------------------------------------
*/
it('schreibt die PID als allererstes', function () {
// Der Startbefehl wartet darauf, dass hier etwas steht, und bis dahin gilt
// der Lauf als nicht angelaufen. Steht es weiter unten, liest ein früher
// Poll `running`-aber-nicht-lebendig und erklärt einen gesunden Lauf für
// tot.
$driver = base_path('deploy/bootstrap/lib/bridge-run.sh');
expect(file_exists($driver))->toBeTrue('bridge-run.sh fehlt');
$pidAt = null;
foreach (file($driver) ?: [] as $i => $line) {
if (str_contains($line, '/pid"') && str_contains($line, '$$')) {
$pidAt = $i;
break;
}
}
expect($pidAt)->not->toBeNull('keine Zeile schreibt $$ in die pid-Datei')
->and($pidAt)->toBeLessThan(60);
});
it('stellt den Zeitgeber vor dem ersten verändernden Aufruf', function () {
// Dieselbe Zusicherung wie bei bridge.sh, hier auf der Ebene des Treibers:
// die Reihenfolge der AUFRUFE im Skripttext. Umgekehrt wäre es die
// Reihenfolge, die einen Host dauerhaft unerreichbar macht.
$driver = base_path('deploy/bootstrap/lib/bridge-run.sh');
expect(file_exists($driver))->toBeTrue('bridge-run.sh fehlt');
$text = file_get_contents($driver);
$backup = strpos($text, 'backup_network_config');
$schedule = strpos($text, 'schedule_network_rollback');
$disown = strpos($text, 'disown_network_manager');
$build = strpos($text, 'build_bridge');
expect($backup)->not->toBeFalse()
->and($schedule)->not->toBeFalse()
->and($disown)->not->toBeFalse()
->and($build)->not->toBeFalse()
->and($backup)->toBeLessThan($schedule)
->and($schedule)->toBeLessThan($disown)
->and($disown)->toBeLessThan($build);
});
it('bestellt den Zeitgeber nirgends selbst ab', function () {
// Nur der Zeitgeber stellt zurück, und nur CluPilot bestellt ihn ab — nach
// dem Wiederverbinden. Ein Treiber, der das selbst täte, rät über seine
// eigene Erreichbarkeit von außen.
$driver = base_path('deploy/bootstrap/lib/bridge-run.sh');
expect(file_exists($driver))->toBeTrue('bridge-run.sh fehlt');
expect(file_get_contents($driver))->not->toContain('cancel_network_rollback');
});
it('lässt den Treiber von einer Shell parsen', function () {
$driver = base_path('deploy/bootstrap/lib/bridge-run.sh');
expect(file_exists($driver))->toBeTrue('bridge-run.sh fehlt');
expect(Process::run(['sh', '-n', $driver])->successful())->toBeTrue();
});
it('erkennt cloud-init als Fremdverwalter des Netzes', function () {
// Aus dem laufenden Zustand abzuleiten löst das LESEN, nicht das SCHREIBEN.
// Führt cloud-init das Netz, griffe die Brücke entweder sofort nicht oder,
// schlimmer, sie griffe jetzt und würde beim nächsten Neustart wieder
// eingesammelt — mit Kunden darauf. Der Zeitgeber fängt diesen Fall NICHT
// ab, denn zu seiner Zeit war alles in Ordnung.
$etc = $this->dir.'/etc';
mkdir("{$etc}/cloud", 0o755, true);
file_put_contents("{$etc}/cloud/cloud.cfg", "datasource_list: [ Hetzner ]\n");
expect(callBridgeFn('foreign_network_manager', ['CLUPILOT_ETC' => $etc]))
->toBe('cloud-init');
});
it('meldet keinen Fremdverwalter auf einer Maschine mit reinem ifupdown', function () {
$etc = $this->dir.'/etc';
mkdir($etc, 0o755, true);
expect(callBridgeFn('foreign_network_manager', ['CLUPILOT_ETC' => $etc]))
->toBe('');
});
it('entmachtet cloud-init im gesicherten Stand', function () {
$etc = $this->dir.'/etc';
mkdir("{$etc}/cloud", 0o755, true);
file_put_contents("{$etc}/cloud/cloud.cfg", "datasource_list: [ Hetzner ]\n");
runBridgeSh('disown_network_manager cloud-init ens3', [
'CLUPILOT_ETC' => $etc,
// Die Notiz, aus der die Rücknahme später liest, WAS entmachtet wurde.
'CLUPILOT_WORK_DIR' => $this->dir.'/work',
]);
expect(file_get_contents("{$etc}/cloud/cloud.cfg.d/99-clupilot-disable-network.cfg"))
->toContain('network: {config: disabled}');
});
/**
* Baut eine Sandkiste, in der bridge-run.sh wirklich durchläuft.
*
* Der Kniff ist die `ip`-Attrappe: sie antwortet VOR dem `ifreload` anders als
* danach, weil die `ifreload`-Attrappe eine Marke setzt. Ohne das könnte
* `bridge_proven` nie wahr werden — die Brücke trägt die Standardroute ja erst,
* nachdem umgestellt wurde.
*
* @return array{work:string, calls:string}
*/
function bridgeSandbox(string $dir, bool $bridgeComesUp = true, int $handshakeAge = 5, bool $withGateway = true): array
{
$work = "{$dir}/work";
$bin = "{$dir}/bin";
$state = "{$dir}/state";
foreach ([$work, $bin, $state, "{$dir}/units", "{$dir}/sbin", "{$dir}/etc"] as $d) {
mkdir($d, 0o755, true);
}
copy(base_path('deploy/bootstrap/lib/bridge.sh'), "{$work}/bridge.sh");
file_put_contents("{$dir}/interfaces", "# die Fassung von vorher\n");
$up = $bridgeComesUp ? "[ -f '{$state}/bridged' ]" : 'false';
// Eine Standardroute ohne `via` ist eine Link-Route. Sie hat kein Gateway,
// und ein `awk '{ print $3 }'` läse dort den KARTENNAMEN.
$route = $withGateway ? 'default via 10.0.0.1 dev $DEV' : 'default dev $DEV scope link';
file_put_contents("{$bin}/ip", <<<SH
#!/bin/sh
if {$up}; then DEV=vmbr0; else DEV=enp0s31f6; fi
case "\$*" in
'-4 route show default') echo "{$route}" ;;
'-4 -o addr show dev enp0s31f6 scope global')
echo '2: enp0s31f6 inet 10.0.0.7/24 scope global enp0s31f6' ;;
'-4 -o addr show dev vmbr0 scope global')
{$up} && echo '5: vmbr0 inet 10.0.0.7/24 scope global vmbr0' ;;
'link show vmbr0') {$up} || exit 1 ;;
'-4 route show dev enp0s31f6')
echo '10.0.0.0/24 proto kernel scope link src 10.0.0.7' ;;
'-4 route get 10.0.0.1') echo '10.0.0.1 dev enp0s31f6 src 10.0.0.7' ;;
'-6 -o addr show dev enp0s31f6 scope global') ;;
'-6 route show default') ;;
*) exit 1 ;;
esac
SH);
file_put_contents("{$bin}/ifreload", "#!/bin/sh\ntouch '{$state}/bridged'\necho ifreload >> '{$dir}/calls'\n");
file_put_contents("{$bin}/systemctl", "#!/bin/sh\necho \"systemctl \$*\" >> '{$dir}/calls'\n");
file_put_contents("{$bin}/wg", "#!/bin/sh\nprintf '%s\\t%s\\n' 'HUBKEY=' '".(time() - $handshakeAge)."'\n");
file_put_contents("{$bin}/logger", "#!/bin/sh\nexit 0\n");
foreach (['ip', 'ifreload', 'systemctl', 'wg', 'logger'] as $f) {
chmod("{$bin}/{$f}", 0o755);
}
// `http_get` als Funktion: bridge.sh legt seine eigene nur unter einem
// `command -v`-Schutz an, wer zuerst da ist behält recht — und env wird vor
// bridge.sh gesourced.
file_put_contents("{$work}/env", implode("\n", [
"CLUPILOT_WORK_DIR={$work}",
"CLUPILOT_IP={$bin}/ip",
"CLUPILOT_IFRELOAD={$bin}/ifreload",
"CLUPILOT_SYSTEMCTL={$bin}/systemctl",
"CLUPILOT_WG={$bin}/wg",
"CLUPILOT_INTERFACES_FILE={$dir}/interfaces",
"CLUPILOT_INTERFACES_D={$dir}/interfaces.d",
"CLUPILOT_NET_BACKUP={$dir}/sicherung",
"CLUPILOT_UNIT_DIR={$dir}/units",
"CLUPILOT_SBIN_DIR={$dir}/sbin",
"CLUPILOT_SYS_NET={$dir}/sys",
"CLUPILOT_ETC={$dir}/etc",
'CLUPILOT_WG_HUB_PUBKEY=HUBKEY=',
'CLUPILOT_HANDSHAKE_TRIES=1',
'CLUPILOT_HANDSHAKE_WAIT=0',
'http_get() { return 0; }',
'',
]));
fakeSysNet($dir, 'enp0s31f6', 'a8:a1:59:00:11:22');
return ['work' => $work, 'calls' => "{$dir}/calls"];
}
it('fährt den ganzen Ablauf durch und meldet ok', function () {
// Bis hierher prüfen die Tests, dass der Treiber DASTEHT — `sh -n` und die
// Reihenfolge im Text. Keiner prüft, dass er LÄUFT. Genau das ist aber die
// Datei, die auf einem echten Host das Netz umstellt.
$box = bridgeSandbox($this->dir);
$result = Process::path($box['work'])
->env(['CLUPILOT_WORK_DIR' => $box['work']])
->run('sh '.base_path('deploy/bootstrap/lib/bridge-run.sh'));
expect(trim((string) file_get_contents($box['work'].'/state')))->toBe('ok')
->and(trim((string) file_get_contents($box['work'].'/phase')))->toBe('wartet auf CluPilot')
->and($result->exitCode())->toBe(0)
// Die Strophe ist geschrieben und trägt die Karte als Port.
->and(file_get_contents($this->dir.'/interfaces'))->toContain('bridge-ports enp0s31f6')
// Und die Rückfahrkarte steht noch: abbestellen ist CluPilots Sache.
->and(file_exists($this->dir.'/units/clupilot-network-rollback.timer'))->toBeTrue()
->and(file_get_contents($box['calls']))->not->toContain('stop clupilot-network-rollback.timer');
});
it('schreibt kein Gateway in die Strophe, wenn die Standardroute keins hat', function () {
// Der Beweis über den PRODUKTIVPFAD, nicht über eine Einzelfunktion.
// `detect_network_style` auf `default_gateway()` umzustellen half nichts,
// solange bridge-run.sh sein Gateway weiter mit `awk '{ print $3 }'` las:
// der Treiber reichte `ens3` an build_bridge weiter, und in der Strophe
// stand `gateway ens3`. Ein Test an der Bibliothek allein hätte das nie
// gesehen.
$box = bridgeSandbox($this->dir, withGateway: false);
Process::path($box['work'])
->env(['CLUPILOT_WORK_DIR' => $box['work']])
->run('sh '.base_path('deploy/bootstrap/lib/bridge-run.sh'));
$stanza = (string) file_get_contents($this->dir.'/interfaces');
expect($stanza)->toContain('address 10.0.0.7/24')
->not->toContain('gateway enp0s31f6')
->not->toContain('pointopoint')
// Die Link-Route geht sonst beim Umbau verloren.
->toContain('up ip route add default dev vmbr0');
});
it('nimmt Karte und Gateway aus DERSELBEN Standardroute', function () {
// Bei zwei Standardrouten nahm `detect_primary_interface` das `dev` der
// ersten und `default_gateway` das `via` der zweiten — die Brücke bekäme
// die Karte der einen mit dem Gateway der anderen.
$ip = fakeIp($this->dir, [
'-4 route show default' => "default dev ens3 scope link\ndefault via 10.0.0.1 dev ens4 metric 200",
]);
expect(runBridgeSh('detect_primary_interface', ['CLUPILOT_IP' => $ip]))->toBe('ens3')
->and(runBridgeSh('default_gateway', ['CLUPILOT_IP' => $ip]))->toBe('');
});
it('meldet failed und lässt den Zeitgeber stehen, wenn die Brücke nicht trägt', function () {
// Der Fall, für den die ganze Konstruktion gebaut ist. Der Treiber räumt
// NICHT selbst auf — er überlässt es dem Zeitgeber und sagt nur, warum.
$box = bridgeSandbox($this->dir, bridgeComesUp: false);
$result = Process::path($box['work'])
->env(['CLUPILOT_WORK_DIR' => $box['work']])
->run('sh '.base_path('deploy/bootstrap/lib/bridge-run.sh'));
expect(trim((string) file_get_contents($box['work'].'/state')))->toBe('failed')
->and($result->exitCode())->toBe(1)
->and(file_get_contents($box['work'].'/note'))->toContain('Zeitgeber')
->and(file_exists($this->dir.'/units/clupilot-network-rollback.timer'))->toBeTrue()
->and(file_get_contents($box['calls']))->not->toContain('stop clupilot-network-rollback.timer');
});
it('meldet failed, wenn die Brücke steht, der Tunnel aber schal bleibt', function () {
// Öffentlich erreichbar und trotzdem ausgesperrt: die Richtung, die der
// Treiber ohne die Handshake-Prüfung für Erfolg gehalten hätte.
$box = bridgeSandbox($this->dir, handshakeAge: 3600);
Process::path($box['work'])
->env(['CLUPILOT_WORK_DIR' => $box['work']])
->run('sh '.base_path('deploy/bootstrap/lib/bridge-run.sh'));
expect(trim((string) file_get_contents($box['work'].'/state')))->toBe('failed')
->and(file_get_contents($box['calls']))->toContain('restart wg-quick@wg0')
->and(file_exists($this->dir.'/units/clupilot-network-rollback.timer'))->toBeTrue();
});
it('lässt jede Bibliothek des Bootstraps von einer Shell parsen', function () {
// network.sh und proxmox.sh werden beim Herauslösen beschnitten. Ein
// verrutschter Schnitt fiele sonst erst auf dem Rettungssystem-Weg auf, und
// der wird selten gefahren.
foreach (glob(base_path('deploy/bootstrap/lib/*.sh')) ?: [] as $file) {
expect(Process::run(['sh', '-n', $file])->successful())
->toBeTrue('kein gültiges POSIX-sh: '.$file);
}
});
Reference in New Issue View Git Blame Copy Permalink