mirror of
https://gitea.com/gitea/act_runner.git
synced 2026-06-15 14:24:22 +02:00
205af7cd01
## Problem Several runner code paths could drop the **tail** of a step's log output, so a failing (or cancelled) step would show output that is missing its last line(s). This was observed in practice and traced to four independent issues. ## Root causes & fixes ### 1. Trailing line without a newline was never flushed `common.lineWriter` buffers output until it sees a `\n`. A final line **without** a trailing newline (e.g. an error message printed right before a process exits, a panic, `printf` without `\n`) stayed in the internal buffer and was never emitted — the writer exposed no flush at all. - Added `lineWriter.Flush()` (idempotent), a `Flusher` interface, and a `FlushWriter(io.Writer)` helper. - Flush at every stream EOF: the exec copy goroutine, the container `attach()` streaming goroutine, and at step end (`useStepLogger`). ### 2. Cancellation/timeout truncated output `waitForCommand` returned immediately on `ctx.Done()` and abandoned the output-copy goroutine, losing output the command had already produced. It now drains with a bounded grace period before returning. The response channel is buffered so the goroutine can't leak if the drain times out. ### 3. `attach()` raced the final bytes Container output was streamed in a fire-and-forget goroutine that `wait()` did not synchronize with, so the step could proceed before the last bytes were written. `wait()` now blocks on the streaming goroutine (bounded) so output is fully drained and flushed first. ### 4. `::stop-commands::` silently dropped lines from the step log Lines between `::stop-commands::<token>` and its end token were echoed without the `raw_output` field **and** short-circuited the handler chain (`return false`), so they never reached the step log (non-raw entries aren't appended while a step is running). Now returns `true` so they are still captured. Reviewed-on: https://gitea.com/gitea/runner/pulls/1028 Reviewed-by: Zettat123 <39446+zettat123@noreply.gitea.com>
73 lines
1.9 KiB
Go
73 lines
1.9 KiB
Go
// Copyright 2020 The Gitea Authors. All rights reserved.
|
|
// Copyright 2020 The nektos/act Authors. All rights reserved.
|
|
// SPDX-License-Identifier: MIT
|
|
|
|
package common
|
|
|
|
import (
|
|
"io"
|
|
"testing"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
)
|
|
|
|
func TestLineWriter(t *testing.T) {
|
|
lines := make([]string, 0)
|
|
lineHandler := func(s string) bool {
|
|
lines = append(lines, s)
|
|
return true
|
|
}
|
|
|
|
lineWriter := NewLineWriter(lineHandler)
|
|
|
|
assert := assert.New(t)
|
|
write := func(s string) {
|
|
n, err := lineWriter.Write([]byte(s))
|
|
assert.NoError(err) //nolint:testifylint // pre-existing issue from nektos/act
|
|
assert.Equal(len(s), n, s)
|
|
}
|
|
|
|
write("hello")
|
|
write(" ")
|
|
write("world!!\nextra")
|
|
write(" line\n and another\nlast")
|
|
write(" line\n")
|
|
write("no newline here...")
|
|
|
|
assert.Len(lines, 4)
|
|
assert.Equal("hello world!!\n", lines[0])
|
|
assert.Equal("extra line\n", lines[1])
|
|
assert.Equal(" and another\n", lines[2])
|
|
assert.Equal("last line\n", lines[3])
|
|
}
|
|
|
|
func TestLineWriterFlush(t *testing.T) {
|
|
lines := make([]string, 0)
|
|
lineHandler := func(s string) bool {
|
|
lines = append(lines, s)
|
|
return true
|
|
}
|
|
|
|
lineWriter := NewLineWriter(lineHandler)
|
|
|
|
assert := assert.New(t)
|
|
_, err := lineWriter.Write([]byte("complete line\npartial line without newline"))
|
|
assert.NoError(err) //nolint:testifylint // pre-existing pattern from nektos/act
|
|
|
|
// Only the newline-terminated line is emitted before flushing.
|
|
assert.Equal([]string{"complete line\n"}, lines)
|
|
|
|
// Flushing emits the buffered, not-yet-terminated trailing line.
|
|
FlushWriter(lineWriter)
|
|
assert.Equal([]string{"complete line\n", "partial line without newline"}, lines)
|
|
|
|
// Flushing again is a no-op: nothing is buffered.
|
|
FlushWriter(lineWriter)
|
|
assert.Len(lines, 2)
|
|
}
|
|
|
|
func TestFlushWriterIgnoresNonFlusher(t *testing.T) {
|
|
// FlushWriter must be a safe no-op for writers that do not buffer lines.
|
|
assert.NotPanics(t, func() { FlushWriter(io.Discard) })
|
|
}
|