wal-g

1
package pg
2

3
import (
4
	"github.com/spf13/cobra"
5
	"github.com/wal-g/tracelog"
6
	"github.com/wal-g/wal-g/internal"
7
	"github.com/wal-g/wal-g/internal/databases/postgres"
8
	"github.com/wal-g/wal-g/internal/multistorage"
9
	"github.com/wal-g/wal-g/internal/multistorage/policies"
10
	"github.com/wal-g/wal-g/pkg/storages/storage"
11
)
12

13
const UseSentinelTimeFlag = "use-sentinel-time"
14
const UseSentinelTimeDescription = "Use backup creation time from sentinel for backups ordering."
15
const DeleteGarbageExamples = `  garbage           Deletes outdated WAL archives and leftover backups files from storage
16
  garbage ARCHIVES  Deletes only outdated WAL archives from storage
17
  garbage BACKUPS   Deletes only leftover backups files from storage`
18
const DeleteGarbageUse = "garbage [ARCHIVES|BACKUPS]"
19
const afterFlag = "after"
20

21
var confirmed = false
22
var useSentinelTime = false
23
var deleteTargetUserData = ""
24

25
// deleteCmd represents the delete command
26
var deleteCmd = &cobra.Command{
27
	Use:   "delete",
28
	Short: internal.DeleteShortDescription, // TODO : improve description
29
}
30

31
var deleteBeforeCmd = &cobra.Command{
32
	Use:     internal.DeleteBeforeUsageExample, // TODO : improve description
33
	Example: internal.DeleteBeforeExamples,
34
	Args:    internal.DeleteBeforeArgsValidator,
35
	Run:     runDeleteBefore,
36
}
37

38
var deleteRetainCmd = &cobra.Command{
39
	Use:       internal.DeleteRetainUsageExample, // TODO : improve description
40
	Example:   internal.DeleteRetainExamples,
41
	ValidArgs: internal.StringModifiers,
42
	Args:      internal.DeleteRetainArgsValidator,
43
	Run:       runDeleteRetain,
44
}
45

46
var deleteEverythingCmd = &cobra.Command{
47
	Use:       internal.DeleteEverythingUsageExample, // TODO : improve description
48
	Example:   internal.DeleteEverythingExamples,
49
	ValidArgs: internal.StringModifiersDeleteEverything,
50
	Args:      internal.DeleteEverythingArgsValidator,
51
	Run:       runDeleteEverything,
52
}
53

54
var deleteTargetCmd = &cobra.Command{
55
	Use:     internal.DeleteTargetUsageExample, // TODO : improve description
56
	Example: internal.DeleteTargetExamples,
57
	Args:    internal.DeleteTargetArgsValidator,
58
	Run:     runDeleteTarget,
59
}
60

61
var deleteGarbageCmd = &cobra.Command{
62
	Use:     DeleteGarbageUse,
63
	Example: DeleteGarbageExamples,
64
	Args:    DeleteGarbageArgsValidator,
65
	Run:     runDeleteGarbage,
66
}
67

68
func runDeleteBefore(cmd *cobra.Command, args []string) {
69
	folder := configureFolder()
70

71
	permanentBackups, permanentWals := postgres.GetPermanentBackupsAndWals(folder)
72

73
	deleteHandler, err := postgres.NewDeleteHandler(folder, permanentBackups, permanentWals, useSentinelTime)
74
	tracelog.ErrorLogger.FatalOnError(err)
75

76
	deleteHandler.HandleDeleteBefore(args, confirmed)
77
}
78

79
func runDeleteRetain(cmd *cobra.Command, args []string) {
80
	folder := configureFolder()
81

82
	permanentBackups, permanentWals := postgres.GetPermanentBackupsAndWals(folder)
83

84
	deleteHandler, err := postgres.NewDeleteHandler(folder, permanentBackups, permanentWals, useSentinelTime)
85
	tracelog.ErrorLogger.FatalOnError(err)
86

87
	afterValue, _ := cmd.Flags().GetString(afterFlag)
88
	if afterValue == "" {
89
		deleteHandler.HandleDeleteRetain(args, confirmed)
90
	} else {
91
		deleteHandler.HandleDeleteRetainAfter(append(args, afterValue), confirmed)
92
	}
93
}
94

