Files
slacker-bot/slackerbot/internal/local/transfer.go
T
2026-11-01 13:01:54 -05:00

266 lines
6.3 KiB
Go

package local
import (
"bytes"
"context"
"errors"
"fmt"
"io"
"os"
"os/exec"
"path/filepath"
"strings"
"sync"
"time"
"slackerbot/internal/model"
"slackerbot/internal/storage"
"slackerbot/internal/util"
)
type transfer struct {
cmd *exec.Cmd
out io.ReadCloser
in io.WriteCloser
stderr bytes.Buffer
snapshot string
tmpDir string
drive string
machine string
seen map[string]bool
latest string
}
type transfers struct {
mu sync.Mutex
m map[string]*transfer
}
func (t *transfers) add(x *transfer) string {
id := util.RandomHex(8)
t.mu.Lock()
defer t.mu.Unlock()
if t.m == nil {
t.m = map[string]*transfer{}
}
t.m[id] = x
return id
}
func (t *transfers) get(id string) (*transfer, error) {
t.mu.Lock()
defer t.mu.Unlock()
if x := t.m[id]; x != nil {
return x, nil
}
return nil, fmt.Errorf("no transfer %s", id)
}
func (t *transfers) take(id string) *transfer {
t.mu.Lock()
defer t.mu.Unlock()
x := t.m[id]
delete(t.m, id)
return x
}
func (l *Local) home(drive, machine string) (string, error) {
if _, err := l.drive(drive); err != nil {
return "", err
}
if !model.IsOurs(machine) {
return "", fmt.Errorf("unexpected machine name %q", machine)
}
return filepath.Join(drive, machine), nil
}
func (l *Local) WaitStopped(ctx context.Context, machine string) error {
ctx, cancel := context.WithTimeout(ctx, 2*time.Minute)
defer cancel()
for l.IsRunning(machine) {
select {
case <-ctx.Done():
return fmt.Errorf("%s didn't stop in time", machine)
case <-time.After(500 * time.Millisecond):
}
}
return nil
}
// With a parent export, only the changes since the parent's snapshot are sent.
func (l *Local) ExportHome(ctx context.Context, drive, machine, parent string) (string, error) {
home, err := l.home(drive, machine)
if err != nil {
return "", err
}
args := []string{"send", "-q"}
if parent != "" {
p, err := l.exports.get(parent)
if err != nil {
return "", err
}
args = append(args, "-p", p.snapshot)
}
snapshot := filepath.Join(drive, ".move-"+machine+"-"+util.RandomHex(4))
if out, err := exec.Command("btrfs", "subvolume", "snapshot", "-r", home, snapshot).CombinedOutput(); err != nil {
return "", fmt.Errorf("snapshot: %v: %s", err, strings.TrimSpace(string(out)))
}
x := &transfer{snapshot: snapshot, drive: drive, machine: machine}
x.cmd = exec.Command("btrfs", append(args, snapshot)...)
x.cmd.Stderr = &x.stderr
if x.out, err = x.cmd.StdoutPipe(); err == nil {
err = x.cmd.Start()
}
if err != nil {
storage.DeleteSubvolume(snapshot)
return "", err
}
return l.exports.add(x), nil
}
func (l *Local) ReadExport(ctx context.Context, id string, max int) ([]byte, bool, error) {
x, err := l.exports.get(id)
if err != nil {
return nil, false, err
}
buf := make([]byte, max)
n, err := io.ReadFull(x.out, buf)
if errors.Is(err, io.EOF) || errors.Is(err, io.ErrUnexpectedEOF) {
if werr := x.cmd.Wait(); werr != nil {
return nil, false, fmt.Errorf("btrfs send: %v: %s", werr, strings.TrimSpace(x.stderr.String()))
}
return buf[:n], true, nil
}
return buf[:n], false, err
}
func (l *Local) CloseExport(ctx context.Context, id string) error {
x := l.exports.take(id)
if x == nil {
return nil
}
if x.cmd.ProcessState == nil {
_ = x.cmd.Process.Kill()
_ = x.cmd.Wait()
}
return storage.DeleteSubvolume(x.snapshot)
}
func (l *Local) ImportHome(ctx context.Context, drive, machine string) (string, error) {
home, err := l.home(drive, machine)
if err != nil {
return "", err
}
if _, err := os.Stat(home); err == nil {
return "", fmt.Errorf("%s already has a home folder for %s; remove it first", l.name, machine)
}
x := &transfer{drive: drive, machine: machine, seen: map[string]bool{},
tmpDir: filepath.Join(drive, ".incoming-"+machine+"-"+util.RandomHex(4))}
if err := os.Mkdir(x.tmpDir, 0o700); err != nil {
return "", err
}
return l.imports.add(x), nil
}
func (l *Local) WriteImport(ctx context.Context, id string, data []byte) error {
x, err := l.imports.get(id)
if err != nil {
return err
}
if x.cmd == nil {
x.stderr.Reset()
x.cmd = exec.Command("btrfs", "receive", "-q", x.tmpDir)
x.cmd.Stderr = &x.stderr
if x.in, err = x.cmd.StdinPipe(); err == nil {
err = x.cmd.Start()
}
if err != nil {
x.cmd = nil
return err
}
}
if _, err := x.in.Write(data); err != nil {
return fmt.Errorf("btrfs receive: %v: %s", err, strings.TrimSpace(x.stderr.String()))
}
return nil
}
func (l *Local) EndReceive(ctx context.Context, id string) error {
x, err := l.imports.get(id)
if err != nil {
return err
}
if x.cmd == nil {
return errors.New("nothing was received")
}
x.in.Close()
err = x.cmd.Wait()
x.cmd = nil
if err != nil {
return fmt.Errorf("btrfs receive: %v: %s", err, strings.TrimSpace(x.stderr.String()))
}
entries, err := os.ReadDir(x.tmpDir)
if err != nil {
return err
}
for _, e := range entries {
if !x.seen[e.Name()] {
x.seen[e.Name()] = true
x.latest = e.Name()
}
}
return nil
}
// Received subvolumes are read-only; a writable snapshot of the latest one
// becomes the new home.
func (l *Local) FinishImport(ctx context.Context, id string, quotaMB int64) error {
x := l.imports.take(id)
if x == nil {
return fmt.Errorf("no transfer %s", id)
}
defer cleanupIncoming(x.tmpDir)
if x.latest == "" {
return errors.New("nothing was received")
}
home := filepath.Join(x.drive, x.machine)
if out, err := exec.Command("btrfs", "subvolume", "snapshot", filepath.Join(x.tmpDir, x.latest), home).CombinedOutput(); err != nil {
return fmt.Errorf("snapshot: %v: %s", err, strings.TrimSpace(string(out)))
}
return storage.SetQuota(home, quotaMB)
}
func (l *Local) AbortImport(ctx context.Context, id string) error {
x := l.imports.take(id)
if x == nil {
return nil
}
if x.cmd != nil {
x.in.Close()
_ = x.cmd.Process.Kill()
_ = x.cmd.Wait()
}
cleanupIncoming(x.tmpDir)
return nil
}
func (l *Local) DeleteHome(ctx context.Context, drive, machine string) error {
home, err := l.home(drive, machine)
if err != nil {
return err
}
if l.IsRunning(machine) {
return fmt.Errorf("%s is running", machine)
}
return storage.DeleteSubvolume(home)
}
func cleanupIncoming(dir string) {
entries, _ := os.ReadDir(dir)
for _, e := range entries {
_ = storage.DeleteSubvolume(filepath.Join(dir, e.Name()))
}
_ = os.RemoveAll(dir)
}