feat: docker compose backup
This commit is contained in:
@@ -0,0 +1,261 @@
|
||||
package backup
|
||||
|
||||
import (
|
||||
"archive/tar"
|
||||
"compress/gzip"
|
||||
"context"
|
||||
"fmt"
|
||||
"io"
|
||||
"log/slog"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"time"
|
||||
|
||||
"git.misaka.ren/M1saka/docker_backup/internal/config"
|
||||
)
|
||||
|
||||
// Result holds the outcome of backing up a single project.
|
||||
type Result struct {
|
||||
ProjectName string
|
||||
Error error
|
||||
BackupPath string
|
||||
FileSize int64
|
||||
Downtime time.Duration
|
||||
Duration time.Duration
|
||||
}
|
||||
|
||||
// Engine orchestrates backup of Docker Compose projects.
|
||||
type Engine struct {
|
||||
BackupDir string
|
||||
TempDir string
|
||||
DryRun bool
|
||||
Logger *slog.Logger
|
||||
}
|
||||
|
||||
// NewEngine creates a new backup engine.
|
||||
func NewEngine(backupDir, tempDir string, dryRun bool, logger *slog.Logger) *Engine {
|
||||
if logger == nil {
|
||||
logger = slog.Default()
|
||||
}
|
||||
return &Engine{
|
||||
BackupDir: backupDir,
|
||||
TempDir: tempDir,
|
||||
DryRun: dryRun,
|
||||
Logger: logger,
|
||||
}
|
||||
}
|
||||
|
||||
// Run backs up all configured projects. Results are returned in order.
|
||||
func (e *Engine) Run(ctx context.Context, projects []config.ProjectConfig) []Result {
|
||||
results := make([]Result, 0, len(projects))
|
||||
for _, proj := range projects {
|
||||
results = append(results, e.backupOne(ctx, proj))
|
||||
}
|
||||
return results
|
||||
}
|
||||
|
||||
func (e *Engine) backupOne(ctx context.Context, proj config.ProjectConfig) Result {
|
||||
start := time.Now()
|
||||
result := Result{ProjectName: proj.Name}
|
||||
|
||||
if err := ctx.Err(); err != nil {
|
||||
result.Error = err
|
||||
result.Duration = time.Since(start)
|
||||
return result
|
||||
}
|
||||
|
||||
e.Logger.Info("starting backup", "project", proj.Name, "path", proj.Path)
|
||||
|
||||
composeFilePath := filepath.Join(proj.Path, proj.ComposeFile)
|
||||
if _, err := os.Stat(composeFilePath); err != nil && !e.DryRun {
|
||||
result.Error = fmt.Errorf("compose file not found: %s: %w", composeFilePath, err)
|
||||
result.Duration = time.Since(start)
|
||||
return result
|
||||
}
|
||||
|
||||
backupPath := e.backupPath(proj.Name)
|
||||
if e.DryRun {
|
||||
result.BackupPath = backupPath
|
||||
result.Duration = time.Since(start)
|
||||
e.Logger.Info("dry-run: backup plan complete", "project", proj.Name, "file", backupPath)
|
||||
return result
|
||||
}
|
||||
|
||||
executor := NewComposeExecutor(proj.Path, proj.ComposeFile)
|
||||
|
||||
// 1. Stop the compose project.
|
||||
stopStart := time.Now()
|
||||
if err := executor.Stop(ctx); err != nil {
|
||||
result.Error = fmt.Errorf("stop: %w", err)
|
||||
result.Duration = time.Since(start)
|
||||
return result
|
||||
}
|
||||
e.Logger.Info("compose stopped", "project", proj.Name)
|
||||
|
||||
// 2. Create a staging directory.
|
||||
stagingDir, err := os.MkdirTemp(e.TempDir, "dc-backup-"+proj.Name+"-*")
|
||||
if err != nil {
|
||||
_ = restartCompose(executor)
|
||||
result.Error = fmt.Errorf("create staging dir: %w", err)
|
||||
result.Duration = time.Since(start)
|
||||
return result
|
||||
}
|
||||
|
||||
// 3. Copy project directory to staging.
|
||||
copier := &DirectoryCopier{Exclude: proj.Exclude, Context: ctx}
|
||||
if err := copier.Copy(proj.Path, stagingDir); err != nil {
|
||||
_ = os.RemoveAll(stagingDir)
|
||||
_ = restartCompose(executor)
|
||||
result.Error = fmt.Errorf("copy: %w", err)
|
||||
result.Duration = time.Since(start)
|
||||
return result
|
||||
}
|
||||
e.Logger.Info("files copied to staging", "project", proj.Name, "staging", stagingDir)
|
||||
|
||||
// 4. Immediately restart the compose project.
|
||||
if err := restartCompose(executor); err != nil {
|
||||
_ = os.RemoveAll(stagingDir)
|
||||
result.Error = fmt.Errorf("start: %w", err)
|
||||
result.Duration = time.Since(start)
|
||||
return result
|
||||
}
|
||||
result.Downtime = time.Since(stopStart)
|
||||
e.Logger.Info("compose restarted", "project", proj.Name, "downtime", result.Downtime)
|
||||
|
||||
// 5. Compress staging directory to the backup destination.
|
||||
backupDir := filepath.Dir(backupPath)
|
||||
if err := os.MkdirAll(backupDir, 0755); err != nil {
|
||||
_ = os.RemoveAll(stagingDir)
|
||||
result.Error = fmt.Errorf("create backup dir: %w", err)
|
||||
result.Duration = time.Since(start)
|
||||
return result
|
||||
}
|
||||
|
||||
if err := createTarGz(ctx, stagingDir, backupPath); err != nil {
|
||||
_ = os.RemoveAll(stagingDir)
|
||||
result.Error = fmt.Errorf("compress: %w", err)
|
||||
result.Duration = time.Since(start)
|
||||
return result
|
||||
}
|
||||
e.Logger.Info("backup compressed", "project", proj.Name, "file", backupPath)
|
||||
|
||||
// 6. Clean up staging.
|
||||
_ = os.RemoveAll(stagingDir)
|
||||
|
||||
// 7. Record file size.
|
||||
if fi, err := os.Stat(backupPath); err == nil {
|
||||
result.FileSize = fi.Size()
|
||||
}
|
||||
|
||||
result.BackupPath = backupPath
|
||||
result.Duration = time.Since(start)
|
||||
e.Logger.Info("backup complete", "project", proj.Name, "duration", result.Duration, "size", result.FileSize)
|
||||
return result
|
||||
}
|
||||
|
||||
func (e *Engine) backupPath(projectName string) string {
|
||||
timestamp := time.Now().Format("20060102-150405.000000000")
|
||||
backupFile := fmt.Sprintf("%s-%s.tar.gz", projectName, timestamp)
|
||||
return filepath.Join(e.BackupDir, projectName, backupFile)
|
||||
}
|
||||
|
||||
func restartCompose(executor *ComposeExecutor) error {
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
|
||||
defer cancel()
|
||||
return executor.Start(ctx)
|
||||
}
|
||||
|
||||
// createTarGz creates a tar.gz archive from a source directory.
|
||||
func createTarGz(ctx context.Context, srcDir, dstPath string) error {
|
||||
f, err := os.Create(dstPath)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
gw := gzip.NewWriter(f)
|
||||
tw := tar.NewWriter(gw)
|
||||
|
||||
walkErr := filepath.WalkDir(srcDir, func(path string, d os.DirEntry, err error) error {
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
select {
|
||||
case <-ctx.Done():
|
||||
return ctx.Err()
|
||||
default:
|
||||
}
|
||||
|
||||
rel, err := filepath.Rel(srcDir, path)
|
||||
if err != nil {
|
||||
return fmt.Errorf("rel: %w", err)
|
||||
}
|
||||
if rel == "." {
|
||||
return nil
|
||||
}
|
||||
|
||||
info, err := d.Info()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
linkTarget := ""
|
||||
if info.Mode()&os.ModeSymlink != 0 {
|
||||
linkTarget, err = os.Readlink(path)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
|
||||
header, err := tar.FileInfoHeader(info, linkTarget)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
header.Name = filepath.ToSlash(rel)
|
||||
|
||||
if err := tw.WriteHeader(header); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
if d.IsDir() || !info.Mode().IsRegular() {
|
||||
return nil
|
||||
}
|
||||
|
||||
return copyFileToTar(tw, path)
|
||||
})
|
||||
|
||||
closeErr := closeTarGz(tw, gw, f)
|
||||
if walkErr != nil {
|
||||
return walkErr
|
||||
}
|
||||
return closeErr
|
||||
}
|
||||
|
||||
func closeTarGz(tw *tar.Writer, gw *gzip.Writer, f *os.File) error {
|
||||
if err := tw.Close(); err != nil {
|
||||
_ = gw.Close()
|
||||
_ = f.Close()
|
||||
return fmt.Errorf("close tar: %w", err)
|
||||
}
|
||||
if err := gw.Close(); err != nil {
|
||||
_ = f.Close()
|
||||
return fmt.Errorf("close gzip: %w", err)
|
||||
}
|
||||
if err := f.Close(); err != nil {
|
||||
return fmt.Errorf("close file: %w", err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// copyFileToTar opens a file and copies it into the tar writer.
|
||||
// The file is closed before returning — no deferred leak in a loop.
|
||||
func copyFileToTar(tw *tar.Writer, path string) error {
|
||||
srcFile, err := os.Open(path)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
defer srcFile.Close()
|
||||
|
||||
_, err = io.Copy(tw, srcFile)
|
||||
return err
|
||||
}
|
||||
Reference in New Issue
Block a user