Files
pipelines/internal/server/terminal_manager.go
T
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

349 lines
10 KiB
Go

package server
import (
"context"
"crypto/rand"
"encoding/hex"
"errors"
"fmt"
"log"
"os/exec"
"strings"
"sync"
"syscall"
"time"
"unicode/utf8"
"git.a-wan.net/alan/pipelines/internal/protocol"
)
// terminalStore persists the machine's terminal list; *pipeline.Store
// implements it.
type terminalStore interface {
SaveTerminal(ctx context.Context, terminal protocol.TerminalRecord, keep int) error
DeleteTerminal(ctx context.Context, id string) error
Terminals(ctx context.Context) ([]protocol.TerminalRecord, error)
}
// terminalManager owns the machine's terminals (terminal.go in protocol).
type terminalManager struct {
base context.Context
store terminalStore
clients *terminalClients
// login is the login command of a terminal starting in a directory.
login func(dir string) (*exec.Cmd, error)
promptWait time.Duration
home func() (string, error)
now func() time.Time
flush time.Duration
mu sync.Mutex
terms map[string]*terminalProcess
wg sync.WaitGroup
}
func newTerminalManager(base context.Context, store terminalStore) *terminalManager {
return &terminalManager{
base: base, store: store, clients: &terminalClients{},
login: terminalLoginCommand, promptWait: terminalPromptWait, home: OperatorHomeDirectory, now: time.Now, flush: 50 * time.Millisecond,
terms: map[string]*terminalProcess{},
}
}
func newTerminalID() (string, error) {
var b [8]byte
if _, err := rand.Read(b[:]); err != nil {
return "", err
}
return "term_" + hex.EncodeToString(b[:]), nil
}
// Open starts a terminal in cwd at cols x rows at the machine's login prompt
// and returns its record once the prompt shows. clientID (when set) is
// subscribed to its output before the login writes. A login that cannot ask
// for the password is refused.
func (m *terminalManager) Open(ctx context.Context, clientID, cwd string, cols, rows int) (protocol.TerminalRecord, error) {
if m.store == nil {
return protocol.TerminalRecord{}, errors.New("terminals need the server's store, which is not configured")
}
if !chatShellTerminals {
return protocol.TerminalRecord{}, errors.New(protocol.ChatShellTerminalUnsupported)
}
home, err := m.home()
if err != nil {
return protocol.TerminalRecord{}, err
}
dir, err := resolveTerminalCwd(home, cwd)
if err != nil {
return protocol.TerminalRecord{}, err
}
id, err := newTerminalID()
if err != nil {
return protocol.TerminalRecord{}, err
}
cmd, err := m.login(dir)
if err != nil {
return protocol.TerminalRecord{}, err
}
p, err := m.start(clientID, id, dir, cmd, cols, rows)
if err != nil {
return protocol.TerminalRecord{}, err
}
if err := m.awaitPrompt(p); err != nil {
m.refuse(p)
return protocol.TerminalRecord{}, err
}
record := p.snapshot(false, 0)
if err := m.store.SaveTerminal(ctx, record, protocol.TerminalEndedKept); err != nil {
m.refuse(p)
return protocol.TerminalRecord{}, fmt.Errorf("could not start the terminal: %v", err)
}
record = p.snapshot(false, 0)
m.publishRecord(record)
return record, nil
}
// start runs cmd in a new terminal's PTY and supervises it; the terminal
// counts against the limit from here on.
func (m *terminalManager) start(clientID, id, dir string, cmd *exec.Cmd, cols, rows int) (*terminalProcess, error) {
m.mu.Lock()
defer m.mu.Unlock()
if m.base.Err() != nil {
return nil, errors.New("the server is stopping")
}
if running := m.runningLocked(); running >= protocol.TerminalOpenLimit {
return nil, fmt.Errorf("this machine already has %d open terminals; close one first", running)
}
cols, rows = chatShellTerminalSize(cols, rows)
shell := strings.Join(cmd.Args[:min(len(cmd.Args), 3)], " ")
record := protocol.TerminalRecord{ID: id, Cwd: dir, Shell: shell, CreatedAt: m.now().UnixMilli(), Status: protocol.TerminalRunning, Cols: cols, Rows: rows}
p := newTerminalProcess(record)
terminal, err := p.startAttachment(cmd)
if err != nil {
return nil, fmt.Errorf("could not start the terminal: %v", err)
}
m.terms[id] = p
if clientID != "" {
m.clients.subscribe(clientID, id)
}
m.wg.Add(1)
go m.supervise(p, cmd, terminal)
go p.pumpInput()
return p, nil
}
// awaitPrompt waits for the login's password prompt: a login that ends,
// opens a shell without asking, or stays silent is refused.
func (m *terminalManager) awaitPrompt(p *terminalProcess) error {
timer := time.NewTimer(m.promptWait)
defer timer.Stop()
for {
login, _ := p.loginState()
switch {
case login.unprompted:
return errors.New("su opened a shell without asking for a password (does the account have none?); terminals are refused")
case login.prompted:
return nil
}
select {
case <-p.loginChanged:
case <-p.done:
login, output := p.loginState()
if login.prompted && !login.unprompted {
return nil
}
return fmt.Errorf("the login prompt (su) ended before asking for a password: %s", terminalLastLine(output))
case <-timer.C:
return fmt.Errorf("the login prompt (su) did not ask for a password within %s; terminals are refused", m.promptWait)
}
}
}
// refuse ends a terminal that never showed its prompt, without listing it.
func (m *terminalManager) refuse(p *terminalProcess) {
p.mu.Lock()
p.closing, p.refused = true, true
p.mu.Unlock()
p.signal(syscall.SIGKILL)
<-p.done
}
// terminalLastLine is the last non-empty line of a terminal's output, for a
// refusal message.
func terminalLastLine(output string) string {
lines := strings.Split(strings.ReplaceAll(output, "\r", ""), "\n")
for i := len(lines) - 1; i >= 0; i-- {
if line := strings.TrimSpace(lines[i]); line != "" {
return line
}
}
return "it printed nothing"
}
func (m *terminalManager) runningLocked() int {
running := 0
for _, p := range m.terms {
if p.running() {
running++
}
}
return running
}
// List is every recorded terminal, oldest first, with the live state of the
// ones this process holds.
func (m *terminalManager) List(ctx context.Context) ([]protocol.TerminalRecord, error) {
if m.store == nil {
return nil, errors.New("terminals need the server's store, which is not configured")
}
records, err := m.store.Terminals(ctx)
if err != nil {
return nil, err
}
for i, record := range records {
if p := m.process(record.ID); p != nil {
records[i] = p.snapshot(false, 0)
}
}
return records, nil
}
func (m *terminalManager) process(id string) *terminalProcess {
m.mu.Lock()
defer m.mu.Unlock()
return m.terms[id]
}
func (m *terminalManager) live(id string) (*terminalProcess, error) {
p := m.process(id)
if p == nil || !p.running() {
return nil, errors.New("this terminal is not running")
}
return p, nil
}
// Input queues data for a running terminal, in arrival order. It is kept
// nowhere else: what the shell echoes is output.
func (m *terminalManager) Input(id, data string) error {
switch {
case data == "":
return errors.New("input is required")
case len(data) > protocol.ChatShellInputLimit:
return errors.New("the input exceeds 16 KiB; send it in parts")
case !utf8.ValidString(data):
return errors.New("input must be UTF-8 text")
}
p, err := m.live(id)
if err != nil {
return err
}
select {
case <-p.done:
return errors.New("this terminal is not running")
case p.input <- []byte(data):
return nil
default:
return errors.New("the terminal is not reading its input; wait for it or press Ctrl-C")
}
}
// Resize sets a running terminal's size and returns its record.
func (m *terminalManager) Resize(id string, cols, rows int) (protocol.TerminalRecord, error) {
if cols <= 0 || rows <= 0 {
return protocol.TerminalRecord{}, errors.New("positive cols and rows are required")
}
p, err := m.live(id)
if err != nil {
return protocol.TerminalRecord{}, err
}
cols, rows = chatShellTerminalSize(cols, rows)
p.mu.Lock()
p.record.Cols, p.record.Rows = cols, rows
terminal := p.pty
p.mu.Unlock()
if terminal != nil {
if err := resizeChatShellTerminal(terminal, cols, rows); err != nil {
return protocol.TerminalRecord{}, err
}
}
return p.snapshot(false, 0), nil
}
// Output is one terminal with its retained output from byte after on. A
// terminal ended before this process started has no output.
func (m *terminalManager) Output(ctx context.Context, id string, after int64) (protocol.TerminalRecord, error) {
if p := m.process(id); p != nil {
return p.snapshot(true, after), nil
}
records, err := m.List(ctx)
if err != nil {
return protocol.TerminalRecord{}, err
}
for _, record := range records {
if record.ID == id {
return record, nil
}
}
return protocol.TerminalRecord{}, errors.New("this machine has no such terminal")
}
// Close ends a terminal (killing its login and shell) and forgets
// it. It waits briefly for the shell to go and returns the closed record.
func (m *terminalManager) Close(ctx context.Context, id string) (protocol.TerminalRecord, error) {
if m.store == nil {
return protocol.TerminalRecord{}, errors.New("terminals need the server's store, which is not configured")
}
p := m.process(id)
if p != nil && p.running() {
p.mu.Lock()
p.closing = true
p.mu.Unlock()
p.signal(syscall.SIGHUP)
select {
case <-p.done:
case <-time.After(3 * time.Second):
p.signal(syscall.SIGKILL)
<-p.done
}
return p.snapshot(false, 0), nil
}
record, err := m.Output(ctx, id, 0)
if err != nil {
return protocol.TerminalRecord{}, err
}
m.forget(id)
record.Output, record.OutputStart = "", 0
record.Status = protocol.TerminalClosed
m.publishRecord(record)
return record, nil
}
// forget drops a terminal's record and retained output.
func (m *terminalManager) forget(id string) {
m.mu.Lock()
delete(m.terms, id)
m.mu.Unlock()
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
if err := m.store.DeleteTerminal(ctx, id); err != nil {
log.Printf("terminal delete %s: %v", id, err)
}
}
func (m *terminalManager) save(record protocol.TerminalRecord) {
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
if err := m.store.SaveTerminal(ctx, record, protocol.TerminalEndedKept); err != nil {
log.Printf("terminal save %s: %v", record.ID, err)
}
}
func (m *terminalManager) publishRecord(record protocol.TerminalRecord) {
record.Output, record.OutputStart = "", 0
m.clients.publish(protocol.TerminalEventFrame{TerminalID: record.ID, Terminal: &record})
}
// Wait blocks until every supervised terminal has been released (tests,
// shutdown).
func (m *terminalManager) Wait() { m.wg.Wait() }