add: run video in pipe

internal/pipespy/pipespy.go

@@ -0,0 +1,159 @@
+// Package pipespy provides a structure which connects multiple things, forwarding data, but also
+// calling a helper in the middle to spy.
+package pipespy
+
+import (
+	"errors"
+	"fmt"
+	"io"
+	"os/exec"
+	"sync"
+
+	"github.com/rs/zerolog/log"
+)
+
+type process interface {
+	// Sets the stdin.
+	SetStdin(io.Reader)
+	// Sets the stdout.
+	SetStdout(io.Writer)
+
+	// Start the process; should block until the process completes, then free Stdin and Stdout.
+	Run() error
+}
+
+type CmdWrap struct {
+	cmd *exec.Cmd
+}
+
+func NewCmd(cmd *exec.Cmd) *CmdWrap {
+	return &CmdWrap{
+		cmd: cmd,
+	}
+}
+
+func (s *CmdWrap) SetStdin(r io.Reader) {
+	s.cmd.Stdin = r
+}
+
+func (s *CmdWrap) SetStdout(w io.Writer) {
+	s.cmd.Stdout = w
+}
+
+func (s *CmdWrap) Run() error {
+	if err := s.cmd.Start(); err != nil {
+		return fmt.Errorf("failed to start command: %w", err)
+	}
+	return s.cmd.Wait()
+}
+
+type wrap struct {
+	proc process
+
+	writeCloser io.WriteCloser
+}
+
+func (s *wrap) SetStdin(r io.ReadCloser) {
+	s.proc.SetStdin(r)
+}
+
+func (s *wrap) SetStdout(w io.WriteCloser) {
+	s.writeCloser = w
+	s.proc.SetStdout(w)
+}
+
+func (s *wrap) Run() error {
+	defer s.writeCloser.Close()
+	return s.proc.Run()
+}
+
+type Pipe struct {
+	processOrder []*Spy
+}
+
+func New() *Pipe {
+	return &Pipe{}
+}
+
+// Add a process to the pipeline. Use the returned spy object to snoop on it.
+// Snoop must be called before Start; will panic otherwise.
+func (p *Pipe) Add(proc process) *Spy {
+	w := &wrap{
+		proc: proc,
+	}
+	piperReader, pipeWriter := io.Pipe()
+	w.SetStdout(pipeWriter)
+	spy := &Spy{
+		stdIn: piperReader,
+		proc:  w,
+	}
+	p.processOrder = append(p.processOrder, spy)
+	if l := len(p.processOrder) - 1; l > 0 {
+		p.processOrder[l].proc.SetStdin(p.processOrder[l-1].Snoop())
+	}
+	return spy
+}
+
+// Starts the pipeline; there is a Go routine created to ensure readers dont stall.
+// Make sure to kill the processes, which will cause EOF to propegate. The returned
+// function can be used to wait for all to cleanly exit.
+func (p *Pipe) Start() func() []error {
+	errorCh := make(chan error, len(p.processOrder))
+	wg := sync.WaitGroup{}
+	wg.Add(len(p.processOrder))
+	for _, s := range p.processOrder {
+		s.running = true
+		go func(s *Spy) {
+			defer wg.Done()
+			buff := make([]byte, 128)
+			var err error
+			for n := 1; err == nil || n == 0; _, err = s.stdIn.Read(buff) {
+				// do nothing
+			}
+			if !errors.Is(err, io.EOF) {
+				log.Warn().Err(err).Msg("unexpected error from reader")
+			}
+		}(s)
+		go func(s *Spy) {
+			if err := s.proc.Run(); err != nil {
+				errorCh <- err
+			}
+
+			// will this cause some writes to get lost? is that a problem?
+			for _, closer := range s.closers {
+				if err := closer(); err != nil {
+					log.Warn().Err(err).Msg("error closing pipe")
+				}
+			}
+		}(s)
+	}
+	return func() []error {
+		wg.Wait()
+		close(errorCh)
+		var errs []error
+		for err := range errorCh {
+			errs = append(errs, err)
+		}
+		return errs
+
+	}
+}
+
+type Spy struct {
+	stdIn   io.Reader
+	closers []func() error
+	proc    *wrap
+	running bool
+}
+
+// Snoop on the Stdout of the process being spied; reader will recieve a copy of the bytes.
+func (s *Spy) Snoop() io.ReadCloser {
+	if s.running {
+		panic("Call to snoop on a running process")
+	}
+	pipeReader, pipeWriter := io.Pipe()
+	s.closers = append(s.closers, pipeWriter.Close)
+	r := io.TeeReader(s.stdIn, pipeWriter)
+	s.stdIn = r
+	return pipeReader
+}

