Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
33 changes: 26 additions & 7 deletions e2e/framework/exec.go
Original file line number Diff line number Diff line change
Expand Up @@ -5,13 +5,13 @@ import (
"context"
"encoding/json"
"fmt"
"io"
"os"
"os/exec"
"path/filepath"
"strings"
"time"

"github.com/devsy-org/devsy/e2e/framework/internal/livetee"
"github.com/devsy-org/devsy/pkg/docker"
)

Expand All @@ -29,10 +29,16 @@ func (f *Framework) ExecCommandOutput(ctx context.Context, args []string) (strin
cmd := exec.CommandContext(ctx, filepath.Join(f.DevsyBinDir, f.DevsyBinName), args...)
docker.PrepareForGroupCancellation(cmd)
cmd.WaitDelay = execWaitDelay
cmd.Stdout = io.MultiWriter(os.Stdout, &execOut)
outTee := livetee.New(&execOut, os.Stdout)
cmd.Stdout = outTee
cmd.Stderr = os.Stderr

if err := cmd.Run(); err != nil {
err := cmd.Run()
f.liveStdoutDropped.Add(outTee.Close())
if err != nil {
if ctx.Err() != nil {
return execOut.String(), ctx.Err()
}
return "", err
}

Expand Down Expand Up @@ -67,10 +73,16 @@ func (f *Framework) ExecCommandContaining(
cmd := exec.CommandContext(ctx, filepath.Join(f.DevsyBinDir, f.DevsyBinName), args...)
docker.PrepareForGroupCancellation(cmd)
cmd.WaitDelay = execWaitDelay
cmd.Stdout = io.MultiWriter(os.Stdout, &execOut)
outTee := livetee.New(&execOut, os.Stdout)
cmd.Stdout = outTee
cmd.Stderr = os.Stderr

if err := cmd.Run(); err != nil {
err := cmd.Run()
f.liveStdoutDropped.Add(outTee.Close())
if err != nil {
if ctx.Err() != nil {
return ctx.Err()
}
return err
}

Expand All @@ -91,10 +103,17 @@ func (f *Framework) ExecCommandCapture(ctx context.Context, args []string) (stri
cmd := exec.CommandContext(ctx, filepath.Join(f.DevsyBinDir, f.DevsyBinName), args...)
docker.PrepareForGroupCancellation(cmd)
cmd.WaitDelay = execWaitDelay
cmd.Stdout = io.MultiWriter(os.Stdout, &execOut)
cmd.Stderr = io.MultiWriter(os.Stderr, &execErr)
outTee := livetee.New(&execOut, os.Stdout)
cmd.Stdout = outTee
errTee := livetee.New(&execErr, os.Stderr)
cmd.Stderr = errTee

err := cmd.Run()
f.liveStdoutDropped.Add(outTee.Close())
f.liveStderrDropped.Add(errTee.Close())
if err != nil && ctx.Err() != nil {
err = ctx.Err()
}
return execOut.String(), execErr.String(), err
}

Expand Down
107 changes: 107 additions & 0 deletions e2e/framework/exec_capture_test.go
Original file line number Diff line number Diff line change
@@ -0,0 +1,107 @@
package framework

import (
"context"
"fmt"
"io"
"os"
"os/exec"
"path/filepath"
"strings"
"testing"
"time"

"github.com/stretchr/testify/suite"
)

func TestCaptureChild(t *testing.T) {
switch os.Getenv("DEVSY_CAPTURE_CHILD") {
case "exit":
_, _ = fmt.Fprint(os.Stdout, "stdout")
_, _ = fmt.Fprint(os.Stderr, "stderr")
os.Exit(3)
case "blocked":
_, _ = fmt.Fprint(os.Stdout, strings.Repeat("x", 2<<20))
_, _ = fmt.Fprint(os.Stderr, "ready")
time.Sleep(time.Minute)
os.Exit(0)
}
}

type captureSuite struct{ suite.Suite }

func TestCaptureSuite(t *testing.T) { suite.Run(t, new(captureSuite)) }
func (s *captureSuite) TestExit() {
s.T().Setenv("DEVSY_CAPTURE_CHILD", "exit")
out, stderr, err := s.framework().
ExecCommandCapture(context.Background(), []string{"-test.run=^TestCaptureChild$"})
var exit *exec.ExitError
s.Require().ErrorAs(err, &exit)
s.Equal(3, exit.ExitCode())
s.Equal("stdout", out)
s.Equal("stderr", stderr)
}

func (s *captureSuite) TestBlockedLiveOutput() {
s.T().Setenv("DEVSY_CAPTURE_CHILD", "blocked")
outRead, outWrite, err := os.Pipe()
s.Require().NoError(err)
errRead, errWrite, err := os.Pipe()
s.Require().NoError(err)
oldOut, oldErr := os.Stdout, os.Stderr
os.Stdout, os.Stderr = outWrite, errWrite
defer func() {
os.Stdout, os.Stderr = oldOut, oldErr
_ = outRead.Close()
_ = outWrite.Close()
_ = errRead.Close()
_ = errWrite.Close()
}()
f := s.framework()
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
type result struct {
out, stderr string
err error
}
done := make(chan result, 1)
go func() {
out, stderr, err := f.ExecCommandCapture(ctx, []string{"-test.run=^TestCaptureChild$"})
done <- result{out, stderr, err}
}()
ready := make(chan error, 1)
go func() {
b := make([]byte, 5)
_, err := io.ReadFull(errRead, b)
if err == nil && string(b) != "ready" {
err = fmt.Errorf("unexpected stderr %q", b)
}
ready <- err
}()
select {
case err := <-ready:
s.Require().NoError(err)
case <-time.After(15 * time.Second):
s.FailNow("child did not complete output")
}
cancel()
select {
case got := <-done:
s.ErrorIs(got.err, context.Canceled)
s.Equal(strings.Repeat("x", 2<<20), got.out)
s.Equal("ready", got.stderr)
dropped, _ := f.LiveOutputDropped()
s.Positive(dropped)
case <-time.After(40 * time.Second):
s.FailNow("capture did not return")
}
}

func (s *captureSuite) framework() *Framework {
executable, err := os.Executable()
s.Require().NoError(err)
return &Framework{
DevsyBinDir: filepath.Dir(executable),
DevsyBinName: filepath.Base(executable),
}
}
11 changes: 9 additions & 2 deletions e2e/framework/framework.go
Original file line number Diff line number Diff line change
Expand Up @@ -2,11 +2,14 @@ package framework

import (
"runtime"
"sync/atomic"
)

type Framework struct {
DevsyBinDir string
DevsyBinName string
DevsyBinDir string
DevsyBinName string
liveStdoutDropped atomic.Int64
liveStderrDropped atomic.Int64
}

func NewDefaultFramework(path string) *Framework {
Expand All @@ -33,3 +36,7 @@ func NewDefaultFramework(path string) *Framework {

return &Framework{DevsyBinDir: path, DevsyBinName: binName}
}

func (f *Framework) LiveOutputDropped() (int64, int64) {
return f.liveStdoutDropped.Load(), f.liveStderrDropped.Load()
}
93 changes: 93 additions & 0 deletions e2e/framework/internal/livetee/tee.go
Original file line number Diff line number Diff line change
@@ -0,0 +1,93 @@
package livetee

import (
"io"
"sync"
"time"
)

const (
chunkSize = 8 << 10
queueChunks = 128
drainTimeout = 100 * time.Millisecond
)

type Tee struct {
capture io.Writer
chunks chan []byte
done chan struct{}
mu sync.Mutex
queued int64
dropped int64
stopped bool
}

func New(capture, live io.Writer) *Tee {
t := &Tee{capture: capture}
if live != nil {
t.chunks = make(chan []byte, queueChunks)
t.done = make(chan struct{})
go t.run(live)
}
return t
}

func (t *Tee) Write(p []byte) (int, error) {
n, err := t.capture.Write(p)
if t.chunks == nil {
return n, err
}
for remaining := p[:n]; len(remaining) > 0; {
size := min(len(remaining), chunkSize)
chunk := make([]byte, size)
copy(chunk, remaining[:size])
t.mu.Lock()
select {
case t.chunks <- chunk:
t.queued += int64(size)
default:
t.dropped += int64(size)
}
t.mu.Unlock()
remaining = remaining[size:]
}
return n, err
}

func (t *Tee) Close() int64 {
if t.chunks != nil {
close(t.chunks)
timer := time.NewTimer(drainTimeout)
defer timer.Stop()
select {
case <-t.done:
case <-timer.C:
t.mu.Lock()
t.stopped = true
t.dropped += t.queued
t.queued = 0
t.mu.Unlock()
}
Comment thread
skevetter marked this conversation as resolved.
Resolved
}
t.mu.Lock()
defer t.mu.Unlock()
return t.dropped
}

func (t *Tee) run(live io.Writer) {
defer close(t.done)
for chunk := range t.chunks {
t.mu.Lock()
if t.stopped {
t.mu.Unlock()
return
}
t.queued -= int64(len(chunk))
t.mu.Unlock()
n, _ := live.Write(chunk)
n = max(0, min(n, len(chunk)))
t.mu.Lock()
t.dropped += int64(len(chunk) - n)
t.mu.Unlock()
}
}
82 changes: 82 additions & 0 deletions e2e/framework/internal/livetee/tee_test.go
Original file line number Diff line number Diff line change
@@ -0,0 +1,82 @@
package livetee

import (
"bytes"
"io"
"sync/atomic"
"testing"
"time"

"github.com/stretchr/testify/suite"
)

type teeSuite struct{ suite.Suite }

func TestTeeSuite(t *testing.T) { suite.Run(t, new(teeSuite)) }

type blockedWriter struct {
entered chan struct{}
release chan struct{}
writes atomic.Int64
}

func (w *blockedWriter) Write(p []byte) (int, error) {
w.writes.Add(1)
select {
case <-w.entered:
default:
close(w.entered)
}
<-w.release
return len(p), nil
}

func (s *teeSuite) TestBlockedDropsAndReleases() {
w := &blockedWriter{entered: make(chan struct{}), release: make(chan struct{})}
var captured bytes.Buffer
tee := New(&captured, w)
_, err := tee.Write([]byte("first"))
s.Require().NoError(err)
select {
case <-w.entered:
case <-time.After(5 * time.Second):
s.FailNow("writer not entered")
}
payload := bytes.Repeat([]byte("x"), (queueChunks+2)*chunkSize)
_, err = tee.Write(payload)
s.Require().NoError(err)
s.Equal(int64((queueChunks+2)*chunkSize), tee.Close())
s.Equal(append([]byte("first"), payload...), captured.Bytes())
close(w.release)
select {
case <-tee.done:
s.Equal(int64(1), w.writes.Load())
case <-time.After(5 * time.Second):
s.FailNow("writer did not finish")
}
}

func (s *teeSuite) TestLiveOrder() {
var captured, live bytes.Buffer
tee := New(&captured, &live)
for _, part := range []string{"one", "two", "three"} {
_, err := tee.Write([]byte(part))
s.Require().NoError(err)
}
s.Zero(tee.Close())
s.Equal("onetwothree", captured.String())
s.Equal(captured.String(), live.String())
}

type shortWriter struct{}

func (shortWriter) Write(p []byte) (int, error) { return len(p) / 2, io.ErrShortWrite }

func (s *teeSuite) TestShortWriteCountsDroppedBytes() {
var captured bytes.Buffer
tee := New(&captured, shortWriter{})
_, err := tee.Write([]byte("123456"))
s.Require().NoError(err)
s.Equal(int64(3), tee.Close())
s.Equal("123456", captured.String())
}
Loading
Loading