Comment diffuser la sortie d'une commande en temps réel à l'aide de Go ?

Sortie de commande en streaming en ligne

Considérez le code suivant qui exécute une commande et capture sa sortie :

cmdParams := [][]string{
    {filepath.Join(dir, path), "npm", "install"},
    {filepath.Join(pdir, n.path), "gulp"},
}
for _, cp := range cmdParams {
    log.Printf("Starting %s in folder %s...", cp[1:], cp[0])
    cmd := exec.Command(cp[1], cp[2:]...)
    cmd.Dir = cp[0]
    // Wait to finish, get output:
    out, err := cmd.Output()
    if err != nil {
        log.Printf("Error running %s: %v\n", cp[1:], err)
        return
    }
    log.Println("Finished %s, output: %s", cp[1:], out)
}

Ce code capture la sortie complète de la commande et ne l'imprime qu'une fois l'exécution de la commande terminée. Cependant, il est nécessaire de diffuser la sortie en temps réel.

Pour réaliser une diffusion en direct de la sortie, nous pouvons modifier le code comme suit :

cmdParams := [][]string{
    {filepath.Join(dir, path), "npm", "install"},
    {filepath.Join(pdir, n.path), "gulp"},
}
for _, cp := range cmdParams {
    log.Printf("Starting %s in folder %s...", cp[1:], cp[0])
    cmd := exec.Command(cp[1], cp[2:]...)
    cmd.Dir = cp[0]

    stdout, err := cmd.StdoutPipe()
    if err != nil {
        log.Printf("%s cmd.StdoutPipe() error: %v\n", cp[1:], err)
        return
    }
    // Start command:
    if err = cmd.Start(); err != nil {
        log.Printf("%s start error: %v\n", cp[1:], err)
        return
    }

    // Stream command output:
    scanner := bufio.NewScanner(stdout)
    scanner.Split(bufio.ScanRunes)
    for scanner.Scan() {
        fmt.Print(scanner.Text())
    }
    if scanner.Err() != nil {
        log.Printf("Reading %s stdout error: %v\n", cp[1:], err)
        return
    }

    // Get execution success or failure:
    if err = cmd.Wait(); err != nil {
        log.Printf("Error running %s: %v\n", cp[1:], err)
        return
    }
    log.Printf("Finished %s", cp[1:])
}

Voici une explication des modifications :

• cmd.StdoutPipe() crée un tube pour lire le standard de la commande sortie.
• cmd.Start() démarre la commande en arrière-plan.
• bufio.NewScanner(stdout) crée un scanner pour lire à partir du tube stdout.
• scanner. Split(bufio.ScanRunes) configure le scanner pour qu'il lise par runes, fournissant une diffusion en direct.
• Le scanner La boucle Scan() lit et imprime en continu chaque rune (caractère) produite par la commande.
• Une fois la boucle terminée (l'écriture de la commande sur stdout est terminée), scanner.Err() vérifie toute erreur.
• cmd.Wait() attend la fin de la commande et vérifie les erreurs.
• L'instruction finale log.Println() enregistre le résultat de la commande. achèvement.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!