Written by: Robert R. Russell on Thursday, August 6, 2020.
Today’s project is parsing a snapshot into a custom datatype that gives us more accessible options to manipulate snapshots. First, the regular expression strings need to be moved into separate files so I can reference them across other files.
The essential parts of a snapshot are:
To parse a snapshot out of a string.
Below is a function that implements the listed requirements.
/*
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 {
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
}
Now that I can create a Snapshot structure I need some utility methods for them.
<path>@<snapshot name>
The following code will implement those utility methods.
/*
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, "%d-%d-%d-%d%d", 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
}
You can get the entire source code for the tool below.
©2020 Robert R. Russell — All rights reserved