151 lines
3.6 KiB
Go
151 lines
3.6 KiB
Go
// Package jobs provides definitions and features for Backup Jobs themselves.
|
|
// [BackupJob] is the primary resource here.
|
|
// [BackupJob.Do] is the main entrypoint for running through the backup process.
|
|
package jobs
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"log"
|
|
"os/exec"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"git.gentoo.party/sam/thanks/internal/zfs"
|
|
)
|
|
|
|
type BackupJob struct {
|
|
Source string `yaml:"source"` // the source dataset (e.g., zroot)
|
|
TargetHost string `yaml:"targetHost"` // SSH-compatible host
|
|
Target string `yaml:"target"` // the target dataset
|
|
Keep int `yaml:"keep"` // number of snapshots to keep
|
|
Recursive bool `yaml:"recursive"` // create recursive snapshots
|
|
Prefix string `yaml:"prefix"` // name each snapshot with this prefix
|
|
}
|
|
|
|
// func (j *BackupJob) getBaseSnap() {
|
|
// params := "zfs get -j -d 1 -t snapshot guid,creation %s"
|
|
// srcCmd := fmt.Sprintf(params, j.Source)
|
|
// dstCmd := fmt.Sprintf(params, j.Target)
|
|
// }
|
|
func (j *BackupJob) listSnapshots(ctx context.Context) ([]zfs.Snapshot, error) {
|
|
out, err := zfs.Cmd(ctx, "zfs list -Hp -o name,creation -t snapshot -s creation %s | grep '%s'", j.Source, j.Prefix)
|
|
if err != nil {
|
|
execErr, ok := err.(*exec.ExitError)
|
|
if !ok {
|
|
log.Printf("%s\n", out)
|
|
return nil, err
|
|
}
|
|
|
|
if execErr.ExitCode() == 1 {
|
|
return nil, nil
|
|
}
|
|
}
|
|
|
|
snapList := strings.Split(string(out), "\n")
|
|
snaps := make([]zfs.Snapshot, len(snapList)-1)
|
|
|
|
for i, snap := range snapList {
|
|
params := strings.Split(snap, "\t") // "zroot@foo\tTIME" -> ["zroot@foo", "TIME"]
|
|
if len(params) != 2 {
|
|
continue
|
|
}
|
|
log.Printf("%+v\n", params)
|
|
t, err := strconv.ParseInt(params[1], 10, 64)
|
|
if err != nil {
|
|
log.Fatalf("invalid time %s", params[1])
|
|
}
|
|
|
|
identifier := strings.Split(params[0], "@") // zroot@foo -> ["zroot", "foo"]
|
|
|
|
snaps[i] = zfs.Snapshot{
|
|
SnapshotName: identifier[1],
|
|
Dataset: identifier[0],
|
|
Name: params[0],
|
|
Creation: time.Unix(t, 0),
|
|
}
|
|
}
|
|
|
|
return snaps, nil
|
|
}
|
|
|
|
func (j *BackupJob) snapName() string {
|
|
// ts := time.Now().Format(time.RFC3339)
|
|
ts := time.Now().UnixMicro()
|
|
if j.Prefix == "" {
|
|
return fmt.Sprintf("%d", ts)
|
|
} else {
|
|
return fmt.Sprintf("%s%d", j.Prefix, ts)
|
|
}
|
|
}
|
|
|
|
func (j *BackupJob) Snapshot(ctx context.Context) (string, error) {
|
|
snapName := j.snapName()
|
|
snap := fmt.Sprintf("%s@%s", j.Source, snapName)
|
|
|
|
out, err := zfs.Cmd(
|
|
ctx,
|
|
"zfs snapshot %s",
|
|
snap,
|
|
)
|
|
if err != nil {
|
|
log.Printf("zfs-snapshot: error: %s", out)
|
|
return snapName, nil
|
|
}
|
|
return snap, err
|
|
}
|
|
|
|
func (j *BackupJob) FullSend(ctx context.Context, snap string) {
|
|
out, err := zfs.Cmd(
|
|
ctx,
|
|
"zfs send -Lec %s | ssh %s zfs recv -Fu %s",
|
|
snap,
|
|
j.TargetHost,
|
|
j.Target,
|
|
)
|
|
if err != nil {
|
|
log.Fatalf("zfs-send: error: %s", out)
|
|
}
|
|
}
|
|
|
|
func (j *BackupJob) IncrementalSend(ctx context.Context, prevSnap *zfs.Snapshot, newSnap string) {
|
|
out, err := zfs.Cmd(
|
|
ctx,
|
|
"zfs send -I@%s %s | ssh %s zfs recv %s",
|
|
prevSnap.SnapshotName,
|
|
newSnap,
|
|
j.TargetHost,
|
|
j.Target,
|
|
)
|
|
if err != nil {
|
|
// FIXME: return an error so we can cleanup
|
|
log.Fatalf("zfs-send: error: %s", out)
|
|
}
|
|
}
|
|
|
|
func (j *BackupJob) Do(ctx context.Context) {
|
|
currentSnaps, err := j.listSnapshots(ctx)
|
|
if err != nil {
|
|
log.Fatal("failed to list existing snapshots")
|
|
}
|
|
var prev *zfs.Snapshot
|
|
|
|
if len(currentSnaps) > 0 {
|
|
prev = ¤tSnaps[len(currentSnaps)-1]
|
|
}
|
|
|
|
newSnapshot, err := j.Snapshot(ctx)
|
|
if err != nil {
|
|
log.Fatalf("error creating new snapshot: %s", err.Error())
|
|
}
|
|
|
|
if prev == nil {
|
|
// Full Send
|
|
j.FullSend(ctx, newSnapshot)
|
|
} else {
|
|
// Inc send
|
|
j.IncrementalSend(ctx, prev, newSnapshot)
|
|
}
|
|
}
|