545 lines
16 KiB
Go
545 lines
16 KiB
Go
package main
|
|
|
|
import (
|
|
"encoding/json"
|
|
"errors"
|
|
"flag"
|
|
"fmt"
|
|
"io"
|
|
"os"
|
|
"os/exec"
|
|
"strconv"
|
|
"sync"
|
|
"sync/atomic"
|
|
"time"
|
|
)
|
|
|
|
func cmdAgent(args []string) error {
|
|
fs := flag.NewFlagSet("agent", flag.ContinueOnError)
|
|
role := fs.String("role", "", "control|sink|source-stream (internal)")
|
|
path := fs.String("path", "", "path to read/write")
|
|
size := fs.Int64("size", 0, "total sync size in bytes")
|
|
blockSize := fs.Int64("block-size", defaultBlockSize, "block size in bytes")
|
|
if err := fs.Parse(args); err != nil {
|
|
return err
|
|
}
|
|
|
|
switch *role {
|
|
case "control":
|
|
return runControlAgent()
|
|
case "sink":
|
|
return runSinkRole(*path, *size, *blockSize)
|
|
case "source-stream":
|
|
return runSourceStreamRole(*path, *size, *blockSize)
|
|
default:
|
|
return fmt.Errorf("agent: unknown or missing --role %q (want control|sink|source-stream)", *role)
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------
|
|
// control role: long-lived per-side orchestration agent, driven by the
|
|
// manager over stdin/stdout with CtrlMsg frames.
|
|
// ---------------------------------------------------------------------
|
|
|
|
func runControlAgent() error {
|
|
in := NewFrameReader(os.Stdin)
|
|
out := NewFrameWriter(os.Stdout)
|
|
|
|
for {
|
|
typ, payload, err := in.ReadFrame()
|
|
if err != nil {
|
|
return nil // manager closed the pipe; nothing left to do
|
|
}
|
|
if typ != frameCtrlJSON {
|
|
return fmt.Errorf("control agent: unexpected frame type %d", typ)
|
|
}
|
|
var m CtrlMsg
|
|
if err := json.Unmarshal(payload, &m); err != nil {
|
|
return fmt.Errorf("control agent: decode message: %w", err)
|
|
}
|
|
switch m.Type {
|
|
case msgStat:
|
|
handleStat(out, m)
|
|
case msgPrepare:
|
|
handlePrepare(out, m)
|
|
case msgConnectPush:
|
|
runPushDriver(m, out)
|
|
case msgConnectPull:
|
|
runPullDriver(m, out)
|
|
case msgClose:
|
|
_ = out.WriteJSON(CtrlMsg{Type: msgBye})
|
|
return nil
|
|
default:
|
|
_ = out.WriteJSON(CtrlMsg{Type: msgError, Message: fmt.Sprintf("unknown command %q", m.Type)})
|
|
}
|
|
}
|
|
}
|
|
|
|
// readHashFrame reads one frameHashTable off fr and expands it.
|
|
func readHashFrame(fr *FrameReader) ([][32]byte, error) {
|
|
typ, payload, err := fr.ReadFrame()
|
|
if err != nil {
|
|
return nil, fmt.Errorf("read hash table: %w", err)
|
|
}
|
|
if typ != frameHashTable {
|
|
return nil, fmt.Errorf("expected hash table frame, got type %d", typ)
|
|
}
|
|
return unflattenHashes(payload)
|
|
}
|
|
|
|
func handleStat(out *FrameWriter, m CtrlMsg) {
|
|
info, err := statPath(m.Path)
|
|
if err != nil {
|
|
_ = out.WriteJSON(CtrlMsg{Type: msgError, Message: err.Error(), NeedPriv: isPermErr(err)})
|
|
return
|
|
}
|
|
_ = out.WriteJSON(CtrlMsg{Type: msgStatOK, Exists: info.Exists, IsDevice: info.IsDevice, Size: info.Size})
|
|
}
|
|
|
|
func handlePrepare(out *FrameWriter, m CtrlMsg) {
|
|
if err := prepareDest(m.Path, m.Size); err != nil {
|
|
_ = out.WriteJSON(CtrlMsg{Type: msgError, Message: err.Error(), NeedPriv: isPermErr(err)})
|
|
return
|
|
}
|
|
_ = out.WriteJSON(CtrlMsg{Type: msgPrepareOK, Size: m.Size})
|
|
}
|
|
|
|
// isPermErr reports whether err (or anything it wraps, including a bare
|
|
// syscall errno from an ioctl) is a permission failure — the signal that
|
|
// retrying the agent under sudo might help.
|
|
func isPermErr(err error) bool {
|
|
return errors.Is(err, os.ErrPermission)
|
|
}
|
|
|
|
// peerAgentCommand builds the *exec.Cmd for a one-shot helper (sink /
|
|
// source-stream) on the peer — locally or over ssh — wrapping it in sudo
|
|
// when req.Sudo is set (interactive sudo locally; "sudo -n" remotely, since
|
|
// a password prompt would corrupt the binary stream on stdout).
|
|
func peerAgentCommand(req CtrlMsg, tailArgs []string) *exec.Cmd {
|
|
if req.PeerLocal {
|
|
if req.Sudo {
|
|
return sudoLocalCommand(tailArgs)
|
|
}
|
|
return localAgentCommand(tailArgs)
|
|
}
|
|
peerArgs := append([]string{req.RemoteBin}, tailArgs...)
|
|
if req.Sudo {
|
|
peerArgs = append([]string{"sudo", "-n", "--"}, peerArgs...)
|
|
}
|
|
return sshCommand(req.SSHBin, req.SSHOpts, true, req.ConnectTimeoutSec, req.PeerUser, req.PeerHost, peerArgs)
|
|
}
|
|
|
|
// ---------------------------------------------------------------------
|
|
// push driver: runs inside the SOURCE control agent. Spawns ssh straight
|
|
// to the destination host, running the "sink" role, and — once it answers
|
|
// READY — performs the whole read/hash/compare/send loop itself.
|
|
// ---------------------------------------------------------------------
|
|
|
|
func runPushDriver(req CtrlMsg, out *FrameWriter) {
|
|
tailArgs := []string{
|
|
"agent", "--role", "sink",
|
|
"--path", req.PeerPath,
|
|
"--size", strconv.FormatInt(req.Size, 10),
|
|
"--block-size", strconv.FormatInt(req.BlockSize, 10),
|
|
}
|
|
cmd := peerAgentCommand(req, tailArgs)
|
|
stdin, err := cmd.StdinPipe()
|
|
if err != nil {
|
|
_ = out.WriteJSON(CtrlMsg{Type: msgPushFailed, Reason: err.Error()})
|
|
return
|
|
}
|
|
stdout, err := cmd.StdoutPipe()
|
|
if err != nil {
|
|
_ = out.WriteJSON(CtrlMsg{Type: msgPushFailed, Reason: err.Error()})
|
|
return
|
|
}
|
|
stderrBuf := newLimitedBuffer(4096)
|
|
cmd.Stderr = stderrBuf
|
|
|
|
if err := cmd.Start(); err != nil {
|
|
_ = out.WriteJSON(CtrlMsg{Type: msgPushFailed, Reason: fmt.Sprintf("start ssh: %v", err)})
|
|
return
|
|
}
|
|
fw := NewFrameWriter(stdin)
|
|
fr := NewFrameReader(stdout)
|
|
|
|
timeout := time.Duration(req.ConnectTimeoutSec+2) * time.Second
|
|
if err := waitReady(fr, timeout); err != nil {
|
|
_ = cmd.Process.Kill()
|
|
_ = cmd.Wait()
|
|
_ = out.WriteJSON(CtrlMsg{Type: msgPushFailed, Reason: fmt.Sprintf("%v (remote stderr: %s)", err, stderrBuf.String())})
|
|
return
|
|
}
|
|
|
|
// Handshake succeeded: we're committed to push for this run. The sink
|
|
// now sends the current per-block hashes of the destination it just
|
|
// read; the source loop compares against those to decide what to send.
|
|
hashes, err := readHashFrame(fr)
|
|
if err != nil {
|
|
_ = cmd.Process.Kill()
|
|
_ = cmd.Wait()
|
|
_ = out.WriteJSON(CtrlMsg{Type: msgError, Message: fmt.Sprintf("%v (remote stderr: %s)", err, stderrBuf.String())})
|
|
return
|
|
}
|
|
|
|
srcFile, err := os.Open(req.Path)
|
|
if err != nil {
|
|
_ = cmd.Process.Kill()
|
|
_ = cmd.Wait()
|
|
_ = out.WriteJSON(CtrlMsg{Type: msgError, Message: err.Error(), NeedPriv: isPermErr(err)})
|
|
return
|
|
}
|
|
defer srcFile.Close()
|
|
|
|
if fatalErr := pumpPush(req, hashes, srcFile, fw, fr, out); fatalErr != nil {
|
|
_ = cmd.Process.Kill()
|
|
_ = cmd.Wait()
|
|
_ = out.WriteJSON(CtrlMsg{Type: msgError, Message: fatalErr.Error()})
|
|
return
|
|
}
|
|
if err := cmd.Wait(); err != nil {
|
|
_ = out.WriteJSON(CtrlMsg{Type: msgError, Message: fmt.Sprintf("sink process: %v (stderr: %s)", err, stderrBuf.String())})
|
|
return
|
|
}
|
|
_ = out.WriteJSON(CtrlMsg{Type: msgPushOK})
|
|
}
|
|
|
|
func waitReady(fr *FrameReader, timeout time.Duration) error {
|
|
type result struct {
|
|
typ frameType
|
|
err error
|
|
}
|
|
ch := make(chan result, 1)
|
|
go func() {
|
|
typ, _, err := fr.ReadFrame()
|
|
ch <- result{typ, err}
|
|
}()
|
|
select {
|
|
case r := <-ch:
|
|
if r.err != nil {
|
|
return fmt.Errorf("handshake failed: %w", r.err)
|
|
}
|
|
if r.typ != frameReady {
|
|
return fmt.Errorf("handshake failed: unexpected frame type %d", r.typ)
|
|
}
|
|
return nil
|
|
case <-time.After(timeout):
|
|
return fmt.Errorf("handshake timed out after %s", timeout)
|
|
}
|
|
}
|
|
|
|
type ackEvent struct {
|
|
index uint64
|
|
eof bool
|
|
err error
|
|
}
|
|
|
|
// pumpPush runs the source-side read/hash/compare/send loop against fw
|
|
// (the pipe to the remote sink) while concurrently draining ACK/ERR frames
|
|
// from fr, so it can wait for every sent block's write to be confirmed
|
|
// before declaring the push done.
|
|
func pumpPush(req CtrlMsg, hashes [][32]byte, srcFile *os.File, fw *FrameWriter, fr *FrameReader, out *FrameWriter) error {
|
|
const maxInFlight = 32
|
|
sem := make(chan struct{}, maxInFlight)
|
|
|
|
var pendingMu sync.Mutex
|
|
pending := make(map[uint64]bool)
|
|
|
|
var copied, skipped int64
|
|
var lastProgress time.Time
|
|
maybeProgress := func() {
|
|
if time.Since(lastProgress) < 500*time.Millisecond {
|
|
return
|
|
}
|
|
lastProgress = time.Now()
|
|
_ = out.WriteJSON(CtrlMsg{
|
|
Type: msgProgress, Copied: atomic.LoadInt64(&copied), Skipped: atomic.LoadInt64(&skipped),
|
|
TotalBlocks: int64(len(hashes)),
|
|
})
|
|
}
|
|
|
|
ackEvents := make(chan ackEvent, 256)
|
|
go func() {
|
|
for {
|
|
typ, payload, err := fr.ReadFrame()
|
|
if err != nil {
|
|
if err == io.EOF {
|
|
ackEvents <- ackEvent{eof: true}
|
|
} else {
|
|
ackEvents <- ackEvent{err: err}
|
|
}
|
|
return
|
|
}
|
|
switch typ {
|
|
case frameAck:
|
|
idx, err := decodeIndexFrame(payload)
|
|
if err != nil {
|
|
ackEvents <- ackEvent{err: err}
|
|
return
|
|
}
|
|
ackEvents <- ackEvent{index: idx}
|
|
case frameErr:
|
|
idx, msg, _ := decodeErrFrame(payload)
|
|
ackEvents <- ackEvent{err: fmt.Errorf("remote reported error at block %d: %s", idx, msg)}
|
|
return
|
|
default:
|
|
ackEvents <- ackEvent{err: fmt.Errorf("unexpected frame type %d from sink", typ)}
|
|
return
|
|
}
|
|
}
|
|
}()
|
|
|
|
sendErrCh := make(chan error, 1)
|
|
go func() {
|
|
sendErrCh <- runSourceLoop(sourceLoopParams{
|
|
File: srcFile, Size: req.Size, BlockSize: req.BlockSize, Hashes: hashes, Out: fw,
|
|
OnSkip: func(uint64) { atomic.AddInt64(&skipped, 1); maybeProgress() },
|
|
OnSend: func(idx uint64, _ [32]byte) {
|
|
sem <- struct{}{}
|
|
pendingMu.Lock()
|
|
pending[idx] = true
|
|
pendingMu.Unlock()
|
|
},
|
|
})
|
|
}()
|
|
|
|
// Wait for both: the send loop to finish (all DATA frames + DONE sent)
|
|
// and the ack stream to end. Sink closes its stdout (a clean EOF) only
|
|
// after it has acked every block it received, so an EOF while blocks
|
|
// are still unconfirmed is treated as a real failure below.
|
|
sendCh := sendErrCh
|
|
ackCh := ackEvents
|
|
var fatalErr error
|
|
idle := time.NewTimer(120 * time.Second)
|
|
defer idle.Stop()
|
|
for sendCh != nil || ackCh != nil {
|
|
if !idle.Stop() {
|
|
select {
|
|
case <-idle.C:
|
|
default:
|
|
}
|
|
}
|
|
idle.Reset(120 * time.Second)
|
|
select {
|
|
case sendErr := <-sendCh:
|
|
sendCh = nil
|
|
if sendErr != nil {
|
|
fatalErr = sendErr
|
|
}
|
|
case ev := <-ackCh:
|
|
switch {
|
|
case ev.err != nil:
|
|
fatalErr = ev.err
|
|
ackCh = nil
|
|
case ev.eof:
|
|
ackCh = nil
|
|
default:
|
|
pendingMu.Lock()
|
|
_, ok := pending[ev.index]
|
|
delete(pending, ev.index)
|
|
pendingMu.Unlock()
|
|
if ok {
|
|
atomic.AddInt64(&copied, 1)
|
|
}
|
|
<-sem
|
|
maybeProgress()
|
|
}
|
|
case <-idle.C:
|
|
fatalErr = fmt.Errorf("timed out waiting for the sink")
|
|
}
|
|
if fatalErr != nil {
|
|
break
|
|
}
|
|
}
|
|
if fatalErr != nil {
|
|
return fatalErr
|
|
}
|
|
|
|
pendingMu.Lock()
|
|
n := len(pending)
|
|
pendingMu.Unlock()
|
|
if n > 0 {
|
|
return fmt.Errorf("sink closed the connection with %d block write confirmation(s) still outstanding", n)
|
|
}
|
|
|
|
_ = out.WriteJSON(CtrlMsg{Type: msgProgress, Copied: atomic.LoadInt64(&copied), Skipped: atomic.LoadInt64(&skipped), TotalBlocks: int64(len(hashes))})
|
|
return nil
|
|
}
|
|
|
|
// ---------------------------------------------------------------------
|
|
// pull driver: runs inside the DEST control agent. It reads and hashes the
|
|
// local destination itself, spawns ssh to the source host running the
|
|
// "source-stream" role, feeds it that hash table, then writes whatever it
|
|
// streams back straight to the local destination — no round trip needed to
|
|
// confirm a write, since dest-agent itself performed it.
|
|
// ---------------------------------------------------------------------
|
|
|
|
func runPullDriver(req CtrlMsg, out *FrameWriter) {
|
|
tailArgs := []string{
|
|
"agent", "--role", "source-stream",
|
|
"--path", req.PeerPath,
|
|
"--size", strconv.FormatInt(req.Size, 10),
|
|
"--block-size", strconv.FormatInt(req.BlockSize, 10),
|
|
}
|
|
cmd := peerAgentCommand(req, tailArgs)
|
|
stdin, err := cmd.StdinPipe()
|
|
if err != nil {
|
|
_ = out.WriteJSON(CtrlMsg{Type: msgPullFailed, Reason: err.Error()})
|
|
return
|
|
}
|
|
stdout, err := cmd.StdoutPipe()
|
|
if err != nil {
|
|
_ = out.WriteJSON(CtrlMsg{Type: msgPullFailed, Reason: err.Error()})
|
|
return
|
|
}
|
|
stderrBuf := newLimitedBuffer(4096)
|
|
cmd.Stderr = stderrBuf
|
|
|
|
if err := cmd.Start(); err != nil {
|
|
_ = out.WriteJSON(CtrlMsg{Type: msgPullFailed, Reason: fmt.Sprintf("start ssh: %v", err)})
|
|
return
|
|
}
|
|
fw := NewFrameWriter(stdin)
|
|
fr := NewFrameReader(stdout)
|
|
|
|
timeout := time.Duration(req.ConnectTimeoutSec+2) * time.Second
|
|
if err := waitReady(fr, timeout); err != nil {
|
|
_ = cmd.Process.Kill()
|
|
_ = cmd.Wait()
|
|
_ = out.WriteJSON(CtrlMsg{Type: msgPullFailed, Reason: fmt.Sprintf("%v (remote stderr: %s)", err, stderrBuf.String())})
|
|
return
|
|
}
|
|
|
|
// Handshake succeeded. Open the destination, fingerprint its current
|
|
// content block by block, and hand that table to the source stream so it
|
|
// only sends back what differs.
|
|
dstFile, err := os.OpenFile(req.Path, os.O_RDWR, 0)
|
|
if err != nil {
|
|
_ = cmd.Process.Kill()
|
|
_ = cmd.Wait()
|
|
_ = out.WriteJSON(CtrlMsg{Type: msgError, Message: err.Error(), NeedPriv: isPermErr(err)})
|
|
return
|
|
}
|
|
defer dstFile.Close()
|
|
|
|
hashes, err := hashFileBlocks(dstFile, req.Size, req.BlockSize)
|
|
if err != nil {
|
|
_ = cmd.Process.Kill()
|
|
_ = cmd.Wait()
|
|
_ = out.WriteJSON(CtrlMsg{Type: msgError, Message: err.Error(), NeedPriv: isPermErr(err)})
|
|
return
|
|
}
|
|
if err := fw.WriteFrame(frameHashTable, flattenHashes(hashes)); err != nil {
|
|
_ = cmd.Process.Kill()
|
|
_ = cmd.Wait()
|
|
_ = out.WriteJSON(CtrlMsg{Type: msgError, Message: fmt.Sprintf("send hash table: %v", err)})
|
|
return
|
|
}
|
|
|
|
loopErr := runDestLoop(destLoopParams{
|
|
File: dstFile, BlockSize: req.BlockSize, In: fr,
|
|
OnCtrlMsg: func(m CtrlMsg) {
|
|
if m.Type == msgProgress {
|
|
_ = out.WriteJSON(m)
|
|
}
|
|
},
|
|
})
|
|
|
|
if loopErr != nil {
|
|
_ = cmd.Process.Kill()
|
|
_ = cmd.Wait()
|
|
_ = out.WriteJSON(CtrlMsg{Type: msgError, Message: loopErr.Error()})
|
|
return
|
|
}
|
|
if err := cmd.Wait(); err != nil {
|
|
_ = out.WriteJSON(CtrlMsg{Type: msgError, Message: fmt.Sprintf("source-stream process: %v (stderr: %s)", err, stderrBuf.String())})
|
|
return
|
|
}
|
|
_ = out.WriteJSON(CtrlMsg{Type: msgPullOK})
|
|
}
|
|
|
|
// ---------------------------------------------------------------------
|
|
// sink role: one-shot process spawned (over ssh, in push mode) on the
|
|
// destination host. Dumb write endpoint: verify+pwrite+ack per block.
|
|
// ---------------------------------------------------------------------
|
|
|
|
func runSinkRole(path string, size, blockSize int64) error {
|
|
out := NewFrameWriter(os.Stdout)
|
|
in := NewFrameReader(os.Stdin)
|
|
|
|
f, err := os.OpenFile(path, os.O_RDWR, 0)
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "sink: open %s: %v\n", path, err)
|
|
return err
|
|
}
|
|
defer f.Close()
|
|
|
|
// Answer the handshake immediately so the push driver's short readiness
|
|
// timeout isn't spent hashing a large destination.
|
|
if err := out.WriteFrame(frameReady, nil); err != nil {
|
|
return err
|
|
}
|
|
|
|
hashes, err := hashFileBlocks(f, size, blockSize)
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "sink: hash %s: %v\n", path, err)
|
|
return err
|
|
}
|
|
if err := out.WriteFrame(frameHashTable, flattenHashes(hashes)); err != nil {
|
|
return err
|
|
}
|
|
|
|
return runDestLoop(destLoopParams{File: f, BlockSize: blockSize, In: in, AckOut: out})
|
|
}
|
|
|
|
// ---------------------------------------------------------------------
|
|
// source-stream role: one-shot process spawned (over ssh, in pull mode) on
|
|
// the source host. Reads the hash table, then performs the same
|
|
// read/hash/compare/send loop a local push driver would, writing straight
|
|
// to its own stdout.
|
|
// ---------------------------------------------------------------------
|
|
|
|
func runSourceStreamRole(path string, size, blockSize int64) error {
|
|
out := NewFrameWriter(os.Stdout)
|
|
in := NewFrameReader(os.Stdin)
|
|
|
|
f, err := os.Open(path)
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "source-stream: open %s: %v\n", path, err)
|
|
return err
|
|
}
|
|
defer f.Close()
|
|
|
|
if err := out.WriteFrame(frameReady, nil); err != nil {
|
|
return err
|
|
}
|
|
|
|
typ, payload, err := in.ReadFrame()
|
|
if err != nil {
|
|
return fmt.Errorf("source-stream: read hash table: %w", err)
|
|
}
|
|
if typ != frameHashTable {
|
|
return fmt.Errorf("source-stream: expected hash table frame, got type %d", typ)
|
|
}
|
|
hashes, err := unflattenHashes(payload)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
var copied, skipped int64
|
|
var lastProgress time.Time
|
|
maybeProgress := func() {
|
|
if time.Since(lastProgress) < 500*time.Millisecond {
|
|
return
|
|
}
|
|
lastProgress = time.Now()
|
|
_ = out.WriteJSON(CtrlMsg{Type: msgProgress, Copied: copied, Skipped: skipped, TotalBlocks: int64(len(hashes))})
|
|
}
|
|
|
|
return runSourceLoop(sourceLoopParams{
|
|
File: f, Size: size, BlockSize: blockSize, Hashes: hashes, Out: out,
|
|
OnSkip: func(uint64) { skipped++; maybeProgress() },
|
|
OnSend: func(uint64, [32]byte) { copied++; maybeProgress() },
|
|
})
|
|
}
|