autorestic/internal/location.go

459 lines
11 KiB
Go
Raw Normal View History

2021-04-08 23:55:10 +00:00
package internal
import (
"fmt"
2021-04-11 12:03:38 +00:00
"io/ioutil"
"os"
"path/filepath"
2021-04-15 19:55:35 +00:00
"strings"
2021-04-11 13:02:27 +00:00
"time"
2021-04-12 08:55:57 +00:00
"github.com/cupcakearmy/autorestic/internal/colors"
2022-02-16 20:42:54 +00:00
"github.com/cupcakearmy/autorestic/internal/flags"
2021-04-11 13:02:27 +00:00
"github.com/cupcakearmy/autorestic/internal/lock"
2021-10-26 13:57:40 +00:00
"github.com/cupcakearmy/autorestic/internal/metadata"
2021-04-11 13:02:27 +00:00
"github.com/robfig/cron"
2021-04-08 23:55:10 +00:00
)
2021-04-15 19:55:35 +00:00
type LocationType string
const (
2021-10-31 21:33:02 +00:00
TypeLocal LocationType = "local"
TypeVolume LocationType = "volume"
2021-04-15 19:55:35 +00:00
)
2021-04-08 23:55:10 +00:00
type HookArray = []string
type LocationForgetOption string
const (
LocationForgetYes LocationForgetOption = "yes"
LocationForgetNo LocationForgetOption = "no"
LocationForgetPrune LocationForgetOption = "prune"
)
2021-04-08 23:55:10 +00:00
type Hooks struct {
Dir string `mapstructure:"dir"`
Before HookArray `mapstructure:"before,omitempty"`
After HookArray `mapstructure:"after,omitempty"`
Success HookArray `mapstructure:"success,omitempty"`
Failure HookArray `mapstructure:"failure,omitempty"`
2021-04-08 23:55:10 +00:00
}
type LocationCopy = map[string][]string
2021-04-08 23:55:10 +00:00
type Location struct {
name string `mapstructure:",omitempty"`
From []string `mapstructure:"from,omitempty"`
Type string `mapstructure:"type,omitempty"`
To []string `mapstructure:"to,omitempty"`
Hooks Hooks `mapstructure:"hooks,omitempty"`
Cron string `mapstructure:"cron,omitempty"`
Options Options `mapstructure:"options,omitempty"`
ForgetOption LocationForgetOption `mapstructure:"forget,omitempty"`
CopyOption LocationCopy `mapstructure:"copy,omitempty"`
2021-04-08 23:55:10 +00:00
}
func GetLocation(name string) (Location, bool) {
2021-04-16 20:02:25 +00:00
l, ok := GetConfig().Locations[name]
l.name = name
return l, ok
}
2021-07-11 11:51:04 +00:00
func (l Location) validate() error {
2021-10-31 21:33:02 +00:00
if len(l.From) == 0 {
2021-04-16 20:02:25 +00:00
return fmt.Errorf(`Location "%s" is missing "from" key`, l.name)
2021-04-11 22:02:35 +00:00
}
2021-10-31 21:33:02 +00:00
t, err := l.getType()
if err != nil {
return err
}
switch t {
case TypeLocal:
for _, path := range l.From {
if from, err := GetPathRelativeToConfig(path); err != nil {
2021-05-01 20:54:52 +00:00
return err
} else {
2021-10-31 21:33:02 +00:00
if stat, err := os.Stat(from); err != nil {
return err
} else {
if !stat.IsDir() {
return fmt.Errorf("\"%s\" is not valid directory for location \"%s\"", from, l.name)
}
2021-05-01 20:54:52 +00:00
}
2021-04-24 10:40:33 +00:00
}
}
2021-10-31 21:33:02 +00:00
case TypeVolume:
if len(l.From) > 1 {
return fmt.Errorf(`location "%s" has more than one docker volume`, l.name)
}
2021-04-24 10:40:33 +00:00
}
2021-04-11 22:02:35 +00:00
if len(l.To) == 0 {
return fmt.Errorf(`location "%s" has no "to" targets`, l.name)
2021-04-11 22:02:35 +00:00
}
2021-04-08 23:55:10 +00:00
// Check if backends are all valid
for _, to := range l.To {
_, ok := GetBackend(to)
2021-04-08 23:55:10 +00:00
if !ok {
return fmt.Errorf(`location "%s" has an invalid backend "%s"`, l.name, to)
}
}
// Check copy option
for copyFrom, copyTo := range l.CopyOption {
if _, ok := GetBackend(copyFrom); !ok {
return fmt.Errorf(`location "%s" has an invalid backend "%s" in copy option`, l.name, copyFrom)
}
if !ArrayContains(l.To, copyFrom) {
return fmt.Errorf(`location "%s" has an invalid copy from "%s"`, l.name, copyFrom)
}
for _, copyToTarget := range copyTo {
if _, ok := GetBackend(copyToTarget); !ok {
return fmt.Errorf(`location "%s" has an invalid backend "%s" in copy option`, l.name, copyToTarget)
}
if ArrayContains(l.To, copyToTarget) {
return fmt.Errorf(`location "%s" cannot copy to "%s" as it's already a target`, l.name, copyToTarget)
}
}
}
// Check if forget type is correct
if l.ForgetOption != "" {
if l.ForgetOption != LocationForgetYes && l.ForgetOption != LocationForgetNo && l.ForgetOption != LocationForgetPrune {
return fmt.Errorf("invalid value for forget option: %s", l.ForgetOption)
2021-04-08 23:55:10 +00:00
}
}
return nil
}
2021-10-31 21:33:02 +00:00
func (l Location) ExecuteHooks(commands []string, options ExecuteOptions) error {
2021-04-12 08:55:57 +00:00
if len(commands) == 0 {
return nil
}
2021-10-31 21:33:02 +00:00
if l.Hooks.Dir != "" {
if dir, err := GetPathRelativeToConfig(l.Hooks.Dir); err != nil {
return err
} else {
options.Dir = dir
}
}
2021-04-12 14:15:17 +00:00
colors.Secondary.Println("\nRunning hooks")
2021-04-08 23:55:10 +00:00
for _, command := range commands {
2021-04-12 14:15:17 +00:00
colors.Body.Println("> " + command)
_, out, err := ExecuteCommand(options, "-c", command)
2021-04-12 14:15:17 +00:00
if err != nil {
2021-04-24 10:40:33 +00:00
colors.Error.Println(out)
2021-04-11 16:17:21 +00:00
return err
}
2022-02-16 20:42:54 +00:00
if flags.VERBOSE {
2021-04-24 10:40:33 +00:00
colors.Faint.Println(out)
}
2021-04-11 16:17:21 +00:00
}
2021-04-12 14:15:17 +00:00
colors.Body.Println("")
2021-04-11 16:17:21 +00:00
return nil
}
2021-04-08 23:55:10 +00:00
2021-10-31 21:33:02 +00:00
func (l Location) getType() (LocationType, error) {
t := strings.ToLower(l.Type)
if t == "" || t == "local" {
return TypeLocal, nil
} else if t == "volume" {
return TypeVolume, nil
2021-04-15 19:55:35 +00:00
}
2021-10-31 21:33:02 +00:00
return "", fmt.Errorf("invalid location type \"%s\"", l.Type)
2021-04-15 19:55:35 +00:00
}
2021-11-07 10:48:03 +00:00
func buildTag(parts ...string) string {
2021-10-31 21:33:02 +00:00
parts = append([]string{"ar"}, parts...)
return strings.Join(parts, ":")
2021-04-15 19:55:35 +00:00
}
2021-11-07 10:48:03 +00:00
func (l Location) getLocationTags() string {
return buildTag("location", l.name)
2021-04-15 19:55:35 +00:00
}
2021-10-28 15:29:32 +00:00
func (l Location) Backup(cron bool, specificBackend string) []error {
2021-05-06 13:55:32 +00:00
var errors []error
2021-10-28 15:29:32 +00:00
var backends []string
2021-04-16 20:02:25 +00:00
colors.PrimaryPrint(" Backing up location \"%s\" ", l.name)
2021-10-31 21:33:02 +00:00
t, err := l.getType()
if err != nil {
errors = append(errors, err)
return errors
}
cwd, _ := GetPathRelativeToConfig(".")
2021-04-12 08:55:57 +00:00
options := ExecuteOptions{
Command: "bash",
2021-10-31 21:33:02 +00:00
Dir: cwd,
2021-10-26 13:57:40 +00:00
Envs: map[string]string{
"AUTORESTIC_LOCATION": l.name,
},
2021-04-12 08:55:57 +00:00
}
2021-04-15 19:55:35 +00:00
2021-07-12 17:10:36 +00:00
if err := l.validate(); err != nil {
errors = append(errors, err)
goto after
}
2021-04-15 19:55:35 +00:00
// Hooks
2021-10-31 21:33:02 +00:00
if err := l.ExecuteHooks(l.Hooks.Before, options); err != nil {
2021-05-06 13:55:32 +00:00
errors = append(errors, err)
goto after
2021-04-12 08:55:57 +00:00
}
2021-04-15 19:55:35 +00:00
// Backup
2021-10-28 15:29:32 +00:00
if specificBackend == "" {
backends = l.To
} else {
2021-10-29 16:35:21 +00:00
if l.hasBackend(specificBackend) {
backends = []string{specificBackend}
} else {
errors = append(errors, fmt.Errorf("backup location \"%s\" has no backend \"%s\"", l.name, specificBackend))
return errors
2021-10-28 15:29:32 +00:00
}
}
for i, to := range backends {
2021-04-12 08:55:57 +00:00
backend, _ := GetBackend(to)
2021-04-16 20:02:25 +00:00
colors.Secondary.Printf("Backend: %s\n", backend.name)
2021-04-12 08:55:57 +00:00
env, err := backend.getEnv()
if err != nil {
2021-05-06 13:55:32 +00:00
errors = append(errors, err)
continue
2021-04-08 23:55:10 +00:00
}
2021-04-15 19:55:35 +00:00
2021-04-11 16:17:21 +00:00
cmd := []string{"backup"}
2021-10-31 22:07:12 +00:00
cmd = append(cmd, combineOptions("backup", l, backend)...)
2021-04-20 18:49:09 +00:00
if cron {
2021-11-07 10:48:03 +00:00
cmd = append(cmd, "--tag", buildTag("cron"))
2021-04-20 18:49:09 +00:00
}
2021-11-07 10:48:03 +00:00
cmd = append(cmd, "--tag", l.getLocationTags())
2021-04-15 19:55:35 +00:00
backupOptions := ExecuteOptions{
Envs: env,
}
var code int = 0
2021-04-15 19:55:35 +00:00
var out string
switch t {
case TypeLocal:
2021-10-31 21:33:02 +00:00
for _, from := range l.From {
path, err := GetPathRelativeToConfig(from)
if err != nil {
errors = append(errors, err)
goto after
}
cmd = append(cmd, path)
}
code, out, err = ExecuteResticCommand(backupOptions, cmd...)
2021-04-15 19:55:35 +00:00
case TypeVolume:
2021-10-31 21:33:02 +00:00
ok := CheckIfVolumeExists(l.From[0])
if !ok {
errors = append(errors, fmt.Errorf("volume \"%s\" does not exist", l.From[0]))
continue
}
cmd = append(cmd, "/data")
code, out, err = backend.ExecDocker(l, cmd)
2021-04-08 23:55:10 +00:00
}
2021-10-26 13:57:40 +00:00
// Extract metadata
2021-10-26 13:57:40 +00:00
md := metadata.ExtractMetadataFromBackupLog(out)
md.ExitCode = fmt.Sprint(code)
2021-10-26 13:57:40 +00:00
mdEnv := metadata.MakeEnvFromMetadata(&md)
for k, v := range mdEnv {
options.Envs[k+"_"+fmt.Sprint(i)] = v
options.Envs[k+"_"+strings.ToUpper(backend.name)] = v
}
// If error save it and continue
if err != nil {
colors.Error.Println(out)
errors = append(errors, fmt.Errorf("%s@%s:\n%s%s", l.name, backend.name, out, err))
continue
}
// Copy
if md.SnapshotID != "" {
for copyFrom, copyTo := range l.CopyOption {
b1, _ := GetBackend(copyFrom)
for _, copyToTarget := range copyTo {
b2, _ := GetBackend(copyToTarget)
colors.Secondary.Println("Copying " + copyFrom + " → " + copyToTarget)
env, _ := b1.getEnv()
env2, _ := b2.getEnv()
// Add the second repo to the env with a "2" suffix
for k, v := range env2 {
env[k+"2"] = v
}
_, out, err := ExecuteResticCommand(ExecuteOptions{
Envs: env,
}, "copy", md.SnapshotID)
if flags.VERBOSE {
colors.Faint.Println(out)
}
if err != nil {
errors = append(errors, err)
}
}
}
}
2022-02-16 20:42:54 +00:00
if flags.VERBOSE {
colors.Faint.Println(out)
}
2021-04-12 08:55:57 +00:00
}
2021-04-15 19:55:35 +00:00
// After hooks
2021-10-31 21:33:02 +00:00
if err := l.ExecuteHooks(l.Hooks.After, options); err != nil {
2021-05-06 13:55:32 +00:00
errors = append(errors, err)
2021-04-12 08:55:57 +00:00
}
2021-05-06 13:55:32 +00:00
after:
var commands []string
var isSuccess = len(errors) == 0
if isSuccess {
2021-05-06 13:55:32 +00:00
commands = l.Hooks.Success
} else {
commands = l.Hooks.Failure
2021-05-06 13:55:32 +00:00
}
2021-10-31 21:33:02 +00:00
if err := l.ExecuteHooks(commands, options); err != nil {
2021-05-06 13:55:32 +00:00
errors = append(errors, err)
}
// Forget and optionally prune
if isSuccess && l.ForgetOption != "" && l.ForgetOption != LocationForgetNo {
l.Forget(l.ForgetOption == LocationForgetPrune, false)
}
2021-10-31 21:33:02 +00:00
if len(errors) == 0 {
colors.Success.Println("Done")
}
2021-05-06 13:55:32 +00:00
return errors
2021-04-08 23:55:10 +00:00
}
2021-04-11 11:04:11 +00:00
2021-04-11 12:22:46 +00:00
func (l Location) Forget(prune bool, dry bool) error {
2021-04-16 20:02:25 +00:00
colors.PrimaryPrint("Forgetting for location \"%s\"", l.name)
2021-04-12 14:15:17 +00:00
for _, to := range l.To {
backend, _ := GetBackend(to)
2021-04-16 20:02:25 +00:00
colors.Secondary.Printf("For backend \"%s\"\n", backend.name)
2021-04-12 14:15:17 +00:00
env, err := backend.getEnv()
if err != nil {
return nil
}
options := ExecuteOptions{
2021-04-15 19:55:35 +00:00
Envs: env,
2021-04-12 14:15:17 +00:00
}
2021-11-07 10:48:03 +00:00
cmd := []string{"forget", "--tag", l.getLocationTags()}
2021-04-11 11:04:11 +00:00
if prune {
cmd = append(cmd, "--prune")
}
2021-04-11 12:22:46 +00:00
if dry {
cmd = append(cmd, "--dry-run")
}
2021-10-31 22:07:12 +00:00
cmd = append(cmd, combineOptions("forget", l, backend)...)
_, out, err := ExecuteResticCommand(options, cmd...)
2022-02-16 20:42:54 +00:00
if flags.VERBOSE {
2021-04-12 14:15:17 +00:00
colors.Faint.Println(out)
}
2021-04-11 11:04:11 +00:00
if err != nil {
return err
}
2021-04-12 14:15:17 +00:00
}
colors.Success.Println("Done")
return nil
2021-04-11 11:04:11 +00:00
}
2021-04-11 12:03:38 +00:00
func (l Location) hasBackend(backend string) bool {
for _, b := range l.To {
if b == backend {
return true
}
}
return false
}
func buildRestoreCommand(l Location, to string, snapshot string, options []string) []string {
base := []string{"restore", "--target", to, "--tag", l.getLocationTags(), snapshot}
base = append(base, options...)
return base
}
func (l Location) Restore(to, from string, force bool, snapshot string, options []string) error {
2021-04-11 12:03:38 +00:00
if from == "" {
from = l.To[0]
} else if !l.hasBackend(from) {
return fmt.Errorf("invalid backend: \"%s\"", from)
}
2021-10-31 21:33:02 +00:00
if snapshot == "" {
snapshot = "latest"
}
colors.PrimaryPrint("Restoring location \"%s\"", l.name)
backend, _ := GetBackend(from)
2021-10-31 21:33:02 +00:00
colors.Secondary.Printf("Restoring %s@%s → %s\n", snapshot, backend.name, to)
t, err := l.getType()
2021-04-11 16:17:21 +00:00
if err != nil {
2021-10-31 21:33:02 +00:00
return err
2021-04-11 16:17:21 +00:00
}
2021-10-31 21:33:02 +00:00
switch t {
2021-04-15 19:55:35 +00:00
case TypeLocal:
to, err = filepath.Abs(to)
if err != nil {
return err
}
2021-04-15 19:55:35 +00:00
// Check if target is empty
if !force {
notEmptyError := fmt.Errorf("target %s is not empty", to)
_, err = os.Stat(to)
if err == nil {
files, err := ioutil.ReadDir(to)
if err != nil {
return err
}
if len(files) > 0 {
return notEmptyError
}
} else {
if !os.IsNotExist(err) {
return err
}
}
}
err = backend.Exec(buildRestoreCommand(l, to, snapshot, options))
2021-04-15 19:55:35 +00:00
case TypeVolume:
_, _, err = backend.ExecDocker(l, buildRestoreCommand(l, "/", snapshot, options))
2021-04-15 19:55:35 +00:00
}
2021-04-11 12:03:38 +00:00
if err != nil {
return err
}
2021-04-12 14:15:17 +00:00
colors.Success.Println("Done")
2021-04-11 12:03:38 +00:00
return nil
}
2021-04-11 13:02:27 +00:00
func (l Location) RunCron() error {
if l.Cron == "" {
return nil
}
schedule, err := cron.ParseStandard(l.Cron)
if err != nil {
return err
}
2021-04-16 20:02:25 +00:00
last := time.Unix(lock.GetCron(l.name), 0)
2021-04-11 22:17:29 +00:00
next := schedule.Next(last)
2021-04-11 13:02:27 +00:00
now := time.Now()
if now.After(next) {
2021-04-16 20:02:25 +00:00
lock.SetCron(l.name, now.Unix())
2021-10-28 15:29:32 +00:00
l.Backup(true, "")
2021-04-11 13:02:27 +00:00
} else {
2022-02-16 20:42:54 +00:00
if !flags.CRON_LEAN {
2021-04-28 08:54:07 +00:00
colors.Body.Printf("Skipping \"%s\", not due yet.\n", l.name)
}
2021-04-11 13:02:27 +00:00
}
return nil
}