path: root/org/_posts/2022-01-07-démarrer-un-serveur-avant-de-connaître-son-adresse-IP.org

#+options: toc:nil

#+begin_export html
---
layout: default
title: Démarrer un serveur avant de connaître son adresse IP
excerpt: Lorsque vous démarrez votre serveur sur un réseau dynamique, il est possible qu’il démarre avant que l’adresse IP soit connue. Que faire ?
---
#+end_export

C’est un problème qui impacte tous les bidouilleurs à domicile. C’est
déjà suffisamment complexe de configurer sa Bidule Box, mais un
nouveau problème intervient. À la maison, vous avez sans doute une
adresse IP dynamique. C’est-à-dire que si vous débranchez votre
routeur et que vous le rebranchez, vous obtiendrez une nouvelle
adresse IP. Sur ma connexion Escrorange, toutefois, il semble que ce
ne soit le cas que pour IPv4. Malheureusement, cela ne change rien au
problème finalement : lorsque mon ordi démarre, il y a un court laps
de temps pendant lequel le réseau est initialisé, mais je n’ai pas
encore d’adresse IP. Ou alors, je ne les ai pas encore toutes.

Si mon service réseau décide de démarrer à ce moment-là, je me
retrouve bien embarassé : il ne sera tout simplement pas accessible
(ou seulement partiellement), et le problème ne sera peut-être jamais
détecté.

La solution retenue par systemd [[https://access.redhat.com/documentation/en-us/red_hat_enterprise_linux/8/html/configuring_and_managing_networking/systemd-network-targets-and-services_configuring-and-managing-networking][consiste à définir une cible
=network-online.target=]], qui ne sera activée que quand la négociation
des adresses sera terminée. Comme noté sur le site de Red Hat, cette
solution n’est utile que pour le démarrage du système. En cas de panne
temporaire du réseau sans redémarrage de la machine, il n’y aura pas
de redémarrage du service. Malgré cette limitation, la solution
s’applique à tous les services nécessitant de se lier au réseau. Mais
peut-être est-il possible de concevoir mieux chaque service, afin que
le problème ne se pose pas ?

Nous allons aujourd’hui voir comment il est possible de concevoir le
service réseau de sorte à ce qu’il puisse réagir à la présence d’une
nouvelle adresse IP à lier, ou à la disparition d’une adresse
utilisée.

* Dites bonjour :)
Nous allons concevoir un serveur très simple : il lui est donné comme
configuration un nom de domaine et un nom de service, et il se liera à
toutes les adresses connues de ce domaine, selon le protocole TCP,
dont le port correspond au service. Lorsqu’un client se connectera, on
enverra "Bonjour :)" et on terminera la connexion.

