Merge branch 'crew/lint5'

This commit is contained in:
sam committed 2026-07-29 10:37:36 +10:00
commit f303998e14
13 files changed
+129 -86

No files matched your search

+5 -5
View File
@@ -87,7 +87,7 @@ func (g *Gateway) Start(ctx context.Context, router *gateway.Router) error {
g.log.Error("email accept", "err", err)
continue
}
go g.handleSMTP(conn)
go g.handleSMTP(ctx, conn)
}
}
@@ -103,7 +103,7 @@ func (g *Gateway) Stop(ctx context.Context) error {
}
// handleSMTP processes one SMTP session.
func (g *Gateway) handleSMTP(conn net.Conn) {
func (g *Gateway) handleSMTP(ctx context.Context, conn net.Conn) {
defer func() { _ = conn.Close() }()
r := bufio.NewReader(conn)
w := bufio.NewWriter(conn)
@@ -136,7 +136,7 @@ func (g *Gateway) handleSMTP(conn net.Conn) {
case inData:
if line == "." {
// End of DATA — process the message.
g.processMessage(mailFrom, rcptTo, dataBuf.String())
g.processMessage(ctx, mailFrom, rcptTo, dataBuf.String())
write(250, "OK: message accepted")
return
}
@@ -185,7 +185,7 @@ func extractAddr(line string) string {
// processMessage extracts text from the raw email and routes it through
// the gateway router. Replies are sent back via SMTP.
func (g *Gateway) processMessage(from, to, raw string) {
func (g *Gateway) processMessage(ctx context.Context, from, to, raw string) {
g.mu.Lock()
router := g.router
g.mu.Unlock()
@@ -204,7 +204,7 @@ func (g *Gateway) processMessage(from, to, raw string) {
From: from,
Text: text,
}
reply, err := router.Route(context.Background(), msg)
reply, err := router.Route(ctx, msg)
if err != nil {
g.log.Error("email route", "err", err, "from", from)
return
+2 -2
View File
@@ -140,11 +140,11 @@ func (g *Gateway) Start(ctx context.Context, router *gateway.Router) error {
select {
case <-ctx.Done():
cancel()
return g.Stop(context.Background())
return g.Stop(context.WithoutCancel(ctx))
case req := <-g.restartCh:
g.log.Info("restarting telegram gateway", "requested_by", req.chatID)
cancel()
if err := g.Stop(context.Background()); err != nil {
if err := g.Stop(context.WithoutCancel(ctx)); err != nil {
g.log.Warn("stop during restart failed", "error", err)
}
if g.Reload != nil {
+1 -1
View File
@@ -84,7 +84,7 @@ func (g *Gateway) Start(ctx context.Context, router *gateway.Router) error {
g.log.Info("webhook gateway listening", "addr", addr)
go func() {
<-ctx.Done()
shutdownCtx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
shutdownCtx, cancel := context.WithTimeout(context.WithoutCancel(ctx), 5*time.Second)
defer cancel()
_ = g.server.Shutdown(shutdownCtx)
}()
+5 -5
View File
@@ -191,7 +191,7 @@ func (p *Pool) Acquire(ctx context.Context, mounts []storage.Mount, env []string
if _, err := p.cli.ContainerStart(ctx, resp.ID, client.ContainerStartOptions{}); err != nil {
// Best-effort cleanup.
if _, rmErr := p.cli.ContainerRemove(context.Background(), resp.ID, client.ContainerRemoveOptions{Force: true}); rmErr != nil {
if _, rmErr := p.cli.ContainerRemove(context.WithoutCancel(ctx), resp.ID, client.ContainerRemoveOptions{Force: true}); rmErr != nil {
p.log.Warn("container remove after start failure", "id", resp.ID[:12], "err", rmErr)
}
p.mu.Lock()
@@ -208,7 +208,7 @@ func (p *Pool) Acquire(ctx context.Context, mounts []storage.Mount, env []string
// GracePeriod is configured, the container stays alive for that duration
// before being killed -- the agent can handle follow-ups (gate re-runs,
// human replies) during this window. PRD section 1.
func (p *Pool) Release(c *Container) {
func (p *Pool) Release(ctx context.Context, c *Container) {
if c == nil {
return
}
@@ -218,13 +218,13 @@ func (p *Pool) Release(c *Container) {
time.Sleep(p.cfg.GracePeriod)
}
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
stopCtx, cancel := context.WithTimeout(ctx, 10*time.Second)
defer cancel()
if _, err := p.cli.ContainerStop(ctx, c.ID, client.ContainerStopOptions{}); err != nil {
if _, err := p.cli.ContainerStop(stopCtx, c.ID, client.ContainerStopOptions{}); err != nil {
p.log.Warn("container stop failed", "id", c.ID[:12], "err", err)
}
if _, err := p.cli.ContainerRemove(context.Background(), c.ID, client.ContainerRemoveOptions{Force: true}); err != nil {
if _, err := p.cli.ContainerRemove(context.WithoutCancel(ctx), c.ID, client.ContainerRemoveOptions{Force: true}); err != nil {
p.log.Warn("container remove failed", "id", c.ID[:12], "err", err)
}
+1 -1
View File
@@ -947,7 +947,7 @@ func (d *Daemon) process(ctx context.Context, task *store.Task) {
_ = d.Store.Transition(ctx, task.ID, store.StatusRunning, store.StatusParked, "container acquire failed: "+err.Error())
return
}
defer d.ContainerPool.Release(ctr)
defer d.ContainerPool.Release(ctx, ctr)
}
// Set the working label only after successful container setup (or when no
+5 -5
View File
@@ -144,14 +144,14 @@ type TaskController interface {
// responder. Gateway implementations call Route on every inbound
// message.
type Router struct {
Store StatusReader
Models ModelManager // nil = /model not configured
Store StatusReader
Models ModelManager // nil = /model not configured
// ModelPersist persists the active model selection so it survives
// restarts (e.g. writing back to identity config). nil = not configured.
ModelPersist func(ctx context.Context, modelRef string) error
// Personas holds the available personality registry for /personality.
Personas *PersonaRegistry
Tasks TaskCreator // nil = /spawn not configured
Personas *PersonaRegistry
Tasks TaskCreator // nil = /spawn not configured
Controller TaskController // nil = /approve and /cancel not configured
LLM LLMResponder // nil = LLM not wired yet
// LLMStream is the optional streaming responder. When set, adapters
@@ -169,7 +169,7 @@ type Router struct {
// /undo, /retry, /compress) are available. When nil, those
// commands report "not configured".
Sessions SessionStore
Agents AgentReader // nil = /agents not configured
Agents AgentReader // nil = /agents not configured
sessionTracker *sessionTracker
gatewayName string
}
+6 -3
View File
@@ -758,7 +758,8 @@ func TestRouteResumeNotConfigured(t *testing.T) {
func TestRouteResumeNoMatch(t *testing.T) {
r := NewRouter(nil, nil, "test-gw")
r.Sessions = &fakeSessionLister{fakeSessionStore: newFakeSessionStore(),
r.Sessions = &fakeSessionLister{
fakeSessionStore: newFakeSessionStore(),
sessions: []SessionContext{
{SessionID: "session-1"},
},
@@ -774,7 +775,8 @@ func TestRouteResumeNoMatch(t *testing.T) {
func TestRouteResumeAmbiguous(t *testing.T) {
r := NewRouter(nil, nil, "test-gw")
r.Sessions = &fakeSessionLister{fakeSessionStore: newFakeSessionStore(),
r.Sessions = &fakeSessionLister{
fakeSessionStore: newFakeSessionStore(),
sessions: []SessionContext{
{SessionID: "abc-123"},
{SessionID: "abc-456"},
@@ -791,7 +793,8 @@ func TestRouteResumeAmbiguous(t *testing.T) {
func TestRouteResumeExactMatch(t *testing.T) {
r := NewRouter(nil, nil, "test-gw")
r.Sessions = &fakeSessionLister{fakeSessionStore: newFakeSessionStore(),
r.Sessions = &fakeSessionLister{
fakeSessionStore: newFakeSessionStore(),
sessions: []SessionContext{
{SessionID: "abc-123"},
{SessionID: "abc-456"},
+9 -11
View File
@@ -486,6 +486,15 @@ func (m *Manager) Prefetch(query string) (string, error) {
// (18.8). Results from successful prefetches are stored and included in
// SystemPromptBlock() output.
func (m *Manager) PrefetchContext(ctx context.Context, query string) (string, error) {
// Apply the manager's default timeout if the caller hasn't set a
// shorter deadline. Derived before the loop so we never nest a
// context inside a loop (fatcontext).
if _, hasDeadline := ctx.Deadline(); !hasDeadline {
var cancel context.CancelFunc
ctx, cancel = context.WithTimeout(ctx, m.prefetchTimeout)
defer cancel()
}
m.mu.RLock()
providers := m.activeProvidersLocked()
m.mu.RUnlock()
@@ -508,17 +517,6 @@ func (m *Manager) PrefetchContext(ctx context.Context, query string) (string, er
}
defer flag.Store(false)
// Apply the manager's default timeout if the caller hasn't set a
// shorter deadline.
if _, hasDeadline := ctx.Deadline(); !hasDeadline {
var cancel context.CancelFunc
// Assignment, not declaration: `:=` here would scope the
// timeout-bearing ctx to this if-block, so the deadline would
// silently never apply to the call below.
ctx, cancel = context.WithTimeout(ctx, m.prefetchTimeout)
defer cancel()
}
start := time.Now()
// Run Prefetch in a goroutine so we can respect the context deadline.
+5
View File
@@ -555,10 +555,15 @@ func dockerTestClient(t *testing.T, roundTrip func(*http.Request) (*http.Respons
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
resp, err := roundTrip(req)
if err != nil {
// roundTrip may return a partial response alongside the error.
if resp != nil {
resp.Body.Close()
}
t.Errorf("Docker test handler: %v", err)
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
defer resp.Body.Close()
for key, values := range resp.Header {
for _, value := range values {
w.Header().Add(key, value)
+55 -32
View File
@@ -103,9 +103,8 @@ type StdioTransport struct {
// pending maps message IDs (as raw JSON) to response channels.
pending map[string]chan []byte
// ctx is cancelled by Stop(). Background goroutines select on this.
ctx context.Context
cancel context.CancelFunc
// stopCh is closed by Stop(). Background goroutines select on this.
stopCh chan struct{}
// readerWg tracks the reader goroutine so Stop can wait for it.
readerWg sync.WaitGroup
@@ -164,18 +163,22 @@ func (t *StdioTransport) Start(ctx context.Context) error {
return fmt.Errorf("mcp: stop in progress")
}
t.state = StateStarting
// Create a fresh context for this lifecycle. If we're restarting from
// Error state, the previous context was already cancelled; make a new one.
if t.ctx != nil {
t.cancel()
// Create a fresh stop channel for this lifecycle. If we're restarting
// from Error state, the previous stop channel is already closed.
if t.stopCh != nil {
select {
case <-t.stopCh:
default:
close(t.stopCh)
}
}
t.ctx, t.cancel = context.WithCancel(context.Background())
t.stopCh = make(chan struct{})
// Reset crash and failure counters on explicit user start.
t.crashCount = 0
t.startupFailures = 0
t.mu.Unlock()
return t.startSubprocess()
return t.startSubprocess(context.WithoutCancel(ctx))
}
// stopSubprocess kills the current subprocess and waits for it to exit.
@@ -225,8 +228,12 @@ func (t *StdioTransport) Stop(_ context.Context) error {
// opens a window where a concurrent Start() could see a state it isn't
// guarding against and race a fresh subprocess against this shutdown.
t.state = StateStopping
if t.cancel != nil {
t.cancel()
if t.stopCh != nil {
select {
case <-t.stopCh:
default:
close(t.stopCh)
}
}
t.mu.Unlock()
@@ -345,22 +352,22 @@ func (t *StdioTransport) Notify(ctx context.Context, body []byte) error {
// startSubprocess spawns the MCP server subprocess and starts the reader
// goroutine. Must be called without t.mu held.
func (t *StdioTransport) startSubprocess() error {
cmd, stdin, stdout, err := t.spawnProcess()
func (t *StdioTransport) startSubprocess(ctx context.Context) error {
cmd, stdin, stdout, err := t.spawnProcess(ctx)
if err != nil {
t.mu.Lock()
t.state = StateError
t.mu.Unlock()
return err
}
return t.commitSpawnedProcess(cmd, stdin, stdout, false)
return t.commitSpawnedProcess(ctx, cmd, stdin, stdout, false)
}
// commitSpawnedProcess installs a freshly spawned subprocess as the
// transport's active one and starts its reader goroutine. spawnProcess runs
// without t.mu held (it performs a real fork/exec), so a concurrent Stop()
// can cancel t.ctx and commit StateStopped while a spawn is still in
// flight. commitSpawnedProcess re-checks t.ctx under the lock immediately
// can close t.stopCh and commit StateStopped while a spawn is still in
// flight. commitSpawnedProcess re-checks stopCh under the lock immediately
// before committing: if Stop() already won, the just-spawned subprocess is
// discarded (killed and reaped) instead of clobbering the Stopped state
// Stop() already reported to its own caller. Both startSubprocess (a fresh
@@ -370,9 +377,9 @@ func (t *StdioTransport) startSubprocess() error {
// resetStartupFailures resets the spawn-failure counter on success; it is
// true only for attemptRestart, since Start() already resets both crash and
// startup-failure counters itself before the first spawn attempt.
func (t *StdioTransport) commitSpawnedProcess(cmd *exec.Cmd, stdin io.WriteCloser, stdout *bufio.Reader, resetStartupFailures bool) error {
func (t *StdioTransport) commitSpawnedProcess(ctx context.Context, cmd *exec.Cmd, stdin io.WriteCloser, stdout *bufio.Reader, resetStartupFailures bool) error {
t.mu.Lock()
if t.ctx.Err() != nil {
if t.isStopped() {
t.state = StateStopped
t.mu.Unlock()
_ = stdin.Close()
@@ -380,7 +387,7 @@ func (t *StdioTransport) commitSpawnedProcess(cmd *exec.Cmd, stdin io.WriteClose
_ = cmd.Process.Kill()
_ = cmd.Wait()
}
return t.ctx.Err()
return errTransportStopped
}
t.cmd = cmd
t.stdin = stdin
@@ -392,15 +399,15 @@ func (t *StdioTransport) commitSpawnedProcess(cmd *exec.Cmd, stdin io.WriteClose
// Start the reader goroutine.
t.readerWg.Add(1)
go t.runReader(stdout)
go t.runReader(ctx, stdout)
return nil
}
// spawnProcess creates and starts the subprocess. Returns the cmd,
// stdin writer, and buffered stdout reader.
func (t *StdioTransport) spawnProcess() (*exec.Cmd, io.WriteCloser, *bufio.Reader, error) {
cmd := exec.CommandContext(t.ctx, t.config.Command, t.config.Args...)
func (t *StdioTransport) spawnProcess(ctx context.Context) (*exec.Cmd, io.WriteCloser, *bufio.Reader, error) {
cmd := exec.CommandContext(ctx, t.config.Command, t.config.Args...)
cmd.Env = append(os.Environ(), t.config.Env...)
cmd.Dir = t.config.Dir
@@ -428,7 +435,7 @@ func (t *StdioTransport) spawnProcess() (*exec.Cmd, io.WriteCloser, *bufio.Reade
// subprocess's stdout, routing responses to the matching pending
// channels. On error (process crash, pipe close), it initiates the
// auto-restart sequence.
func (t *StdioTransport) runReader(reader *bufio.Reader) {
func (t *StdioTransport) runReader(ctx context.Context, reader *bufio.Reader) {
defer t.readerWg.Done()
for {
@@ -437,7 +444,7 @@ func (t *StdioTransport) runReader(reader *bufio.Reader) {
// The subprocess is dead or the pipe is broken. Attempt restart
// if we weren't asked to stop.
t.mu.Lock()
cancelled := t.ctx.Err() != nil
cancelled := t.isStopped()
shuttingDown := t.state == StateStopping || t.state == StateStopped
t.mu.Unlock()
@@ -445,7 +452,7 @@ func (t *StdioTransport) runReader(reader *bufio.Reader) {
return
}
t.handleProcessDeath()
t.handleProcessDeath(ctx)
return
}
@@ -486,7 +493,7 @@ func (t *StdioTransport) deliverResponse(body []byte) {
// handleProcessDeath is called when the reader detects the subprocess
// has died. It increments crashCount for backoff, transitions to Starting,
// closes pending channels, and initiates the auto-restart sequence.
func (t *StdioTransport) handleProcessDeath() {
func (t *StdioTransport) handleProcessDeath(ctx context.Context) {
t.mu.Lock()
if t.state != StateRunning {
t.mu.Unlock()
@@ -508,7 +515,7 @@ func (t *StdioTransport) handleProcessDeath() {
}
// Attempt restart (outside lock because it waits).
t.attemptRestart()
t.attemptRestart(ctx)
}
// failAllPendingLocked closes all pending response channels with an error.
@@ -528,11 +535,11 @@ func (t *StdioTransport) failAllPendingLocked() {
// Crash loops where the process starts but immediately dies are bounded
// by exponential backoff growing up to MaxBackoff. Spawn failures
// (binary not found, permissions, etc.) count against MaxRetries.
func (t *StdioTransport) attemptRestart() {
func (t *StdioTransport) attemptRestart(ctx context.Context) {
for {
// Check preconditions under lock.
t.mu.Lock()
if t.ctx.Err() != nil {
if t.isStopped() {
t.state = StateStopped
t.mu.Unlock()
return
@@ -563,7 +570,7 @@ func (t *StdioTransport) attemptRestart() {
// Wait for the backoff period, but abort if the transport is stopped.
timer := time.NewTimer(backoff)
select {
case <-t.ctx.Done():
case <-t.stopCh:
timer.Stop()
t.mu.Lock()
t.state = StateStopped
@@ -573,7 +580,7 @@ func (t *StdioTransport) attemptRestart() {
}
// Try to start the subprocess.
cmd, stdin, stdout, err := t.spawnProcess()
cmd, stdin, stdout, err := t.spawnProcess(ctx)
if err != nil {
t.mu.Lock()
t.startupFailures++
@@ -585,7 +592,7 @@ func (t *StdioTransport) attemptRestart() {
// so a concurrent Stop() that cancelled the context while
// spawnProcess was in flight discards this subprocess instead of
// clobbering the Stopped state Stop() already reported.
_ = t.commitSpawnedProcess(cmd, stdin, stdout, true)
_ = t.commitSpawnedProcess(ctx, cmd, stdin, stdout, true)
return
}
}
@@ -633,6 +640,22 @@ func writeMessageWithTimeout(w io.Writer, data []byte, timeout time.Duration) er
// ── Helpers ─────────────────────────────────────────────────────────────
// isStopped returns true if the transport stop channel has been closed.
// Must be called with t.mu held or from a goroutine that doesn't need
// the lock for ordering.
func (t *StdioTransport) isStopped() bool {
select {
case <-t.stopCh:
return true
default:
return false
}
}
// errTransportStopped is returned by the lifecycle context when the
// transport is stopped.
var errTransportStopped = errors.New("mcp: transport stopped")
// extractMessageID extracts the "id" field from a JSON body as a raw JSON
// string. This is used as the key for correlating requests with responses.
// A missing "id" returns an empty string (for notifications, which don't
+28 -14
View File
@@ -72,8 +72,8 @@ type SSETransport struct {
pending map[string]chan []byte
ctx context.Context
cancel context.CancelFunc
// stopCh is closed by Stop(). Background goroutines select on this.
stopCh chan struct{}
// The SSE reader goroutine.
readerWg sync.WaitGroup
@@ -100,7 +100,7 @@ func (t *SSETransport) Start(ctx context.Context) error {
return fmt.Errorf("mcp sse: already running")
}
t.state = StateStarting
t.ctx, t.cancel = context.WithCancel(context.Background())
t.stopCh = make(chan struct{})
t.messageEndpoint = t.config.MessageEndpoint // fallback; endpoint event overrides
t.mu.Unlock()
@@ -116,8 +116,12 @@ func (t *SSETransport) Stop(_ context.Context) error {
return nil
}
t.state = StateStopping
if t.cancel != nil {
t.cancel()
if t.stopCh != nil {
select {
case <-t.stopCh:
default:
close(t.stopCh)
}
}
if t.respBody != nil {
_ = t.respBody.Close()
@@ -240,13 +244,13 @@ func (t *SSETransport) connect(ctx context.Context) error {
// Start the background SSE event reader.
t.readerWg.Add(1)
go t.runReader(resp.Body, reader)
go t.runReader(ctx, resp.Body, reader)
return nil
}
// runReader loops reading SSE events from the stream, routing
// "message" events to the corresponding pending channel.
func (t *SSETransport) runReader(body io.Closer, reader *bufio.Reader) {
func (t *SSETransport) runReader(ctx context.Context, body io.Closer, reader *bufio.Reader) {
defer t.readerWg.Done()
defer func() { _ = body.Close() }()
@@ -255,13 +259,13 @@ func (t *SSETransport) runReader(body io.Closer, reader *bufio.Reader) {
if err != nil {
// Stream closed or errored. Attempt reconnect.
t.mu.Lock()
cancelled := t.ctx.Err() != nil
cancelled := t.isStopped()
stopping := t.state == StateStopping || t.state == StateStopped
t.mu.Unlock()
if cancelled || stopping {
return
}
t.reconnect()
t.reconnect(ctx)
return
}
switch event {
@@ -283,11 +287,11 @@ func (t *SSETransport) runReader(body io.Closer, reader *bufio.Reader) {
// reconnect attempts to re-establish the SSE connection with exponential
// backoff. On success, the reader goroutine restarts.
func (t *SSETransport) reconnect() {
func (t *SSETransport) reconnect(ctx context.Context) {
backoff := t.config.effectiveReconnectBackoff()
for {
t.mu.Lock()
if t.ctx.Err() != nil {
if t.isStopped() {
t.state = StateStopped
t.mu.Unlock()
return
@@ -300,13 +304,13 @@ func (t *SSETransport) reconnect() {
timer := time.NewTimer(backoff)
select {
case <-t.ctx.Done():
case <-t.stopCh:
timer.Stop()
return
case <-timer.C:
}
req, err := http.NewRequestWithContext(t.ctx, http.MethodGet, t.config.SSEEndpoint, nil)
req, err := http.NewRequestWithContext(ctx, http.MethodGet, t.config.SSEEndpoint, nil)
if err != nil {
backoff = nextBackoff(backoff, t.config.effectiveMaxReconnectBackoff())
continue
@@ -339,7 +343,7 @@ func (t *SSETransport) reconnect() {
t.mu.Unlock()
t.readerWg.Add(1)
go t.runReader(resp.Body, reader)
go t.runReader(ctx, resp.Body, reader)
return
}
}
@@ -485,5 +489,15 @@ func readSSEEvent(r *bufio.Reader) (event, data string, err error) {
}
}
// isStopped returns true if the transport stop channel has been closed.
func (t *SSETransport) isStopped() bool {
select {
case <-t.stopCh:
return true
default:
return false
}
}
// Compile-time interface check.
var _ Transport = (*SSETransport)(nil)
+6 -6
View File
@@ -601,7 +601,7 @@ func TestStdioTransportConcurrentStartDuringStop(t *testing.T) {
// regression test for a race where startSubprocess (the path Start() uses
// to commit a freshly spawned subprocess) could clobber a StateStopped
// already committed and reported by a concurrent Stop(): spawnProcess runs
// without t.mu held (it's a real fork/exec), so Stop() can cancel t.ctx and
// without t.mu held (it's a real fork/exec), so Stop() can close t.stopCh and
// return Stopped to its own caller while a spawn is still in flight. The
// commit path used to unconditionally set state = StateRunning afterward,
// wedging the transport in a Running state no caller of Stop() would ever
@@ -623,21 +623,21 @@ func TestStdioTransportCommitSpawnedProcessDiscardsWhenContextRacesAhead(t *test
tr.mu.Lock()
tr.state = StateStarting
tr.ctx, tr.cancel = context.WithCancel(context.Background())
tr.stopCh = make(chan struct{})
tr.mu.Unlock()
cmd, stdin, stdout, err := tr.spawnProcess()
cmd, stdin, stdout, err := tr.spawnProcess(context.Background())
if err != nil {
t.Fatalf("spawnProcess: %v", err)
}
// Simulate a concurrent Stop() winning the race between spawn and
// commit: it would have cancelled this exact context.
// commit: it would have closed this exact stop channel.
tr.mu.Lock()
tr.cancel()
close(tr.stopCh)
tr.mu.Unlock()
err = tr.commitSpawnedProcess(cmd, stdin, stdout, false)
err = tr.commitSpawnedProcess(context.Background(), cmd, stdin, stdout, false)
if err == nil {
t.Fatal("expected error when context was cancelled before commit")
}
+1 -1
View File
@@ -61,7 +61,7 @@ func (s *Server) Run(ctx context.Context, listen string) error {
srv := &http.Server{Addr: listen, Handler: s.Handler(), ReadHeaderTimeout: 5 * time.Second}
go func() {
<-ctx.Done()
shutdownCtx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
shutdownCtx, cancel := context.WithTimeout(context.WithoutCancel(ctx), 2*time.Second)
defer cancel()
_ = srv.Shutdown(shutdownCtx)
}()