95
func runDeleteEverything(cmd *cobra.Command, args []string) {
96
	folder := configureFolder()
97

98
	permanentBackups, permanentWals := postgres.GetPermanentBackupsAndWals(folder)
99

100
	deleteHandler, err := postgres.NewDeleteHandler(folder, permanentBackups, permanentWals, useSentinelTime)
101
	tracelog.ErrorLogger.FatalOnError(err)
102

103
	permanentBackupNames := make([]string, 0, len(permanentBackups))
104
	for backup, isPerm := range permanentBackups {
105
		if isPerm {
106
			permanentBackupNames = append(permanentBackupNames, backup.Name)
107
		}
108
	}
109
	deleteHandler.HandleDeleteEverything(args, permanentBackupNames, confirmed)
110
}
111

112
func runDeleteTarget(cmd *cobra.Command, args []string) {
113
	folder := configureFolder()
114

115
	permanentBackups, permanentWals := postgres.GetPermanentBackupsAndWals(folder)
116

117
	findFullBackup := false
118
	modifier := internal.ExtractDeleteTargetModifierFromArgs(args)
119
	if modifier == internal.FindFullDeleteModifier {
120
		findFullBackup = true
121
		// remove the extracted modifier from args
122
		args = args[1:]
123
	}
124

125
	deleteHandler, err := postgres.NewDeleteHandler(folder, permanentBackups, permanentWals, useSentinelTime)
126
	tracelog.ErrorLogger.FatalOnError(err)
127
	targetBackupSelector, err := internal.CreateTargetDeleteBackupSelector(cmd, args, deleteTargetUserData, postgres.NewGenericMetaFetcher())
128
	tracelog.ErrorLogger.FatalOnError(err)
129

130
	deleteHandler.HandleDeleteTarget(targetBackupSelector, confirmed, findFullBackup)
131
}
132

133
func runDeleteGarbage(cmd *cobra.Command, args []string) {
134
	folder := configureFolder()
135

136
	permanentBackups, permanentWals := postgres.GetPermanentBackupsAndWals(folder)
137

138
	deleteHandler, err := postgres.NewDeleteHandler(folder, permanentBackups, permanentWals, false)
139
	tracelog.ErrorLogger.FatalOnError(err)
140

141
	err = deleteHandler.HandleDeleteGarbage(args, confirmed)
142
	tracelog.ErrorLogger.FatalOnError(err)
143
}
144

145
func configureFolder() storage.Folder {
146
	multiSt, err := postgres.ConfigureMultiStorage(true)
147
	tracelog.ErrorLogger.FatalfOnError("Failed to configure multi-storage: %v", err)
148

149
	rootFolder, err := multistorage.UseAllAliveStorages(multiSt.RootFolder())
150
	tracelog.InfoLogger.Printf("Backup to delete will be searched in storages: %v", multistorage.UsedStorages(rootFolder))
151
	tracelog.ErrorLogger.FatalOnError(err)
152
	return multistorage.SetPolicies(rootFolder, policies.UniteAllStorages)
153
}
154

155
func DeleteGarbageArgsValidator(cmd *cobra.Command, args []string) error {
156
	modifiers := []string{postgres.DeleteGarbageArchivesModifier, postgres.DeleteGarbageBackupsModifier}
157
	return internal.DeleteArgsValidator(args, modifiers, 0, 1)
158
}
159

160
func init() {
161
	Cmd.AddCommand(deleteCmd)
162

163
	deleteTargetCmd.Flags().StringVar(
164
		&deleteTargetUserData, internal.DeleteTargetUserDataFlag, "", internal.DeleteTargetUserDataDescription)
165
	deleteRetainCmd.Flags().StringP(afterFlag, "a", "", "Set the time after which retain backups")
166

167
	deleteCmd.AddCommand(deleteRetainCmd, deleteBeforeCmd, deleteEverythingCmd, deleteTargetCmd, deleteGarbageCmd)
168
	deleteCmd.PersistentFlags().BoolVar(&confirmed, internal.ConfirmFlag, false, "Confirms backup deletion")
169
	deleteCmd.PersistentFlags().BoolVar(&useSentinelTime, UseSentinelTimeFlag, false, UseSentinelTimeDescription)
170
}
171