Files
inbuxa-installer/internal/tui/install.go
T
jcoffey-dev 9b398bcf6f join: the console and the webmail on the host, too
--console host and --webmail host work for join as for install: the
console's files pointed at the server, the webmail under systemd on the
installer's own Node with an environment naming the server. Containers
only for what runs in one, so front ends on the host behind your own web
server (--proxy snippets, now written for join too) need no runtime.

survey: a shape the installer can add what is missing for reads as an offer
(with --install-deps: ...) rather than a refusal, as the interface says it.
The interface's legend no longer says host installs are the server only.

e2e/cases/join-host.sh: both on the host behind nginx, no runtime, a person
signs in through it.
2026-10-12 15:36:57 -07:00

901 lines
24 KiB
Go
Raw Permalink Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
// SPDX-FileCopyrightText: 2026 Coffey Labs LLC
// SPDX-License-Identifier: AGPL-3.0-or-later
package tui
// The installer's interface: six screens, always in this order, with the
// plan in front of the operator before anything happens (installer spec §4).
//
// It is a way of filling in the flags with the machine's own facts on
// screen, not a second implementation. Every screen writes into the same
// plan.Options the flags do, the plan is plan.Build's, the install is
// apply.Run's, and the plan screen shows the command that would do the same
// without the interface.
import (
"context"
"fmt"
"io"
"path/filepath"
"strings"
"sync"
"git.coffeylabs.org/inbuxa/inbuxa-installer/internal/apply"
"git.coffeylabs.org/inbuxa/inbuxa-installer/internal/host"
"git.coffeylabs.org/inbuxa/inbuxa-installer/internal/plan"
)
const (
screenFound = iota
screenNames
screenComponents
screenReach
screenPlan
screenApply
)
var screenTitles = []string{"What it found", "Names", "Components", "Reach", "The plan", "Install"}
// Installer carries out an install. In the program it is apply.Run and
// apply.Verify; tests give it something that changes nothing.
type Installer interface {
Run(ctx context.Context, p plan.Plan, f host.Facts, log apply.Log) (*apply.Result, error)
Verify(ctx context.Context, res *apply.Result, o plan.Options, log apply.Log) []string
}
// Wizard is the interface's state.
type Wizard struct {
Facts host.Facts
Installer Installer
o plan.Options
screen int
scroll int
message string // a refusal or a hint, shown above the footer
fields []*field
focus int
row int
shapes map[plan.Component]plan.Shape
proxy int // 0 caddy, 1 snippets for your own, 2 none
built plan.Plan
buildErr error
confirming bool
progress *progress
cancel context.CancelFunc
stopping bool
changed chan struct{}
}
type field struct {
label, hint string
value []rune
cursor int
toggle bool // a yes/no field, in value "yes" or ""
placeholder func(o plan.Options) string
}
func (f *field) text() string { return string(f.value) }
// NewWizard starts at the first screen with what the flags default to.
func NewWizard(f host.Facts, inst Installer) *Wizard {
w := &Wizard{Facts: f, Installer: inst, changed: make(chan struct{}, 1)}
w.o.Dir = "/var/lib/inbuxa"
under := func(prefix string) func(plan.Options) string {
return func(o plan.Options) string {
if o.Domain == "" {
return prefix + "DOMAIN"
}
return prefix + o.Domain
}
}
w.fields = []*field{
{label: "Mail domain", hint: "the domain people's addresses are at", placeholder: func(plan.Options) string { return "example.com" }},
{label: "Mail server", hint: "the server's own name, which MX points at", placeholder: under("mail.")},
{label: "Console", hint: "where the administration console is served", placeholder: under("admin.")},
{label: "Webmail", hint: "where people read their mail", placeholder: under("webmail.")},
{label: "ACME contact", hint: "where the certificate authority writes about certificates", placeholder: under("postmaster@")},
{label: "Directory", hint: "where the installation lives", value: []rune(w.o.Dir)},
{label: "Try it on loopback", hint: "no public ports, no certificates, no DNS: an evaluation on this machine", toggle: true},
}
for _, f := range w.fields {
f.cursor = len(f.value)
}
w.shapes = map[plan.Component]plan.Shape{plan.Server: plan.Container, plan.Console: plan.Container, plan.Webmail: plan.Container}
for _, c := range []plan.Component{plan.Server, plan.Console, plan.Webmail} {
w.shapes[c] = w.defaultShape(c)
}
return w
}
// defaultShape is what the flags default to, a container, wherever the
// machine can run one or the installer can make it able to; the server goes
// on the host only where containers are out of reach altogether.
func (w *Wizard) defaultShape(c plan.Component) plan.Shape {
if _, blocked := w.cellNote(c, plan.Container); !blocked {
return plan.Container
}
if c == plan.Server && plan.Available(w.Facts, c, plan.Host).OK {
return plan.Host
}
return plan.Container
}
// Changed is when an install moved on.
func (w *Wizard) Changed() <-chan struct{} { return w.changed }
func (w *Wizard) poke() {
select {
case w.changed <- struct{}{}:
default:
}
}
// Options is what the screens filled in, as the flags would have.
func (w *Wizard) Options() plan.Options {
o := w.o
o.Domain = strings.TrimSpace(w.fields[0].text())
o.MailHost = strings.TrimSpace(w.fields[1].text())
o.ConsoleHost = strings.TrimSpace(w.fields[2].text())
o.WebmailHost = strings.TrimSpace(w.fields[3].text())
o.ACMEEmail = strings.TrimSpace(w.fields[4].text())
o.Dir = strings.TrimSpace(w.fields[5].text())
o.Local = w.fields[6].text() == "yes"
o.Proxy = []string{"caddy", "snippets", "none"}[w.proxy]
o.Choices = nil
for _, c := range []plan.Component{plan.Server, plan.Console, plan.Webmail} {
o.Choices = append(o.Choices, plan.Choice{Component: c, Shape: w.shapes[c]})
}
// What the machine lacks for the shapes chosen is installed rather
// than refused: the components screen says what that will be.
o.InstallDeps = len(w.needs(o)) > 0
return o
}
func (w *Wizard) needs(o plan.Options) []string {
p, _ := plan.Build(w.Facts, withDeps(o))
var names []string
for _, n := range p.Needs {
names = append(names, n.Name)
}
return names
}
func withDeps(o plan.Options) plan.Options {
o.InstallDeps = true
if o.Domain == "" && !o.Local {
o.Domain = "example.com" // enough to build a plan to read the needs from
}
return o
}
// Update handles one key.
func (w *Wizard) Update(k Key) bool {
if w.screen == screenApply {
return w.updateApply(k)
}
if k.Kind == KeyCtrlC {
return true
}
if w.confirming {
switch {
case k.Kind == KeyRune && (k.Rune == 'y' || k.Rune == 'Y'):
w.confirming = false
w.startInstall()
default:
w.confirming = false
w.message = "Nothing has happened."
}
return false
}
w.message = ""
// q quits everywhere but in a text field, where it is a letter
if k.Kind == KeyRune && k.Rune == 'q' && !(w.screen == screenNames && !w.fields[w.focus].toggle) {
return true
}
if k.Kind == KeyEsc && w.screen > screenFound {
w.screen--
w.scroll = 0
return false
}
switch w.screen {
case screenFound:
w.updateScroll(k)
if k.Kind == KeyEnter {
w.next()
}
case screenNames:
w.updateNames(k)
case screenComponents:
w.updateComponents(k)
case screenReach:
w.updateReach(k)
case screenPlan:
w.updateScroll(k)
if k.Kind == KeyEnter {
switch {
case w.buildErr != nil:
w.message = "The plan can't be carried out as it stands: Esc to go back and change it."
case !w.Facts.Root:
w.message = "Installing needs root: run it again as root (sudo inbuxa). Nothing has happened."
default:
w.confirming = true
}
}
}
return false
}
func (w *Wizard) next() {
w.screen++
w.scroll = 0
if w.screen == screenPlan {
w.built, w.buildErr = plan.Build(w.Facts, w.Options())
}
}
func (w *Wizard) updateScroll(k Key) {
switch k.Kind {
case KeyUp:
w.scroll--
case KeyDown:
w.scroll++
case KeyPgUp:
w.scroll -= 10
case KeyPgDn:
w.scroll += 10
case KeyHome:
w.scroll = 0
}
if w.scroll < 0 {
w.scroll = 0
}
}
func (w *Wizard) updateNames(k Key) {
f := w.fields[w.focus]
switch k.Kind {
case KeyUp, KeyBackTab:
if w.focus > 0 {
w.focus--
}
case KeyDown, KeyTab:
if w.focus < len(w.fields)-1 {
w.focus++
}
case KeyEnter:
if w.focus < len(w.fields)-1 {
w.focus++
return
}
if why := w.namesProblem(); why != "" {
w.message = why
return
}
w.next()
case KeyRune:
if f.toggle {
if k.Rune == ' ' || k.Rune == 'y' || k.Rune == 'n' {
w.toggle(f, k.Rune)
}
return
}
f.value = append(f.value[:f.cursor], append([]rune{k.Rune}, f.value[f.cursor:]...)...)
f.cursor++
case KeyBackspace:
if !f.toggle && f.cursor > 0 {
f.value = append(f.value[:f.cursor-1], f.value[f.cursor:]...)
f.cursor--
}
case KeyDelete:
if !f.toggle && f.cursor < len(f.value) {
f.value = append(f.value[:f.cursor], f.value[f.cursor+1:]...)
}
case KeyLeft:
if f.cursor > 0 {
f.cursor--
}
case KeyRight:
if f.cursor < len(f.value) {
f.cursor++
}
case KeyHome:
f.cursor = 0
case KeyEnd:
f.cursor = len(f.value)
case KeyCtrlU:
if !f.toggle {
f.value, f.cursor = nil, 0
}
}
}
func (w *Wizard) toggle(f *field, r rune) {
on := f.text() == "yes"
switch r {
case 'y':
on = true
case 'n':
on = false
default:
on = !on
}
if on {
f.value = []rune("yes")
// A loopback evaluation still needs a domain for its mailboxes;
// the one reserved for testing is the honest default.
if strings.TrimSpace(w.fields[0].text()) == "" {
w.fields[0].value = []rune("example.test")
w.fields[0].cursor = len(w.fields[0].value)
}
} else {
f.value = nil
}
}
// namesProblem is why the names can't be used yet, or "".
func (w *Wizard) namesProblem() string {
o := w.Options()
if o.Domain == "" {
return "A mail domain is needed (or turn on \"Try it on loopback\")."
}
for i, v := range []string{o.Domain, o.MailHost, o.ConsoleHost, o.WebmailHost} {
if v != "" && (strings.ContainsAny(v, " /:@") || !strings.Contains(v, ".")) {
return fmt.Sprintf("%s %q is not a name like example.com.", w.fields[i].label, v)
}
}
if o.ACMEEmail != "" && !strings.Contains(o.ACMEEmail, "@") {
return "The ACME contact is an email address."
}
if o.Dir == "" || !filepath.IsAbs(o.Dir) {
return "The directory is a full path, like /var/lib/inbuxa."
}
return ""
}
var shapeOrder = []plan.Shape{plan.Skip, plan.Container, plan.Host}
func (w *Wizard) updateComponents(k Key) {
comps := []plan.Component{plan.Server, plan.Console, plan.Webmail}
c := comps[w.row]
idx := 0
for i, s := range shapeOrder {
if s == w.shapes[c] {
idx = i
}
}
switch k.Kind {
case KeyUp, KeyBackTab:
if w.row > 0 {
w.row--
}
case KeyDown, KeyTab:
if w.row < len(comps)-1 {
w.row++
}
case KeyLeft:
if idx > 0 {
w.shapes[c] = shapeOrder[idx-1]
}
case KeyRight:
if idx < len(shapeOrder)-1 {
w.shapes[c] = shapeOrder[idx+1]
}
case KeyRune:
switch k.Rune {
case 's':
w.shapes[c] = plan.Skip
case 'c':
w.shapes[c] = plan.Container
case 'h':
w.shapes[c] = plan.Host
}
case KeyEnter:
if why := w.componentsProblem(); why != "" {
w.message = why
return
}
w.next()
}
}
// cellNote is what a choice means on this machine: "" when it simply works.
func (w *Wizard) cellNote(c plan.Component, s plan.Shape) (note string, blocked bool) {
if s == plan.Skip {
return "", false
}
a := plan.Available(w.Facts, c, s)
if a.OK {
return "", false
}
// Missing but fixable: the plan installs it, and says so.
o := w.Options()
o.Choices = []plan.Choice{{Component: c, Shape: s}}
if _, err := plan.Build(w.Facts, withDeps(o)); err == nil {
return a.Why + " -- the installer will install what is missing", false
}
return a.Why, true
}
func (w *Wizard) componentsProblem() string {
any := false
for _, c := range []plan.Component{plan.Server, plan.Console, plan.Webmail} {
if w.shapes[c] != plan.Skip {
any = true
}
if note, blocked := w.cellNote(c, w.shapes[c]); blocked {
return fmt.Sprintf("%s can't be a %s install here: %s", c, w.shapes[c], note)
}
}
if !any {
return "Choose at least one component."
}
if w.shapes[plan.Server] == plan.Skip {
return "Front ends for a server on another machine are installed with inbuxa join, not here: keep the server, or quit and use join."
}
// What each choice can do on its own is above; what the choices can't
// do together -- a console of files on loopback, with no web server to
// serve them -- only the whole plan says.
if _, err := plan.Build(w.Facts, withDeps(w.Options())); err != nil {
return err.Error()
}
return ""
}
func (w *Wizard) updateReach(k Key) {
if w.Options().Local {
if k.Kind == KeyEnter {
w.next()
}
return
}
switch k.Kind {
case KeyUp:
if w.proxy > 0 {
w.proxy--
}
case KeyDown:
if w.proxy < 2 {
w.proxy++
}
case KeyEnter:
w.next()
}
}
// View draws the current screen.
func (w *Wizard) View(width, height int) []string {
if width < 60 || height < 16 {
return []string{"", " The window is too small for the installer.", " Make it at least 60 by 16, or press q to quit."}
}
var out []string
steps := make([]string, len(screenTitles))
for i, t := range screenTitles {
switch {
case i == w.screen:
steps[i] = Bold(Accent(t))
case i < w.screen:
steps[i] = t
default:
steps[i] = Dim(t)
}
}
out = append(out, " "+Bold("inbuxa installer")+Dim(" · ")+strings.Join(steps, Dim(" › ")), "")
var body []string
var help string
switch w.screen {
case screenFound:
body = indent(strings.Split(strings.TrimRight(plan.SurveyText(w.Facts), "\n"), "\n"))
help = "Enter: continue ↑↓: scroll q: quit"
case screenNames:
body, help = w.viewNames(width)
case screenComponents:
body, help = w.viewComponents(width)
case screenReach:
body, help = w.viewReach(width)
case screenPlan:
body, help = w.viewPlan(width)
case screenApply:
body, help = w.viewApply(width, height-5)
}
room := height - len(out) - 3
if w.screen == screenFound || w.screen == screenPlan {
if max := len(body) - room; w.scroll > max {
w.scroll = max
}
if w.scroll < 0 {
w.scroll = 0
}
body = body[w.scroll:]
}
if len(body) > room {
body = append(body[:room-1], Dim(" … ↓ for more"))
}
out = append(out, body...)
for len(out) < height-2 {
out = append(out, "")
}
switch {
case w.confirming:
out = append(out, " "+Bold(Warn("Install now? This changes this machine. y to go ahead, any other key not to.")))
case w.message != "":
out = append(out, " "+Warn(w.message))
default:
out = append(out, "")
}
out = append(out, " "+Dim(help))
return out
}
func indent(lines []string) []string {
out := make([]string, len(lines))
for i, l := range lines {
out[i] = " " + l
}
return out
}
func (w *Wizard) viewNames(width int) ([]string, string) {
o := w.Options()
local := o.Local
body := []string{" " + Bold("Where it will be reached"), ""}
for i, f := range w.fields {
label := Pad(f.label, 20)
var val string
switch {
case f.toggle:
val = "[ ]"
if f.text() == "yes" {
val = "[x]"
}
if i == w.focus {
val = Reverse(val)
}
case len(f.value) == 0 && i != w.focus:
val = Dim(f.placeholder(o))
case i == w.focus:
s := f.value
before, at, after := string(s[:f.cursor]), " ", ""
if f.cursor < len(s) {
at, after = string(s[f.cursor]), string(s[f.cursor+1:])
}
val = before + Reverse(at) + after
if len(f.value) == 0 {
val = Reverse(" ") + Dim(f.placeholder(o))
}
default:
val = f.text()
}
dimmed := local && i >= 1 && i <= 4
line := " "
if i == w.focus {
line = Accent("› ")
}
if dimmed {
line += Dim(label + f.text())
} else {
line += label + val
}
body = append(body, line)
if i == w.focus {
body = append(body, " "+Dim(Pad("", 18)+f.hint))
}
}
if local {
body = append(body, "", " "+Dim("On loopback the names only name the mail domain; nothing is published."))
}
return body, "↑↓ Tab: move type to edit Space: toggle Enter: next Esc: back Ctrl-C: quit"
}
func (w *Wizard) viewComponents(width int) ([]string, string) {
body := []string{" " + Bold("What goes on this machine, and how"), ""}
comps := []plan.Component{plan.Server, plan.Console, plan.Webmail}
labels := map[plan.Component]string{plan.Server: "Mail server", plan.Console: "Console", plan.Webmail: "Webmail"}
for i, c := range comps {
line := " "
if i == w.row {
line = Accent("› ")
}
line += Pad(labels[c], 14)
for _, s := range shapeOrder {
cell := " " + string(s) + " "
_, blocked := w.cellNote(c, s)
switch {
case w.shapes[c] == s && blocked:
cell = Reverse(Bad(cell))
case w.shapes[c] == s:
cell = Reverse(cell)
case blocked:
cell = Dim(cell)
}
line += cell + " "
}
body = append(body, line)
if note, blocked := w.cellNote(c, w.shapes[c]); note != "" {
style := Dim
if blocked {
style = Bad
}
for _, l := range WrapProse(note, width-20) {
body = append(body, " "+style(l))
}
}
}
body = append(body, "",
" "+Dim("container: an image, run with this machine's docker or podman"),
" "+Dim("host: from its release, under systemd or as files a web server serves"),
" "+Dim("skip: not on this machine"))
return body, "↑↓: component ←→ or s/c/h: choose Enter: next Esc: back q: quit"
}
func (w *Wizard) viewReach(width int) ([]string, string) {
body := []string{" " + Bold("What answers on ports 80 and 443"), ""}
if w.Options().Local {
body = append(body, " A loopback evaluation publishes nothing: no proxy, no certificates.",
" The server, the console and the webmail answer on 127.0.0.1 only.")
return body, "Enter: continue Esc: back q: quit"
}
options := []struct{ name, about string }{
{"Caddy, managed by the installer", "It holds 80 and 443, gets certificates for every name, and passes the server's own certificate challenges through."},
{"Your own web server, with its configuration written", "Nothing here takes 80 or 443. The installer writes an nginx configuration and a Caddyfile fragment for the web server you run, and trusts it in front of the suite; loading it is yours."},
{"Nothing in front", "Nothing here takes 80 or 443, and nothing is written. The server answers on 127.0.0.1:8081, the console on 127.0.0.1:8082, the webmail on 127.0.0.1:8080."},
}
for i, opt := range options {
mark := "( )"
if w.proxy == i {
mark = Accent("(•)")
}
line := " " + mark + " " + opt.name
if w.proxy == i {
line = " " + mark + " " + Bold(opt.name)
}
body = append(body, line)
for _, l := range WrapProse(opt.about, width-10) {
body = append(body, " "+Dim(l))
}
body = append(body, "")
}
return body, "↑↓: choose Enter: next Esc: back q: quit"
}
func (w *Wizard) viewPlan(width int) ([]string, string) {
if w.buildErr != nil {
body := []string{" " + Bad(Bold("This can't be carried out as it stands")), ""}
for _, l := range WrapProse(w.buildErr.Error(), width-6) {
body = append(body, " "+l)
}
return body, "Esc: back q: quit"
}
body := []string{" " + Dim("Nothing has happened yet. This is everything that will."), ""}
for _, l := range strings.Split(strings.TrimRight(w.built.String(), "\n"), "\n") {
for _, wl := range Wrap(l, width-4) {
body = append(body, " "+wl)
}
}
body = append(body, "", " "+Dim("The same, without the interface:"))
for _, l := range Wrap(Command(w.built.Options), width-6) {
body = append(body, " "+Accent(l))
}
return body, "Enter: install ↑↓ PgUp PgDn: scroll Esc: back q: quit"
}
// Command is the flags that do what the screens chose, leaving out what
// would be the default anyway.
func Command(o plan.Options) string {
args := []string{"inbuxa", "install"}
add := func(flag, v, def string) {
if v != "" && v != def {
args = append(args, flag, v)
}
}
if o.Local {
args = append(args, "--local")
}
add("--domain", o.Domain, "")
add("--mail-host", o.MailHost, "mail."+o.Domain)
add("--console-host", o.ConsoleHost, "admin."+o.Domain)
add("--webmail-host", o.WebmailHost, "webmail."+o.Domain)
add("--email", o.ACMEEmail, "postmaster@"+o.Domain)
add("--server", string(o.Shape(plan.Server)), "container")
add("--console", string(o.Shape(plan.Console)), "container")
add("--webmail", string(o.Shape(plan.Webmail)), "container")
if !o.Local {
add("--proxy", o.Proxy, "caddy")
}
add("--dir", o.Dir, "/var/lib/inbuxa")
if o.InstallDeps {
args = append(args, "--install-deps")
}
return strings.Join(append(args, "--yes"), " ")
}
// ---- the install itself ----
// progress is what the install has said so far. apply calls it from its own
// goroutine; the screen reads it under the lock.
type progress struct {
mu sync.Mutex
steps []string
lines []string
done bool
err error
result *apply.Result
problems []string
poke func()
}
func (p *progress) Step(format string, a ...any) {
p.mu.Lock()
s := fmt.Sprintf(format, a...)
p.steps = append(p.steps, s)
p.lines = append(p.lines, s)
p.mu.Unlock()
p.poke()
}
func (p *progress) Info(format string, a ...any) {
p.mu.Lock()
p.lines = append(p.lines, " "+fmt.Sprintf(format, a...))
p.mu.Unlock()
p.poke()
}
func (p *progress) Out() io.Writer { return lineWriter{p} }
type lineWriter struct{ p *progress }
func (l lineWriter) Write(b []byte) (int, error) {
l.p.mu.Lock()
for _, line := range strings.Split(strings.TrimRight(string(b), "\n"), "\n") {
if strings.TrimSpace(line) != "" {
l.p.lines = append(l.p.lines, " "+strings.TrimRight(line, "\r"))
}
}
l.p.mu.Unlock()
l.p.poke()
return len(b), nil
}
func (w *Wizard) startInstall() {
w.screen = screenApply
w.message = ""
ctx, cancel := context.WithCancel(context.Background())
w.cancel = cancel
pr := &progress{poke: w.poke}
w.progress = pr
p := w.built
go func() {
res, err := w.Installer.Run(ctx, p, w.Facts, pr)
var problems []string
if err == nil {
pr.Step("checking it works")
problems = w.Installer.Verify(ctx, res, p.Options, pr)
}
pr.mu.Lock()
pr.done, pr.err, pr.result, pr.problems = true, err, res, problems
pr.mu.Unlock()
pr.poke()
}()
}
func (w *Wizard) updateApply(k Key) bool {
pr := w.progress
pr.mu.Lock()
done := pr.done
pr.mu.Unlock()
if done {
return k.Kind == KeyCtrlC || k.Kind == KeyEnter || (k.Kind == KeyRune && k.Rune == 'q')
}
if w.stopping {
if k.Kind == KeyRune && (k.Rune == 'y' || k.Rune == 'Y') {
w.cancel()
w.message = "Stopping after the step that is running…"
} else {
w.message = "Carrying on."
}
w.stopping = false
return false
}
if k.Kind == KeyCtrlC || (k.Kind == KeyRune && k.Rune == 'q') {
w.stopping = true
w.message = "Stop the install? It will be left part done; running it again picks up from there. y to stop."
}
return false
}
func (w *Wizard) viewApply(width, room int) ([]string, string) {
pr := w.progress
pr.mu.Lock()
defer pr.mu.Unlock()
var body []string
for i, s := range pr.steps {
mark := Good("✓")
switch {
case i == len(pr.steps)-1 && !pr.done:
mark = Accent("›")
case i == len(pr.steps)-1 && pr.err != nil:
mark = Bad("✗")
}
body = append(body, " "+mark+" "+s)
}
if pr.done {
body = append(body, "")
body = append(body, Summary(pr.result, pr.err, pr.problems)...)
return body, "Enter or q: leave (the summary stays in your terminal)"
}
// Under the steps, the last of what is being said
logRoom := room - len(body) - 2
if logRoom > 2 {
body = append(body, "", " "+Dim("─ "+strings.Repeat("─", width-8)))
tail := pr.lines
if len(tail) > logRoom-1 {
tail = tail[len(tail)-(logRoom-1):]
}
for _, l := range tail {
body = append(body, " "+Dim(l))
}
}
return body, "q or Ctrl-C: stop"
}
// Summary is what the install leaves the operator holding, as the flag path
// prints it; the interface shows it, then prints it again once the terminal
// is back, so it stays in the scrollback.
func Summary(res *apply.Result, err error, problems []string) []string {
var out []string
if err != nil {
out = append(out, " "+Bad(Bold("Stopped: "))+err.Error())
if res != nil && res.AdminUser != "" {
out = append(out, "", " The administrator was already created; its password is in "+filepath.Join(res.Dir, "credentials.txt")+".")
}
return out
}
head := Good(Bold("Done."))
if len(problems) > 0 {
head = Warn(Bold("Installed, with problems to look at:"))
}
out = append(out, " "+head+" "+res.Dir)
for _, p := range problems {
out = append(out, " "+Warn("problem: ")+p)
}
row := func(k, v string) {
if v != "" {
out = append(out, fmt.Sprintf(" %-15s%s", k, v))
}
}
row("administrator", res.AdminUser)
row("first mailbox", res.FirstUser)
row("passwords", filepath.Join(res.Dir, "credentials.txt"))
row("console", res.ConsoleURL)
row("webmail", res.WebmailURL)
if res.Certificate != "" {
row("certificate", "issued by "+res.Certificate)
}
row("dns records", res.ZoneFile)
if res.ProxyConfig != "" {
row("proxy config", res.ProxyConfig+" (load it into your web server)")
}
return out
}
// Outcome is how the install ended, once the interface has closed: the
// summary to print, and whether it succeeded.
func (w *Wizard) Outcome() (summary []string, ran, ok bool) {
if w.progress == nil {
return nil, false, true
}
pr := w.progress
pr.mu.Lock()
defer pr.mu.Unlock()
if !pr.done {
return []string{" The install was left before it finished; run inbuxa again to pick it up."}, true, false
}
return Summary(pr.result, pr.err, pr.problems), true, pr.err == nil && len(pr.problems) == 0
}