227c036aa5
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.
134 lines
3.3 KiB
Go
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)
|
|
}
|
|
}
|