Files
archie/internal/releaseupdate/command.go
T

128 lines
4.0 KiB
Go

package releaseupdate
import (
"bufio"
"bytes"
"context"
"encoding/json"
"fmt"
"os/exec"
"strconv"
"strings"
)
// updateResultSentinel prefixes the one line an install command may print to
// report its structured Result. Every other line is forwarded to progress
// as-is.
const updateResultSentinel = "ARCHIE_UPDATE_RESULT "
// CommandCatalog reads a Snapshot JSON document from an explicitly configured
// argv command. It never invokes a shell; deployment tooling remains an
// administrator-owned adapter.
type CommandCatalog struct{ Command []string }
func (c CommandCatalog) Check(ctx context.Context) (Snapshot, error) {
if len(c.Command) == 0 {
return Snapshot{}, fmt.Errorf("update check command is empty")
}
output, err := exec.CommandContext(ctx, c.Command[0], c.Command[1:]...).Output()
if err != nil {
return Snapshot{}, fmt.Errorf("run update check: %w", err)
}
var snapshot Snapshot
if err := json.Unmarshal(output, &snapshot); err != nil {
return Snapshot{}, fmt.Errorf("decode update check output: %w", err)
}
return snapshot, nil
}
// CommandInstaller runs the deployment's install command. HealthURL is
// passed as ARCHIE_HEALTH_URL when set.
type CommandInstaller struct {
Command []string
HealthURL string
}
// Install runs the command, streaming stdout lines to progress. One line may
// be a structured Result.
func (i CommandInstaller) Install(ctx context.Context, snapshot Snapshot, meta InstallMeta, progress func(string)) (Result, error) {
if len(i.Command) == 0 {
return Result{}, fmt.Errorf("update install command is empty")
}
cmd := exec.CommandContext(ctx, i.Command[0], i.Command[1:]...)
versions := componentVersions(snapshot)
cmd.Env = append(
cmd.Environ(),
"ARCHIE_UPDATE_CHANNEL="+meta.Channel,
"ARCHIE_UPDATE_CHAT_ID="+strconv.FormatInt(meta.ChatID, 10),
"ARCHIE_UPDATE_THREAD_ID="+strconv.Itoa(meta.ThreadID),
"ARCHIE_UPDATE_REPORT_PATH="+meta.ReportPath,
"ARCHIE_UPDATE_DAEMON_PREVIOUS="+versions[ComponentDaemon].Installed,
"ARCHIE_UPDATE_DAEMON_VERSION="+versions[ComponentDaemon].Available,
"ARCHIE_UPDATE_AGENT_PREVIOUS="+versions[ComponentAgent].Installed,
"ARCHIE_UPDATE_AGENT_VERSION="+versions[ComponentAgent].Available,
)
if i.HealthURL != "" {
cmd.Env = append(cmd.Env, "ARCHIE_HEALTH_URL="+i.HealthURL)
}
stdout, err := cmd.StdoutPipe()
if err != nil {
return Result{}, fmt.Errorf("open update installer stdout: %w", err)
}
var stderr bytes.Buffer
cmd.Stderr = &stderr
if err := cmd.Start(); err != nil {
return Result{}, fmt.Errorf("start update installer: %w", err)
}
var result Result
var resultErr error
scanner := bufio.NewScanner(stdout)
scanner.Buffer(make([]byte, 0, 64*1024), 1024*1024)
for scanner.Scan() {
line := scanner.Text()
if rest, ok := strings.CutPrefix(line, updateResultSentinel); ok {
if err := json.Unmarshal([]byte(rest), &result); err != nil {
resultErr = fmt.Errorf("decode update installer result: %w", err)
}
continue
}
progress(line)
}
if err := scanner.Err(); err != nil {
resultErr = fmt.Errorf("read update installer output: %w", err)
}
waitErr := cmd.Wait()
if waitErr != nil {
return result, fmt.Errorf("run update installer: %w: %s", waitErr, stderr.String())
}
if resultErr != nil {
return result, resultErr
}
return result, nil
}
// componentVersions reduces an approved snapshot to the two components the
// reference binary installer owns. Available is intentionally blank for an
// unchanged component: the install script treats these values as the complete
// approved plan, not as hints to rediscover work after approval.
func componentVersions(snapshot Snapshot) map[string]Component {
versions := map[string]Component{
ComponentDaemon: {},
ComponentAgent: {},
}
for _, component := range snapshot.Components {
if component.ID != ComponentDaemon && component.ID != ComponentAgent {
continue
}
if component.Available == component.Installed {
component.Available = ""
}
versions[component.ID] = component
}
return versions
}