Files
alan 227c036aa5 Start machine terminals at the su login prompt instead of tmux
A new terminal runs su -l for the server's own account in its PTY, so the
operator types the account password before getting a shell. Opening is
refused when su is missing, the server runs as root, or su opens a shell
without asking. The Pipelines-owned tmux backing, its reattach and its
persisted session names are removed: terminals end with the server and
are listed as ended. A starting server ends leftover pipelines-term_*
sessions on tmux -L pipelines only.
2026-11-10 00:37:11 +00:00

134 lines
3.3 KiB
Go

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)
}
}