internal/pipespy/pipespy_test.go

@@ -0,0 +1,115 @@
+package pipespy_test
+
+import (
+	"errors"
+	"fmt"
+	"io"
+	"sync"
+	"testing"
+
+	"github.com/chathaway-codes/home-sensors/v2/internal/pipespy"
+	"github.com/google/go-cmp/cmp"
+)
+
+func TestPipeSpy(t *testing.T) {
+	pipe := pipespy.New()
+
+	readPipe, writerPipe := io.Pipe()
+	stage1 := &simpleWriter{t: t, stdIn: readPipe}
+	stage2 := &simpleWriter{t: t}
+
+	stdOut1 := pipe.Add(stage1).Snoop()
+	stdOut2 := pipe.Add(stage2).Snoop()
+	pipe.Add(&simpleWriter{t: t})
+
+	// Spawn threads to keep reading the snoop
+	var buff1, buff2 []byte
+	var err1, err2 error
+	var wg sync.WaitGroup
+	wg.Add(2)
+	go func() {
+		defer wg.Done()
+		buff1, err1 = io.ReadAll(stdOut1)
+		if errors.Is(err1, io.EOF) {
+			err1 = nil
+		}
+	}()
+	go func() {
+		defer wg.Done()
+		buff2, err2 = io.ReadAll(stdOut2)
+		if errors.Is(err2, io.EOF) {
+			err2 = nil
+		}
+	}()
+
+	wait := pipe.Start()
+
+	msg := "This is a message!"
+	fmt.Fprint(writerPipe, msg)
+	if err := writerPipe.Close(); err != nil {
+		t.Fatalf("failed to close pipe: %v", err)
+	}
+
+	wait()
+	wg.Wait()
+
+	if err1 != nil || err2 != nil {
+		t.Errorf("Got errs %v and %v; want nil or EOF", err1, err2)
+	}
+
+	if diff := cmp.Diff(string(buff1), msg); diff != "" {
+		t.Errorf("got diff:\n%s", diff)
+	}
+	if diff := cmp.Diff(string(buff2), msg); diff != "" {
+		t.Errorf("got diff:\n%s", diff)
+	}
+}
+
+func TestPipeSpyError(t *testing.T) {
+	readPipe, writerPipe := io.Pipe()
+	pipe := pipespy.New()
+	pipe.Add(&simpleWriter{t: t, stdIn: readPipe})
+	pipe.Add(&simpleWriter{t: t, err: fmt.Errorf("this is an error")})
+	pipe.Add(&simpleWriter{t: t})
+
+	wait := pipe.Start()
+	if _, err := fmt.Fprintf(writerPipe, "Hello"); err != nil {
+		t.Fatalf("error: %v", err)
+	}
+	writerPipe.Close()
+
+	errs := wait()
+
+	if len(errs) != 1 {
+		t.Errorf("Expected 1 err; got %d", len(errs))
+	}
+}
+
+type simpleWriter struct {
+	stdIn   io.Reader
+	stdOut  io.Writer
+	gotData []byte
+	err     error
+	t       *testing.T
+}
+
+func (s *simpleWriter) SetStdin(r io.Reader) {
+	s.stdIn = r
+}
+
+func (s *simpleWriter) SetStdout(w io.Writer) {
+	s.stdOut = w
+}
+
+func (s *simpleWriter) Run() error {
+	if s.err != nil {
+		return s.err
+	}
+	bytes, err := io.ReadAll(s.stdIn)
+	if err != nil && !errors.Is(err, io.EOF) {
+		s.t.Errorf("Unexpected err: %v", err)
+	}
+	s.gotData = bytes
+	s.stdOut.Write(bytes)
+	return nil
+}