315 lines
9.3 KiB
Go
315 lines
9.3 KiB
Go
package server
|
|
|
|
import (
|
|
"context"
|
|
"crypto/rand"
|
|
"encoding/hex"
|
|
"errors"
|
|
"fmt"
|
|
"log"
|
|
"os"
|
|
"os/exec"
|
|
"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)
|
|
}
|
|
|
|
const (
|
|
terminalNoTmuxReason = "The Pipelines server restarted and this shell ended with it (tmux is not installed on this machine, so shells do not outlive the server)."
|
|
terminalGoneReason = "Its tmux session ended while the Pipelines server was stopped."
|
|
terminalStopReason = "The Pipelines server stopped and this shell ended with it (tmux is not installed on this machine)."
|
|
// terminalReattachLimit bounds how often a tmux client that exits while
|
|
// its session lives is replaced before the terminal is given up.
|
|
terminalReattachLimit = 5
|
|
)
|
|
|
|
// terminalManager owns the machine's terminals (terminal.go in protocol).
|
|
type terminalManager struct {
|
|
base context.Context
|
|
store terminalStore
|
|
clients *terminalClients
|
|
tmux *terminalTmux
|
|
shell func() string
|
|
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, tmux *terminalTmux) *terminalManager {
|
|
return &terminalManager{
|
|
base: base, store: store, clients: &terminalClients{}, tmux: tmux,
|
|
shell: chatShellProgram, 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 login shell in cwd at cols x rows and returns its record.
|
|
// clientID (when set) is subscribed to its output before the shell writes.
|
|
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
|
|
}
|
|
m.mu.Lock()
|
|
defer m.mu.Unlock()
|
|
if m.base.Err() != nil {
|
|
return protocol.TerminalRecord{}, errors.New("the server is stopping")
|
|
}
|
|
if running := m.runningLocked(); running >= protocol.TerminalOpenLimit {
|
|
return protocol.TerminalRecord{}, fmt.Errorf("this machine already has %d open terminals; close one first", running)
|
|
}
|
|
cols, rows = chatShellTerminalSize(cols, rows)
|
|
shell := m.shell()
|
|
record := protocol.TerminalRecord{ID: id, Cwd: dir, Shell: shell, CreatedAt: m.now().UnixMilli(), Status: protocol.TerminalRunning, Cols: cols, Rows: rows}
|
|
var cmd *exec.Cmd
|
|
if m.tmux != nil {
|
|
record.Tmux = terminalTmuxName(id)
|
|
if err := m.tmux.create(record.Tmux, dir, shell, cols, rows); err != nil {
|
|
return protocol.TerminalRecord{}, fmt.Errorf("could not start the terminal: %v", err)
|
|
}
|
|
cmd = m.tmux.attach(record.Tmux)
|
|
} else {
|
|
cmd = exec.Command(shell, "-l")
|
|
cmd.Env = terminalEnv(os.Environ(), dir)
|
|
}
|
|
cmd.Dir = dir
|
|
p := newTerminalProcess(record)
|
|
terminal, err := p.startAttachment(cmd)
|
|
if err == nil {
|
|
err = m.store.SaveTerminal(ctx, record, protocol.TerminalEndedKept)
|
|
if err != nil {
|
|
p.signal(syscall.SIGKILL)
|
|
terminal.Close()
|
|
_ = cmd.Wait()
|
|
}
|
|
}
|
|
if err != nil {
|
|
if record.Tmux != "" {
|
|
_ = m.tmux.kill(record.Tmux)
|
|
}
|
|
return protocol.TerminalRecord{}, 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()
|
|
m.publishRecord(record)
|
|
return record, nil
|
|
}
|
|
|
|
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 shell and tmux session) 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
|
|
name := p.record.Tmux
|
|
p.mu.Unlock()
|
|
if name != "" && m.tmux != nil {
|
|
if err := m.tmux.kill(name); err != nil {
|
|
log.Printf("terminal close %s: %v", id, err)
|
|
}
|
|
}
|
|
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
|
|
}
|
|
if record.Tmux != "" && m.tmux != nil && m.tmux.alive(record.Tmux) {
|
|
_ = m.tmux.kill(record.Tmux)
|
|
}
|
|
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() }
|