Instruction select

Fait partie de la section Programmation Orientée Objet du Journey GO de Coddy. Leçon 62 sur 107.

L’instruction select permet à une goroutine d’attendre simultanément plusieurs opérations sur des canaux. Elle ressemble à une instruction switch, mais chaque cas implique l’envoi ou la réception sur un canal. Lorsque plusieurs canaux sont prêts, select en choisit un au hasard.

func main() {
    ch1 := make(chan string)
    ch2 := make(chan string)
    
    go func() { ch1 <- "from channel 1" }()
    go func() { ch2 <- "from channel 2" }()
    
    select {
    case msg1 := <-ch1:
        fmt.Println(msg1)
    case msg2 := <-ch2:
        fmt.Println(msg2)
    }
}

Sans select, la réception depuis ch1 serait bloquée jusqu’à l’arrivée des données, ce qui pourrait entraîner la perte de données sur ch2. Avec select, le canal qui reçoit des données en premier est traité.

Le cas default rend select non bloquant. Il s’exécute immédiatement si aucun canal n’est prêt :

select {
case msg := <-messages:
    fmt.Println("Received:", msg)
default:
    fmt.Println("No message available")
}

Un schéma courant combine select avec des délais d’expiration à l’aide de time.After, qui renvoie un canal recevant une valeur après la durée spécifiée :

select {
case result := <-ch:
    fmt.Println("Got result:", result)
case <-time.After(2 * time.Second):
    fmt.Println("Timeout!")
}

Cela empêche votre programme d’attendre indéfiniment lorsqu’une opération sur un canal pourrait ne jamais se terminer.

Défi

Facile

Construisons un moniteur de services qui utilise l’instruction select pour gérer plusieurs sources de données simultanées. Votre moniteur écoutera différents canaux de services simultanément et réagira de manière appropriée lorsque des données arrivent ou lorsqu’aucune mise à jour n’est disponible.

Vous organiserez votre code sur deux fichiers :

monitor.go : définissez votre logique de surveillance des services avec une gestion des canaux basée sur select.
Créez une structure ServiceUpdate avec des champs Name (string) et Status (string).

Implémentez une fonction Monitor qui accepte trois canaux : primary chan ServiceUpdate, backup chan ServiceUpdate et done chan bool. Cette fonction doit utiliser select pour écouter simultanément les trois canaux :
- Lors de la réception depuis primary : renvoyer la chaîne formatée Primary: [Name] is [Status]
- Lors de la réception depuis backup : renvoyer la chaîne formatée Backup: [Name] is [Status]
- Lors de la réception depuis done : renvoyer Monitoring stopped
Implémentez une fonction CheckStatus qui accepte un seul canal updates chan ServiceUpdate et utilise select avec un cas default pour effectuer une vérification non bloquante :
- Si une mise à jour est disponible : renvoyer Update available: [Name]
- Si aucune mise à jour n’est disponible (cas par défaut) : renvoyer No updates pending
main.go : configurez les canaux et présentez le comportement de select bloquant et non bloquant.
Lisez un mode depuis l’entrée afin de déterminer quel scénario exécuter : primary, backup, stop ou check.

Pour les modes primary, backup et stop : lisez également un nom de service et son état. Créez les trois canaux, lancez une goroutine qui envoie des données au canal approprié en fonction du mode, puis appelez Monitor et affichez son résultat.

Pour le mode check : lisez un nom de service et son état, ainsi qu’un indicateur (send ou nosend) précisant s’il faut envoyer des données avant la vérification. Créez un canal tamponné d’une capacité de 1. Si l’indicateur vaut send, envoyez une mise à jour au canal avant d’appeler CheckStatus. Affichez le résultat de CheckStatus.

Les entrées suivantes seront fournies :

Ligne 1 : mode (primary, backup, stop ou check)
Ligne 2 : nom du service
Ligne 3 : état du service
Ligne 4 (uniquement pour le mode check) : send ou nosend

Par exemple, avec :

primary
Database
healthy

Votre sortie doit être :

Primary: Database is healthy

Et avec :

check
Cache
active
nosend

Votre sortie doit être :

No updates pending

Essayez vous-même

package main

import (
	"fmt"
)

func main() {
	var mode string
	fmt.Scanln(&mode)

	var serviceName string
	fmt.Scanln(&serviceName)

	var serviceStatus string
	fmt.Scanln(&serviceStatus)

	// TODO: Gérer les différents modes : "primary", "backup", "stop", "check"
	
	// Pour les modes "primary", "backup", "stop" :
	// - Créer trois canaux : primary, backup, done
	// - Lancer une goroutine qui envoie des données au canal approprié
	// - Appeler Monitor et afficher le résultat
	
	// Pour le mode "check" :
	// - Lire le flag supplémentaire ("send" ou "nosend")
	// - Créer un canal bufferisé d'une capacité de 1
	// - Si le flag est "send", envoyer une mise à jour au canal
	// - Appeler CheckStatus et afficher le résultat
	
}