mirror of
https://github.com/octoleo/restic.git
synced 2024-05-28 22:50:48 +00:00
305 lines
7.1 KiB
Go
305 lines
7.1 KiB
Go
package main
|
|
|
|
import (
|
|
"fmt"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/restic/restic"
|
|
"github.com/restic/restic/backend"
|
|
"golang.org/x/crypto/ssh/terminal"
|
|
)
|
|
|
|
type CmdBackup struct {
|
|
Parent string `short:"p" long:"parent" description:"use this parent snapshot (default: last snapshot in repo that has the same target)"`
|
|
Force bool `short:"f" long:"force" description:"Force re-reading the target. Overrides the \"parent\" flag"`
|
|
}
|
|
|
|
func init() {
|
|
_, err := parser.AddCommand("backup",
|
|
"save file/directory",
|
|
"The backup command creates a snapshot of a file or directory",
|
|
&CmdBackup{})
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
}
|
|
|
|
func formatBytes(c uint64) string {
|
|
b := float64(c)
|
|
|
|
switch {
|
|
case c > 1<<40:
|
|
return fmt.Sprintf("%.3f TiB", b/(1<<40))
|
|
case c > 1<<30:
|
|
return fmt.Sprintf("%.3f GiB", b/(1<<30))
|
|
case c > 1<<20:
|
|
return fmt.Sprintf("%.3f MiB", b/(1<<20))
|
|
case c > 1<<10:
|
|
return fmt.Sprintf("%.3f KiB", b/(1<<10))
|
|
default:
|
|
return fmt.Sprintf("%dB", c)
|
|
}
|
|
}
|
|
|
|
func formatSeconds(sec uint64) string {
|
|
hours := sec / 3600
|
|
sec -= hours * 3600
|
|
min := sec / 60
|
|
sec -= min * 60
|
|
if hours > 0 {
|
|
return fmt.Sprintf("%d:%02d:%02d", hours, min, sec)
|
|
}
|
|
|
|
return fmt.Sprintf("%d:%02d", min, sec)
|
|
}
|
|
|
|
func formatPercent(numerator uint64, denominator uint64) string {
|
|
if denominator == 0 {
|
|
return ""
|
|
}
|
|
|
|
percent := 100.0 * float64(numerator) / float64(denominator)
|
|
|
|
if percent > 100 {
|
|
percent = 100
|
|
}
|
|
|
|
return fmt.Sprintf("%3.2f%%", percent)
|
|
}
|
|
|
|
func formatRate(bytes uint64, duration time.Duration) string {
|
|
sec := float64(duration) / float64(time.Second)
|
|
rate := float64(bytes) / sec / (1 << 20)
|
|
return fmt.Sprintf("%.2fMiB/s", rate)
|
|
}
|
|
|
|
func formatDuration(d time.Duration) string {
|
|
sec := uint64(d / time.Second)
|
|
return formatSeconds(sec)
|
|
}
|
|
|
|
func printTree2(indent int, t *restic.Tree) {
|
|
for _, node := range t.Nodes {
|
|
if node.Tree() != nil {
|
|
fmt.Printf("%s%s/\n", strings.Repeat(" ", indent), node.Name)
|
|
printTree2(indent+1, node.Tree())
|
|
} else {
|
|
fmt.Printf("%s%s\n", strings.Repeat(" ", indent), node.Name)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (cmd CmdBackup) Usage() string {
|
|
return "DIR/FILE [snapshot-ID]"
|
|
}
|
|
|
|
func newCacheRefreshProgress() *restic.Progress {
|
|
p := restic.NewProgress(time.Second)
|
|
p.OnStart = func() {
|
|
fmt.Printf("refreshing cache\n")
|
|
}
|
|
|
|
if !terminal.IsTerminal(int(os.Stdout.Fd())) {
|
|
return p
|
|
}
|
|
|
|
p.OnUpdate = func(s restic.Stat, d time.Duration, ticker bool) {
|
|
fmt.Printf("\x1b[2K[%s] %d trees loaded\r", formatDuration(d), s.Trees)
|
|
}
|
|
p.OnDone = func(s restic.Stat, d time.Duration, ticker bool) {
|
|
fmt.Printf("\x1b[2Krefreshed cache in %s\n", formatDuration(d))
|
|
}
|
|
|
|
return p
|
|
}
|
|
|
|
func newScanProgress() *restic.Progress {
|
|
if !terminal.IsTerminal(int(os.Stdout.Fd())) {
|
|
return nil
|
|
}
|
|
|
|
p := restic.NewProgress(time.Second)
|
|
p.OnUpdate = func(s restic.Stat, d time.Duration, ticker bool) {
|
|
fmt.Printf("\x1b[2K[%s] %d directories, %d files, %s\r", formatDuration(d), s.Dirs, s.Files, formatBytes(s.Bytes))
|
|
}
|
|
p.OnDone = func(s restic.Stat, d time.Duration, ticker bool) {
|
|
fmt.Printf("\x1b[2Kscanned %d directories, %d files in %s\n", s.Dirs, s.Files, formatDuration(d))
|
|
}
|
|
|
|
return p
|
|
}
|
|
|
|
func newArchiveProgress(todo restic.Stat) *restic.Progress {
|
|
if !terminal.IsTerminal(int(os.Stdout.Fd())) {
|
|
return nil
|
|
}
|
|
|
|
archiveProgress := restic.NewProgress(time.Second)
|
|
|
|
var bps, eta uint64
|
|
itemsTodo := todo.Files + todo.Dirs
|
|
|
|
archiveProgress.OnUpdate = func(s restic.Stat, d time.Duration, ticker bool) {
|
|
sec := uint64(d / time.Second)
|
|
if todo.Bytes > 0 && sec > 0 && ticker {
|
|
bps = s.Bytes / sec
|
|
if s.Bytes >= todo.Bytes {
|
|
eta = 0
|
|
} else if bps > 0 {
|
|
eta = (todo.Bytes - s.Bytes) / bps
|
|
}
|
|
}
|
|
|
|
itemsDone := s.Files + s.Dirs
|
|
|
|
status1 := fmt.Sprintf("[%s] %s %s/s %s / %s %d / %d items ",
|
|
formatDuration(d),
|
|
formatPercent(s.Bytes, todo.Bytes),
|
|
formatBytes(bps),
|
|
formatBytes(s.Bytes), formatBytes(todo.Bytes),
|
|
itemsDone, itemsTodo)
|
|
status2 := fmt.Sprintf("ETA %s ", formatSeconds(eta))
|
|
|
|
w, _, err := terminal.GetSize(int(os.Stdout.Fd()))
|
|
if err == nil {
|
|
if len(status1)+len(status2) > w {
|
|
max := w - len(status2) - 4
|
|
status1 = status1[:max] + "... "
|
|
}
|
|
}
|
|
|
|
fmt.Printf("\x1b[2K%s%s\r", status1, status2)
|
|
}
|
|
|
|
archiveProgress.OnDone = func(s restic.Stat, d time.Duration, ticker bool) {
|
|
fmt.Printf("\nduration: %s, %s\n", formatDuration(d), formatRate(todo.Bytes, d))
|
|
}
|
|
|
|
return archiveProgress
|
|
}
|
|
|
|
func (cmd CmdBackup) Execute(args []string) error {
|
|
if len(args) == 0 {
|
|
return fmt.Errorf("wrong number of parameters, Usage: %s", cmd.Usage())
|
|
}
|
|
|
|
target := make([]string, 0, len(args))
|
|
for _, d := range args {
|
|
if a, err := filepath.Abs(d); err == nil {
|
|
d = a
|
|
}
|
|
target = append(target, d)
|
|
}
|
|
|
|
s, err := OpenRepo()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
var (
|
|
parentSnapshot string
|
|
parentSnapshotID backend.ID
|
|
)
|
|
|
|
// Force using a parent
|
|
if !cmd.Force && cmd.Parent != "" {
|
|
parentSnapshot, err = s.FindSnapshot(cmd.Parent)
|
|
if err != nil {
|
|
return fmt.Errorf("invalid id %q: %v", cmd.Parent, err)
|
|
}
|
|
|
|
parentSnapshotID, err = backend.ParseID(parentSnapshot)
|
|
if err != nil {
|
|
return fmt.Errorf("invalid parent snapshot id %v", parentSnapshot)
|
|
}
|
|
|
|
fmt.Printf("found parent snapshot %v\n", parentSnapshotID)
|
|
}
|
|
|
|
// Find last snapshot to set it as parent, if not already set
|
|
if !cmd.Force && parentSnapshot == "" {
|
|
samePaths := func(expected, actual []string) bool {
|
|
if len(expected) != len(actual) {
|
|
return false
|
|
}
|
|
for i := range expected {
|
|
if expected[i] != actual[i] {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
var latest time.Time
|
|
|
|
for snapshotIDString := range s.List(backend.Snapshot, make(chan struct{})) {
|
|
snapshotID, err := backend.ParseID(snapshotIDString)
|
|
if err != nil {
|
|
return fmt.Errorf("Error with the listing of snapshots inputting invalid backend ids: %v", err)
|
|
}
|
|
|
|
snapshot, err := restic.LoadSnapshot(s, snapshotID)
|
|
if err != nil {
|
|
return fmt.Errorf("Error listing snapshot: %v", err)
|
|
}
|
|
if snapshot.Time.After(latest) && samePaths(snapshot.Paths, target) {
|
|
latest = snapshot.Time
|
|
parentSnapshotID = snapshotID
|
|
parentSnapshot = snapshotIDString
|
|
}
|
|
|
|
}
|
|
if parentSnapshot != "" {
|
|
fmt.Printf("using parent snapshot %v\n", parentSnapshotID)
|
|
}
|
|
}
|
|
|
|
fmt.Printf("scan %v\n", target)
|
|
|
|
stat, err := restic.Scan(target, newScanProgress())
|
|
|
|
// TODO: add filter
|
|
// arch.Filter = func(dir string, fi os.FileInfo) bool {
|
|
// return true
|
|
// }
|
|
|
|
arch, err := restic.NewArchiver(s)
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "err: %v\n", err)
|
|
}
|
|
|
|
arch.Error = func(dir string, fi os.FileInfo, err error) error {
|
|
// TODO: make ignoring errors configurable
|
|
fmt.Fprintf(os.Stderr, "\x1b[2K\rerror for %s: %v\n", dir, err)
|
|
return nil
|
|
}
|
|
|
|
err = arch.Cache().RefreshSnapshots(s, newCacheRefreshProgress())
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
fmt.Printf("loading blobs\n")
|
|
err = arch.Preload()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
_, id, err := arch.Snapshot(newArchiveProgress(stat), target, parentSnapshotID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
plen, err := s.PrefixLength(backend.Snapshot)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
fmt.Printf("snapshot %s saved\n", id[:plen/2])
|
|
|
|
return nil
|
|
}
|