package server import ( "context" "log" "os" "os/exec" "syscall" "time" "git.a-wan.net/alan/pipelines/internal/protocol" ) // supervise streams one terminal (cmd on terminal) until it ends: its login // or shell exits, it is closed, or the server stops, which ends it too. func (m *terminalManager) supervise(p *terminalProcess, cmd *exec.Cmd, terminal *os.File) { defer m.wg.Done() defer close(p.done) stopFlush, flushDone := make(chan struct{}), make(chan struct{}) go m.flushLoop(p, stopFlush, flushDone) titled := func(string) { p.mu.Lock() listed := !p.refused && p.login.prompted p.mu.Unlock() if listed { record := p.snapshot(false, 0) m.save(record) m.publishRecord(record) } } readDone := make(chan struct{}) go func() { defer close(readDone) p.read(terminal, titled) }() attachDone := make(chan error, 1) go func() { attachDone <- p.waitAttachment(cmd, terminal, readDone) }() var waitErr error select { case waitErr = <-attachDone: case <-m.base.Done(): p.signal(syscall.SIGHUP) select { case waitErr = <-attachDone: case <-time.After(time.Second): p.signal(syscall.SIGKILL) waitErr = <-attachDone } } shutdown := m.base.Err() != nil close(stopFlush) <-flushDone m.emit(p, true) p.mu.Lock() // A terminal that never showed its prompt was never listed: Open // refuses it, so it is forgotten unannounced. listed := p.login.prompted && !p.refused switch { case p.closing: p.record.Status = protocol.TerminalClosed default: p.record.Status = protocol.TerminalExited p.record.EndedAt = m.now().UnixMilli() switch { case shutdown: p.record.Reason = terminalStopReason case !p.login.loggedIn: p.record.Reason = terminalLoginFailedReason p.record.ExitCode = terminalExitCode(waitErr) default: p.record.ExitCode = terminalExitCode(waitErr) } } p.pty, p.cmd = nil, nil p.mu.Unlock() record := p.snapshot(false, 0) switch { case !listed || record.Status == protocol.TerminalClosed: m.forget(record.ID) default: m.save(record) } if !shutdown && listed { m.publishRecord(record) } } // flushLoop pushes new output in batches until stop is closed. func (m *terminalManager) flushLoop(p *terminalProcess, stop <-chan struct{}, done chan<- struct{}) { defer close(done) ticker := time.NewTicker(m.flush) defer ticker.Stop() for { select { case <-stop: return case <-ticker.C: m.emit(p, false) } } } // emit pushes the output written since the last frame. func (m *terminalManager) emit(p *terminalProcess, final bool) { p.mu.Lock() text, offset, end, ok := p.out.pending(protocol.TerminalChunkLimit, final) id := p.record.ID p.mu.Unlock() if ok { m.clients.publish(protocol.TerminalEventFrame{TerminalID: id, Output: text, Offset: offset, End: end}) } } // recover records the terminals a previous server process left running as // ended: they ended with it. func (m *terminalManager) recover(ctx context.Context) { if m.store == nil { return } records, err := m.store.Terminals(ctx) if err != nil { log.Printf("terminal recover: %v", err) return } for _, record := range records { if record.Status != protocol.TerminalRunning { continue } record.Status, record.EndedAt = protocol.TerminalExited, m.now().UnixMilli() record.Reason = terminalRestartReason m.save(record) } }