Compare commits
12 commits
dae1d0a935
...
1b37bd6b4b
| Author | SHA1 | Date | |
|---|---|---|---|
|
1b37bd6b4b |
|||
|
50bc2497ec |
|||
|
f18e23c425 |
|||
|
e34c5df89f |
|||
|
9a1e941b15 |
|||
|
080ce82d0d |
|||
|
c34915e3e2 |
|||
|
b2893c15c1 |
|||
|
8bab3e2e1f |
|||
|
f7da876977 |
|||
|
682696214a |
|||
|
4f7d55a9ed |
59 changed files with 1744 additions and 228 deletions
|
|
@ -33,7 +33,7 @@ jobs:
|
|||
echo "Building for ${BINARI}/${GOOS}/${GOARCH} (release: ${RELEASE_CIBLE})"
|
||||
go env GOOS GOARCH
|
||||
mkdir -p dist/
|
||||
go build -o dist/${BINARI}_${GOOS}_${GOARCH} ./cmd/${BINARI}
|
||||
go build -ldflags "-X main.version=${RELEASE_CIBLE}" -o dist/${BINARI}_${GOOS}_${GOARCH} ./cmd/${BINARI}
|
||||
echo "artifact pour ${RELEASE_CIBLE} ${BINARI} ${GOOS} ${GOARCH}" > dist/${BINARI}-${GOOS}-${GOARCH}.txt
|
||||
ls -l ./dist
|
||||
- name: Upload artifact
|
||||
|
|
|
|||
|
|
@ -16,7 +16,7 @@ bash ./deploy.sh -t 0.2.0 -i
|
|||
|
||||
`deploy.sh` se met à jour lui-même depuis la branche, télécharge binaires, units systemd et
|
||||
scripts depuis la release, et les vérifie contre le manifeste `SHA256SUMS`. Le drapeau `-i`
|
||||
prépare l'host : paquets, module `br_netfilter`, `sysctl`, et bridges.
|
||||
prépare l'host : paquets, `sysctl`, et bridges.
|
||||
|
||||
Options utiles :
|
||||
|
||||
|
|
|
|||
138
api/agent.yaml
138
api/agent.yaml
|
|
@ -489,6 +489,63 @@ paths:
|
|||
"500":
|
||||
$ref: "#/components/responses/InternalError"
|
||||
|
||||
# ── Host ───────────────────────────────────────────────────────────────────
|
||||
|
||||
/register:
|
||||
get:
|
||||
summary: Facts of the host that do not change while it runs
|
||||
operationId: getRegister
|
||||
description: >-
|
||||
Read once when the agent starts and kept in memory. Will also be sent to the broker of the
|
||||
orchestrator at startup.
|
||||
responses:
|
||||
"200":
|
||||
description: Host facts
|
||||
content:
|
||||
application/json:
|
||||
schema:
|
||||
$ref: "#/components/schemas/HostRegister"
|
||||
"405":
|
||||
description: Method other than GET
|
||||
content:
|
||||
application/json:
|
||||
schema:
|
||||
$ref: "#/components/schemas/Error"
|
||||
"503":
|
||||
description: Host facts could not be read when the agent started (the error says why)
|
||||
content:
|
||||
application/json:
|
||||
schema:
|
||||
$ref: "#/components/schemas/Error"
|
||||
|
||||
/ping:
|
||||
get:
|
||||
summary: Current state of the host and of the agent
|
||||
operationId: getPing
|
||||
description: >-
|
||||
Last reading, taken when the agent starts then every times.host_state_interval seconds and
|
||||
kept in memory; collected_at gives its age. boot_time and agent_start_time tell a host
|
||||
reboot from an agent restart; boot_time plus uptime_seconds give the clock of the host.
|
||||
responses:
|
||||
"200":
|
||||
description: Last host state
|
||||
content:
|
||||
application/json:
|
||||
schema:
|
||||
$ref: "#/components/schemas/HostPing"
|
||||
"405":
|
||||
description: Method other than GET
|
||||
content:
|
||||
application/json:
|
||||
schema:
|
||||
$ref: "#/components/schemas/Error"
|
||||
"503":
|
||||
description: No reading has succeeded yet
|
||||
content:
|
||||
application/json:
|
||||
schema:
|
||||
$ref: "#/components/schemas/Error"
|
||||
|
||||
components:
|
||||
|
||||
parameters:
|
||||
|
|
@ -932,6 +989,87 @@ components:
|
|||
type: string
|
||||
example: "203.0.113.1"
|
||||
|
||||
HostRegister:
|
||||
type: object
|
||||
properties:
|
||||
hostname:
|
||||
type: string
|
||||
example: hv1
|
||||
cpu:
|
||||
type: object
|
||||
properties:
|
||||
vendor:
|
||||
type: string
|
||||
example: AuthenticAMD
|
||||
model:
|
||||
type: string
|
||||
example: AMD EPYC 7272 12-Core Processor
|
||||
sockets:
|
||||
type: integer
|
||||
example: 1
|
||||
cores:
|
||||
type: integer
|
||||
description: Physical cores, all sockets together
|
||||
example: 12
|
||||
threads:
|
||||
type: integer
|
||||
description: Logical processors, all sockets together
|
||||
example: 24
|
||||
memory_bytes:
|
||||
type: integer
|
||||
format: int64
|
||||
example: 134217728000
|
||||
os:
|
||||
type: object
|
||||
description: From /etc/os-release
|
||||
properties:
|
||||
id:
|
||||
type: string
|
||||
example: debian
|
||||
version_id:
|
||||
type: string
|
||||
example: "12"
|
||||
pretty_name:
|
||||
type: string
|
||||
example: Debian GNU/Linux 12 (bookworm)
|
||||
kernel:
|
||||
type: string
|
||||
example: 6.1.0-26-amd64
|
||||
|
||||
HostPing:
|
||||
type: object
|
||||
properties:
|
||||
agent_version:
|
||||
type: string
|
||||
description: Release tag, commit for a lab build, undefined when not set at build time
|
||||
example: 0.3.0
|
||||
collected_at:
|
||||
type: integer
|
||||
format: int64
|
||||
description: Unix time (seconds) of the reading
|
||||
example: 1793520853
|
||||
boot_time:
|
||||
type: integer
|
||||
format: int64
|
||||
description: Unix time (seconds) the host booted
|
||||
example: 1793499123
|
||||
agent_start_time:
|
||||
type: integer
|
||||
format: int64
|
||||
description: Unix time (seconds) the agent started
|
||||
example: 1793499190
|
||||
uptime_seconds:
|
||||
type: number
|
||||
example: 21730.4
|
||||
load:
|
||||
type: array
|
||||
description: Load average over 1, 5 and 15 minutes
|
||||
minItems: 3
|
||||
maxItems: 3
|
||||
items:
|
||||
type: number
|
||||
example: [0.12, 0.3, 0.25]
|
||||
|
||||
Error:
|
||||
type: object
|
||||
properties:
|
||||
|
|
|
|||
|
|
@ -14,6 +14,7 @@ import (
|
|||
configuration "git.g3e.fr/syonad/two/internal/config/agent"
|
||||
dispatcher "git.g3e.fr/syonad/two/internal/dispatcher/agent"
|
||||
"git.g3e.fr/syonad/two/internal/frr"
|
||||
"git.g3e.fr/syonad/two/internal/host"
|
||||
"git.g3e.fr/syonad/two/internal/migration"
|
||||
"git.g3e.fr/syonad/two/internal/netif"
|
||||
agentmetrics "git.g3e.fr/syonad/two/internal/prometheus/agent"
|
||||
|
|
@ -28,6 +29,8 @@ import (
|
|||
|
||||
const shutdownTimeout = 20 * time.Second
|
||||
|
||||
var version = "undefined"
|
||||
|
||||
func main() {
|
||||
confFile := flag.String("config", "/etc/two/agent.yml", "config file path")
|
||||
flag.Parse()
|
||||
|
|
@ -35,6 +38,7 @@ func main() {
|
|||
}
|
||||
|
||||
func run(confFile string) int {
|
||||
start := time.Now()
|
||||
cfg, err := configuration.LoadConfig(confFile)
|
||||
if err != nil {
|
||||
slog.Error("failed to load config", "error", err)
|
||||
|
|
@ -96,6 +100,7 @@ func run(confFile string) int {
|
|||
promAddr := fmt.Sprintf("%s:%d", cfg.Prometheus.Address, cfg.Prometheus.Port)
|
||||
|
||||
log.Info("starting agent",
|
||||
"version", version,
|
||||
"api", apiAddr,
|
||||
"prometheus", promAddr,
|
||||
"workers", cfg.Worker.Count,
|
||||
|
|
@ -108,7 +113,10 @@ func run(confFile string) int {
|
|||
|
||||
d := dispatcher.New(q, db, cfg, log.With(slog.String("component", "dispatcher")))
|
||||
|
||||
apiSrv := agentapi.New(d, db, log.With(slog.String("component", "api")), apiAddr)
|
||||
hostInfo := host.NewCollector(os.DirFS("/"), version, start, cfg.Times.HostState(), log.With(slog.String("component", "host")))
|
||||
go hostInfo.Run(ctx)
|
||||
|
||||
apiSrv := agentapi.New(d, db, log.With(slog.String("component", "api")), apiAddr, hostInfo)
|
||||
go apiSrv.Start()
|
||||
|
||||
promSrv := promserver.New(promAddr, registry)
|
||||
|
|
|
|||
|
|
@ -35,6 +35,8 @@ times:
|
|||
timeout_vms_start: 300
|
||||
# Interval between each state check
|
||||
poll_interval: 2
|
||||
# Interval between two readings of the host state served by GET /ping
|
||||
host_state_interval: 10
|
||||
|
||||
# Bridge interface used when the requested iface_type is not found in interfaces
|
||||
default_interface: br-000000
|
||||
|
|
|
|||
|
|
@ -44,18 +44,20 @@ Paquets
|
|||
``/24`` et ``/32``
|
||||
* - ``internal/frr``
|
||||
- génération des commandes FRR, seul point d'appel à ``vtysh``
|
||||
* - ``internal/host``
|
||||
- connaissance de l'hôte : faits lus au démarrage (``/register``), état mesuré périodiquement en mémoire (``/ping``)
|
||||
* - ``internal/sysctl``
|
||||
- écriture sous ``/proc/sys``, dans un netns si besoin
|
||||
* - ``internal/netns``
|
||||
- network namespaces : create/delete/call
|
||||
* - ``internal/netif``
|
||||
- netlink : bridge, veth, vxlan, tap, routes, adresses
|
||||
* - ``internal/nft``, ``internal/iptables``
|
||||
- wrappers dédiés ; ne pas appeler ces binaires ailleurs
|
||||
* - ``internal/nft``
|
||||
- wrapper dédié ; ne pas appeler ``nft`` ailleurs
|
||||
* - ``internal/qemu``, ``internal/qmp``
|
||||
- lancement de QEMU et client QMP sur socket Unix
|
||||
* - ``internal/vm``
|
||||
- cycle de vie d'une VM : tap, iptables, metadata, qemu
|
||||
- cycle de vie d'une VM : tap, nftables, metadata, qemu
|
||||
* - ``internal/dhcp``
|
||||
- plan d'adressage ip → mac, et configurations dnsmasq du backend historique
|
||||
* - ``internal/dhcpbackend``
|
||||
|
|
|
|||
|
|
@ -13,18 +13,18 @@ Chemin d'une requête
|
|||
.. mermaid::
|
||||
|
||||
graph LR
|
||||
V["VM<br/>vers interface_ip:53 ou :123"] --> N["netns du VPC<br/>chaîne TWO-HOSTSVC<br/>DNAT vers 169.254.169.253"]
|
||||
V["VM<br/>vers interface_ip:53 ou :123"] --> N["netns du VPC<br/>chaîne nftables hostsvc<br/>DNAT vers 169.254.169.253"]
|
||||
N --> H["two-hostsvc<br/>socket dans le netns<br/>169.254.169.253 sur la dummy hostsvc"]
|
||||
H -->|"depuis l'hôte"| U["serveurs amont<br/>puis résolveur ou horloge de l'hôte"]
|
||||
|
||||
À la création d'un VPC sur l'hyperviseur, l'agent pose dans son netns :
|
||||
|
||||
* une interface ``dummy`` ``hostsvc`` portant ``169.254.169.253/32`` ;
|
||||
* une chaîne iptables ``TWO-HOSTSVC`` (table ``nat``), appelée depuis ``PREROUTING`` pour le seul
|
||||
trafic à destination d'une adresse locale du netns (``addrtype LOCAL`` : les gateways des
|
||||
subnets, anycast compris). Elle renvoie d'abord ce qui arrive par ``br-public`` (le segment
|
||||
public de l'hôte) et par ``l3-+`` (le lien vers la VRF), puis redirige 53 en UDP et TCP et 123
|
||||
en UDP vers ``169.254.169.253`` ;
|
||||
* une chaîne nftables ``hostsvc`` dans la table ``ip two``, accrochée à ``prerouting`` en
|
||||
priorité ``dstnat``. Elle renvoie d'abord ce qui arrive par ``br-public`` (le segment public de
|
||||
l'hôte) et par ``l3-*`` (le lien vers la VRF), puis redirige 53 en UDP et TCP et 123 en UDP vers
|
||||
``169.254.169.253``, pour le seul trafic à destination d'une adresse locale du netns
|
||||
(``fib daddr type local`` : les gateways des subnets, anycast compris) ;
|
||||
|
||||
puis demande à ``two-hostsvc`` d'ouvrir ses sockets dans ce netns. La réponse repart par
|
||||
conntrack, avec l'adresse de la gateway pour source. Une VM qui interroge un résolveur extérieur
|
||||
|
|
|
|||
|
|
@ -34,7 +34,7 @@ reçoivent du trafic. Il désactive aussi ``br_netfilter`` dans le netns
|
|||
conntrack voit chaque trame pontée et le SNAT de la passerelle NAT ne s'applique plus.
|
||||
|
||||
Dans le netns, l'agent pose aussi la ``dummy`` ``hostsvc`` (``169.254.169.253/32``) et la chaîne
|
||||
iptables ``TWO-HOSTSVC``, puis demande à ``two-hostsvc`` de servir le VPC : c'est le chemin du
|
||||
nftables ``hostsvc`` (table ``ip two``), puis demande à ``two-hostsvc`` de servir le VPC : c'est le chemin du
|
||||
DNS et du NTP des VM (voir :doc:`dns-ntp`). Si ``two-hostsvc`` ne répond pas, la création du VPC
|
||||
échoue.
|
||||
|
||||
|
|
|
|||
|
|
@ -8,7 +8,7 @@ Prérequis
|
|||
---------
|
||||
|
||||
Un host Linux avec KVM, sur lequel vous avez ``root``. Les opérations réseau (network
|
||||
namespaces, netlink, VXLAN, nftables, iptables) et QEMU ne fonctionnent que sous Linux.
|
||||
namespaces, netlink, VXLAN, nftables) et QEMU ne fonctionnent que sous Linux.
|
||||
|
||||
Déploiement
|
||||
-----------
|
||||
|
|
@ -75,7 +75,7 @@ Ce que fait ``-i``
|
|||
------------------
|
||||
|
||||
**Paquets** — ``qemu-system-x86``, ``qemu-utils``, ``ovmf``, ``dnsmasq``, ``nftables``,
|
||||
``iptables``, ``nfs-common``, ``jq``, ``curl``, **sans les paquets recommandés** : ceux de
|
||||
``nfs-common``, ``jq``, ``curl``, **sans les paquets recommandés** : ceux de
|
||||
``qemu-system-x86`` (interface graphique, gtk, gstreamer, pilotes de stockage réseau) ne servent
|
||||
pas à un hyperviseur sans écran, et l'installation passe d'environ 270 à 65 Mo — rejouée à chaque
|
||||
démarrage, la racine étant en tmpfs. ``qemu-utils`` est demandé explicitement : ``qemu-img`` sert
|
||||
|
|
@ -87,10 +87,11 @@ dans les netns.
|
|||
aux hyperviseurs qui déclarent ``dhcp.backend: dnsmasq``, et tant qu'un hyperviseur peut revenir
|
||||
en arrière. Voir :doc:`/exploitation/configuration`.
|
||||
|
||||
**Noyau** — chargement de ``br_netfilter``, puis ``net.ipv4.ip_forward = 1`` et
|
||||
``net.bridge.bridge-nf-call-iptables = 1``. Cette dernière clé est **requise** par la DNAT vers
|
||||
le serveur de metadata : sans elle, iptables ne voit pas le trafic bridgé des VM et cloud-init
|
||||
ne se provisionne pas. Contrepartie assumée : tout le trafic inter-VM traverse les tables NAT.
|
||||
**Noyau** — ``net.ipv4.ip_forward = 1``. ``br_netfilter`` n'est pas chargé : le filtrage des
|
||||
ponts est en nftables (famille ``bridge``) et les redirections vers le serveur de metadata et
|
||||
vers ``two-hostsvc`` sont posées dans le netns de chaque VPC, où l'agent coupe déjà
|
||||
``bridge-nf-call-*``. Chargé, le module ferait passer tout le trafic bridgé des VM par netfilter
|
||||
(``bridge-nf-call-iptables`` vaut 1 par défaut).
|
||||
|
||||
**Réseau** — création du bridge public, puis rattachement de l'uplink au bridge principal,
|
||||
l'adresse et la route par défaut étant déplacées de l'interface physique vers le bridge.
|
||||
|
|
|
|||
|
|
@ -274,7 +274,7 @@ code de sortie vaut 1 si une vérification échoue **ou si aucune n'a été fait
|
|||
**Tests autonomes.** Avant chaque test, le runner supprime les ressources ``tNN`` laissées par un
|
||||
passage précédent, puis relève l'état de chaque hôte de l'en-tête ``# hôtes:``. Après le test, il
|
||||
supprime ses VM, ses subnets puis ses VPC, et vérifie que l'hôte est revenu à l'état relevé
|
||||
(``assert_clean`` : netns, liens, adresses, routes, règles nftables de pont et iptables,
|
||||
(``assert_clean`` : netns, liens, adresses, routes, règles nftables de l'hôte et de chaque netns,
|
||||
configuration FRR et ``frr.conf``, fichiers de ``/run/two``, ``dnsmasq.d`` et des volumes, unités
|
||||
``two-vm-*``, processus dnsmasq et QEMU). Aucun test ne dépend d'un autre : n'importe lequel se lance seul.
|
||||
|
||||
|
|
@ -320,6 +320,10 @@ Générée par ``test/e2e/run.sh --matrice`` à partir des en-têtes ; à régé
|
|||
- machine d'états — 409 pendant creating, suppression depuis error, sockets QEMU d'une VM en error retirés, dépendances VM → subnet → VPC, suppression d'un subnet en attente de ses VM, arrêt d'une VM juste démarrée par renvoi de system_powerdown, recréation sous le même nom
|
||||
- hv1
|
||||
- #41, #84, #79
|
||||
* - ``13-hote``
|
||||
- connaissance de l'hôte — /register (hostname, CPU, RAM, OS, noyau) lu au démarrage, /ping (version, démarrages de l'hôte et de l'agent, uptime, load) mesuré périodiquement, lecture seule, redémarrage de l'agent distingué de celui de l'hôte
|
||||
- hv1
|
||||
- #39
|
||||
* - ``21-dhcp-two``
|
||||
- DHCP par le serveur intégré (backend two) — bail, server-id, renouvellement, option 121, un serveur par subnet, démarrages simultanés
|
||||
- hv1
|
||||
|
|
|
|||
|
|
@ -80,6 +80,7 @@ Exécution des commandes
|
|||
timeout_subnet_start: 300
|
||||
timeout_vms_start: 300
|
||||
poll_interval: 2
|
||||
host_state_interval: 10
|
||||
|
||||
``worker.count`` est le nombre de goroutines qui exécutent les commandes ; ``buffer_size`` le
|
||||
nombre de commandes en attente au-delà duquel ``Dispatch`` bloque.
|
||||
|
|
@ -101,6 +102,9 @@ La section ``times`` règle, en secondes, les attentes des commandes asynchrones
|
|||
création d'une VM : attente des subnets de ses interfaces ``running``.
|
||||
``poll_interval``
|
||||
pas de toutes ces attentes.
|
||||
``host_state_interval``
|
||||
intervalle entre deux mesures de l'état de l'hôte servi par ``GET /ping`` (voir
|
||||
:doc:`observabilite`).
|
||||
|
||||
Chaque valeur doit être strictement positive, et ``next_vms_shutdown`` inférieur à
|
||||
``timeout_vms_stop`` ; sinon l'agent refuse de démarrer. Les attentes s'enchaînent — une VM,
|
||||
|
|
|
|||
|
|
@ -150,6 +150,7 @@ Depuis l'host, l'instance correspondante :
|
|||
|
||||
systemctl status 'metadata@<vm>'
|
||||
ls -l /run/two/metadata/<vm>/
|
||||
ip netns exec <vpc> nft list chain ip two md-<vm> # une dnat par IP de la VM
|
||||
|
||||
Le user-data est servi vide
|
||||
---------------------------
|
||||
|
|
@ -179,8 +180,7 @@ est redirigée vers ``two-hostsvc`` dans le netns du VPC (voir :doc:`../concepts
|
|||
systemctl status two-hostsvc
|
||||
cat /run/two/hostsvc/hostsvc.state # le VPC doit y figurer
|
||||
ip -n <vpc> -4 addr show dev hostsvc # 169.254.169.253/32
|
||||
ip netns exec <vpc> iptables -t nat -S TWO-HOSTSVC # 2 RETURN puis 3 DNAT
|
||||
ip netns exec <vpc> iptables -t nat -L TWO-HOSTSVC -v -n # compteurs des redirections
|
||||
ip netns exec <vpc> nft list chain ip two hostsvc # 2 return puis 3 dnat
|
||||
ip netns exec <vpc> ss -lntu | grep 169.254.169.253 # 53/udp, 53/tcp, 123/udp
|
||||
journalctl -u two-hostsvc -n 50
|
||||
|
||||
|
|
|
|||
|
|
@ -27,6 +27,31 @@ Les états sont ceux du :doc:`cycle de vie </concepts/cycle-de-vie>`. Une valeur
|
|||
durable sur ``error`` est l'alerte la plus utile à poser ; une valeur durable sur ``creating``
|
||||
ou ``deleting`` signale une opération qui n'aboutit pas.
|
||||
|
||||
Connaissance de l'hôte
|
||||
----------------------
|
||||
|
||||
Deux routes de l'API de l'agent, en lecture seule (voir :doc:`api-agent/reference`) :
|
||||
|
||||
``GET /register``
|
||||
ce qui ne change pas tant que l'hôte tourne : hostname, CPU (fabricant, modèle, sockets,
|
||||
cœurs, threads), RAM totale, OS (``/etc/os-release``) et noyau. Lu une fois au démarrage de
|
||||
l'agent ; si la lecture échoue, l'agent démarre quand même, journalise ``host facts
|
||||
unavailable`` et la route répond 503 avec l'erreur.
|
||||
``GET /ping``
|
||||
l'état courant : version de l'agent, démarrage de l'hôte (``boot_time``) et de l'agent
|
||||
(``agent_start_time``), uptime de l'hôte et load sur 1, 5 et 15 minutes. Mesuré au démarrage
|
||||
puis toutes les ``times.host_state_interval`` secondes (10 par défaut), gardé en mémoire ;
|
||||
``collected_at`` donne l'heure de la mesure. 503 tant qu'aucune mesure n'a réussi ; une mesure
|
||||
en échec est journalisée (``host state collection failed``) et la précédente reste servie.
|
||||
|
||||
Les dates sont des timestamps Unix en secondes. Un ``boot_time`` qui change signale un
|
||||
redémarrage de l'hôte, un ``agent_start_time`` seul un redémarrage de l'agent ;
|
||||
``boot_time`` + ``uptime_seconds`` donne l'horloge de l'hôte au moment de la mesure.
|
||||
|
||||
La version de l'agent est injectée au build : le tag pour une release, le commit court
|
||||
(suffixé ``-dirty`` si l'arbre avait des modifications) pour les binaires de test du lab,
|
||||
``undefined`` sinon. Elle figure aussi dans la ligne ``starting agent`` du journal.
|
||||
|
||||
Watchdog
|
||||
--------
|
||||
|
||||
|
|
@ -52,8 +77,8 @@ Dès qu'un VPC est ``running`` sur l'hyperviseur, il contrôle aussi le relais D
|
|||
* ``two-hostsvc`` injoignable sur sa socket de contrôle : une notification, aucun VPC de
|
||||
l'hyperviseur n'a plus de DNS ni de NTP ;
|
||||
* pour chaque VPC ``running`` : VPC absent de la liste servie par ``two-hostsvc``,
|
||||
``169.254.169.253`` absente de la ``dummy`` ``hostsvc``, ou chaîne ``TWO-HOSTSVC`` absente ou
|
||||
incomplète dans son netns. Un VPC créé par une version antérieure à la 0.3.0 n'a rien de tout
|
||||
``169.254.169.253`` absente de la ``dummy`` ``hostsvc``, ou chaîne ``hostsvc`` de la table
|
||||
``ip two`` absente ou incomplète dans son netns. Un VPC créé par une version antérieure à la 0.3.0 n'a rien de tout
|
||||
cela : il est signalé à chaque tick jusqu'à sa recréation.
|
||||
|
||||
Avec une section ``bgp`` dans la configuration, il contrôle aussi le plan de contrôle :
|
||||
|
|
|
|||
|
|
@ -27,7 +27,7 @@ func newTestServerWith(t *testing.T, cfg *configuration.Config) (*Server, *badge
|
|||
q := worker.New(100)
|
||||
logger := slog.New(slog.NewTextHandler(io.Discard, nil))
|
||||
d := dispatcher.New(q, db, cfg, logger)
|
||||
return New(d, db, logger, "127.0.0.1:0"), db
|
||||
return New(d, db, logger, "127.0.0.1:0", &fakeHost{}), db
|
||||
}
|
||||
|
||||
func init() {
|
||||
|
|
|
|||
56
internal/api/agent/host.go
Normal file
56
internal/api/agent/host.go
Normal file
|
|
@ -0,0 +1,56 @@
|
|||
package agentapi
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"net/http"
|
||||
|
||||
"git.g3e.fr/syonad/two/internal/host"
|
||||
)
|
||||
|
||||
type HostInfo interface {
|
||||
Register() (host.Facts, error)
|
||||
Ping() (host.Ping, bool)
|
||||
}
|
||||
|
||||
func (s *Server) RegisterHandler(w http.ResponseWriter, r *http.Request) {
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
if r.Method != http.MethodGet {
|
||||
http.Error(w, `{"error":"method not allowed"}`, http.StatusMethodNotAllowed)
|
||||
return
|
||||
}
|
||||
f, err := s.host.Register()
|
||||
if err != nil {
|
||||
w.WriteHeader(http.StatusServiceUnavailable)
|
||||
json.NewEncoder(w).Encode(ErrorResponse{Error: "host facts unavailable: " + err.Error()})
|
||||
return
|
||||
}
|
||||
json.NewEncoder(w).Encode(HostRegister{
|
||||
Hostname: f.Hostname,
|
||||
CPU: HostCPU{Vendor: f.CPU.Vendor, Model: f.CPU.Model, Sockets: f.CPU.Sockets, Cores: f.CPU.Cores, Threads: f.CPU.Threads},
|
||||
MemoryBytes: f.MemoryBytes,
|
||||
OS: HostOS{ID: f.OS.ID, VersionID: f.OS.VersionID, PrettyName: f.OS.PrettyName},
|
||||
Kernel: f.Kernel,
|
||||
})
|
||||
}
|
||||
|
||||
func (s *Server) PingHandler(w http.ResponseWriter, r *http.Request) {
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
if r.Method != http.MethodGet {
|
||||
http.Error(w, `{"error":"method not allowed"}`, http.StatusMethodNotAllowed)
|
||||
return
|
||||
}
|
||||
p, ok := s.host.Ping()
|
||||
if !ok {
|
||||
w.WriteHeader(http.StatusServiceUnavailable)
|
||||
json.NewEncoder(w).Encode(ErrorResponse{Error: "no host state collected yet"})
|
||||
return
|
||||
}
|
||||
json.NewEncoder(w).Encode(HostPing{
|
||||
AgentVersion: p.AgentVersion,
|
||||
CollectedAt: p.CollectedAt,
|
||||
BootTime: p.BootTime,
|
||||
AgentStartTime: p.AgentStartTime,
|
||||
UptimeSeconds: p.UptimeSeconds,
|
||||
Load: p.Load,
|
||||
})
|
||||
}
|
||||
103
internal/api/agent/host_test.go
Normal file
103
internal/api/agent/host_test.go
Normal file
|
|
@ -0,0 +1,103 @@
|
|||
package agentapi
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
"git.g3e.fr/syonad/two/internal/host"
|
||||
)
|
||||
|
||||
type fakeHost struct {
|
||||
facts host.Facts
|
||||
factsErr error
|
||||
ping *host.Ping
|
||||
}
|
||||
|
||||
func (f *fakeHost) Register() (host.Facts, error) { return f.facts, f.factsErr }
|
||||
|
||||
func (f *fakeHost) Ping() (host.Ping, bool) {
|
||||
if f.ping == nil {
|
||||
return host.Ping{}, false
|
||||
}
|
||||
return *f.ping, true
|
||||
}
|
||||
|
||||
func serveHost(t *testing.T, h *fakeHost, method, path string) *httptest.ResponseRecorder {
|
||||
t.Helper()
|
||||
s, _ := newTestServer(t)
|
||||
s.host = h
|
||||
w := httptest.NewRecorder()
|
||||
s.srv.Handler.ServeHTTP(w, httptest.NewRequest(method, path, nil))
|
||||
return w
|
||||
}
|
||||
|
||||
func TestRegister_ServesTheFacts(t *testing.T) {
|
||||
h := &fakeHost{facts: host.Facts{
|
||||
Hostname: "hv1",
|
||||
CPU: host.CPU{Vendor: "AuthenticAMD", Model: "AMD EPYC 7272 12-Core Processor", Sockets: 1, Cores: 12, Threads: 24},
|
||||
MemoryBytes: 134217728000,
|
||||
OS: host.OS{ID: "debian", VersionID: "12", PrettyName: "Debian GNU/Linux 12 (bookworm)"},
|
||||
Kernel: "6.1.0-26-amd64",
|
||||
}}
|
||||
w := serveHost(t, h, http.MethodGet, "/register")
|
||||
if w.Code != http.StatusOK {
|
||||
t.Fatalf("attendu 200, obtenu %d : %s", w.Code, w.Body.String())
|
||||
}
|
||||
want := `{"hostname":"hv1","cpu":{"vendor":"AuthenticAMD","model":"AMD EPYC 7272 12-Core Processor","sockets":1,"cores":12,"threads":24},"memory_bytes":134217728000,"os":{"id":"debian","version_id":"12","pretty_name":"Debian GNU/Linux 12 (bookworm)"},"kernel":"6.1.0-26-amd64"}`
|
||||
if got := strings.TrimSpace(w.Body.String()); got != want {
|
||||
t.Errorf("corps :\n%s\nattendu :\n%s", got, want)
|
||||
}
|
||||
}
|
||||
|
||||
func TestRegister_UnavailableFacts(t *testing.T) {
|
||||
w := serveHost(t, &fakeHost{factsErr: errors.New("open proc/cpuinfo: file does not exist")}, http.MethodGet, "/register")
|
||||
if w.Code != http.StatusServiceUnavailable {
|
||||
t.Fatalf("attendu 503, obtenu %d", w.Code)
|
||||
}
|
||||
var e ErrorResponse
|
||||
if err := json.NewDecoder(w.Body).Decode(&e); err != nil || e.Error != "host facts unavailable: open proc/cpuinfo: file does not exist" {
|
||||
t.Errorf("erreur %q, %v", e.Error, err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestPing_ServesTheLastState(t *testing.T) {
|
||||
h := &fakeHost{ping: &host.Ping{
|
||||
State: host.State{BootTime: 1793499123, UptimeSeconds: 21730.4, Load: [3]float64{0.12, 0.3, 0.25}},
|
||||
AgentVersion: "0.3.0",
|
||||
AgentStartTime: 1793499190,
|
||||
CollectedAt: 1793520853,
|
||||
}}
|
||||
w := serveHost(t, h, http.MethodGet, "/ping")
|
||||
if w.Code != http.StatusOK {
|
||||
t.Fatalf("attendu 200, obtenu %d : %s", w.Code, w.Body.String())
|
||||
}
|
||||
want := `{"agent_version":"0.3.0","collected_at":1793520853,"boot_time":1793499123,"agent_start_time":1793499190,"uptime_seconds":21730.4,"load":[0.12,0.3,0.25]}`
|
||||
if got := strings.TrimSpace(w.Body.String()); got != want {
|
||||
t.Errorf("corps :\n%s\nattendu :\n%s", got, want)
|
||||
}
|
||||
}
|
||||
|
||||
func TestPing_BeforeTheFirstCollection(t *testing.T) {
|
||||
w := serveHost(t, &fakeHost{}, http.MethodGet, "/ping")
|
||||
if w.Code != http.StatusServiceUnavailable {
|
||||
t.Fatalf("attendu 503, obtenu %d", w.Code)
|
||||
}
|
||||
if !strings.Contains(w.Body.String(), "no host state collected yet") {
|
||||
t.Errorf("corps %s", w.Body.String())
|
||||
}
|
||||
}
|
||||
|
||||
func TestHostRoutes_ReadOnly(t *testing.T) {
|
||||
h := &fakeHost{ping: &host.Ping{}}
|
||||
for _, path := range []string{"/register", "/ping"} {
|
||||
for _, method := range []string{http.MethodPost, http.MethodPut, http.MethodDelete} {
|
||||
if w := serveHost(t, h, method, path); w.Code != http.StatusMethodNotAllowed {
|
||||
t.Errorf("%s %s : attendu 405, obtenu %d", method, path, w.Code)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -123,3 +123,34 @@ type FloatingIP struct {
|
|||
IP string `json:"ip,omitempty"`
|
||||
Gateway string `json:"gateway,omitempty"`
|
||||
}
|
||||
|
||||
type HostCPU struct {
|
||||
Vendor string `json:"vendor"`
|
||||
Model string `json:"model"`
|
||||
Sockets int `json:"sockets"`
|
||||
Cores int `json:"cores"`
|
||||
Threads int `json:"threads"`
|
||||
}
|
||||
|
||||
type HostOS struct {
|
||||
ID string `json:"id"`
|
||||
VersionID string `json:"version_id"`
|
||||
PrettyName string `json:"pretty_name"`
|
||||
}
|
||||
|
||||
type HostRegister struct {
|
||||
Hostname string `json:"hostname"`
|
||||
CPU HostCPU `json:"cpu"`
|
||||
MemoryBytes uint64 `json:"memory_bytes"`
|
||||
OS HostOS `json:"os"`
|
||||
Kernel string `json:"kernel"`
|
||||
}
|
||||
|
||||
type HostPing struct {
|
||||
AgentVersion string `json:"agent_version"`
|
||||
CollectedAt int64 `json:"collected_at"`
|
||||
BootTime int64 `json:"boot_time"`
|
||||
AgentStartTime int64 `json:"agent_start_time"`
|
||||
UptimeSeconds float64 `json:"uptime_seconds"`
|
||||
Load [3]float64 `json:"load"`
|
||||
}
|
||||
|
|
|
|||
|
|
@ -17,11 +17,12 @@ type Server struct {
|
|||
dispatcher *dispatcher.Dispatcher
|
||||
db *badger.DB
|
||||
logger *slog.Logger
|
||||
host HostInfo
|
||||
srv *http.Server
|
||||
}
|
||||
|
||||
func New(d *dispatcher.Dispatcher, db *badger.DB, logger *slog.Logger, address string) *Server {
|
||||
s := &Server{dispatcher: d, db: db, logger: logger}
|
||||
func New(d *dispatcher.Dispatcher, db *badger.DB, logger *slog.Logger, address string, h HostInfo) *Server {
|
||||
s := &Server{dispatcher: d, db: db, logger: logger, host: h}
|
||||
mux := http.NewServeMux()
|
||||
mux.HandleFunc("/vpcs", s.VpcsHandler)
|
||||
mux.HandleFunc("/vpcs/", s.VpcByNameHandler)
|
||||
|
|
@ -33,6 +34,8 @@ func New(d *dispatcher.Dispatcher, db *badger.DB, logger *slog.Logger, address s
|
|||
mux.HandleFunc("/nat-gateways/", s.NATGatewayByNameHandler)
|
||||
mux.HandleFunc("/floating-ips", s.FloatingIPsHandler)
|
||||
mux.HandleFunc("/floating-ips/", s.FloatingIPByNameHandler)
|
||||
mux.HandleFunc("/register", s.RegisterHandler)
|
||||
mux.HandleFunc("/ping", s.PingHandler)
|
||||
s.srv = &http.Server{Addr: address, Handler: s.logMiddleware(mux)}
|
||||
return s
|
||||
}
|
||||
|
|
|
|||
|
|
@ -78,6 +78,7 @@ func LoadConfig(path string) (*Config, error) {
|
|||
v.SetDefault("times.timeout_subnet_start", TimeoutSubnetStart)
|
||||
v.SetDefault("times.timeout_vms_start", TimeoutVMsStart)
|
||||
v.SetDefault("times.poll_interval", PollInterval)
|
||||
v.SetDefault("times.host_state_interval", HostStateInterval)
|
||||
v.SetDefault("metadata.run_dir", "/run/two/metadata")
|
||||
v.SetDefault("dhcp.backend", BackendTwo)
|
||||
v.SetDefault("hostsvc.dns_upstream", []string{})
|
||||
|
|
|
|||
|
|
@ -13,6 +13,7 @@ const (
|
|||
TimeoutSubnetStart = 300
|
||||
TimeoutVMsStart = 300
|
||||
PollInterval = 2
|
||||
HostStateInterval = 10
|
||||
)
|
||||
|
||||
type Times struct {
|
||||
|
|
@ -23,6 +24,7 @@ type Times struct {
|
|||
TimeoutSubnetStart int `mapstructure:"timeout_subnet_start"`
|
||||
TimeoutVMsStart int `mapstructure:"timeout_vms_start"`
|
||||
PollInterval int `mapstructure:"poll_interval"`
|
||||
HostStateInterval int `mapstructure:"host_state_interval"`
|
||||
}
|
||||
|
||||
func seconds(value, fallback int) time.Duration {
|
||||
|
|
@ -39,6 +41,7 @@ func (t Times) VPCStop() time.Duration { return seconds(t.TimeoutVPCStop, Ti
|
|||
func (t Times) SubnetStart() time.Duration { return seconds(t.TimeoutSubnetStart, TimeoutSubnetStart) }
|
||||
func (t Times) VMsStart() time.Duration { return seconds(t.TimeoutVMsStart, TimeoutVMsStart) }
|
||||
func (t Times) Poll() time.Duration { return seconds(t.PollInterval, PollInterval) }
|
||||
func (t Times) HostState() time.Duration { return seconds(t.HostStateInterval, HostStateInterval) }
|
||||
|
||||
func (t Times) Validate() error {
|
||||
for _, f := range []struct {
|
||||
|
|
@ -52,6 +55,7 @@ func (t Times) Validate() error {
|
|||
{"timeout_subnet_start", t.TimeoutSubnetStart},
|
||||
{"timeout_vms_start", t.TimeoutVMsStart},
|
||||
{"poll_interval", t.PollInterval},
|
||||
{"host_state_interval", t.HostStateInterval},
|
||||
} {
|
||||
if f.value <= 0 {
|
||||
return fmt.Errorf("times.%s %d must be a positive number of seconds", f.key, f.value)
|
||||
|
|
|
|||
|
|
@ -19,6 +19,7 @@ func TestLoadConfig_TimesDefauts(t *testing.T) {
|
|||
TimeoutSubnetStart: 300,
|
||||
TimeoutVMsStart: 300,
|
||||
PollInterval: 2,
|
||||
HostStateInterval: 10,
|
||||
}
|
||||
if cfg.Times != want {
|
||||
t.Errorf("times par défaut : %+v, attendu %+v", cfg.Times, want)
|
||||
|
|
@ -26,11 +27,11 @@ func TestLoadConfig_TimesDefauts(t *testing.T) {
|
|||
}
|
||||
|
||||
func TestLoadConfig_TimesValeursExplicites(t *testing.T) {
|
||||
cfg, err := LoadConfig(writeYAML(t, "times:\n timeout_vms_stop: 600\n next_vms_shutdown: 10\n timeout_subnet_stop: 700\n timeout_vpc_stop: 800\n timeout_subnet_start: 50\n timeout_vms_start: 60\n poll_interval: 1\n"))
|
||||
cfg, err := LoadConfig(writeYAML(t, "times:\n timeout_vms_stop: 600\n next_vms_shutdown: 10\n timeout_subnet_stop: 700\n timeout_vpc_stop: 800\n timeout_subnet_start: 50\n timeout_vms_start: 60\n poll_interval: 1\n host_state_interval: 5\n"))
|
||||
if err != nil {
|
||||
t.Fatalf("LoadConfig a échoué : %v", err)
|
||||
}
|
||||
want := Times{600, 10, 700, 800, 50, 60, 1}
|
||||
want := Times{600, 10, 700, 800, 50, 60, 1, 5}
|
||||
if cfg.Times != want {
|
||||
t.Errorf("times : %+v, attendu %+v", cfg.Times, want)
|
||||
}
|
||||
|
|
@ -55,6 +56,7 @@ func TestLoadConfig_TimesInvalidesRefuses(t *testing.T) {
|
|||
{"times:\n timeout_subnet_start: 0\n", "times.timeout_subnet_start 0"},
|
||||
{"times:\n timeout_vms_start: 0\n", "times.timeout_vms_start 0"},
|
||||
{"times:\n poll_interval: 0\n", "times.poll_interval 0"},
|
||||
{"times:\n host_state_interval: 0\n", "times.host_state_interval 0"},
|
||||
{"times:\n next_vms_shutdown: 300\n", "times.next_vms_shutdown 300 must be below times.timeout_vms_stop 300"},
|
||||
} {
|
||||
if _, err := LoadConfig(writeYAML(t, c.yaml)); err == nil || !strings.Contains(err.Error(), c.msg) {
|
||||
|
|
@ -79,14 +81,15 @@ func TestTimesDurees(t *testing.T) {
|
|||
{"SubnetStart", zero.SubnetStart(), 300 * time.Second},
|
||||
{"VMsStart", zero.VMsStart(), 300 * time.Second},
|
||||
{"Poll", zero.Poll(), 2 * time.Second},
|
||||
{"HostState", zero.HostState(), 10 * time.Second},
|
||||
}
|
||||
for _, c := range cases {
|
||||
if c.got != c.want {
|
||||
t.Errorf("Times{}.%s() = %v, attendu %v", c.name, c.got, c.want)
|
||||
}
|
||||
}
|
||||
set := Times{11, 12, 13, 14, 15, 16, 17}
|
||||
got := []time.Duration{set.VMsStop(), set.VMsShutdown(), set.SubnetStop(), set.VPCStop(), set.SubnetStart(), set.VMsStart(), set.Poll()}
|
||||
set := Times{11, 12, 13, 14, 15, 16, 17, 18}
|
||||
got := []time.Duration{set.VMsStop(), set.VMsShutdown(), set.SubnetStop(), set.VPCStop(), set.SubnetStart(), set.VMsStart(), set.Poll(), set.HostState()}
|
||||
for i, d := range got {
|
||||
if want := time.Duration(11+i) * time.Second; d != want {
|
||||
t.Errorf("durée %d = %v, attendu %v", i, d, want)
|
||||
|
|
|
|||
78
internal/host/collector.go
Normal file
78
internal/host/collector.go
Normal file
|
|
@ -0,0 +1,78 @@
|
|||
package host
|
||||
|
||||
import (
|
||||
"context"
|
||||
"io/fs"
|
||||
"log/slog"
|
||||
"sync"
|
||||
"time"
|
||||
)
|
||||
|
||||
type Ping struct {
|
||||
State
|
||||
AgentVersion string
|
||||
AgentStartTime int64
|
||||
CollectedAt int64
|
||||
}
|
||||
|
||||
type Collector struct {
|
||||
fsys fs.FS
|
||||
version string
|
||||
start time.Time
|
||||
interval time.Duration
|
||||
logger *slog.Logger
|
||||
now func() time.Time
|
||||
facts Facts
|
||||
factsErr error
|
||||
|
||||
mu sync.RWMutex
|
||||
last *Ping
|
||||
}
|
||||
|
||||
func NewCollector(fsys fs.FS, version string, start time.Time, interval time.Duration, logger *slog.Logger) *Collector {
|
||||
c := &Collector{fsys: fsys, version: version, start: start, interval: interval, logger: logger, now: time.Now}
|
||||
c.facts, c.factsErr = ReadFacts(fsys)
|
||||
if c.factsErr != nil {
|
||||
logger.Error("host facts unavailable", "error", c.factsErr)
|
||||
}
|
||||
return c
|
||||
}
|
||||
|
||||
func (c *Collector) Register() (Facts, error) {
|
||||
return c.facts, c.factsErr
|
||||
}
|
||||
|
||||
func (c *Collector) Ping() (Ping, bool) {
|
||||
c.mu.RLock()
|
||||
defer c.mu.RUnlock()
|
||||
if c.last == nil {
|
||||
return Ping{}, false
|
||||
}
|
||||
return *c.last, true
|
||||
}
|
||||
|
||||
func (c *Collector) Run(ctx context.Context) {
|
||||
ticker := time.NewTicker(c.interval)
|
||||
defer ticker.Stop()
|
||||
c.collect()
|
||||
for {
|
||||
select {
|
||||
case <-ctx.Done():
|
||||
return
|
||||
case <-ticker.C:
|
||||
c.collect()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (c *Collector) collect() {
|
||||
s, err := ReadState(c.fsys)
|
||||
if err != nil {
|
||||
c.logger.Error("host state collection failed", "error", err)
|
||||
return
|
||||
}
|
||||
p := Ping{State: s, AgentVersion: c.version, AgentStartTime: c.start.Unix(), CollectedAt: c.now().Unix()}
|
||||
c.mu.Lock()
|
||||
c.last = &p
|
||||
c.mu.Unlock()
|
||||
}
|
||||
102
internal/host/collector_test.go
Normal file
102
internal/host/collector_test.go
Normal file
|
|
@ -0,0 +1,102 @@
|
|||
package host
|
||||
|
||||
import (
|
||||
"context"
|
||||
"io"
|
||||
"log/slog"
|
||||
"strings"
|
||||
"testing"
|
||||
"time"
|
||||
)
|
||||
|
||||
func discard() *slog.Logger { return slog.New(slog.NewTextHandler(io.Discard, nil)) }
|
||||
|
||||
func TestCollector_RegisterServesTheFactsReadAtCreation(t *testing.T) {
|
||||
fsys := debian12()
|
||||
c := NewCollector(fsys, "0.3.0", time.Unix(1792210950, 0), time.Hour, discard())
|
||||
fsys["proc/sys/kernel/hostname"].Data = []byte("autre\n")
|
||||
f, err := c.Register()
|
||||
if err != nil || f.Hostname != "hv1" {
|
||||
t.Errorf("Register = %q, %v ; hv1 lu à la création attendu", f.Hostname, err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestCollector_RegisterKeepsTheReadError(t *testing.T) {
|
||||
fsys := debian12()
|
||||
delete(fsys, "proc/cpuinfo")
|
||||
var logs strings.Builder
|
||||
c := NewCollector(fsys, "0.3.0", time.Unix(0, 0), time.Hour, slog.New(slog.NewTextHandler(&logs, nil)))
|
||||
if _, err := c.Register(); err == nil {
|
||||
t.Error("Register sans cpuinfo : aucune erreur")
|
||||
}
|
||||
if !strings.Contains(logs.String(), "host facts unavailable") {
|
||||
t.Errorf("erreur non journalisée : %q", logs.String())
|
||||
}
|
||||
}
|
||||
|
||||
func TestCollector_PingBeforeAnyCollection(t *testing.T) {
|
||||
c := NewCollector(debian12(), "0.3.0", time.Unix(0, 0), time.Hour, discard())
|
||||
if _, ok := c.Ping(); ok {
|
||||
t.Error("Ping avant toute mesure : instantané rendu")
|
||||
}
|
||||
}
|
||||
|
||||
func TestCollector_PingServesTheLastCollection(t *testing.T) {
|
||||
c := NewCollector(debian12(), "0.3.0", time.Unix(1792210950, 0), time.Hour, discard())
|
||||
c.now = func() time.Time { return time.Unix(1793454325, 0) }
|
||||
c.collect()
|
||||
got, ok := c.Ping()
|
||||
want := Ping{
|
||||
State: State{BootTime: 1792210880, UptimeSeconds: 1243445.41, Load: [3]float64{0.08, 0.03, 0.04}},
|
||||
AgentVersion: "0.3.0",
|
||||
AgentStartTime: 1792210950,
|
||||
CollectedAt: 1793454325,
|
||||
}
|
||||
if !ok || got != want {
|
||||
t.Errorf("Ping = %+v, %v ; %+v attendu", got, ok, want)
|
||||
}
|
||||
}
|
||||
|
||||
func TestCollector_FailedCollectionKeepsThePreviousOne(t *testing.T) {
|
||||
fsys := debian12()
|
||||
var logs strings.Builder
|
||||
c := NewCollector(fsys, "0.3.0", time.Unix(0, 0), time.Hour, slog.New(slog.NewTextHandler(&logs, nil)))
|
||||
c.now = func() time.Time { return time.Unix(100, 0) }
|
||||
c.collect()
|
||||
delete(fsys, "proc/loadavg")
|
||||
c.now = func() time.Time { return time.Unix(200, 0) }
|
||||
c.collect()
|
||||
got, ok := c.Ping()
|
||||
if !ok || got.CollectedAt != 100 {
|
||||
t.Errorf("Ping = %+v, %v ; mesure de 100 gardée attendue", got, ok)
|
||||
}
|
||||
if !strings.Contains(logs.String(), "host state collection failed") {
|
||||
t.Errorf("échec non journalisé : %q", logs.String())
|
||||
}
|
||||
}
|
||||
|
||||
func TestCollector_RunCollectsAtOnceAndStopsWithTheContext(t *testing.T) {
|
||||
c := NewCollector(debian12(), "0.3.0", time.Unix(0, 0), time.Hour, discard())
|
||||
ctx, cancel := context.WithCancel(context.Background())
|
||||
done := make(chan struct{})
|
||||
go func() {
|
||||
c.Run(ctx)
|
||||
close(done)
|
||||
}()
|
||||
deadline := time.Now().Add(5 * time.Second)
|
||||
for {
|
||||
if _, ok := c.Ping(); ok {
|
||||
break
|
||||
}
|
||||
if time.Now().After(deadline) {
|
||||
t.Fatal("aucune mesure au démarrage de Run")
|
||||
}
|
||||
time.Sleep(10 * time.Millisecond)
|
||||
}
|
||||
cancel()
|
||||
select {
|
||||
case <-done:
|
||||
case <-time.After(5 * time.Second):
|
||||
t.Fatal("Run ne s'arrête pas à l'annulation du contexte")
|
||||
}
|
||||
}
|
||||
225
internal/host/host.go
Normal file
225
internal/host/host.go
Normal file
|
|
@ -0,0 +1,225 @@
|
|||
package host
|
||||
|
||||
import (
|
||||
"bufio"
|
||||
"fmt"
|
||||
"io/fs"
|
||||
"strconv"
|
||||
"strings"
|
||||
)
|
||||
|
||||
type CPU struct {
|
||||
Vendor string
|
||||
Model string
|
||||
Sockets int
|
||||
Cores int
|
||||
Threads int
|
||||
}
|
||||
|
||||
type OS struct {
|
||||
ID string
|
||||
VersionID string
|
||||
PrettyName string
|
||||
}
|
||||
|
||||
type Facts struct {
|
||||
Hostname string
|
||||
CPU CPU
|
||||
MemoryBytes uint64
|
||||
OS OS
|
||||
Kernel string
|
||||
}
|
||||
|
||||
type State struct {
|
||||
BootTime int64
|
||||
UptimeSeconds float64
|
||||
Load [3]float64
|
||||
}
|
||||
|
||||
func ReadFacts(fsys fs.FS) (Facts, error) {
|
||||
var f Facts
|
||||
var err error
|
||||
if f.Hostname, err = readLine(fsys, "proc/sys/kernel/hostname"); err != nil {
|
||||
return Facts{}, err
|
||||
}
|
||||
if f.Kernel, err = readLine(fsys, "proc/sys/kernel/osrelease"); err != nil {
|
||||
return Facts{}, err
|
||||
}
|
||||
data, err := fs.ReadFile(fsys, "proc/cpuinfo")
|
||||
if err != nil {
|
||||
return Facts{}, err
|
||||
}
|
||||
if f.CPU, err = parseCPUInfo(string(data)); err != nil {
|
||||
return Facts{}, err
|
||||
}
|
||||
data, err = fs.ReadFile(fsys, "proc/meminfo")
|
||||
if err != nil {
|
||||
return Facts{}, err
|
||||
}
|
||||
if f.MemoryBytes, err = parseMemTotal(string(data)); err != nil {
|
||||
return Facts{}, err
|
||||
}
|
||||
data, err = fs.ReadFile(fsys, "etc/os-release")
|
||||
if err != nil {
|
||||
return Facts{}, err
|
||||
}
|
||||
f.OS = parseOSRelease(string(data))
|
||||
return f, nil
|
||||
}
|
||||
|
||||
func ReadState(fsys fs.FS) (State, error) {
|
||||
var s State
|
||||
data, err := fs.ReadFile(fsys, "proc/stat")
|
||||
if err != nil {
|
||||
return State{}, err
|
||||
}
|
||||
if s.BootTime, err = parseBootTime(string(data)); err != nil {
|
||||
return State{}, err
|
||||
}
|
||||
line, err := readLine(fsys, "proc/uptime")
|
||||
if err != nil {
|
||||
return State{}, err
|
||||
}
|
||||
if s.UptimeSeconds, err = parseUptime(line); err != nil {
|
||||
return State{}, err
|
||||
}
|
||||
if line, err = readLine(fsys, "proc/loadavg"); err != nil {
|
||||
return State{}, err
|
||||
}
|
||||
if s.Load, err = parseLoadAvg(line); err != nil {
|
||||
return State{}, err
|
||||
}
|
||||
return s, nil
|
||||
}
|
||||
|
||||
func readLine(fsys fs.FS, name string) (string, error) {
|
||||
data, err := fs.ReadFile(fsys, name)
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
line := strings.TrimSpace(string(data))
|
||||
if line == "" {
|
||||
return "", fmt.Errorf("%s: empty", name)
|
||||
}
|
||||
return line, nil
|
||||
}
|
||||
|
||||
func parseCPUInfo(data string) (CPU, error) {
|
||||
var cpu CPU
|
||||
sockets := map[string]bool{}
|
||||
cores := map[string]bool{}
|
||||
var physical string
|
||||
scanner := bufio.NewScanner(strings.NewReader(data))
|
||||
for scanner.Scan() {
|
||||
key, value, ok := strings.Cut(scanner.Text(), ":")
|
||||
if !ok {
|
||||
continue
|
||||
}
|
||||
value = strings.TrimSpace(value)
|
||||
switch strings.TrimSpace(key) {
|
||||
case "processor":
|
||||
cpu.Threads++
|
||||
physical = ""
|
||||
case "vendor_id":
|
||||
cpu.Vendor = value
|
||||
case "model name":
|
||||
cpu.Model = value
|
||||
case "physical id":
|
||||
physical = value
|
||||
sockets[value] = true
|
||||
case "core id":
|
||||
if physical == "" {
|
||||
return CPU{}, fmt.Errorf("cpuinfo: core id %s without physical id", value)
|
||||
}
|
||||
cores[physical+"/"+value] = true
|
||||
}
|
||||
}
|
||||
if err := scanner.Err(); err != nil {
|
||||
return CPU{}, fmt.Errorf("cpuinfo: %w", err)
|
||||
}
|
||||
if cpu.Threads == 0 || len(sockets) == 0 || len(cores) == 0 {
|
||||
return CPU{}, fmt.Errorf("cpuinfo: %d processors, %d physical ids, %d core ids", cpu.Threads, len(sockets), len(cores))
|
||||
}
|
||||
cpu.Sockets = len(sockets)
|
||||
cpu.Cores = len(cores)
|
||||
return cpu, nil
|
||||
}
|
||||
|
||||
func parseMemTotal(data string) (uint64, error) {
|
||||
for _, line := range strings.Split(data, "\n") {
|
||||
fields := strings.Fields(line)
|
||||
if len(fields) != 3 || fields[0] != "MemTotal:" || fields[2] != "kB" {
|
||||
continue
|
||||
}
|
||||
kb, err := strconv.ParseUint(fields[1], 10, 64)
|
||||
if err != nil {
|
||||
return 0, fmt.Errorf("meminfo: MemTotal: %w", err)
|
||||
}
|
||||
return kb * 1024, nil
|
||||
}
|
||||
return 0, fmt.Errorf("meminfo: no MemTotal in kB")
|
||||
}
|
||||
|
||||
func parseOSRelease(data string) OS {
|
||||
var rel OS
|
||||
for _, line := range strings.Split(data, "\n") {
|
||||
key, value, ok := strings.Cut(strings.TrimSpace(line), "=")
|
||||
if !ok {
|
||||
continue
|
||||
}
|
||||
if unquoted, err := strconv.Unquote(value); err == nil {
|
||||
value = unquoted
|
||||
}
|
||||
switch key {
|
||||
case "ID":
|
||||
rel.ID = value
|
||||
case "VERSION_ID":
|
||||
rel.VersionID = value
|
||||
case "PRETTY_NAME":
|
||||
rel.PrettyName = value
|
||||
}
|
||||
}
|
||||
return rel
|
||||
}
|
||||
|
||||
func parseBootTime(data string) (int64, error) {
|
||||
for _, line := range strings.Split(data, "\n") {
|
||||
fields := strings.Fields(line)
|
||||
if len(fields) == 2 && fields[0] == "btime" {
|
||||
t, err := strconv.ParseInt(fields[1], 10, 64)
|
||||
if err != nil {
|
||||
return 0, fmt.Errorf("stat: btime: %w", err)
|
||||
}
|
||||
return t, nil
|
||||
}
|
||||
}
|
||||
return 0, fmt.Errorf("stat: no btime")
|
||||
}
|
||||
|
||||
func parseUptime(line string) (float64, error) {
|
||||
fields := strings.Fields(line)
|
||||
if len(fields) != 2 {
|
||||
return 0, fmt.Errorf("uptime: %q", line)
|
||||
}
|
||||
up, err := strconv.ParseFloat(fields[0], 64)
|
||||
if err != nil {
|
||||
return 0, fmt.Errorf("uptime: %w", err)
|
||||
}
|
||||
return up, nil
|
||||
}
|
||||
|
||||
func parseLoadAvg(line string) ([3]float64, error) {
|
||||
var load [3]float64
|
||||
fields := strings.Fields(line)
|
||||
if len(fields) != 5 {
|
||||
return load, fmt.Errorf("loadavg: %q", line)
|
||||
}
|
||||
for i := range load {
|
||||
v, err := strconv.ParseFloat(fields[i], 64)
|
||||
if err != nil {
|
||||
return load, fmt.Errorf("loadavg: %w", err)
|
||||
}
|
||||
load[i] = v
|
||||
}
|
||||
return load, nil
|
||||
}
|
||||
128
internal/host/host_test.go
Normal file
128
internal/host/host_test.go
Normal file
|
|
@ -0,0 +1,128 @@
|
|||
package host
|
||||
|
||||
import (
|
||||
"os"
|
||||
"strings"
|
||||
"testing"
|
||||
"testing/fstest"
|
||||
)
|
||||
|
||||
func debian12() fstest.MapFS {
|
||||
fsys := fstest.MapFS{}
|
||||
for _, name := range []string{
|
||||
"proc/cpuinfo", "proc/meminfo", "proc/stat", "proc/uptime", "proc/loadavg",
|
||||
"proc/sys/kernel/osrelease", "proc/sys/kernel/hostname", "etc/os-release",
|
||||
} {
|
||||
data, err := os.ReadFile("testdata/debian12/" + name)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
fsys[name] = &fstest.MapFile{Data: data}
|
||||
}
|
||||
return fsys
|
||||
}
|
||||
|
||||
func TestReadFacts_Debian12(t *testing.T) {
|
||||
got, err := ReadFacts(debian12())
|
||||
if err != nil {
|
||||
t.Fatalf("ReadFacts: %v", err)
|
||||
}
|
||||
want := Facts{
|
||||
Hostname: "hv1",
|
||||
CPU: CPU{Vendor: "AuthenticAMD", Model: "QEMU Virtual CPU version 2.5+", Sockets: 1, Cores: 2, Threads: 2},
|
||||
MemoryBytes: 2010432 * 1024,
|
||||
OS: OS{ID: "debian", VersionID: "12", PrettyName: "Debian GNU/Linux 12 (bookworm)"},
|
||||
Kernel: "6.8.0-50-generic",
|
||||
}
|
||||
if got != want {
|
||||
t.Errorf("faits %+v, %+v attendus", got, want)
|
||||
}
|
||||
}
|
||||
|
||||
func TestReadState_Debian12(t *testing.T) {
|
||||
got, err := ReadState(debian12())
|
||||
if err != nil {
|
||||
t.Fatalf("ReadState: %v", err)
|
||||
}
|
||||
want := State{BootTime: 1792210880, UptimeSeconds: 1243445.41, Load: [3]float64{0.08, 0.03, 0.04}}
|
||||
if got != want {
|
||||
t.Errorf("état %+v, %+v attendu", got, want)
|
||||
}
|
||||
}
|
||||
|
||||
func TestParseCPUInfo_SocketsCoresAndThreadsAreDistinct(t *testing.T) {
|
||||
data, err := os.ReadFile("testdata/cpuinfo-2x2x2")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
got, err := parseCPUInfo(string(data))
|
||||
if err != nil {
|
||||
t.Fatalf("parseCPUInfo: %v", err)
|
||||
}
|
||||
if got.Sockets != 2 || got.Cores != 4 || got.Threads != 8 {
|
||||
t.Errorf("%d sockets, %d cœurs, %d threads ; 2, 4 et 8 attendus", got.Sockets, got.Cores, got.Threads)
|
||||
}
|
||||
}
|
||||
|
||||
func TestParseCPUInfo_RefusesMissingTopology(t *testing.T) {
|
||||
data, err := os.ReadFile("testdata/debian12/proc/cpuinfo")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
for label, input := range map[string]string{
|
||||
"vide": "",
|
||||
"sans physical id": strings.ReplaceAll(string(data), "physical id\t: 0\n", ""),
|
||||
"sans core id": strings.ReplaceAll(strings.ReplaceAll(string(data), "core id\t\t: 0\n", ""), "core id\t\t: 1\n", ""),
|
||||
} {
|
||||
if _, err := parseCPUInfo(input); err == nil {
|
||||
t.Errorf("%s : accepté", label)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestReadFacts_FailsOnAMissingFile(t *testing.T) {
|
||||
for _, name := range []string{"proc/cpuinfo", "proc/meminfo", "etc/os-release", "proc/sys/kernel/osrelease", "proc/sys/kernel/hostname"} {
|
||||
fsys := debian12()
|
||||
delete(fsys, name)
|
||||
if _, err := ReadFacts(fsys); err == nil || !strings.Contains(err.Error(), name) {
|
||||
t.Errorf("sans %s : erreur %v", name, err)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestReadState_FailsOnAMissingFile(t *testing.T) {
|
||||
for _, name := range []string{"proc/stat", "proc/uptime", "proc/loadavg"} {
|
||||
fsys := debian12()
|
||||
delete(fsys, name)
|
||||
if _, err := ReadState(fsys); err == nil || !strings.Contains(err.Error(), name) {
|
||||
t.Errorf("sans %s : erreur %v", name, err)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestParseOSRelease_Rocky10Quoted(t *testing.T) {
|
||||
data, err := os.ReadFile("testdata/rocky10/etc/os-release")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
got := parseOSRelease(string(data))
|
||||
want := OS{ID: "rocky", VersionID: "10.2", PrettyName: "Rocky Linux 10.2 (Red Quartz)"}
|
||||
if got != want {
|
||||
t.Errorf("%+v, %+v attendu", got, want)
|
||||
}
|
||||
}
|
||||
|
||||
func TestParsers_RefuseMalformedInput(t *testing.T) {
|
||||
if _, err := parseMemTotal("MemFree: 12 kB\n"); err == nil {
|
||||
t.Error("meminfo sans MemTotal accepté")
|
||||
}
|
||||
if _, err := parseBootTime("cpu 1 2 3\n"); err == nil {
|
||||
t.Error("stat sans btime accepté")
|
||||
}
|
||||
if _, err := parseUptime("12.5"); err == nil {
|
||||
t.Error("uptime à un champ accepté")
|
||||
}
|
||||
if _, err := parseLoadAvg("0.1 0.2 x 1/2 3"); err == nil {
|
||||
t.Error("loadavg invalide accepté")
|
||||
}
|
||||
}
|
||||
224
internal/host/testdata/cpuinfo-2x2x2
vendored
Normal file
224
internal/host/testdata/cpuinfo-2x2x2
vendored
Normal file
|
|
@ -0,0 +1,224 @@
|
|||
processor : 0
|
||||
vendor_id : AuthenticAMD
|
||||
cpu family : 15
|
||||
model : 107
|
||||
model name : QEMU Virtual CPU version 2.5+
|
||||
stepping : 1
|
||||
microcode : 0x1000065
|
||||
cpu MHz : 999.997
|
||||
cache size : 512 KB
|
||||
physical id : 0
|
||||
siblings : 4
|
||||
core id : 0
|
||||
cpu cores : 2
|
||||
apicid : 0
|
||||
initial apicid : 0
|
||||
fpu : yes
|
||||
fpu_exception : yes
|
||||
cpuid level : 13
|
||||
wp : yes
|
||||
flags : fpu de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush mmx fxsr sse sse2 ht syscall nx lm rep_good nopl cpuid extd_apicid pni cx16 hypervisor lahf_lm cmp_legacy svm 3dnowprefetch vmmcall
|
||||
bugs : fxsave_leak sysret_ss_attrs null_seg swapgs_fence amd_e400 spectre_v1 spectre_v2
|
||||
bogomips : 1999.99
|
||||
TLB size : 1024 4K pages
|
||||
clflush size : 64
|
||||
cache_alignment : 64
|
||||
address sizes : 40 bits physical, 48 bits virtual
|
||||
power management:
|
||||
|
||||
processor : 1
|
||||
vendor_id : AuthenticAMD
|
||||
cpu family : 15
|
||||
model : 107
|
||||
model name : QEMU Virtual CPU version 2.5+
|
||||
stepping : 1
|
||||
microcode : 0x1000065
|
||||
cpu MHz : 999.997
|
||||
cache size : 512 KB
|
||||
physical id : 0
|
||||
siblings : 4
|
||||
core id : 1
|
||||
cpu cores : 2
|
||||
apicid : 0
|
||||
initial apicid : 0
|
||||
fpu : yes
|
||||
fpu_exception : yes
|
||||
cpuid level : 13
|
||||
wp : yes
|
||||
flags : fpu de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush mmx fxsr sse sse2 ht syscall nx lm rep_good nopl cpuid extd_apicid pni cx16 hypervisor lahf_lm cmp_legacy svm 3dnowprefetch vmmcall
|
||||
bugs : fxsave_leak sysret_ss_attrs null_seg swapgs_fence amd_e400 spectre_v1 spectre_v2
|
||||
bogomips : 1999.99
|
||||
TLB size : 1024 4K pages
|
||||
clflush size : 64
|
||||
cache_alignment : 64
|
||||
address sizes : 40 bits physical, 48 bits virtual
|
||||
power management:
|
||||
|
||||
processor : 2
|
||||
vendor_id : AuthenticAMD
|
||||
cpu family : 15
|
||||
model : 107
|
||||
model name : QEMU Virtual CPU version 2.5+
|
||||
stepping : 1
|
||||
microcode : 0x1000065
|
||||
cpu MHz : 999.997
|
||||
cache size : 512 KB
|
||||
physical id : 1
|
||||
siblings : 4
|
||||
core id : 0
|
||||
cpu cores : 2
|
||||
apicid : 0
|
||||
initial apicid : 0
|
||||
fpu : yes
|
||||
fpu_exception : yes
|
||||
cpuid level : 13
|
||||
wp : yes
|
||||
flags : fpu de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush mmx fxsr sse sse2 ht syscall nx lm rep_good nopl cpuid extd_apicid pni cx16 hypervisor lahf_lm cmp_legacy svm 3dnowprefetch vmmcall
|
||||
bugs : fxsave_leak sysret_ss_attrs null_seg swapgs_fence amd_e400 spectre_v1 spectre_v2
|
||||
bogomips : 1999.99
|
||||
TLB size : 1024 4K pages
|
||||
clflush size : 64
|
||||
cache_alignment : 64
|
||||
address sizes : 40 bits physical, 48 bits virtual
|
||||
power management:
|
||||
|
||||
processor : 3
|
||||
vendor_id : AuthenticAMD
|
||||
cpu family : 15
|
||||
model : 107
|
||||
model name : QEMU Virtual CPU version 2.5+
|
||||
stepping : 1
|
||||
microcode : 0x1000065
|
||||
cpu MHz : 999.997
|
||||
cache size : 512 KB
|
||||
physical id : 1
|
||||
siblings : 4
|
||||
core id : 1
|
||||
cpu cores : 2
|
||||
apicid : 0
|
||||
initial apicid : 0
|
||||
fpu : yes
|
||||
fpu_exception : yes
|
||||
cpuid level : 13
|
||||
wp : yes
|
||||
flags : fpu de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush mmx fxsr sse sse2 ht syscall nx lm rep_good nopl cpuid extd_apicid pni cx16 hypervisor lahf_lm cmp_legacy svm 3dnowprefetch vmmcall
|
||||
bugs : fxsave_leak sysret_ss_attrs null_seg swapgs_fence amd_e400 spectre_v1 spectre_v2
|
||||
bogomips : 1999.99
|
||||
TLB size : 1024 4K pages
|
||||
clflush size : 64
|
||||
cache_alignment : 64
|
||||
address sizes : 40 bits physical, 48 bits virtual
|
||||
power management:
|
||||
|
||||
processor : 4
|
||||
vendor_id : AuthenticAMD
|
||||
cpu family : 15
|
||||
model : 107
|
||||
model name : QEMU Virtual CPU version 2.5+
|
||||
stepping : 1
|
||||
microcode : 0x1000065
|
||||
cpu MHz : 999.997
|
||||
cache size : 512 KB
|
||||
physical id : 0
|
||||
siblings : 4
|
||||
core id : 0
|
||||
cpu cores : 2
|
||||
apicid : 0
|
||||
initial apicid : 0
|
||||
fpu : yes
|
||||
fpu_exception : yes
|
||||
cpuid level : 13
|
||||
wp : yes
|
||||
flags : fpu de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush mmx fxsr sse sse2 ht syscall nx lm rep_good nopl cpuid extd_apicid pni cx16 hypervisor lahf_lm cmp_legacy svm 3dnowprefetch vmmcall
|
||||
bugs : fxsave_leak sysret_ss_attrs null_seg swapgs_fence amd_e400 spectre_v1 spectre_v2
|
||||
bogomips : 1999.99
|
||||
TLB size : 1024 4K pages
|
||||
clflush size : 64
|
||||
cache_alignment : 64
|
||||
address sizes : 40 bits physical, 48 bits virtual
|
||||
power management:
|
||||
|
||||
processor : 5
|
||||
vendor_id : AuthenticAMD
|
||||
cpu family : 15
|
||||
model : 107
|
||||
model name : QEMU Virtual CPU version 2.5+
|
||||
stepping : 1
|
||||
microcode : 0x1000065
|
||||
cpu MHz : 999.997
|
||||
cache size : 512 KB
|
||||
physical id : 0
|
||||
siblings : 4
|
||||
core id : 1
|
||||
cpu cores : 2
|
||||
apicid : 0
|
||||
initial apicid : 0
|
||||
fpu : yes
|
||||
fpu_exception : yes
|
||||
cpuid level : 13
|
||||
wp : yes
|
||||
flags : fpu de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush mmx fxsr sse sse2 ht syscall nx lm rep_good nopl cpuid extd_apicid pni cx16 hypervisor lahf_lm cmp_legacy svm 3dnowprefetch vmmcall
|
||||
bugs : fxsave_leak sysret_ss_attrs null_seg swapgs_fence amd_e400 spectre_v1 spectre_v2
|
||||
bogomips : 1999.99
|
||||
TLB size : 1024 4K pages
|
||||
clflush size : 64
|
||||
cache_alignment : 64
|
||||
address sizes : 40 bits physical, 48 bits virtual
|
||||
power management:
|
||||
|
||||
processor : 6
|
||||
vendor_id : AuthenticAMD
|
||||
cpu family : 15
|
||||
model : 107
|
||||
model name : QEMU Virtual CPU version 2.5+
|
||||
stepping : 1
|
||||
microcode : 0x1000065
|
||||
cpu MHz : 999.997
|
||||
cache size : 512 KB
|
||||
physical id : 1
|
||||
siblings : 4
|
||||
core id : 0
|
||||
cpu cores : 2
|
||||
apicid : 0
|
||||
initial apicid : 0
|
||||
fpu : yes
|
||||
fpu_exception : yes
|
||||
cpuid level : 13
|
||||
wp : yes
|
||||
flags : fpu de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush mmx fxsr sse sse2 ht syscall nx lm rep_good nopl cpuid extd_apicid pni cx16 hypervisor lahf_lm cmp_legacy svm 3dnowprefetch vmmcall
|
||||
bugs : fxsave_leak sysret_ss_attrs null_seg swapgs_fence amd_e400 spectre_v1 spectre_v2
|
||||
bogomips : 1999.99
|
||||
TLB size : 1024 4K pages
|
||||
clflush size : 64
|
||||
cache_alignment : 64
|
||||
address sizes : 40 bits physical, 48 bits virtual
|
||||
power management:
|
||||
|
||||
processor : 7
|
||||
vendor_id : AuthenticAMD
|
||||
cpu family : 15
|
||||
model : 107
|
||||
model name : QEMU Virtual CPU version 2.5+
|
||||
stepping : 1
|
||||
microcode : 0x1000065
|
||||
cpu MHz : 999.997
|
||||
cache size : 512 KB
|
||||
physical id : 1
|
||||
siblings : 4
|
||||
core id : 1
|
||||
cpu cores : 2
|
||||
apicid : 0
|
||||
initial apicid : 0
|
||||
fpu : yes
|
||||
fpu_exception : yes
|
||||
cpuid level : 13
|
||||
wp : yes
|
||||
flags : fpu de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush mmx fxsr sse sse2 ht syscall nx lm rep_good nopl cpuid extd_apicid pni cx16 hypervisor lahf_lm cmp_legacy svm 3dnowprefetch vmmcall
|
||||
bugs : fxsave_leak sysret_ss_attrs null_seg swapgs_fence amd_e400 spectre_v1 spectre_v2
|
||||
bogomips : 1999.99
|
||||
TLB size : 1024 4K pages
|
||||
clflush size : 64
|
||||
cache_alignment : 64
|
||||
address sizes : 40 bits physical, 48 bits virtual
|
||||
power management:
|
||||
|
||||
9
internal/host/testdata/debian12/etc/os-release
vendored
Normal file
9
internal/host/testdata/debian12/etc/os-release
vendored
Normal file
|
|
@ -0,0 +1,9 @@
|
|||
PRETTY_NAME="Debian GNU/Linux 12 (bookworm)"
|
||||
NAME="Debian GNU/Linux"
|
||||
VERSION_ID="12"
|
||||
VERSION="12 (bookworm)"
|
||||
VERSION_CODENAME=bookworm
|
||||
ID=debian
|
||||
HOME_URL="https://www.debian.org/"
|
||||
SUPPORT_URL="https://www.debian.org/support"
|
||||
BUG_REPORT_URL="https://bugs.debian.org/"
|
||||
56
internal/host/testdata/debian12/proc/cpuinfo
vendored
Normal file
56
internal/host/testdata/debian12/proc/cpuinfo
vendored
Normal file
|
|
@ -0,0 +1,56 @@
|
|||
processor : 0
|
||||
vendor_id : AuthenticAMD
|
||||
cpu family : 15
|
||||
model : 107
|
||||
model name : QEMU Virtual CPU version 2.5+
|
||||
stepping : 1
|
||||
microcode : 0x1000065
|
||||
cpu MHz : 999.997
|
||||
cache size : 512 KB
|
||||
physical id : 0
|
||||
siblings : 2
|
||||
core id : 0
|
||||
cpu cores : 2
|
||||
apicid : 0
|
||||
initial apicid : 0
|
||||
fpu : yes
|
||||
fpu_exception : yes
|
||||
cpuid level : 13
|
||||
wp : yes
|
||||
flags : fpu de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush mmx fxsr sse sse2 ht syscall nx lm rep_good nopl cpuid extd_apicid pni cx16 hypervisor lahf_lm cmp_legacy svm 3dnowprefetch vmmcall
|
||||
bugs : fxsave_leak sysret_ss_attrs null_seg swapgs_fence amd_e400 spectre_v1 spectre_v2
|
||||
bogomips : 1999.99
|
||||
TLB size : 1024 4K pages
|
||||
clflush size : 64
|
||||
cache_alignment : 64
|
||||
address sizes : 40 bits physical, 48 bits virtual
|
||||
power management:
|
||||
|
||||
processor : 1
|
||||
vendor_id : AuthenticAMD
|
||||
cpu family : 15
|
||||
model : 107
|
||||
model name : QEMU Virtual CPU version 2.5+
|
||||
stepping : 1
|
||||
microcode : 0x1000065
|
||||
cpu MHz : 999.997
|
||||
cache size : 512 KB
|
||||
physical id : 0
|
||||
siblings : 2
|
||||
core id : 1
|
||||
cpu cores : 2
|
||||
apicid : 1
|
||||
initial apicid : 1
|
||||
fpu : yes
|
||||
fpu_exception : yes
|
||||
cpuid level : 13
|
||||
wp : yes
|
||||
flags : fpu de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush mmx fxsr sse sse2 ht syscall nx lm rep_good nopl cpuid extd_apicid pni cx16 hypervisor lahf_lm cmp_legacy svm 3dnowprefetch vmmcall
|
||||
bugs : fxsave_leak sysret_ss_attrs null_seg swapgs_fence amd_e400 spectre_v1 spectre_v2
|
||||
bogomips : 2503.44
|
||||
TLB size : 1024 4K pages
|
||||
clflush size : 64
|
||||
cache_alignment : 64
|
||||
address sizes : 40 bits physical, 48 bits virtual
|
||||
power management:
|
||||
|
||||
1
internal/host/testdata/debian12/proc/loadavg
vendored
Normal file
1
internal/host/testdata/debian12/proc/loadavg
vendored
Normal file
|
|
@ -0,0 +1 @@
|
|||
0.08 0.03 0.04 1/144 6
|
||||
54
internal/host/testdata/debian12/proc/meminfo
vendored
Normal file
54
internal/host/testdata/debian12/proc/meminfo
vendored
Normal file
|
|
@ -0,0 +1,54 @@
|
|||
MemTotal: 2010432 kB
|
||||
MemFree: 690340 kB
|
||||
MemAvailable: 1620016 kB
|
||||
Buffers: 177720 kB
|
||||
Cached: 837308 kB
|
||||
SwapCached: 0 kB
|
||||
Active: 409508 kB
|
||||
Inactive: 681136 kB
|
||||
Active(anon): 81680 kB
|
||||
Inactive(anon): 72 kB
|
||||
Active(file): 327828 kB
|
||||
Inactive(file): 681064 kB
|
||||
Unevictable: 11868 kB
|
||||
Mlocked: 0 kB
|
||||
SwapTotal: 0 kB
|
||||
SwapFree: 0 kB
|
||||
Zswap: 0 kB
|
||||
Zswapped: 0 kB
|
||||
Dirty: 568 kB
|
||||
Writeback: 0 kB
|
||||
AnonPages: 80808 kB
|
||||
Mapped: 166636 kB
|
||||
Shmem: 4936 kB
|
||||
KReclaimable: 105056 kB
|
||||
Slab: 159000 kB
|
||||
SReclaimable: 105056 kB
|
||||
SUnreclaim: 53944 kB
|
||||
KernelStack: 2320 kB
|
||||
PageTables: 2928 kB
|
||||
SecPageTables: 0 kB
|
||||
NFS_Unstable: 0 kB
|
||||
Bounce: 0 kB
|
||||
WritebackTmp: 0 kB
|
||||
CommitLimit: 1005216 kB
|
||||
Committed_AS: 496972 kB
|
||||
VmallocTotal: 34359738367 kB
|
||||
VmallocUsed: 17080 kB
|
||||
VmallocChunk: 0 kB
|
||||
Percpu: 1192 kB
|
||||
HardwareCorrupted: 0 kB
|
||||
AnonHugePages: 0 kB
|
||||
ShmemHugePages: 0 kB
|
||||
ShmemPmdMapped: 0 kB
|
||||
FileHugePages: 0 kB
|
||||
FilePmdMapped: 0 kB
|
||||
Unaccepted: 0 kB
|
||||
HugePages_Total: 0
|
||||
HugePages_Free: 0
|
||||
HugePages_Rsvd: 0
|
||||
HugePages_Surp: 0
|
||||
Hugepagesize: 2048 kB
|
||||
Hugetlb: 0 kB
|
||||
DirectMap4k: 112268 kB
|
||||
DirectMap2M: 1980416 kB
|
||||
10
internal/host/testdata/debian12/proc/stat
vendored
Normal file
10
internal/host/testdata/debian12/proc/stat
vendored
Normal file
|
|
@ -0,0 +1,10 @@
|
|||
cpu 2014808 0 3797047 237290637 7608 0 66047 0 0 0
|
||||
cpu0 997273 0 1861281 118761074 3753 0 27566 0 0 0
|
||||
cpu1 1017534 0 1935766 118529563 3854 0 38481 0 0 0
|
||||
intr 191922858 235 9 0 0 1122 0 0 0 0 0 0 0 144 0 0 0 0 0 0 0 0 0 0 0 0 6 0 3 0 274341 277139 0 0 0 281571 324044 0 1603949 1543300 0 20236 0 1770807 0 21 0 0 0 0 0 0 0 0 0 5953816 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
|
||||
ctxt 212551065
|
||||
btime 1792210880
|
||||
processes 2962640
|
||||
procs_running 1
|
||||
procs_blocked 0
|
||||
softirq 141699889 5 32984936 1057 2776040 0 0 74 54302609 3 51635165
|
||||
1
internal/host/testdata/debian12/proc/sys/kernel/hostname
vendored
Normal file
1
internal/host/testdata/debian12/proc/sys/kernel/hostname
vendored
Normal file
|
|
@ -0,0 +1 @@
|
|||
hv1
|
||||
1
internal/host/testdata/debian12/proc/sys/kernel/osrelease
vendored
Normal file
1
internal/host/testdata/debian12/proc/sys/kernel/osrelease
vendored
Normal file
|
|
@ -0,0 +1 @@
|
|||
6.8.0-50-generic
|
||||
1
internal/host/testdata/debian12/proc/uptime
vendored
Normal file
1
internal/host/testdata/debian12/proc/uptime
vendored
Normal file
|
|
@ -0,0 +1 @@
|
|||
1243445.41 2372906.39
|
||||
20
internal/host/testdata/rocky10/etc/os-release
vendored
Normal file
20
internal/host/testdata/rocky10/etc/os-release
vendored
Normal file
|
|
@ -0,0 +1,20 @@
|
|||
NAME="Rocky Linux"
|
||||
VERSION="10.2 (Red Quartz)"
|
||||
RELEASE_TYPE="stable"
|
||||
ID="rocky"
|
||||
ID_LIKE="rhel centos fedora"
|
||||
VERSION_ID="10.2"
|
||||
PLATFORM_ID="platform:el10"
|
||||
PRETTY_NAME="Rocky Linux 10.2 (Red Quartz)"
|
||||
ANSI_COLOR="0;32"
|
||||
LOGO="fedora-logo-icon"
|
||||
CPE_NAME="cpe:/o:rocky:rocky:10::baseos"
|
||||
HOME_URL="https://rockylinux.org/"
|
||||
VENDOR_NAME="RESF"
|
||||
VENDOR_URL="https://resf.org/"
|
||||
BUG_REPORT_URL="https://bugs.rockylinux.org/"
|
||||
SUPPORT_END="2035-05-31"
|
||||
ROCKY_SUPPORT_PRODUCT="Rocky-Linux-10"
|
||||
ROCKY_SUPPORT_PRODUCT_VERSION="10.2"
|
||||
REDHAT_SUPPORT_PRODUCT="Rocky Linux"
|
||||
REDHAT_SUPPORT_PRODUCT_VERSION="10.2"
|
||||
|
|
@ -1,60 +0,0 @@
|
|||
package iptables
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"fmt"
|
||||
"os/exec"
|
||||
)
|
||||
|
||||
const HostSvcChain = "TWO-HOSTSVC"
|
||||
|
||||
var hostSvcExcluded = []string{"br-public", "l3-+"}
|
||||
|
||||
func hostSvcJump() []string {
|
||||
return []string{"PREROUTING", "-m", "addrtype", "--dst-type", "LOCAL", "-j", HostSvcChain}
|
||||
}
|
||||
|
||||
func hostSvcRules(target string) [][]string {
|
||||
var rules [][]string
|
||||
for _, iface := range hostSvcExcluded {
|
||||
rules = append(rules, []string{HostSvcChain, "-i", iface, "-j", "RETURN"})
|
||||
}
|
||||
for _, p := range []struct{ proto, port string }{{"udp", "53"}, {"tcp", "53"}, {"udp", "123"}} {
|
||||
rules = append(rules, []string{HostSvcChain,
|
||||
"-p", p.proto, "-m", p.proto, "--dport", p.port,
|
||||
"-j", "DNAT", "--to-destination", target,
|
||||
})
|
||||
}
|
||||
return rules
|
||||
}
|
||||
|
||||
func nat(args ...string) *exec.Cmd {
|
||||
return exec.Command("iptables", append([]string{"-t", "nat"}, args...)...)
|
||||
}
|
||||
|
||||
func AddHostSvcRedirect(target string) error {
|
||||
if out, err := nat("-N", HostSvcChain).CombinedOutput(); err != nil {
|
||||
return fmt.Errorf("iptables create chain %s: %w: %s", HostSvcChain, err, out)
|
||||
}
|
||||
for _, rule := range append(hostSvcRules(target), hostSvcJump()) {
|
||||
if out, err := nat(append([]string{"-A"}, rule...)...).CombinedOutput(); err != nil {
|
||||
return fmt.Errorf("iptables hostsvc redirect %v: %w: %s", rule, err, out)
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func HasHostSvcRedirect(target string) (bool, error) {
|
||||
for _, rule := range append(hostSvcRules(target), hostSvcJump()) {
|
||||
err := nat(append([]string{"-C"}, rule...)...).Run()
|
||||
var exit *exec.ExitError
|
||||
switch {
|
||||
case err == nil:
|
||||
case errors.As(err, &exit) && exit.ExitCode() == 1:
|
||||
return false, nil
|
||||
default:
|
||||
return false, fmt.Errorf("iptables check %v: %w", rule, err)
|
||||
}
|
||||
}
|
||||
return true, nil
|
||||
}
|
||||
|
|
@ -1,48 +0,0 @@
|
|||
package iptables
|
||||
|
||||
import (
|
||||
"reflect"
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestHostSvcJump_OnlyLocalDestinations(t *testing.T) {
|
||||
want := []string{"PREROUTING", "-m", "addrtype", "--dst-type", "LOCAL", "-j", "TWO-HOSTSVC"}
|
||||
if got := hostSvcJump(); !reflect.DeepEqual(got, want) {
|
||||
t.Errorf("jump = %v, want %v: traffic to an outside resolver must not be hijacked", got, want)
|
||||
}
|
||||
}
|
||||
|
||||
func TestHostSvcRules_ExclusionsComeFirst(t *testing.T) {
|
||||
rules := hostSvcRules("169.254.169.253")
|
||||
if len(rules) != 5 {
|
||||
t.Fatalf("%d rules, want 2 exclusions and 3 redirections: %v", len(rules), rules)
|
||||
}
|
||||
for i, iface := range []string{"br-public", "l3-+"} {
|
||||
want := []string{"TWO-HOSTSVC", "-i", iface, "-j", "RETURN"}
|
||||
if !reflect.DeepEqual(rules[i], want) {
|
||||
t.Errorf("rule %d = %v, want %v: the public segment and the vrf link must never reach the relay", i, rules[i], want)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestHostSvcRules_RedirectDNSAndNTPOnly(t *testing.T) {
|
||||
var got []string
|
||||
for _, rule := range hostSvcRules("169.254.169.253") {
|
||||
if rule[len(rule)-3] != "DNAT" {
|
||||
continue
|
||||
}
|
||||
if rule[len(rule)-1] != "169.254.169.253" {
|
||||
t.Errorf("rule %v does not target 169.254.169.253", rule)
|
||||
}
|
||||
got = append(got, strings.Join(rule[1:7], " "))
|
||||
}
|
||||
want := []string{
|
||||
"-p udp -m udp --dport 53",
|
||||
"-p tcp -m tcp --dport 53",
|
||||
"-p udp -m udp --dport 123",
|
||||
}
|
||||
if !reflect.DeepEqual(got, want) {
|
||||
t.Errorf("redirections = %v, want %v", got, want)
|
||||
}
|
||||
}
|
||||
|
|
@ -1,44 +0,0 @@
|
|||
package iptables
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"os/exec"
|
||||
|
||||
"git.g3e.fr/syonad/two/internal/metadata"
|
||||
)
|
||||
|
||||
func addRule(args ...string) error {
|
||||
return exec.Command("iptables", append([]string{"-t", "nat", "-A"}, args...)...).Run()
|
||||
}
|
||||
|
||||
func deleteRule(args ...string) error {
|
||||
return exec.Command("iptables", append([]string{"-t", "nat", "-D"}, args...)...).Run()
|
||||
}
|
||||
|
||||
func AddMetadataRedirect(vmIP, gatewayIP, metadataPort string) error {
|
||||
if err := addRule("PREROUTING",
|
||||
"-s", vmIP+"/32",
|
||||
"-d", metadata.ServiceIP+"/32",
|
||||
"-p", "tcp", "-m", "tcp",
|
||||
"--dport", "80",
|
||||
"-j", "DNAT",
|
||||
"--to-destination", gatewayIP+":"+metadataPort,
|
||||
); err != nil {
|
||||
return fmt.Errorf("iptables metadata redirect: %w", err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func DeleteMetadataRedirect(vmIP, gatewayIP, metadataPort string) error {
|
||||
if err := deleteRule("PREROUTING",
|
||||
"-s", vmIP+"/32",
|
||||
"-d", metadata.ServiceIP+"/32",
|
||||
"-p", "tcp", "-m", "tcp",
|
||||
"--dport", "80",
|
||||
"-j", "DNAT",
|
||||
"--to-destination", gatewayIP+":"+metadataPort,
|
||||
); err != nil {
|
||||
return fmt.Errorf("iptables delete metadata redirect: %w", err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
|
@ -1,7 +1,7 @@
|
|||
package metadata
|
||||
|
||||
// ServiceIP is the well-known address guests use to reach the metadata server.
|
||||
// Traffic to it is DNATed to the subnet gateway by internal/iptables, and the
|
||||
// Traffic to it is DNATed to the subnet gateway by internal/nft, and the
|
||||
// route to it is advertised by internal/dhcp.
|
||||
const ServiceIP = "169.254.169.254"
|
||||
|
||||
|
|
|
|||
81
internal/nft/hostsvc.go
Normal file
81
internal/nft/hostsvc.go
Normal file
|
|
@ -0,0 +1,81 @@
|
|||
package nft
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"strings"
|
||||
)
|
||||
|
||||
const HostSvcChain = "hostsvc"
|
||||
|
||||
var hostSvc = natChain{"", "nat", "prerouting", "dstnat"}
|
||||
|
||||
var hostSvcExcluded = []string{"br-public", "l3-*"}
|
||||
|
||||
func hostSvcRules(target string) []string {
|
||||
var rules []string
|
||||
for _, iface := range hostSvcExcluded {
|
||||
rules = append(rules, fmt.Sprintf("iifname %q return", iface))
|
||||
}
|
||||
for _, p := range []struct{ proto, port string }{{"udp", "53"}, {"tcp", "53"}, {"udp", "123"}} {
|
||||
rules = append(rules, fmt.Sprintf("fib daddr type local %s dport %s dnat to %s", p.proto, p.port, target))
|
||||
}
|
||||
return rules
|
||||
}
|
||||
|
||||
func hostSvcScript(target string) string {
|
||||
var b strings.Builder
|
||||
fmt.Fprintf(&b, "add table ip %s\n", Table)
|
||||
name := hostSvc.declare(&b, HostSvcChain)
|
||||
for _, r := range hostSvcRules(target) {
|
||||
fmt.Fprintf(&b, "add rule ip %s %s %s\n", Table, name, r)
|
||||
}
|
||||
return b.String()
|
||||
}
|
||||
|
||||
func SetHostSvcRedirect(target string) error {
|
||||
if err := apply(hostSvcScript(target)); err != nil {
|
||||
return fmt.Errorf("set dns and ntp redirect: %w", err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func HasHostSvcRedirect(target string) (bool, error) {
|
||||
out, err := run([]string{"list", "chains", "ip"}, "")
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
if !hasChain(string(out), HostSvcChain) {
|
||||
return false, nil
|
||||
}
|
||||
out, err = run([]string{"list", "chain", "ip", Table, HostSvcChain}, "")
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
return sameRules(chainRules(string(out)), append([]string{hostSvc.header()}, hostSvcRules(target)...)), nil
|
||||
}
|
||||
|
||||
func hasChain(listing, chain string) bool {
|
||||
table := ""
|
||||
for _, line := range strings.Split(listing, "\n") {
|
||||
fields := strings.Fields(line)
|
||||
switch {
|
||||
case len(fields) == 4 && fields[0] == "table" && fields[1] == "ip":
|
||||
table = fields[2]
|
||||
case len(fields) == 3 && fields[0] == "chain" && table == Table && fields[1] == chain:
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
func sameRules(have, want []string) bool {
|
||||
if len(have) != len(want) {
|
||||
return false
|
||||
}
|
||||
for i := range want {
|
||||
if have[i] != want[i] {
|
||||
return false
|
||||
}
|
||||
}
|
||||
return true
|
||||
}
|
||||
104
internal/nft/hostsvc_test.go
Normal file
104
internal/nft/hostsvc_test.go
Normal file
|
|
@ -0,0 +1,104 @@
|
|||
package nft
|
||||
|
||||
import (
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
|
||||
const listedHostSvcChains = `table ip two {
|
||||
chain snat-ng-t46 {
|
||||
type nat hook postrouting priority srcnat; policy accept;
|
||||
}
|
||||
chain hostsvc {
|
||||
type nat hook prerouting priority dstnat; policy accept;
|
||||
}
|
||||
chain md-t90-m1 {
|
||||
type nat hook prerouting priority dstnat; policy accept;
|
||||
}
|
||||
}
|
||||
`
|
||||
|
||||
const listedHostSvcChain = `table ip two {
|
||||
chain hostsvc {
|
||||
type nat hook prerouting priority dstnat; policy accept;
|
||||
iifname "br-public" return
|
||||
iifname "l3-*" return
|
||||
fib daddr type local udp dport 53 dnat to 169.254.169.253
|
||||
fib daddr type local tcp dport 53 dnat to 169.254.169.253
|
||||
fib daddr type local udp dport 123 dnat to 169.254.169.253
|
||||
}
|
||||
}
|
||||
`
|
||||
|
||||
func TestHostSvcScript(t *testing.T) {
|
||||
want := `add table ip two
|
||||
add chain ip two hostsvc { type nat hook prerouting priority dstnat; policy accept; }
|
||||
flush chain ip two hostsvc
|
||||
add rule ip two hostsvc iifname "br-public" return
|
||||
add rule ip two hostsvc iifname "l3-*" return
|
||||
add rule ip two hostsvc fib daddr type local udp dport 53 dnat to 169.254.169.253
|
||||
add rule ip two hostsvc fib daddr type local tcp dport 53 dnat to 169.254.169.253
|
||||
add rule ip two hostsvc fib daddr type local udp dport 123 dnat to 169.254.169.253
|
||||
`
|
||||
if got := hostSvcScript("169.254.169.253"); got != want {
|
||||
t.Errorf("script :\n%s\nattendu :\n%s", got, want)
|
||||
}
|
||||
}
|
||||
|
||||
func TestHostSvcRules_ExclusionsComeFirst(t *testing.T) {
|
||||
rules := hostSvcRules("169.254.169.253")
|
||||
if len(rules) != 5 {
|
||||
t.Fatalf("%d règles, 2 exclusions et 3 redirections attendues : %v", len(rules), rules)
|
||||
}
|
||||
for i, iface := range []string{"br-public", "l3-*"} {
|
||||
if want := `iifname "` + iface + `" return`; rules[i] != want {
|
||||
t.Errorf("règle %d = %q, %q attendu : le segment public et le lien de la VRF n'atteignent jamais le relais", i, rules[i], want)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestHostSvcRules_OnlyLocalDestinations(t *testing.T) {
|
||||
for _, r := range hostSvcRules("169.254.169.253") {
|
||||
if strings.Contains(r, "dnat") && !strings.HasPrefix(r, "fib daddr type local ") {
|
||||
t.Errorf("%q : un résolveur extérieur ne doit pas être détourné", r)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestHasChain(t *testing.T) {
|
||||
if !hasChain(listedHostSvcChains, "hostsvc") {
|
||||
t.Error("hostsvc non trouvée")
|
||||
}
|
||||
if hasChain(listedHostSvcChains, "md-t90") {
|
||||
t.Error("md-t90 trouvée par préfixe")
|
||||
}
|
||||
if hasChain(strings.Replace(listedHostSvcChains, "table ip two", "table ip nat", 1), "hostsvc") {
|
||||
t.Error("hostsvc trouvée dans une autre table")
|
||||
}
|
||||
if hasChain("", "hostsvc") {
|
||||
t.Error("hostsvc trouvée sans table")
|
||||
}
|
||||
}
|
||||
|
||||
func TestHostSvcListingMatches(t *testing.T) {
|
||||
want := append([]string{hostSvc.header()}, hostSvcRules("169.254.169.253")...)
|
||||
if !sameRules(chainRules(listedHostSvcChain), want) {
|
||||
t.Errorf("affichage nft %v, %v attendu", chainRules(listedHostSvcChain), want)
|
||||
}
|
||||
}
|
||||
|
||||
func TestHostSvcListingMismatches(t *testing.T) {
|
||||
want := append([]string{hostSvc.header()}, hostSvcRules("169.254.169.253")...)
|
||||
for label, listing := range map[string]string{
|
||||
"règle 123 absente": strings.Replace(listedHostSvcChain, "\t\tfib daddr type local udp dport 123 dnat to 169.254.169.253\n", "", 1),
|
||||
"règle 123 sans fib": strings.Replace(listedHostSvcChain, "fib daddr type local udp dport 123", "udp dport 123", 1),
|
||||
"autre cible": strings.Replace(listedHostSvcChain, "53 dnat to 169.254.169.253", "53 dnat to 10.0.0.1", 1),
|
||||
"exclusion après dnat": strings.Replace(strings.Replace(listedHostSvcChain, "\t\tiifname \"br-public\" return\n", "", 1), "dport 123 dnat to 169.254.169.253\n", "dport 123 dnat to 169.254.169.253\n\t\tiifname \"br-public\" return\n", 1),
|
||||
"chaîne sans crochet": strings.Replace(listedHostSvcChain, "\t\ttype nat hook prerouting priority dstnat; policy accept;\n", "", 1),
|
||||
"crochet d'une autre priorité": strings.Replace(listedHostSvcChain, "priority dstnat", "priority srcnat", 1),
|
||||
} {
|
||||
if sameRules(chainRules(listing), want) {
|
||||
t.Errorf("%s : chaîne jugée conforme", label)
|
||||
}
|
||||
}
|
||||
}
|
||||
46
internal/nft/metadata.go
Normal file
46
internal/nft/metadata.go
Normal file
|
|
@ -0,0 +1,46 @@
|
|||
package nft
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"strings"
|
||||
|
||||
"git.g3e.fr/syonad/two/internal/metadata"
|
||||
)
|
||||
|
||||
var metadataChain = natChain{"md-", "nat", "prerouting", "dstnat"}
|
||||
|
||||
func metadataRule(ip, target string) string {
|
||||
return fmt.Sprintf("ip saddr %s ip daddr %s tcp dport 80 dnat to %s", ip, metadata.ServiceIP, target)
|
||||
}
|
||||
|
||||
func metadataSetScript(vm string, ips []string, target string) string {
|
||||
var b strings.Builder
|
||||
fmt.Fprintf(&b, "add table ip %s\n", Table)
|
||||
name := metadataChain.declare(&b, vm)
|
||||
for _, ip := range ips {
|
||||
fmt.Fprintf(&b, "add rule ip %s %s %s\n", Table, name, metadataRule(ip, target))
|
||||
}
|
||||
return b.String()
|
||||
}
|
||||
|
||||
func metadataDeleteScript(vm string) string {
|
||||
var b strings.Builder
|
||||
fmt.Fprintf(&b, "add table ip %s\n", Table)
|
||||
name := metadataChain.declare(&b, vm)
|
||||
fmt.Fprintf(&b, "delete chain ip %s %s\n", Table, name)
|
||||
return b.String()
|
||||
}
|
||||
|
||||
func SetMetadataRedirect(vm string, ips []string, target string) error {
|
||||
if err := apply(metadataSetScript(vm, ips, target)); err != nil {
|
||||
return fmt.Errorf("set metadata redirect %s: %w", vm, err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func DeleteMetadataRedirect(vm string) error {
|
||||
if err := apply(metadataDeleteScript(vm)); err != nil {
|
||||
return fmt.Errorf("delete metadata redirect %s: %w", vm, err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
38
internal/nft/metadata_test.go
Normal file
38
internal/nft/metadata_test.go
Normal file
|
|
@ -0,0 +1,38 @@
|
|||
package nft
|
||||
|
||||
import (
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestMetadataSetScript(t *testing.T) {
|
||||
want := `add table ip two
|
||||
add chain ip two md-t90-m1 { type nat hook prerouting priority dstnat; policy accept; }
|
||||
flush chain ip two md-t90-m1
|
||||
add rule ip two md-t90-m1 ip saddr 10.90.1.10 ip daddr 169.254.169.254 tcp dport 80 dnat to 10.90.1.1:8001
|
||||
add rule ip two md-t90-m1 ip saddr 10.90.2.10 ip daddr 169.254.169.254 tcp dport 80 dnat to 10.90.1.1:8001
|
||||
`
|
||||
if got := metadataSetScript("t90-m1", []string{"10.90.1.10", "10.90.2.10"}, "10.90.1.1:8001"); got != want {
|
||||
t.Errorf("script :\n%s\nattendu :\n%s", got, want)
|
||||
}
|
||||
}
|
||||
|
||||
func TestMetadataDeleteScript(t *testing.T) {
|
||||
want := `add table ip two
|
||||
add chain ip two md-t90-m1 { type nat hook prerouting priority dstnat; policy accept; }
|
||||
flush chain ip two md-t90-m1
|
||||
delete chain ip two md-t90-m1
|
||||
`
|
||||
if got := metadataDeleteScript("t90-m1"); got != want {
|
||||
t.Errorf("script :\n%s\nattendu :\n%s", got, want)
|
||||
}
|
||||
}
|
||||
|
||||
func TestMetadataScriptsStayInTheirChain(t *testing.T) {
|
||||
script := metadataSetScript("t90-m1", []string{"10.90.1.10"}, "10.90.1.1:8001") + metadataDeleteScript("t90-m1")
|
||||
for _, line := range strings.Split(strings.TrimSpace(script), "\n") {
|
||||
if line != "add table ip two" && !strings.Contains(line, " ip two md-t90-m1") {
|
||||
t.Errorf("ligne hors de la chaîne md-t90-m1 : %q", line)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -23,9 +23,13 @@ var natChains = []natChain{
|
|||
{"in-", "filter", "input", "filter"},
|
||||
}
|
||||
|
||||
func (c natChain) header() string {
|
||||
return fmt.Sprintf("type %s hook %s priority %s; policy accept;", c.kind, c.hook, c.priority)
|
||||
}
|
||||
|
||||
func (c natChain) declare(b *strings.Builder, iface string) string {
|
||||
name := c.prefix + iface
|
||||
fmt.Fprintf(b, "add chain ip %s %s { type %s hook %s priority %s; policy accept; }\n", Table, name, c.kind, c.hook, c.priority)
|
||||
fmt.Fprintf(b, "add chain ip %s %s { %s }\n", Table, name, c.header())
|
||||
fmt.Fprintf(b, "flush chain ip %s %s\n", Table, name)
|
||||
return name
|
||||
}
|
||||
|
|
|
|||
|
|
@ -10,7 +10,6 @@ import (
|
|||
|
||||
configuration "git.g3e.fr/syonad/two/internal/config/agent"
|
||||
"git.g3e.fr/syonad/two/internal/dhcpbackend"
|
||||
"git.g3e.fr/syonad/two/internal/iptables"
|
||||
"git.g3e.fr/syonad/two/internal/l3vni"
|
||||
"git.g3e.fr/syonad/two/internal/metadata"
|
||||
"git.g3e.fr/syonad/two/internal/netif"
|
||||
|
|
@ -63,12 +62,7 @@ func StartVM(db *badger.DB, name string, cfg *configuration.Config) error {
|
|||
// métadonnées de l'interface primaire. Toutes les interfaces étant dans le
|
||||
// même VPC, donc le même netns, il est joignable depuis n'importe laquelle.
|
||||
if err := netns.Call(nic.vpcName, func() error {
|
||||
for _, n := range d.nics {
|
||||
if err := iptables.AddMetadataRedirect(n.ip, nic.interfaceIP, d.metadataPort); err != nil {
|
||||
return fmt.Errorf("interface %d: %w", n.index, err)
|
||||
}
|
||||
}
|
||||
return nil
|
||||
return nft.SetMetadataRedirect(name, nicIPs(d.nics), nic.interfaceIP+":"+d.metadataPort)
|
||||
}); err != nil {
|
||||
return fmt.Errorf("add metadata redirect: %w", err)
|
||||
}
|
||||
|
|
@ -186,6 +180,14 @@ func copyFile(src, dst string) error {
|
|||
return out.Sync()
|
||||
}
|
||||
|
||||
func nicIPs(nics []nicData) []string {
|
||||
ips := make([]string, len(nics))
|
||||
for i, n := range nics {
|
||||
ips[i] = n.ip
|
||||
}
|
||||
return ips
|
||||
}
|
||||
|
||||
func nicMACs(nics []nicData) []string {
|
||||
macs := make([]string, len(nics))
|
||||
for i, n := range nics {
|
||||
|
|
|
|||
|
|
@ -18,3 +18,17 @@ func TestNicMACs_KeepsTheOrderAndLowersTheCase(t *testing.T) {
|
|||
t.Errorf("nicMACs = %v, attendu %v", got, want)
|
||||
}
|
||||
}
|
||||
|
||||
func TestNicIPs_EveryInterfaceGetsTheRedirect(t *testing.T) {
|
||||
nics := []nicData{
|
||||
{index: 0, ip: "10.49.1.10"},
|
||||
{index: 1, ip: "10.49.2.10", primary: true},
|
||||
}
|
||||
|
||||
got := nicIPs(nics)
|
||||
|
||||
want := []string{"10.49.1.10", "10.49.2.10"}
|
||||
if !reflect.DeepEqual(got, want) {
|
||||
t.Errorf("nicIPs = %v, attendu %v", got, want)
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -11,7 +11,6 @@ import (
|
|||
|
||||
configuration "git.g3e.fr/syonad/two/internal/config/agent"
|
||||
"git.g3e.fr/syonad/two/internal/dhcpbackend"
|
||||
"git.g3e.fr/syonad/two/internal/iptables"
|
||||
"git.g3e.fr/syonad/two/internal/l3vni"
|
||||
"git.g3e.fr/syonad/two/internal/metadata"
|
||||
"git.g3e.fr/syonad/two/internal/netif"
|
||||
|
|
@ -60,12 +59,7 @@ func StopVM(db *badger.DB, name string, cfg *configuration.Config) error {
|
|||
}
|
||||
|
||||
if err := netns.Call(nic.vpcName, func() error {
|
||||
for _, n := range d.nics {
|
||||
if err := iptables.DeleteMetadataRedirect(n.ip, nic.interfaceIP, d.metadataPort); err != nil {
|
||||
return fmt.Errorf("interface %d: %w", n.index, err)
|
||||
}
|
||||
}
|
||||
return nil
|
||||
return nft.DeleteMetadataRedirect(name)
|
||||
}); err != nil {
|
||||
return fmt.Errorf("delete metadata redirect: %w", err)
|
||||
}
|
||||
|
|
|
|||
|
|
@ -7,9 +7,9 @@ import (
|
|||
hostsvcapi "git.g3e.fr/syonad/two/internal/api/hostsvc"
|
||||
hostsvcclient "git.g3e.fr/syonad/two/internal/client/hostsvc"
|
||||
"git.g3e.fr/syonad/two/internal/hostsvc"
|
||||
"git.g3e.fr/syonad/two/internal/iptables"
|
||||
"git.g3e.fr/syonad/two/internal/netif"
|
||||
"git.g3e.fr/syonad/two/internal/netns"
|
||||
"git.g3e.fr/syonad/two/internal/nft"
|
||||
)
|
||||
|
||||
const HostSvcLink = "hostsvc"
|
||||
|
|
@ -34,7 +34,7 @@ func newSystemHostSvc() systemHostSvc {
|
|||
func (systemHostSvc) InNetns(vpc string, fn func() error) error { return netns.Call(vpc, fn) }
|
||||
func (systemHostSvc) CreateDummy(name string) error { return netif.CreateDummy(name) }
|
||||
func (systemHostSvc) AddrAdd(iface string, ip net.IP) error { return netif.AddrAdd(iface, ip) }
|
||||
func (systemHostSvc) AddRedirect(target string) error { return iptables.AddHostSvcRedirect(target) }
|
||||
func (systemHostSvc) AddRedirect(target string) error { return nft.SetHostSvcRedirect(target) }
|
||||
func (s systemHostSvc) Open(vpc string) error { return s.client.Open(vpc) }
|
||||
func (s systemHostSvc) Close(vpc string) error { return s.client.Close(vpc) }
|
||||
|
||||
|
|
|
|||
|
|
@ -7,9 +7,9 @@ import (
|
|||
hostsvcapi "git.g3e.fr/syonad/two/internal/api/hostsvc"
|
||||
hostsvcclient "git.g3e.fr/syonad/two/internal/client/hostsvc"
|
||||
"git.g3e.fr/syonad/two/internal/hostsvc"
|
||||
"git.g3e.fr/syonad/two/internal/iptables"
|
||||
"git.g3e.fr/syonad/two/internal/netif"
|
||||
"git.g3e.fr/syonad/two/internal/netns"
|
||||
"git.g3e.fr/syonad/two/internal/nft"
|
||||
"git.g3e.fr/syonad/two/internal/state"
|
||||
"git.g3e.fr/syonad/two/internal/vpc"
|
||||
"git.g3e.fr/syonad/two/internal/watchdog/notify"
|
||||
|
|
@ -58,7 +58,7 @@ func (systemHostSvcProbe) Redirect(name string) (bool, error) {
|
|||
var ok bool
|
||||
err := netns.Call(name, func() error {
|
||||
var err error
|
||||
ok, err = iptables.HasHostSvcRedirect(hostsvc.ServiceIP)
|
||||
ok, err = nft.HasHostSvcRedirect(hostsvc.ServiceIP)
|
||||
return err
|
||||
})
|
||||
return ok, err
|
||||
|
|
@ -103,7 +103,7 @@ func CheckHostSvc(db *badger.DB, p hostSvcProbe, n notify.Notifier) error {
|
|||
if ok, err := p.Redirect(name); err != nil {
|
||||
n.Notify(kindVPC, name, fmt.Sprintf("dns and ntp redirection unreadable: %v", err))
|
||||
} else if !ok {
|
||||
n.Notify(kindVPC, name, fmt.Sprintf("dns and ntp redirection to %s missing or incomplete (chain %s)", hostsvc.ServiceIP, iptables.HostSvcChain))
|
||||
n.Notify(kindVPC, name, fmt.Sprintf("dns and ntp redirection to %s missing or incomplete (nft chain ip %s %s)", hostsvc.ServiceIP, nft.Table, nft.HostSvcChain))
|
||||
}
|
||||
}
|
||||
return nil
|
||||
|
|
|
|||
|
|
@ -97,7 +97,7 @@ func TestCheckHostSvc_ReportsEachMissingPiece(t *testing.T) {
|
|||
for name, want := range map[string]string{
|
||||
"vp-unserved": "not served by two-hostsvc: its vms get no dns nor ntp",
|
||||
"vp-noaddr": "169.254.169.253 missing on hostsvc (in netns)",
|
||||
"vp-noredirect": "dns and ntp redirection to 169.254.169.253 missing or incomplete (chain TWO-HOSTSVC)",
|
||||
"vp-noredirect": "dns and ntp redirection to 169.254.169.253 missing or incomplete (nft chain ip two hostsvc)",
|
||||
} {
|
||||
got := r.forName(name)
|
||||
if len(got) != 1 || got[0].kind != "vpc" || got[0].problem != want {
|
||||
|
|
|
|||
|
|
@ -113,6 +113,16 @@
|
|||
- Une IP flottante est refusée (409) sur une interface d'un subnet `public_ip`. Le watchdog
|
||||
contrôle les subnets `public_ip` comme les subnets `bridge`
|
||||
|
||||
**Connaissance de l'hôte (#39)**
|
||||
|
||||
- `GET /register` : hostname, CPU (fabricant, modèle, sockets, cœurs, threads), RAM totale, OS
|
||||
et noyau, lus au démarrage de l'agent (503 si la lecture a échoué)
|
||||
- `GET /ping` : version de l'agent, démarrages de l'hôte et de l'agent (timestamps Unix),
|
||||
uptime de l'hôte et load, mesurés toutes les `times.host_state_interval` secondes (10 par
|
||||
défaut) et gardés en mémoire, avec l'heure de la mesure (`collected_at`)
|
||||
- **L'agent connaît sa version** : injectée au build (tag de la release), affichée dans
|
||||
`/ping` et dans la ligne `starting agent` du journal
|
||||
|
||||
## Correctifs
|
||||
|
||||
- **Chaque VRF de VPC porte une route `unreachable default` (#81).** Une recherche qui échouait
|
||||
|
|
@ -164,6 +174,13 @@
|
|||
`nftables` à la place d'`ebtables`. Les règles ebtables des subnets existants ne sont ni
|
||||
reprises ni retirées : vider l'hyperviseur (VM, subnets, VPC) avant la mise à jour, puis les
|
||||
recréer
|
||||
- **Les redirections passent d'iptables à nftables (#90)** : celle des métadonnées (une chaîne
|
||||
`md-<vm>` par VM) et celle du DNS et du NTP (chaîne `hostsvc`) sont posées dans la table
|
||||
`ip two` du netns de chaque VPC. `bootstrap_kvm.sh` n'installe plus `iptables`, ne charge plus
|
||||
`br_netfilter` et n'écrit plus `net.bridge.bridge-nf-call-iptables = 1`. L'agent ne reprend
|
||||
pas les règles iptables des VM créées par la 0.2.0 : le vidage de l'hyperviseur demandé
|
||||
ci-dessous les retire. Sur un hyperviseur déjà déployé, le module reste chargé jusqu'au
|
||||
redémarrage (ou `modprobe -r br_netfilter`)
|
||||
- **Une VM ne peut plus émettre depuis une adresse qui n'est pas la sienne (#76)** : une VM qui
|
||||
route pour d'autres machines, porte une adresse supplémentaire ou sert le DHCP perd ce trafic.
|
||||
Pour un serveur DHCP, créer l'interface avec `dhcp_server: true`
|
||||
|
|
|
|||
|
|
@ -16,7 +16,7 @@
|
|||
# L'host est stateless (root sur tmpfs) : rien de ce qui suit ne survit à un
|
||||
# reboot, deploy.sh --bootstrap est rejoué à chaque démarrage.
|
||||
|
||||
KVM_PACKAGES="qemu-system-x86 qemu-utils ovmf dnsmasq nftables iptables nfs-common jq curl"
|
||||
KVM_PACKAGES="qemu-system-x86 qemu-utils ovmf dnsmasq nftables nfs-common jq curl"
|
||||
|
||||
kvm_packages () {
|
||||
local DRY_RUN="${1}"
|
||||
|
|
@ -39,15 +39,11 @@ kvm_kernel () {
|
|||
|
||||
info "kernel"
|
||||
|
||||
# modprobe AVANT sysctl : les clés net.bridge.* n'existent pas tant que
|
||||
# br_netfilter n'est pas chargé, et sysctl --system échouerait.
|
||||
run "${DRY_RUN}" "modprobe br_netfilter"
|
||||
run "${DRY_RUN}" "echo br_netfilter > /etc/modules-load.d/two.conf"
|
||||
|
||||
# bridge-nf-call-iptables est requis par le DNAT metadata (169.254.169.254,
|
||||
# cf. internal/iptables) : sans lui, iptables ne voit pas le trafic bridgé
|
||||
# des VMs. Contrepartie : tout le trafic inter-VM traverse les tables nat.
|
||||
run "${DRY_RUN}" "printf 'net.ipv4.ip_forward = 1\nnet.bridge.bridge-nf-call-iptables = 1\n' > /etc/sysctl.d/90-two.conf"
|
||||
# Pas de br_netfilter : le filtrage des ponts est en nftables (famille
|
||||
# bridge) et les DNAT vivent dans les netns, où l'agent coupe déjà
|
||||
# bridge-nf-call-*. Chargé, le module ferait passer tout le trafic bridgé
|
||||
# des VM par netfilter (bridge-nf-call-iptables vaut 1 par défaut).
|
||||
run "${DRY_RUN}" "printf 'net.ipv4.ip_forward = 1\n' > /etc/sysctl.d/90-two.conf"
|
||||
run "${DRY_RUN}" "sysctl --system >/dev/null"
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -30,11 +30,24 @@ clean () {
|
|||
done
|
||||
}
|
||||
|
||||
build_version () {
|
||||
local commit changes
|
||||
commit=$(git -C "${REPO_DIR}" rev-parse --short HEAD) || return 1
|
||||
changes=$(git -C "${REPO_DIR}" status --porcelain) || return 1
|
||||
if [ -n "${changes}" ]; then
|
||||
echo "${commit}-dirty"
|
||||
else
|
||||
echo "${commit}"
|
||||
fi
|
||||
}
|
||||
|
||||
build () {
|
||||
local binary unit script
|
||||
local binary unit script version
|
||||
version=$(build_version) || return 1
|
||||
echo "== version ${version}" >&2
|
||||
for binary in ${BINARIES}; do
|
||||
echo "== ${binary}" >&2
|
||||
(cd "${REPO_DIR}" && CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -o "${BIN_DIR}/${binary}" "./cmd/${binary}") || return 1
|
||||
(cd "${REPO_DIR}" && CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -ldflags "-X main.version=${version}" -o "${BIN_DIR}/${binary}" "./cmd/${binary}") || return 1
|
||||
done
|
||||
for unit in ${UNITS}; do
|
||||
cp "${REPO_DIR}/systemd/${unit}" "${BIN_DIR}/${unit}" || return 1
|
||||
|
|
|
|||
|
|
@ -56,7 +56,8 @@ host_state () {
|
|||
echo "## adresses"; ip -o -4 addr show | awk '{print $2, $4}' | sort
|
||||
echo "## routes"; ip -4 route show table all | grep -v '^local \|^broadcast ' | sort
|
||||
echo "## nftables bridge"; nft list ruleset bridge
|
||||
echo "## iptables"; iptables-save | grep -v '^#' | sed 's/ \[[0-9]*:[0-9]*\]$//'
|
||||
echo "## nftables ip"; nft list ruleset ip
|
||||
echo "## nftables des netns"; local ns; for ns in $(ip netns list | awk '{print $1}' | sort); do echo "# ${ns}"; ip netns exec "${ns}" nft list ruleset; done
|
||||
echo "## frr"; vtysh -c 'show running-config' | grep -v '^Building\|^Current configuration\|^!'
|
||||
echo "## frr.conf"; sha256sum /etc/frr/frr.conf | cut -d' ' -f1
|
||||
echo "## fichiers"; find /run/two /etc/dnsmasq.d "${VOLUMES}" -mindepth 1 ! -type d 2>/dev/null | sort
|
||||
|
|
|
|||
|
|
@ -826,6 +826,23 @@ PY
|
|||
teardown
|
||||
}
|
||||
|
||||
test_build_version_is_the_commit_dirty_when_the_tree_changed () {
|
||||
setup "build_version : commit court, suffixé -dirty si l'arbre a des modifications, échec hors dépôt"
|
||||
local repo="${WORK}/repo" commit
|
||||
git init -q "${repo}" && printf 'a\n' > "${repo}/f" && git -C "${repo}" add f \
|
||||
&& git -C "${repo}" -c user.name=t -c user.email=t@t commit -q -m t || fail "dépôt de test"
|
||||
commit=$(git -C "${repo}" rev-parse --short HEAD)
|
||||
build_version_in () { bash -c ". '${DIR}/build.sh'; REPO_DIR='${1}'; build_version" 2>&1; }
|
||||
[[ $(build_version_in "${repo}") == "${commit}" ]] || fail "arbre propre : $(build_version_in "${repo}")"
|
||||
printf 'b\n' > "${repo}/f"
|
||||
[[ $(build_version_in "${repo}") == "${commit}-dirty" ]] || fail "fichier modifié : $(build_version_in "${repo}")"
|
||||
git -C "${repo}" checkout -q f && printf 'n\n' > "${repo}/nouveau"
|
||||
[[ $(build_version_in "${repo}") == "${commit}-dirty" ]] || fail "fichier non suivi : $(build_version_in "${repo}")"
|
||||
mkdir "${WORK}/hors-depot"
|
||||
build_version_in "${WORK}/hors-depot" >/dev/null && fail "hors dépôt : réussite"
|
||||
teardown
|
||||
}
|
||||
|
||||
for T in $(declare -F | awk '{print $3}' | grep '^test_'); do
|
||||
"${T}"
|
||||
done
|
||||
|
|
|
|||
44
test/e2e/suite/13-hote.sh
Normal file
44
test/e2e/suite/13-hote.sh
Normal file
|
|
@ -0,0 +1,44 @@
|
|||
# fonctionnalité: connaissance de l'hôte — /register (hostname, CPU, RAM, OS, noyau) lu au démarrage, /ping (version, démarrages de l'hôte et de l'agent, uptime, load) mesuré périodiquement, lecture seule, redémarrage de l'agent distingué de celui de l'hôte
|
||||
# hôtes: hv1
|
||||
# tickets: #39
|
||||
|
||||
on hv1 <<'NODE'
|
||||
reg () { api_field register "${1}"; }
|
||||
ping_field () { api_field ping "${1}"; }
|
||||
lscpu_field () { lscpu | awk -F: -v k="${1}" '$1 == k {gsub(/ /, "", $2); print $2}'; }
|
||||
os_field () { (. /etc/os-release && eval "echo \"\${${1}}\""); }
|
||||
near () { awk -v a="${1}" -v b="${2}" -v d="${3}" 'BEGIN { exit !((a - b) <= d && (b - a) <= d) }' || { echo "${1} et ${2} à plus de ${3} s"; return 1; }; }
|
||||
ping_ready () { local i; for i in $(seq 1 30); do [ "$(api_code GET ping)" = 200 ] && return 0; sleep 1; done; return 1; }
|
||||
|
||||
check "/register : 200" expect_code 200 api_code GET register
|
||||
check "/register : hostname = hostname" test "$(reg hostname)" = "$(hostname)"
|
||||
check "/register : threads = nproc" test "$(reg cpu.threads)" = "$(nproc --all)"
|
||||
check "/register : sockets = lscpu" test "$(reg cpu.sockets)" = "$(lscpu_field 'Socket(s)')"
|
||||
check "/register : cœurs = sockets × cœurs par socket (lscpu)" test "$(reg cpu.cores)" = "$(( $(lscpu_field 'Socket(s)') * $(lscpu_field 'Core(s) per socket') ))"
|
||||
check "/register : modèle = lscpu" test "$(reg cpu.model)" = "$(lscpu | sed -n 's/^Model name: *//p')"
|
||||
check "/register : fabricant = lscpu" test "$(reg cpu.vendor)" = "$(lscpu | sed -n 's/^Vendor ID: *//p')"
|
||||
check "/register : RAM = MemTotal" test "$(reg memory_bytes)" = "$(awk '/^MemTotal:/ {printf "%.0f\n", $2 * 1024}' /proc/meminfo)"
|
||||
check "/register : noyau = uname -r" test "$(reg kernel)" = "$(uname -r)"
|
||||
check "/register : OS = os-release (ID, VERSION_ID, PRETTY_NAME)" test "$(reg os.id)|$(reg os.version_id)|$(reg os.pretty_name)" = "$(os_field ID)|$(os_field VERSION_ID)|$(os_field PRETTY_NAME)"
|
||||
|
||||
check "/ping : 200" expect_code 200 api_code GET ping
|
||||
VERSION=$(ping_field agent_version)
|
||||
info "version de l'agent : ${VERSION}"
|
||||
check "/ping : version injectée au build (commit ou tag, pas undefined)" sh -c "echo '${VERSION}' | grep -Eq '^([0-9a-f]{7,}(-dirty)?|[0-9]+\.[0-9]+\.[0-9]+.*)$'"
|
||||
check "/ping : boot_time = btime" test "$(ping_field boot_time)" = "$(awk '/^btime/ {print $2}' /proc/stat)"
|
||||
check "/ping : boot_time + uptime_seconds = collected_at (horloge de l'hôte)" near "$(awk -v b="$(ping_field boot_time)" -v u="$(ping_field uptime_seconds)" 'BEGIN { printf "%d", b + u }')" "$(ping_field collected_at)" 2
|
||||
check "/ping : mesure de moins de 15 s" near "$(ping_field collected_at)" "$(date +%s)" 15
|
||||
check "/ping : trois valeurs de load" test "$(api_field ping 'load | length')" = 3
|
||||
check "/ping : agent_start_time = démarrage de l'unité agent" near "$(ping_field agent_start_time)" "$(date -d "$(systemctl show agent -p ActiveEnterTimestamp --value)" +%s)" 2
|
||||
for path in register ping; do
|
||||
check "POST /${path} : 405" expect_code 405 api_code POST "${path}"
|
||||
done
|
||||
|
||||
BOOT=$(ping_field boot_time)
|
||||
START=$(ping_field agent_start_time)
|
||||
sleep 1
|
||||
check "redémarrage de l'agent" systemctl restart agent
|
||||
check "/ping de nouveau servi après le redémarrage" ping_ready
|
||||
check "après redémarrage : boot_time inchangé" test "$(ping_field boot_time)" = "${BOOT}"
|
||||
check "après redémarrage : agent_start_time plus récent" test "$(ping_field agent_start_time)" -gt "${START}"
|
||||
NODE
|
||||
|
|
@ -50,9 +50,9 @@ ntp_ok () {
|
|||
}
|
||||
no_answer () { ! vm_py "${1}" "${2}" dns_py "${3}" udp deb.debian.org "${4}" >/dev/null 2>&1; }
|
||||
served_ports () { ip netns exec "${1}" ss -Hlntu | awk '$5 ~ /^169\.254\.169\.253:/ {print $1, $5}' | sort | tr '\n' ' '; }
|
||||
rules () { ip netns exec "${1}" iptables -t nat -S TWO-HOSTSVC; }
|
||||
rules () { ip netns exec "${1}" nft list chain ip two hostsvc | sed -n '/^\t\t/s/^\t\t//p'; }
|
||||
state_has () { grep -q "\"${1}\"" /run/two/hostsvc/hostsvc.state; }
|
||||
excluded_first () { [ "$(rules "${1}" | sed -n '2p;3p' | tr '\n' ' ')" = "-A TWO-HOSTSVC -i br-public -j RETURN -A TWO-HOSTSVC -i l3-+ -j RETURN " ]; }
|
||||
excluded_first () { [ "$(rules "${1}" | sed -n '2p;3p' | tr '\n' ' ')" = 'iifname "br-public" return iifname "l3-*" return ' ]; }
|
||||
no_dns () { ! dns_ok "$@" >/dev/null 2>&1; }
|
||||
no_ntp () { ! ntp_ok "$@" >/dev/null 2>&1; }
|
||||
vpc_in_error () {
|
||||
|
|
@ -71,9 +71,10 @@ check "subnet sn-t29b en mode bridge sur br-lan, interface_ip 10.33.0.29" subnet
|
|||
for vpc in vp-t29 vp-t29b; do
|
||||
check "${vpc} : 169.254.169.253 sur la dummy hostsvc" sh -c "ip -n ${vpc} -4 -o addr show dev hostsvc | grep -q ' 169.254.169.253/32 '"
|
||||
check "${vpc} : two-hostsvc n'écoute que 53/udp, 53/tcp et 123/udp sur 169.254.169.253" test "$(served_ports "${vpc}")" = "tcp 169.254.169.253:53 udp 169.254.169.253:123 udp 169.254.169.253:53 "
|
||||
check "${vpc} : chaîne TWO-HOSTSVC, br-public et l3-+ exclus avant toute redirection" excluded_first "${vpc}"
|
||||
check "${vpc} : redirection de 53/udp, 53/tcp et 123/udp vers 169.254.169.253" test "$(rules "${vpc}" | grep -c 'DNAT --to-destination 169.254.169.253')" -eq 3
|
||||
check "${vpc} : appel depuis PREROUTING pour les destinations locales seulement" sh -c "ip netns exec ${vpc} iptables -t nat -S PREROUTING | grep -qx -- '-A PREROUTING -m addrtype --dst-type LOCAL -j TWO-HOSTSVC'"
|
||||
check "${vpc} : chaîne hostsvc de ip two accrochée à prerouting en dstnat" test "$(rules "${vpc}" | head -n 1)" = "type nat hook prerouting priority dstnat; policy accept;"
|
||||
check "${vpc} : br-public et l3-* exclus avant toute redirection" excluded_first "${vpc}"
|
||||
check "${vpc} : redirection de 53/udp, 53/tcp et 123/udp vers 169.254.169.253" test "$(rules "${vpc}" | grep -c 'dnat to 169.254.169.253$')" -eq 3
|
||||
check "${vpc} : redirection pour les destinations locales seulement" test "$(rules "${vpc}" | grep -c '^fib daddr type local .* dnat to 169.254.169.253$')" -eq 3
|
||||
check "${vpc} : inscrit dans l'état de two-hostsvc" state_has "${vpc}"
|
||||
done
|
||||
|
||||
|
|
@ -98,10 +99,11 @@ ip -n vp-t29 addr del 169.254.169.253/32 dev hostsvc
|
|||
check "watchdog : adresse 169.254.169.253 retirée signalée" wait_watchdog "169.254.169.253 missing on hostsvc (in netns)"
|
||||
ip -n vp-t29 addr add 169.254.169.253/32 dev hostsvc
|
||||
check "10.29.1.10 : DNS de nouveau servi une fois l'adresse remise" dns_ok vp-t29 10.29.1.10 10.29.1.254 udp
|
||||
ip netns exec vp-t29 iptables -t nat -D TWO-HOSTSVC -p udp -m udp --dport 123 -j DNAT --to-destination 169.254.169.253
|
||||
check "watchdog : redirection incomplète signalée" wait_watchdog "dns and ntp redirection to 169.254.169.253 missing or incomplete (chain TWO-HOSTSVC)"
|
||||
HANDLE=$(ip netns exec vp-t29 nft -a list chain ip two hostsvc | awk '/udp dport 123 / {print $NF}')
|
||||
check "règle 123 retirée à la main de hostsvc (handle ${HANDLE:-absent})" ip netns exec vp-t29 nft delete rule ip two hostsvc handle "${HANDLE}"
|
||||
check "watchdog : redirection incomplète signalée" wait_watchdog "dns and ntp redirection to 169.254.169.253 missing or incomplete (nft chain ip two hostsvc)"
|
||||
check "10.29.1.10 : sans la règle 123, plus de NTP (témoin)" no_ntp vp-t29 10.29.1.10 10.29.1.254
|
||||
ip netns exec vp-t29 iptables -t nat -A TWO-HOSTSVC -p udp -m udp --dport 123 -j DNAT --to-destination 169.254.169.253
|
||||
check "règle 123 reposée" ip netns exec vp-t29 nft add rule ip two hostsvc fib daddr type local udp dport 123 dnat to 169.254.169.253
|
||||
check "10.29.1.10 : NTP de nouveau servi une fois la règle remise" ntp_ok vp-t29 10.29.1.10 10.29.1.254
|
||||
|
||||
systemctl stop two-hostsvc.service
|
||||
|
|
|
|||
|
|
@ -48,7 +48,7 @@ sleep 20
|
|||
check "après redémarrage : même processus QEMU pour t61-a (ni arrêtée ni recréée)" test "$(pgrep -f "${VOLUMES}/t61-a.qcow2" | sort | tr '\n' ' ')" = "${QEMU}"
|
||||
check "après redémarrage : même processus QEMU pour t61-d" test "$(pgrep -f "${VOLUMES}/t61-d.qcow2" | sort | tr '\n' ' ')" = "${QEMU_D}"
|
||||
check "après redémarrage : mêmes fichiers sous /run/two, /etc/dnsmasq.d et les volumes (sinon, fichiers en cause)" section_unchanged "${STATE_DIR}/t61.restart" fichiers
|
||||
check "après redémarrage : hôte inchangé (netns, liens, taps, adresses, routes, nftables de pont, iptables, FRR, frr.conf, fichiers, unités)" same_as "${STATE_DIR}/t61.restart" host_state
|
||||
check "après redémarrage : hôte inchangé (netns, liens, taps, adresses, routes, nftables de pont, ip et des netns, FRR, frr.conf, fichiers, unités)" same_as "${STATE_DIR}/t61.restart" host_state
|
||||
check "après redémarrage : l'API rend les mêmes ressources dans le même état" same_as "${STATE_DIR}/t61.api" api_snapshot
|
||||
for rr in 10.255.255.1 10.255.255.2; do
|
||||
check "après redémarrage : session EVPN vers ${rr} établie, jamais coupée" sh -c "vtysh -c 'show bgp neighbors ${rr}' | grep -q 'BGP state = Established' && [ \"\$(vtysh -c 'show bgp neighbors ${rr}' | grep -o 'dropped [0-9]*')\" = \"\$(cat '${STATE_DIR}/t61.${rr}')\" ]"
|
||||
|
|
|
|||
|
|
@ -18,7 +18,7 @@ check "${HOST} : aucune instance DHCP (dhcp@, dnsmasq@) ni de métadonnées (met
|
|||
check "${HOST} : aucun socket de contrôle DHCP" none sh -c "ls /run/two/dhcp/*.sock 2>/dev/null"
|
||||
check "${HOST} : aucun processus QEMU" none pgrep -a qemu-system
|
||||
check "${HOST} : aucune règle nftables de pont qui vise une interface de subnet" none sh -c "nft list ruleset bridge | grep -E 'v-[a-z0-9]'"
|
||||
check "${HOST} : aucune règle iptables qui vise une interface de subnet ou de VPC" none sh -c "iptables-save | grep -E -- '(v-|vp-|tap)[a-z0-9]'"
|
||||
check "${HOST} : aucune règle nftables ip qui vise une interface de subnet ou de VPC" none sh -c "nft list ruleset ip | grep -E -- '(v-|vp-|tap)[a-z0-9]'"
|
||||
check "${HOST} : aucun volume de VM de test" none sh -c "ls '${VOLUMES}'/t[0-9][0-9]-* 2>/dev/null"
|
||||
check "${HOST} : FRR garde la base BGP (témoin)" sh -c "vtysh -c 'show running-config' | grep -q 'peer-group fabric'"
|
||||
check "${HOST} : FRR sans aucune VRF de VPC (en mémoire)" none sh -c "vtysh -c 'show running-config' | grep -E '^(vrf |router bgp [0-9]+ vrf )'"
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue