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>
81 lines
1.8 KiB
Go
81 lines
1.8 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 (
|
|
"bytes"
|
|
"io"
|
|
)
|
|
|
|
// LineHandler is a callback function for handling a line
|
|
type LineHandler func(line string) bool
|
|
|
|
// Flusher is implemented by writers that buffer a trailing, not-yet-terminated
|
|
// line. Callers should flush once the underlying stream has reached EOF so the
|
|
// final line (when it is not newline-terminated) is not lost.
|
|
type Flusher interface {
|
|
Flush()
|
|
}
|
|
|
|
type lineWriter struct {
|
|
buffer bytes.Buffer
|
|
handlers []LineHandler
|
|
}
|
|
|
|
// NewLineWriter creates a new instance of a line writer
|
|
func NewLineWriter(handlers ...LineHandler) io.Writer {
|
|
w := new(lineWriter)
|
|
w.handlers = handlers
|
|
return w
|
|
}
|
|
|
|
// FlushWriter flushes w if it implements Flusher. It is a no-op otherwise, so
|
|
// callers can flush an io.Writer without knowing its concrete type.
|
|
func FlushWriter(w io.Writer) {
|
|
if f, ok := w.(Flusher); ok {
|
|
f.Flush()
|
|
}
|
|
}
|
|
|
|
func (lw *lineWriter) Write(p []byte) (n int, err error) {
|
|
pBuf := bytes.NewBuffer(p)
|
|
written := 0
|
|
for {
|
|
line, err := pBuf.ReadString('\n')
|
|
w, _ := lw.buffer.WriteString(line)
|
|
written += w
|
|
if err == nil {
|
|
lw.handleLine(lw.buffer.String())
|
|
lw.buffer.Reset()
|
|
} else if err == io.EOF {
|
|
break
|
|
} else {
|
|
return written, err
|
|
}
|
|
}
|
|
|
|
return written, nil
|
|
}
|
|
|
|
// Flush emits any buffered, not-yet-newline-terminated content as a final line.
|
|
// It is safe to call multiple times; subsequent calls with an empty buffer are
|
|
// no-ops.
|
|
func (lw *lineWriter) Flush() {
|
|
if lw.buffer.Len() == 0 {
|
|
return
|
|
}
|
|
lw.handleLine(lw.buffer.String())
|
|
lw.buffer.Reset()
|
|
}
|
|
|
|
func (lw *lineWriter) handleLine(line string) {
|
|
for _, h := range lw.handlers {
|
|
ok := h(line)
|
|
if !ok {
|
|
break
|
|
}
|
|
}
|
|
}
|