Files
inbuxa-installer/internal/apply/move.go
T
jcoffey-dev ebd68154c3 Host server: setup credentials go only to the server's own listener
A host first boot restarts the server and then sends the bootstrap
credential, then the administrator's password, then the setup's API
key to 127.0.0.1:8080 and later :8081; a move to the host does the same
with the operator's API key. Those are unprivileged ports, and nothing
checked who answered there. A local user who bound one while the
server restarted was sent the password or the key.

Before each such request, the installer now checks that every socket
listening on that port belongs to the server unit's main process
(systemctl show -p MainPID), reading /proc as the port survey already
does; otherwise nothing is sent, and the step waits or fails naming
what holds the port. The jmap client gained a Guard hook for this. A
server in a container is not checked: the runtime publishes its port.

Backport to the 2026 line, by hand where the code differs: the 2026
line has no name-router or log-file steps after a move, so the three
first-boot clients and the move's are the ones guarded, and host.go gains
only PortHeldBy.

Test: TestSetupCredentialsGoOnlyToTheServersOwnListener failed before
(a listener that wasn't the server's received "Basic ..." and "Bearer
the-api-key") and now passes; TestSetupCredentialsGoToTheServer and
TestSetupCredentialsCheckTheClientsCurrentAddress are new.

(backported from commit d647a78d8a)
2026-11-17 16:12:42 -07:00

642 lines
23 KiB
Go

// SPDX-FileCopyrightText: 2026 Coffey Labs LLC
// SPDX-License-Identifier: AGPL-3.0-or-later
package apply
// Moving the mail server between a container and the host, when `install`
// is run again with the other --server.
//
// Its configuration and mail go with it. Only one thing in them names a
// place on disk: config.json, the data store's own description, whose path
// is /var/lib/inbuxa/ in a container and <dir>/server/data/ on the host.
// That is rewritten in the copy. The rest of what differs between the two
// shapes is the server's own settings, which only the server can change, so
// a move needs an API key, as `certs` and `join` do:
//
// - its listeners: everything on [::] inside a container, plain HTTP on
// loopback and no HTTPS of its own on the host (jmap.HostListeners);
// - the addresses exempted from the auto-ban, which are where the front
// ends' requests arrive from: the project network's in a container,
// loopback on the host.
//
// Nothing is moved, only copied, and the original is left where it was: the
// volumes after a move to the host, <dir>/server after a move into a
// container. A failure on the way puts the server back as it was, and the
// archive taken first is in <dir>/backups either way.
import (
"context"
"encoding/json"
"errors"
"fmt"
"io"
"os"
"os/exec"
"path/filepath"
"strings"
"syscall"
"time"
"git.coffeylabs.org/inbuxa/inbuxa-installer/internal/compose"
"git.coffeylabs.org/inbuxa/inbuxa-installer/internal/docker"
"git.coffeylabs.org/inbuxa/inbuxa-installer/internal/host"
"git.coffeylabs.org/inbuxa/inbuxa-installer/internal/jmap"
"git.coffeylabs.org/inbuxa/inbuxa-installer/internal/plan"
"git.coffeylabs.org/inbuxa/inbuxa-installer/internal/state"
)
const (
containerDataPath = "/var/lib/inbuxa/"
containerUser = "2000:2000" // the image's inbuxa user
preMoveDir = ".pre-move"
)
// ErrMoveNeedsKey is a move asked for without an API key.
var ErrMoveNeedsKey = errors.New("an API key is needed to move the server")
// MovingServer says whether running install with these options moves the
// server between shapes, and from which.
func MovingServer(st *state.State, o plan.Options) (from plan.Shape, moving bool) {
// Not after an uninstall either: nothing runs to move, and install
// brings the recorded shape back, or sets up the new one, as it is told.
if st == nil || !st.Installed() || st.Removed() {
return "", false
}
was, wants := st.Shapes["server"], o.Shape(plan.Server)
if was == "" || wants == plan.Skip || was == string(wants) {
return "", false
}
return plan.Shape(was), true
}
// MoveNote is what a plan says about a move before anything happens.
func MoveNote(from, to plan.Shape) string {
return fmt.Sprintf(`Moving the mail server from a %s install to a %s install:
- everything here stops while it moves, a minute or two
- its configuration and mail are archived into backups/ first, then copied
- its listeners and the auto-ban exemptions are changed for the new shape,
with an API key made in the console (--key - or INBUXA_API_KEY)
- the %s copy is left where it is; anything failing puts it back as it was
`, from, to, from)
}
// serverMove is a move begun: the old shape stopped and archived, waiting
// for the new shape's files to be written before finish carries it out.
type serverMove struct {
from, to plan.Shape
dir string
key string
local bool
cmp docker.Compose
log Log
archive string // the archive taken before anything changed
oldImage string // the server image a container install ran
done bool // finish ran: the move happened, or it put things back itself
}
// beginMove checks the key, stops what runs here and archives the server's
// data. Nothing of the new shape is written yet, so a failure here leaves
// the old one exactly as it was.
func beginMove(ctx context.Context, o plan.Options, from plan.Shape, f host.Facts, log Log) (*serverMove, error) {
to := o.Shape(plan.Server)
if o.Key == "" {
return nil, fmt.Errorf("%w from a %s install to a %s install, as its listeners change with it: "+
"make one in the console (your account, API keys) and run this again with --key - "+
"(or INBUXA_API_KEY); it isn't kept", ErrMoveNeedsKey, from, to)
}
docker.UseRuntime(f.Runtime)
m := &serverMove{from: from, to: to, dir: o.Dir, key: o.Key, local: o.Local, log: log,
cmp: docker.Compose{Dir: o.Dir, Runtime: f.Runtime}}
srv := &jmap.Client{BaseURL: "http://" + hostFinalBind, Token: o.Key}
if _, err := srv.Listeners(ctx); err != nil {
return nil, fmt.Errorf("the server on %s didn't take the API key, so nothing was changed: %w", hostFinalBind, err)
}
log.Step("moving the mail server from a %s install to a %s install", from, to)
stamp := time.Now().UTC().Format("20060102T150405Z")
if err := os.MkdirAll(filepath.Join(m.dir, "backups"), 0o700); err != nil {
return nil, err
}
hasCompose := exists(filepath.Join(m.dir, "compose.yaml"))
if from == plan.Container {
b, err := os.ReadFile(filepath.Join(m.dir, "compose.yaml"))
if err != nil {
return nil, err
}
tag := installedVersion(m.dir, plan.Server, plan.Container, string(b))
m.oldImage = strings.TrimSuffix(DefaultServerImage, ":"+tagOf(DefaultServerImage)) + ":" + tag
// The deployment as it is, to put back: the new shape's files are
// written over these before the move is carried out.
if err := m.keepDeployment(); err != nil {
return nil, err
}
log.Info("stopping everything in containers here while the server moves")
if err := m.cmp.Run(ctx, "stop"); err != nil {
return nil, err
}
name, err := archiveVolumes(ctx, m.dir, tag)
if err != nil {
m.cmp.Run(ctx, "start")
return nil, fmt.Errorf("archiving the server's data, so nothing was changed: %w", err)
}
m.archive = name
log.Info("archived its configuration and data to %s", name)
return m, nil
}
// From the host: archived while stopped, then started once more, as it
// was, to be given the listeners a container needs. They take effect at
// its next start, which is in the container.
if hasCompose {
if err := m.keepDeployment(); err != nil {
return nil, err
}
}
if err := runQuiet(ctx, "systemctl", "stop", HostServerUnit); err != nil {
return nil, err
}
m.archive = filepath.Join(m.dir, "backups", "server-host-"+stamp+".tar.gz")
if err := runQuiet(ctx, "tar", "-czf", m.archive, "-C", m.dir, "server"); err != nil {
runQuiet(ctx, "systemctl", "start", HostServerUnit)
return nil, fmt.Errorf("archiving the server's data, so nothing was changed: %w", err)
}
log.Info("archived its configuration and data to %s", m.archive)
if err := runQuiet(ctx, "systemctl", "start", HostServerUnit); err != nil {
return nil, err
}
if err := waitFor(ctx, log, "the server to answer again", 120*time.Second, func(ctx context.Context) error {
return live(ctx, "http://"+hostFinalBind)
}); err != nil {
return nil, withLogs(ctx, err, hostServer{deploy: m.dir}, "server")
}
if err := srv.ContainerListeners(ctx); err != nil {
return nil, m.restoreHost(ctx, fmt.Errorf("changing the server's listeners for a container: %w", err))
}
log.Info("its listeners set for a container, from its next start")
log.Info("stopping everything here while the server moves")
if err := runQuiet(ctx, "systemctl", "disable", "--now", "--quiet", HostServerUnit); err != nil {
return nil, m.restoreHost(ctx, err)
}
if hasCompose {
m.cmp.Run(ctx, "stop")
}
return m, nil
}
// abort puts the old shape back when the install stops between beginMove and
// finish, writing or fetching the new shape's pieces.
func (m *serverMove) abort(ctx context.Context) {
if m.done {
return
}
m.done = true
ctx = context.WithoutCancel(ctx)
if m.from == plan.Container {
m.log.Info("the move stopped before the server moved: putting it back in its container")
removeUnit(ctx, HostServerUnit, hostUnitPath)
m.putDeploymentBack(ctx)
return
}
m.log.Info("the move stopped before the server moved: putting it back on the host")
m.restoreHost(ctx, errors.New("aborted"))
m.putDeploymentBack(ctx)
}
// keepDeployment copies the files the new shape is about to be written
// over, so a failed move can put them back.
func (m *serverMove) keepDeployment() error {
keep := filepath.Join(m.dir, preMoveDir)
os.RemoveAll(keep)
if err := os.MkdirAll(keep, 0o700); err != nil {
return err
}
for _, name := range []string{"compose.yaml", "Caddyfile"} {
b, err := os.ReadFile(filepath.Join(m.dir, name))
if errors.Is(err, os.ErrNotExist) {
continue
} else if err != nil {
return err
}
if err := os.WriteFile(filepath.Join(keep, name), b, 0o640); err != nil {
return err
}
}
return nil
}
// putDeploymentBack restores what keepDeployment kept, and starts it.
func (m *serverMove) putDeploymentBack(ctx context.Context) {
keep := filepath.Join(m.dir, preMoveDir)
for _, name := range []string{"compose.yaml", "Caddyfile"} {
if b, err := os.ReadFile(filepath.Join(keep, name)); err == nil {
os.WriteFile(filepath.Join(m.dir, name), b, 0o640)
} else {
os.Remove(filepath.Join(m.dir, name))
}
}
if exists(filepath.Join(m.dir, "compose.yaml")) {
m.cmp.Run(ctx, "up", "-d", "--remove-orphans")
}
}
// finish carries the move out once the new shape's deployment is written
// and, for the host, its binary, user, directories and environment are in
// place. The server answers in its new shape when it returns nil.
func (m *serverMove) finish(ctx context.Context, stack compose.Stack, snippets bool) error {
m.done = true
var err error
if m.to == plan.Host {
err = m.toHost(ctx, stack, snippets)
} else {
err = m.toContainer(ctx, stack, snippets)
}
if err == nil {
os.RemoveAll(filepath.Join(m.dir, preMoveDir))
}
return err
}
func (m *serverMove) toHost(ctx context.Context, stack compose.Stack, snippets bool) error {
hs := hostServer{deploy: m.dir, log: m.log}
back := func(why error) error {
m.log.Info("putting the server back in its container")
removeUnit(ctx, HostServerUnit, hostUnitPath)
os.Remove(setupDropIn)
os.Remove(setupEnvPath)
m.putDeploymentBack(ctx)
return fmt.Errorf("%w; the server is back in its container with its data as it was (archived in %s)", why, m.archive)
}
m.log.Info("copying its configuration and mail into %s", hs.home())
if err := m.clearForCopy(ctx, hs); err != nil {
return back(err)
}
stage, err := os.MkdirTemp(m.dir, ".move-")
if err != nil {
return back(err)
}
defer os.RemoveAll(stage)
out := exec.CommandContext(ctx, docker.CLI, "run", "--rm", "--user", "0", "--entrypoint", "tar",
"-v", "inbuxa_inbuxa-etc:/from/etc:ro", "-v", "inbuxa_inbuxa-data:/from/data:ro",
m.oldImage, "-cf", "-", "-C", "/from", ".")
in := exec.CommandContext(ctx, "tar", "-xf", "-", "-C", stage)
if err := pipe(out, in); err != nil {
return back(fmt.Errorf("copying the server's volumes: %w", err))
}
// Renamed into place, not copied: the stage is on the same filesystem,
// and a large store should not need twice its size free.
if err := moveContents(filepath.Join(stage, "data"), hs.DataPath()); err != nil {
return back(err)
}
if err := moveContents(filepath.Join(stage, "etc"), hs.home()); err != nil {
return back(err)
}
if err := rewriteDataPath(hs.configPath(), containerDataPath, hs.DataPath()); err != nil {
return back(err)
}
if err := runQuiet(ctx, "chown", "-R", HostServerUser+":"+HostServerUser, hs.home()); err != nil {
return back(err)
}
// The first start is behind the same fence as first boot: its listeners
// are still a container's, on every interface, until they are fitted.
m.log.Info("starting it on the host, on loopback only until its listeners are fitted")
if _, err := hs.WriteUnit(ctx, true); err != nil {
return back(err)
}
if err := hs.Start(ctx, modeFenced, ""); err != nil {
return back(withLogs(ctx, err, hs, "server"))
}
if err := m.cameBack(ctx, hostSetupBind, func() string { return hs.Logs(ctx, "server", 400) }); err != nil {
return back(withLogs(ctx, err, hs, "server"))
}
srv := setupClient(true, jmap.Client{BaseURL: hostSetupBind, Token: m.key})
if err := srv.HostListeners(ctx, hostFinalBind, m.local); err != nil {
return back(fmt.Errorf("fitting the server's listeners to the host: %w", err))
}
m.log.Info("plain HTTP on %s for the proxy and the webmail; 443 is left to the proxy", hostFinalBind)
if stack.ServesWebmail() || stack.Proxy || snippets {
if err := allowOnce(ctx, srv, "127.0.0.1", "the front ends on this machine: their requests arrive from loopback"); err != nil {
return back(fmt.Errorf("exempting the front ends: %w", err))
}
}
if err := hs.Start(ctx, modeNormal, ""); err != nil {
return back(withLogs(ctx, err, hs, "server"))
}
if err := m.cameBack(ctx, "http://"+hostFinalBind, func() string { return hs.Logs(ctx, "server", 400) }); err != nil {
return back(withLogs(ctx, err, hs, "server"))
}
m.log.Info("the server answers on the host; its volumes are left as they were, for `docker volume rm` once you are sure")
return nil
}
func (m *serverMove) toContainer(ctx context.Context, stack compose.Stack, snippets bool) error {
hs := hostServer{deploy: m.dir, log: m.log}
back := func(why error) error {
m.log.Info("putting the server back on the host")
m.cmp.Run(ctx, "rm", "--stop", "--force", "server")
m.restoreHost(ctx, why)
m.putDeploymentBack(ctx)
return fmt.Errorf("%w; the server is back on the host with its data as it was (archived in %s)", why, m.archive)
}
// Its volumes, made by compose so they belong to the project. Volumes
// left from an earlier install in a container hold older data: archived
// and emptied, never mixed with this.
if err := m.cmp.Run(ctx, "create", "server"); err != nil {
return back(err)
}
image := DefaultServerImage
left, _ := docker.Output(ctx, "run", "--rm", "--user", "0", "--entrypoint", "sh",
"-v", "inbuxa_inbuxa-etc:/to/etc", "-v", "inbuxa_inbuxa-data:/to/data", image,
"-c", "ls -A /to/etc /to/data | grep -v '^/to\\|^$' | head -1")
if strings.TrimSpace(left) != "" {
name, err := archiveVolumes(ctx, m.dir, tagOf(image))
if err != nil {
return back(fmt.Errorf("archiving the volumes left from an earlier install: %w", err))
}
m.log.Info("the server's volumes held an earlier install's data: archived to %s and emptied", name)
if _, err := docker.Output(ctx, "run", "--rm", "--user", "0", "--entrypoint", "sh",
"-v", "inbuxa_inbuxa-etc:/to/etc", "-v", "inbuxa_inbuxa-data:/to/data", image,
"-c", "find /to/etc /to/data -mindepth 1 -delete"); err != nil {
return back(err)
}
}
// Only the configuration is staged, to be rewritten; the store goes
// straight from <dir>/server into its volume.
m.log.Info("copying its configuration and mail into the volumes")
stage, err := os.MkdirTemp(m.dir, ".move-")
if err != nil {
return back(err)
}
defer os.RemoveAll(stage)
if err := os.MkdirAll(filepath.Join(stage, "etc"), 0o750); err != nil {
return back(err)
}
staged := filepath.Join(stage, "etc", "config.json")
if err := copyFile(hs.configPath(), staged, 0o640); err != nil {
return back(err)
}
if err := rewriteDataPath(staged, hs.DataPath(), containerDataPath); err != nil {
return back(err)
}
out := exec.CommandContext(ctx, "tar", "-cf", "-", "-C", stage, "etc", "-C", hs.home(), "data")
in := exec.CommandContext(ctx, docker.CLI, "run", "--rm", "-i", "--user", "0", "--entrypoint", "sh",
"-v", "inbuxa_inbuxa-etc:/to/etc", "-v", "inbuxa_inbuxa-data:/to/data", image,
"-c", "tar -xf - -C /to && chown -R "+containerUser+" /to/etc /to/data")
if err := pipe(out, in); err != nil {
return back(fmt.Errorf("filling the server's volumes: %w", err))
}
m.log.Info("starting it in its container")
if err := m.cmp.Run(ctx, "up", "-d", "server"); err != nil {
return back(err)
}
url := "http://" + stack.ServerBind
if err := m.cameBack(ctx, url, func() string { return m.cmp.Logs(ctx, "server", 400) }); err != nil {
return back(withLogs(ctx, err, m.cmp, "server"))
}
// The front ends' requests now arrive from the project network.
srv := &jmap.Client{BaseURL: url, Token: m.key}
exempt := map[string]string{}
if stack.Webmail || stack.WebmailUnit {
exempt[stack.WebmailIP] = "the webmail: every request arrives from this address"
}
if stack.Proxy {
exempt[stack.CaddyIP] = "the proxy: certificate renewals and autoconfig arrive from this address"
}
if snippets {
exempt[stack.GatewayIP] = "your web server in front of the suite: its requests arrive from this address"
}
for addr, why := range exempt {
if addr == "" {
continue
}
if err := allowOnce(ctx, srv, addr, why); err != nil {
return back(fmt.Errorf("exempting %s: %w", addr, err))
}
}
if len(exempt) > 0 {
// They take effect only on a restart.
if err := m.cmp.Run(ctx, "restart", "server"); err != nil {
return back(err)
}
if err := m.cameBack(ctx, url, func() string { return m.cmp.Logs(ctx, "server", 400) }); err != nil {
return back(withLogs(ctx, err, m.cmp, "server"))
}
}
// Off the host: the unit and the binaries go, as uninstall takes them.
removeUnit(ctx, HostServerUnit, hostUnitPath)
old, _ := filepath.Glob(HostServerBinary + ".*")
for _, p := range append(old, HostServerBinary) {
os.Remove(p)
}
os.Remove(filepath.Join(m.dir, "server.env"))
m.log.Info("the server answers in its container; %s is left as it was, to delete once you are sure", hs.home())
return nil
}
// restoreHost puts the archive taken by beginMove back into <dir>/server and
// starts the server on the host again, as it was before the move began.
func (m *serverMove) restoreHost(ctx context.Context, why error) error {
home := hostServer{deploy: m.dir}.home()
os.RemoveAll(home)
if err := runQuiet(ctx, "tar", "-xzf", m.archive, "-C", m.dir); err != nil {
return fmt.Errorf("%w; and putting %s back from %s failed too: %v", why, home, m.archive, err)
}
runQuiet(ctx, "systemctl", "enable", "--quiet", HostServerUnit)
runQuiet(ctx, "systemctl", "restart", HostServerUnit)
return fmt.Errorf("%w; the server was put back on the host as it was", why)
}
// clearForCopy makes sure <dir>/server is empty before the volumes are
// copied into it: what an earlier install on the host left there is
// archived, never mixed with this.
func (m *serverMove) clearForCopy(ctx context.Context, hs hostServer) error {
data := filepath.Join(hs.home(), "data")
if fi, err := os.Lstat(data); err == nil {
if err := isPlainDir(data, fi); err != nil {
return err
}
}
entries, _ := os.ReadDir(hs.DataPath())
if len(entries) == 0 && !exists(hs.configPath()) {
return nil
}
name := filepath.Join(m.dir, "backups", "server-host-earlier-"+time.Now().UTC().Format("20060102T150405Z")+".tar.gz")
if err := runQuiet(ctx, "tar", "-czf", name, "-C", m.dir, "server"); err != nil {
return fmt.Errorf("archiving what an earlier install left in %s: %w", hs.home(), err)
}
m.log.Info("%s held an earlier install's data: archived to %s and emptied", hs.home(), name)
os.Remove(hs.configPath())
for _, e := range entries {
if err := os.RemoveAll(filepath.Join(hs.DataPath(), e.Name())); err != nil {
return err
}
}
return nil
}
// cameBack waits for the server at url and makes sure it came back with its
// configuration: a server that finds none starts in bootstrap mode and says
// so, which means the copy missed something.
func (m *serverMove) cameBack(ctx context.Context, url string, logs func() string) error {
if err := waitFor(ctx, m.log, "the server to answer", 120*time.Second, func(ctx context.Context) error {
return live(ctx, url)
}); err != nil {
return err
}
if strings.Contains(logs(), "bootstrap mode") {
return errors.New("the server came back in bootstrap mode, without its configuration")
}
return nil
}
// allowOnce exempts an address unless it already is.
func allowOnce(ctx context.Context, srv *jmap.Client, address, reason string) error {
have, err := srv.AllowedIPs(ctx)
if err != nil {
return err
}
if have[address] {
return nil
}
return srv.AllowIP(ctx, address, reason)
}
// rewriteDataPath points the data store's description at its new home. Only
// a path under the old home is changed: a store kept elsewhere (PostgreSQL,
// a path the operator chose) is left alone.
//
// config.json is in the server's home, which the server's user can write, so
// it is read without following a link and replaced by a rename, never
// written through whatever is there.
func rewriteDataPath(configPath, from, to string) error {
f, err := openNoFollow(configPath)
if err != nil {
return fmt.Errorf("the server's configuration: %w", err)
}
b, err := io.ReadAll(f)
f.Close()
if err != nil {
return fmt.Errorf("the server's configuration: %w", err)
}
var cfg map[string]any
if err := json.Unmarshal(b, &cfg); err != nil {
return fmt.Errorf("%s isn't JSON: %w", configPath, err)
}
p, ok := cfg["path"].(string)
if !ok || !strings.HasPrefix(p, strings.TrimSuffix(from, "/")) {
return nil
}
cfg["path"] = strings.TrimSuffix(to, "/") + strings.TrimPrefix(p, strings.TrimSuffix(from, "/"))
out, err := json.Marshal(cfg)
if err != nil {
return err
}
info, err := os.Lstat(configPath)
if err != nil {
return err
}
return replaceFile(configPath, out, info.Mode().Perm())
}
// openNoFollow opens a file for reading, refusing a symbolic link.
func openNoFollow(path string) (*os.File, error) {
f, err := os.OpenFile(path, os.O_RDONLY|syscall.O_NOFOLLOW, 0)
if errors.Is(err, syscall.ELOOP) {
return nil, fmt.Errorf("%s is a symbolic link, which the installer will not follow there", path)
}
return f, err
}
// replaceFile puts content at path by writing a new file beside it and
// renaming it over the old one: a link at path is replaced, not followed.
func replaceFile(path string, content []byte, mode os.FileMode) error {
tmp, err := os.CreateTemp(filepath.Dir(path), "."+filepath.Base(path)+".")
if err != nil {
return err
}
defer os.Remove(tmp.Name())
if _, err := tmp.Write(content); err != nil {
tmp.Close()
return err
}
if err := tmp.Chmod(mode); err != nil {
tmp.Close()
return err
}
if err := tmp.Close(); err != nil {
return err
}
return os.Rename(tmp.Name(), path)
}
// moveContents renames everything in src into dest, which is made if need
// be. Both are on one filesystem.
func moveContents(src, dest string) error {
entries, err := os.ReadDir(src)
if errors.Is(err, os.ErrNotExist) {
return nil
} else if err != nil {
return err
}
if err := os.MkdirAll(dest, 0o750); err != nil {
return err
}
for _, e := range entries {
if err := os.Rename(filepath.Join(src, e.Name()), filepath.Join(dest, e.Name())); err != nil {
return err
}
}
return nil
}
func copyFile(src, dest string, mode os.FileMode) error {
in, err := openNoFollow(src)
if err != nil {
return err
}
defer in.Close()
out, err := os.OpenFile(dest, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, mode.Perm())
if err != nil {
return err
}
if _, err := io.Copy(out, in); err != nil {
out.Close()
return err
}
return out.Close()
}
// pipe runs out | in and reports the first of their failures, with what
// each said on its standard error.
func pipe(out, in *exec.Cmd) error {
r, w := io.Pipe()
var outErr, inErr strings.Builder
out.Stdout, out.Stderr = w, &outErr
in.Stdin, in.Stderr = r, &inErr
if err := in.Start(); err != nil {
return err
}
errOut := out.Run()
w.CloseWithError(errOut)
errIn := in.Wait()
switch {
case errOut != nil:
return fmt.Errorf("%w: %s", errOut, strings.TrimSpace(outErr.String()))
case errIn != nil:
return fmt.Errorf("%w: %s", errIn, strings.TrimSpace(inErr.String()))
}
return nil
}
func exists(path string) bool {
_, err := os.Stat(path)
return err == nil
}