Comme on s’attend à ce qu’il y ait plusieurs adresses IP à lier, il y
aura donc plusieurs sockets à surveiller en même temps. Il y a de
bonnes API pour faire cela, comme par exemple [[https://en.wikipedia.org/wiki/Epoll][epoll]], mais nous allons
nous contenter de la fonction =select= car elle est disponible
directement en guile.

#+name: classe-serveur
#+caption: classe-serveur : définition de la classe serveur
#+begin_src scheme :eval no
  (define-class <serveur> ()
    (sockets #:init-value '())
    (hôte #:init-keyword #:hôte #:init-thunk gethostname)
    (service #:init-keyword #:service #:init-value "12345"))
#+end_src

Le nom de l’hôte et le nom du service sont des constantes pour cette
classe. En effet, il serait trop complexe de gérer plusieurs noms
d’hôtes différents. La valeur par défaut du nom d’hôte est le nom de
l’ordinateur (que l’on considère comme dynamique, même s’il serait
assez incongru qu’il change sans que les adresses IP associées
suivent). La valeur par défaut du service, en revanche, est
arbitraire, et c’est au développeur de la fixer.

* Relier le serveur en cas de besoin
Nous pouvons définir une méthode, =relier=, qui s’occupera de
récupérer la liste des adresses IP pour l’hôte, afin de fermer les
sockets obsolètes et d’en lier de nouvelles pour les nouvelles
adresses. Il ne faudrait pas fermer les sockets qui sont toujours
valides, autrement les connexions en attente seraient rejetées.

Par choix, nous allons éviter de faire trop de mutations dans notre
API. La fonction retournera donc deux valeurs : un nouveau serveur, et
la liste des sockets obsolètes. Charge à l’utilisateur de l’API de les
fermer.

#+name: fonction-relier
#+caption: fonction-relier : mettre à jour la liste des sockets à lier
#+begin_src scheme :eval no
  (define-method (relier (serveur <serveur>))
    (define (index adresse)
      ;; retourne une valeur d’index pour adresse, comparable avec
      ;; equal?
      (list
       (sockaddr:fam adresse)
       (sockaddr:path adresse)
       (sockaddr:addr adresse)
       (sockaddr:port adresse)))
    (define tcp
      (protoent:proto (getprotobyname "tcp")))
    (let ((sockets-existantes
           (make-hash-table))
          (nouveau-serveur (shallow-clone serveur)))
      (for-each
       (lambda (socket)
         (let ((adresse (getsockname socket)))
           (hash-set! sockets-existantes
                      ;; On ne peut pas utiliser les adresses telles
                      ;; quelles, sinon equal? ne fonctionnera pas.
                      (index adresse)
                      socket)))
       (slot-ref serveur 'sockets))
      (slot-set!
       nouveau-serveur 'sockets
       (map
        (lambda (info-adresse)
          (let ((adresse (addrinfo:addr info-adresse)))
            (let ((existante
                   (hash-ref sockets-existantes
                             (index adresse))))
              (if existante
                  (begin
                    (hash-remove! sockets-existantes (index adresse))
                    existante)
                  ;; Nouvelle adresse
                  (let ((s (socket (addrinfo:fam info-adresse)
                                   (addrinfo:socktype info-adresse)
                                   (addrinfo:protocol info-adresse))))
                    (bind s adresse)
                    (listen s 10)
                    s)))))
        (getaddrinfo (slot-ref serveur 'hôte)
                     (slot-ref serveur 'service)
                     (logior AI_PASSIVE)
                     0 ;; Famille
                     SOCK_STREAM ;; Avec connexion
                     tcp)))
      (values nouveau-serveur
              (map cdr (hash-map->list cons sockets-existantes)))))

#+end_src

La fonction construit une table de hachage qui retient la liste des
sockets, indexée par l’adresse de la socket. Puisque les adresses IP
sont converties en nombre par guile, la fonction de comparaison
=equal?= permet de retrouver les adresses nécessaires pour satisfaire
=getaddrinfo=.

Par souci de facilité, nous allons appeler directement la fonction
=relier= dans la méthode d’initialisation de la classe de serveur.

#+name: initialisation-serveur
#+caption: initialisation-serveur : initialisation de la classe <serveur>
#+begin_src scheme :eval no
  (define-method (initialize (object <serveur>) initargs)
    (next-method)
    (receive (serveur _)
        (relier object)
      (slot-set! object 'sockets
                 (slot-ref serveur 'sockets))))
#+end_src

On commence bien sûr par appeler =(next-method)=, de sorte à définir
les champs hôte et service grâce à la méthode d’initialisation par
défaut, qui ne se fonde que sur la définition des slots. Il est
possible de détourner cette garantie en utilisant de l’héritage
multiple, mais nous supposerons que l’initialisation pour la classe
fille d’un héritage multiple ne fait pas directement appel à
=(next-method)=, ce qui fera disparaître le problème.

* Utilisons =select=

Comme nous allons utiliser la fonction select, nous devons être en
mesure d’obtenir la liste des ports ou descripteurs de fichiers à
surveiller. On peut simplement retourner la valeur du champ sockets
ici.

#+name: fonction-ports
#+caption: fonction-ports : retourne la liste des ports à surveiller
#+begin_src scheme :eval no
  (define-method (ports (serveur <serveur>))
    (values
     ;; Liste des ports dont on doit surveiller la lecture
     (slot-ref serveur 'sockets)
     ;; Liste des ports dont on attend l’écriture
     '()
     ;; Liste des ports dont on attend une erreur
     '()))
#+end_src

Enfin, lorsque la fonction select aura indiqué un port disponible en
lecture, nous devons agir. En l’occurence, il faut accepter le nouveau
client, lui envoyer le bonjour, et fermer la socket du client. En
revanche, si la socket ne fait pas partie du serveur, il ne faut rien
faire.

#+name: fonction-prête
#+caption: fonction-prête : agit lorsqu’un port est prêt
#+begin_src scheme :eval no
  (define-method (prête (serveur <serveur>) socket direction)
    (when (port? socket)
      (set! socket (port->fdes socket)))
    (for-each
     (lambda (socket-serveur)
       (when (and (eq? direction 'lire)
                  (eqv? (port->fdes socket-serveur) socket))
         (let ((client (accept socket-serveur)))
           (let ((port (car client))
                 (adresse (cdr client)))
             (format port "Bonjour ~a :)\n"
                     (inet-ntop (sockaddr:fam adresse)
                                (sockaddr:addr adresse)))
             (close-port port)))))
     (slot-ref serveur 'sockets))
    serveur)
#+end_src

* Le programme à exécuter
Nous pouvons maintenant exécuter [[file:../../../code/bonjour.scm]] :

#+begin_src scheme :eval no :tangle ../bonjour.scm :noweb no-export #:shebang "#!/usr/local/bin/guile"
  (use-modules (oop goops) (ice-9 receive) (ice-9 match)
               (srfi srfi-19))

  <<classe-serveur>>
  <<fonction-relier>>
  <<initialisation-serveur>>
  <<fonction-ports>>
  <<fonction-prête>>

  (define (main serveur)
    (format #t "~a : le serveur lie les adresses suivantes : ~a\n"
            (date->string (current-date))
            (map
             (lambda (socket)
               (let ((adresse (getsockname socket)))
                 (let ((adresse
                        (inet-ntop (sockaddr:fam adresse) (sockaddr:addr adresse)))
                       (port
                        (sockaddr:port adresse)))
                   (format #f "[~a]:~a" adresse port))))
             (slot-ref serveur 'sockets)))
    (receive (read write except) (ports serveur)
      (match (select read write except 60)
        ((read write except)
         (let traiter ((serveur serveur)
                       (tâches
                        (append
                            (map (lambda (socket)
                                   `(,socket lire))
                                 read)
                            (map (lambda (socket)
                                   `(,socket écrire))
                                 write)
                            (map (lambda (socket)
                                   `(,socket exception))
                                 except))))
           (match tâches
             (()
              (receive (serveur à-fermer) (relier serveur)
                (for-each close-port à-fermer)
                (main serveur)))
             (((socket direction) tâches-restantes ...)
              (traiter (prête serveur socket direction)
                       tâches-restantes))))))))

  (main (make <serveur>))
#+end_src

Ce programme vérifie toutes les 60 secondes (dans le pire des cas) que
les adresses à lier sont à jour, et sert tous les clients qui se
présentent en leur répondant « Bonjour :) ».

Il y a beaucoup de choses à améliorer. Pour commencer, il faudrait
utiliser autre chose que =select=, qui a une complexité temporelle
linéaire et qui ne gère qu’un nombre limité de clients. Nous avons
aussi une complexité linéaire pour vérifier si la socket est rattachée
au serveur, et donc quadratique pour un appel récursif de =main=. Il
faudrait utiliser =epoll=, ou une bibliothèque de gestion du réseau
plus haut niveau comme la GLib, et revoir notre code. Il faudrait
également utiliser getopt-long (en internationalisant les noms longs
d’options) pour choisir le nom d’hôte à lier. Enfin, exécuter
=getaddrinfo= à chaque fois que l’on sert un groupe de clients n’est
pas très pertinent, et attendre 60 secondes peut être long. Pour
détecter les situations où nous devrions relier le serveur, il va
falloir utiliser l’API Netlink, ce que nous ferons une prochaine fois.