Bump golang from 1.24-alpine to 1.25-alpine (#454)

Bumps golang from 1.24-alpine to 1.25-alpine.

---
updated-dependencies:
- dependency-name: golang
  dependency-version: 1.25-alpine
  dependency-type: direct:production
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

.github/workflows/ci.yml

@@ -4,25 +4,11 @@ on:
   push:
     branches: [master]
 
-env: 
-  RESTIC_VERSION: "0.17.1"
-
 jobs:
   test:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v3
-
-      - name: Install restic@${{ env.RESTIC_VERSION }}
-        run: |
-          mkdir -p tools/restic
-          curl --fail --location --silent --show-error --output tools/restic/restic.bz2 \
-            "https://github.com/restic/restic/releases/download/v${RESTIC_VERSION}/restic_${RESTIC_VERSION}_linux_amd64.bz2"
-          bzip2 -d tools/restic/restic.bz2
-          chmod +x tools/restic/restic
-          echo "$GITHUB_WORKSPACE/tools/restic" >> "$GITHUB_PATH"
-      - run: restic version
-
       - uses: actions/setup-go@v3
         with:
           go-version: '^1.21'

Dockerfile

@@ -1,4 +1,4 @@
-FROM golang:1.23-alpine as builder
+FROM golang:1.25-alpine as builder
 
 WORKDIR /app
 COPY go.* .
@@ -6,7 +6,7 @@ RUN go mod download
 COPY . .
 RUN go build
 
-FROM restic/restic:0.17.2
+FROM restic/restic:0.17.3
 RUN apk add --no-cache rclone bash curl docker-cli
 COPY --from=builder /app/autorestic /usr/bin/autorestic
 ENTRYPOINT []

cmd/backup.go

@@ -18,9 +18,11 @@ var backupCmd = &cobra.Command{
 		err := lock.Lock()
 		CheckErr(err)
 		defer lock.Unlock()
+		dry, _ := cmd.Flags().GetBool("dry-run")
 
 		selected, err := internal.GetAllOrSelected(cmd, false)
 		CheckErr(err)
+
 		errors := 0
 		for _, name := range selected {
 			var splitted = strings.Split(name, "@")
@@ -29,7 +31,7 @@ var backupCmd = &cobra.Command{
 				specificBackend = splitted[1]
 			}
 			location, _ := internal.GetLocation(splitted[0])
-			errs := location.Backup(false, specificBackend)
+			errs := location.Backup(false, dry, specificBackend)
 			for _, err := range errs {
 				colors.Error.Printf("%s\n\n", err)
 				errors++
@@ -44,4 +46,5 @@ var backupCmd = &cobra.Command{
 func init() {
 	rootCmd.AddCommand(backupCmd)
 	internal.AddFlagsToCommand(backupCmd, false)
+	backupCmd.Flags().Bool("dry-run", false, "do not write changes, show what would be affected")
 }

cmd/backup_test.go

@@ -1,73 +0,0 @@
-package cmd
-
-import (
-	"os"
-	"path"
-	"testing"
-
-	"github.com/spf13/viper"
-	"github.com/stretchr/testify/assert"
-	"gopkg.in/yaml.v3"
-)
-
-func runCmd(t *testing.T, args ...string) error {
-	t.Helper()
-
-	viper.Reset()
-	rootCmd.SetArgs(args)
-
-	err := rootCmd.Execute()
-	return err
-}
-
-func TestBackupCmd(t *testing.T) {
-	workDir := t.TempDir()
-
-	// Prepare content to be backed up
-	locationDir := path.Join(workDir, "my-location")
-	err := os.Mkdir(locationDir, 0750)
-	assert.Nil(t, err)
-	err = os.WriteFile(path.Join(locationDir, "back-me-up.txt"), []byte("hello world"), 0640)
-	assert.Nil(t, err)
-
-	// Write config file
-	config, err := yaml.Marshal(map[string]interface{}{
-		"version": 2,
-		"locations": map[string]map[string]interface{}{
-			"my-location": {
-				"type": "local",
-				"from": []string{locationDir},
-				"to":   []string{"test"},
-			},
-		},
-		"backends": map[string]map[string]interface{}{
-			"test": {
-				"type": "local",
-				"path": path.Join(workDir, "test-backend"),
-				"key":  "supersecret",
-			},
-		},
-	})
-	assert.Nil(t, err)
-	configPath := path.Join(workDir, ".autorestic.yml")
-	err = os.WriteFile(configPath, config, 0640)
-	assert.Nil(t, err)
-
-	// Init repo (not initialized by default)
-	err = runCmd(t, "exec", "--ci", "-a", "-c", configPath, "init")
-	assert.Nil(t, err)
-
-	// Do the backup
-	err = runCmd(t, "backup", "--ci", "-a", "-c", configPath)
-	assert.Nil(t, err)
-
-	// Restore in a separate dir
-	restoreDir := path.Join(workDir, "restore")
-	err = runCmd(t, "restore", "--ci", "-c", configPath, "-l", "my-location", "--to", restoreDir)
-	assert.Nil(t, err)
-
-	// Check restored file
-	restoredContent, err := os.ReadFile(path.Join(restoreDir, locationDir, "back-me-up.txt"))
-	assert.Nil(t, err)
-	assert.Equal(t, "hello world", string(restoredContent))
-}

docs/pages/backend/index.md

@@ -38,19 +38,3 @@ backends:
 ```
 
 With this setting, if a key is missing, `autorestic` will crash instead of generating a new key and updating your config file.
-
-## Automatic Backend Initialization
-
-`autorestic` is able to automatically initialize backends for you. This is done by setting `init: true` in the config for a given backend. For example:
-
-```yaml | .autorestic.yml
-backend:
-  foo:
-    type: ...
-    path: ...
-    init: true
-```
-
-When you set `init: true` on a backend config, `autorestic` will automatically initialize the underlying `restic` repository that powers the backend if it's not already initialized. In practice, this means that the backend will be initialized the first time it is being backed up to.
-
-This option is helpful in cases where you want to automate the configuration of `autorestic`. This means that instead of running `autorestic exec init -b ...` manually when you create a new backend, you can let `autorestic` initialize it for you.

docs/pages/cli/backup.md

@@ -1,11 +1,14 @@
 # Backup
 
 ```bash
-autorestic backup [-l, --location] [-a, --all]
+autorestic backup [-l, --location] [-a, --all] [--dry-run]
 ```
 
 Performs a backup of all locations if the `-a` flag is passed. To only backup some locations pass one or more `-l` or `--location` flags.
 
+The `--dry-run` flag will do a dry run showing what would have been deleted, but won't touch the actual data.
+
+
 ```bash
 # All
 autorestic backup -a

go.mod

@@ -12,7 +12,6 @@ require (
 	github.com/spf13/cobra v1.4.0
 	github.com/spf13/viper v1.11.0
 	github.com/stretchr/testify v1.9.0
-	gopkg.in/yaml.v3 v3.0.1
 )
 
 require (
@@ -36,4 +35,5 @@ require (
 	golang.org/x/text v0.3.8 // indirect
 	gopkg.in/ini.v1 v1.66.4 // indirect
 	gopkg.in/yaml.v2 v2.4.0 // indirect
+	gopkg.in/yaml.v3 v3.0.1 // indirect
 )

internal/backend.go

@@ -24,7 +24,6 @@ type Backend struct {
 	Path       string            `mapstructure:"path,omitempty" yaml:"path,omitempty"`
 	Key        string            `mapstructure:"key,omitempty" yaml:"key,omitempty"`
 	RequireKey bool              `mapstructure:"requireKey,omitempty" yaml:"requireKey,omitempty"`
-	Init       bool              `mapstructure:"init,omitempty" yaml:"init,omitempty"`
 	Env        map[string]string `mapstructure:"env,omitempty" yaml:"env,omitempty"`
 	Rest       BackendRest       `mapstructure:"rest,omitempty" yaml:"rest,omitempty"`
 	Options    Options           `mapstructure:"options,omitempty" yaml:"options,omitempty"`
@@ -131,44 +130,20 @@ func (b Backend) validate() error {
 		return err
 	}
 	options := ExecuteOptions{Envs: env, Silent: true}
-
-	err = b.EnsureInit()
-	if err != nil {
-		return err
-	}
-
+	// Check if already initialized
 	cmd := []string{"check"}
 	cmd = append(cmd, combineBackendOptions("check", b)...)
 	_, _, err = ExecuteResticCommand(options, cmd...)
-	return err
-}
-
-// EnsureInit initializes the backend if it is not already initialized
-func (b Backend) EnsureInit() error {
-	env, err := b.getEnv()
-	if err != nil {
-		return err
-	}
-	options := ExecuteOptions{Envs: env, Silent: true}
-
-	checkInitCmd := []string{"cat", "config"}
-	checkInitCmd = append(checkInitCmd, combineBackendOptions("cat", b)...)
-	_, _, err = ExecuteResticCommand(options, checkInitCmd...)
-
-	// Note that `restic` has a special exit code (10) to indicate that the
-	// repository does not exist. This exit code was introduced in `restic@0.17.0`
-	// on 2024-07-26. We're not using it here because this is a too recent and
-	// people on older versions of `restic` won't have this feature work  correctly.
-	// See: https://restic.readthedocs.io/en/latest/075_scripting.html#exit-codes
-	if err != nil {
+	if err == nil {
+		return nil
+	} else {
+		// If not initialize
 		colors.Body.Printf("Initializing backend \"%s\"...\n", b.name)
-		initCmd := []string{"init"}
-		initCmd = append(initCmd, combineBackendOptions("init", b)...)
-		_, _, err := ExecuteResticCommand(options, initCmd...)
+		cmd := []string{"init"}
+		cmd = append(cmd, combineBackendOptions("init", b)...)
+		_, _, err := ExecuteResticCommand(options, cmd...)
 		return err
 	}
-
-	return err
 }
 
 func (b Backend) Exec(args []string) error {

internal/backend_test.go

@@ -3,10 +3,8 @@ package internal
 import (
 	"fmt"
 	"os"
-	"path"
 	"testing"
 
-	"github.com/cupcakearmy/autorestic/internal/flags"
 	"github.com/spf13/viper"
 	"github.com/stretchr/testify/assert"
 )
@@ -265,69 +263,3 @@ func TestValidate(t *testing.T) {
 		assert.EqualError(t, err, "backend foo requires a key but none was provided")
 	})
 }
-
-func TestValidateInitsRepo(t *testing.T) {
-	// This is normally initialized by the cobra commands but they don't run in
-	// this test so we do it ourselves.
-	flags.RESTIC_BIN = "restic"
-
-	workDir := t.TempDir()
-
-	b := Backend{
-		name: "test",
-		Type: "local",
-		Path: path.Join(workDir, "backend"),
-		Key:  "supersecret",
-	}
-
-	config = &Config{Backends: map[string]Backend{"test": b}}
-	defer func() { config = nil }()
-
-	// Check should fail because the repo doesn't exist
-	err := b.Exec([]string{"check"})
-	assert.Error(t, err)
-
-	err = b.validate()
-	assert.NoError(t, err)
-
-	// Check should pass now
-	err = b.Exec([]string{"check"})
-	assert.NoError(t, err)
-}
-
-func TestEnsureInit(t *testing.T) {
-	// This is normally initialized by the cobra commands but they don't run in
-	// this test so we do it ourselves.
-	flags.RESTIC_BIN = "restic"
-
-	workDir := t.TempDir()
-
-	b := Backend{
-		name: "test",
-		Type: "local",
-		Path: path.Join(workDir, "backend"),
-		Key:  "supersecret",
-	}
-
-	config = &Config{Backends: map[string]Backend{"test": b}}
-	defer func() { config = nil }()
-
-	// Check should fail because the repo doesn't exist
-	err := b.Exec([]string{"check"})
-	assert.Error(t, err)
-
-	err = b.EnsureInit()
-	assert.NoError(t, err)
-
-	// Check should pass now
-	err = b.Exec([]string{"check"})
-	assert.NoError(t, err)
-
-	// Run again to make sure it's idempotent
-	err = b.EnsureInit()
-	assert.NoError(t, err)
-
-	// Check should still pass
-	err = b.Exec([]string{"check"})
-	assert.NoError(t, err)
-}

internal/config.go

@@ -188,15 +188,31 @@ func CheckConfig() error {
 	if !CheckIfResticIsCallable() {
 		return fmt.Errorf(`%s was not found. Install either with "autorestic install" or manually`, flags.RESTIC_BIN)
 	}
-	for name, backend := range c.Backends {
-		backend.name = name
-		if err := backend.validate(); err != nil {
+
+	cwd, _ := GetPathRelativeToConfig(".")
+	for name, location := range c.Locations {
+		location.name = name
+
+		// Hooks before location validation
+		options := ExecuteOptions{
+			Command: "bash",
+			Dir:     cwd,
+			Envs: map[string]string{
+				"AUTORESTIC_LOCATION": location.name,
+			},
+		}
+		if err := location.ExecuteHooks(location.Hooks.PreValidate, options); err != nil {
+			return err
+		}
+
+		if err := location.validate(); err != nil {
 			return err
 		}
 	}
-	for name, location := range c.Locations {
-		location.name = name
-		if err := location.validate(); err != nil {
+
+	for name, backend := range c.Backends {
+		backend.name = name
+		if err := backend.validate(); err != nil {
 			return err
 		}
 	}

internal/location.go

@@ -168,7 +168,7 @@ func (l Location) getLocationTags() string {
 	return buildTag("location", l.name)
 }
 
-func (l Location) Backup(cron bool, specificBackend string) []error {
+func (l Location) Backup(cron bool, dry bool, specificBackend string) []error {
 	var errors []error
 	var backends []string
 	colors.PrimaryPrint("  Backing up location \"%s\"  ", l.name)
@@ -223,19 +223,14 @@ func (l Location) Backup(cron bool, specificBackend string) []error {
 			continue
 		}
 
-		if backend.Init {
-			err = backend.EnsureInit()
-			if err != nil {
-				errors = append(errors, err)
-				continue
-			}
-		}
-
 		cmd := []string{"backup"}
 		cmd = append(cmd, combineAllOptions("backup", l, backend)...)
 		if cron {
 			cmd = append(cmd, "--tag", buildTag("cron"))
 		}
+		if dry {
+			cmd = append(cmd, "--dry-run")
+		}
 		cmd = append(cmd, "--tag", l.getLocationTags())
 		backupOptions := ExecuteOptions{
 			Envs: env,
@@ -455,7 +450,7 @@ func (l Location) RunCron() error {
 	now := time.Now()
 	if now.After(next) {
 		lock.SetCron(l.name, now.Unix())
-		errs := l.Backup(true, "")
+		errs := l.Backup(true, false, "")
 		if len(errs) > 0 {
 			return fmt.Errorf("Failed to backup location \"%s\":\n%w", l.name, errors.Join(errs...))
 		}