The zfs backup tool
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

265 lines
6.1 KiB

package main
import (
"errors"
"fmt"
"io"
"os/exec"
"regexp"
"strconv"
"strings"
"time"
)
var _ = exec.Command("echo", "hi")
/*
Snapshot represents a snapshot on a zfs pool and filesystem.
*/
type Snapshot struct {
pool string
fsTree []string
Interval uint64
TimeStamp time.Time
}
/*
ParseSnapshot parses a string into a Snapshot.
It returns nil on error.
*/
func ParseSnapshot(input string) *Snapshot {
var snapshotOnly, err = regexp.Compile("^" + PoolNameRegex + "@" + ZfsSnapshotNameRegex + "$")
if err != nil {
return nil
}
if !snapshotOnly.MatchString(input) {
return nil
}
var snapshotPieces []string = snapshotOnly.FindStringSubmatch(input)
var theSnapshot = Snapshot{}
theSnapshot.Interval = intervalStringToUInt(snapshotPieces[1])
var year, month, day, hour, minute int
year, err = strconv.Atoi(snapshotPieces[2])
if err != nil {
return nil
}
month, err = strconv.Atoi(snapshotPieces[3])
if err != nil {
return nil
}
day, err = strconv.Atoi(snapshotPieces[4])
if err != nil {
return nil
}
hour, err = strconv.Atoi(snapshotPieces[5])
if err != nil {
return nil
}
minute, err = strconv.Atoi(snapshotPieces[6])
if err != nil {
return nil
}
theSnapshot.TimeStamp = time.Date(year, time.Month(month), day, hour, minute, 0, 0, time.UTC)
var splitInput []string = strings.Split(input, "@")
if len(splitInput) != 2 {
return nil
}
var paths []string = strings.Split(splitInput[0], "/")
theSnapshot.pool = paths[0]
if len(paths) > 1 {
theSnapshot.fsTree = make([]string, len(paths)-1)
copy(theSnapshot.fsTree, paths[1:])
}
return &theSnapshot
}
func intervalStringToUInt(input string) uint64 {
switch input {
case "yearly":
return 0
case "monthly":
return 1
case "weekly":
return 2
case "daily":
return 3
case "hourly":
return 4
}
return 5
}
/*
Path returns a string containing the path of the snapshot
*/
func (s Snapshot) Path() string {
var temp strings.Builder
temp.WriteString(s.pool)
if len(s.fsTree) > 0 {
for _, v := range s.fsTree {
temp.WriteString("/" + v)
}
}
return temp.String()
}
/*
Name returns a string containing the full name of snapshot
*/
func (s Snapshot) Name() string {
var temp strings.Builder
temp.WriteString("zfs-auto-snap_")
temp.WriteString(intervalUIntToString(s.Interval) + "-")
fmt.Fprintf(&temp, "%04d-%02d-%02d-%02d%02d", s.TimeStamp.Year(), s.TimeStamp.Month(), s.TimeStamp.Day(), s.TimeStamp.Hour(), s.TimeStamp.Minute())
return temp.String()
}
func intervalUIntToString(x uint64) string {
switch x {
case 0:
return "yearly"
case 1:
return "monthly"
case 2:
return "weekly"
case 3:
return "daily"
case 4:
return "hourly"
}
return "frequent"
}
/*
String returns a string equal to s.Path() + "@" + s.Name() for Snapshot s
*/
func (s Snapshot) String() string {
return s.Path() + "@" + s.Name()
}
/*
CompareSnapshotDates returns -2 if x occured before y and would include y in its interval
returns -1 if x occured before y
returns 0 if x and y are the same snapshot
returns +1 if y occured after x
err is non nill if the snapshots do not have the same path
*/
func CompareSnapshotDates(x Snapshot, y Snapshot) (int, error) {
if x.Path() != y.Path() {
return 0, errors.New("Can only compare snapshots with the same path")
}
if x.Interval == y.Interval {
if x.TimeStamp.Equal(y.TimeStamp) {
return 0, nil
}
if x.TimeStamp.Before(y.TimeStamp) {
return -1, nil
}
return 1, nil
}
if x.Interval < y.Interval { // y is from a more frequent backup interval than x
var interval time.Time
switch x.Interval {
case 0:
interval = x.TimeStamp.AddDate(-1, 0, 0)
case 1:
interval = x.TimeStamp.AddDate(0, -1, 0)
case 2:
interval = x.TimeStamp.AddDate(0, 0, -7)
case 3:
interval = x.TimeStamp.AddDate(0, 0, -1)
case 4:
interval = x.TimeStamp.Add(time.Hour * -1)
case 5:
interval = x.TimeStamp.Add(time.Minute * -15)
}
if x.TimeStamp.Before(y.TimeStamp) {
return 1, nil
}
if interval.Before(y.TimeStamp) {
return -2, nil
}
return -1, nil
}
// y is from a less frequent backup interval than x
if x.TimeStamp.Before(y.TimeStamp) {
return -1, nil
}
if x.TimeStamp.After(y.TimeStamp) {
return 1, nil
}
return 0, nil
}
/*
IncrementalSender sets up a zfs send command which will send an incremental snapshot starting
at from and including through. Sender will be overwritten.
*/
func IncrementalSender(from, through Snapshot, sender *exec.Cmd) (snapData io.ReadCloser, err error) {
sender = exec.Command("zfs", "send", "-c", "-i", from.Name(), through.Name())
snapData, err = sender.StdoutPipe()
return
}
/*
Sender sets up a zfs send command which will send a full snapshot. Sender will be overwritten.
*/
func Sender(through Snapshot, sender *exec.Cmd) (snapdata io.ReadCloser, err error) {
sender = exec.Command("zfs", "send", "-c", through.Name())
snapdata, err = sender.StdoutPipe()
return
}
/*
Receiver sets up a zfs receive command which will receive a snapshot
*/
func Receiver(backupPath string, snap Snapshot, receiver *exec.Cmd) (snapdata io.WriteCloser, err error) {
receiver = exec.Command("zfs", "receive", "-x", "mountpoint", backupPath+snap.Path())
snapdata, err = receiver.StdinPipe()
return
}
/*
func testSnapshot(possible string, increment string) (bool, bool) {
var matches = zfsRegex.FindStringSubmatch(possible)
if matches == nil {
return false, false
}
var isASnapshot = true
if matches[1] == increment {
return isASnapshot, true
}
return isASnapshot, false
}
func isAYearlySnapshot(possible string) bool {
_, isYearly := testSnapshot(possible, "yearly")
return isYearly
}
func isAMonthlySnapshot(possible string) bool {
_, isMonthly := testSnapshot(possible, "monthly")
return isMonthly
}
func isAWeeklySnapshot(possible string) bool {
_, isWeekly := testSnapshot(possible, "weekly")
return isWeekly
}
func isADailySnapshot(possible string) bool {
_, isDaily := testSnapshot(possible, "daily")
return isDaily
}
func isAnHourlySnapshot(possible string) bool {
_, isHourly := testSnapshot(possible, "hourly")
return isHourly
}
func isAFrequentSnapshot(possible string) bool {
_, isFrequent := testSnapshot(possible, "frequent")
return isFrequent
}
*/