Егор Смоляков

package main

import (
	"bufio"
	"fmt"
	"io"
	"log"
	"os"
	"os/exec"
)

var done chan bool

type Executor struct {
	wr io.Writer
}

func (e *Executor) SetStdout(w io.Writer) {
	e.wr = w
}

func (e *Executor) Exec() error {
	cmd := exec.Command("ls", "/etc")
	cmd.Stdout = e.wr
	err := cmd.Run()
	return err
}

func send(lines []string) {
	w := bufio.NewWriter(os.Stdout)
	for i := 0; i < len(lines); i++ {
		w.WriteString(lines[i] + "\n")
	}
	w.Flush()
}

const cnt = 3

func main() {
	// create a pipe
	reader, writer := io.Pipe()

	e := &Executor{}
	e.SetStdout(writer)

	go func() {
		lines := make([]string, 0, cnt)
		scanner := bufio.NewScanner(reader)
		linesCnt := 0
		for scanner.Scan() {
			line := scanner.Text()
			// fmt.Println(`out:`, line)

			lines = append(lines, line)

			linesCnt++
			if linesCnt >= cnt {
				linesCnt = 0
				send(lines)
				lines = lines[:0] // clear
			}
		}

		if err := scanner.Err(); err != nil {
			fmt.Fprintln(os.Stderr, "reading standard input:", err)
		}

		if len(lines) > 0 {
			send(lines)
		}
	}()

	err := e.Exec()
	if err != nil {
		log.Fatal(err)
	}
	log.Println("Exec finished!")
}

package main

import (
    "bufio"
    "bytes"
    "fmt"
    "io"
    "log"
    "os/exec"
)

type Executor struct {
    wr io.Writer
}

func (e *Executor) SetStdout(w io.Writer) {
    e.wr = w
}

func (e *Executor) Exec() error {
    cmd := exec.Command("ls", "/etc")
    cmd.Stdout = e.wr
    err := cmd.Run()
    return err
}

type BufferedBrokerWriter struct {
    buffer  bytes.Buffer
    scanner *bufio.Scanner
}

func NewBufferedBrokerWriter() *BufferedBrokerWriter {
    bw := &BufferedBrokerWriter{}
    bw.scanner = bufio.NewScanner(&bw.buffer)
    return bw
}

func (bw *BufferedBrokerWriter) Write(p []byte) (int, error) {
    return bw.buffer.Write(p)
}

func (bw *BufferedBrokerWriter) ReadLines(cnt uint) ([]string, error) {
    lines := make([]string, 0, cnt)
    linesCnt := uint(0)

    for bw.scanner.Scan() {
        line := bw.scanner.Text()
        err := bw.scanner.Err()
        if err != nil || line == `` {
            return lines, err
        }

        lines = append(lines, line)
        linesCnt++
        if linesCnt >= cnt {
            return lines, nil
        }
    }

    return nil, io.EOF
}

func main() {
    // подключаетесь к вашему брокеру сообщений,

    bw := NewBufferedBrokerWriter()

    e := &Executor{}
    e.SetStdout(bw)

    err := e.Exec()
    if err != nil {
        log.Fatal(err)
    }

    for {
        lines, err := bw.ReadLines(2)
        if err == io.EOF {
            break
        }
        fmt.Printf("Lines:\n%+v\n\n", lines)
    }
}