Skip to content

A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.

TypeScript fluxerfluxerapp
5.9 KB
Raw Blame
// SPDX-License-Identifier: AGPL-3.0-or-later

package backup

import (
	"errors"
	"fmt"
	"os"
	"path/filepath"
	"slices"
	"sort"
	"strings"
	"time"
)

const (
	FormatVersion = 2
	formatFull    = 1
	Extension     = ".tar.zst"
	ManifestName  = "manifest.json"
	SumsName      = "SHA256SUMS"
	PartialSuffix = ".partial"
	DumpName      = "postgres/fluxer.dump"
	FilesPrefix   = "files/"
	VolumesPrefix = "volumes/"
)

const (
	StageFiles       = "files"
	StageDatabase    = "database"
	StageStopping    = "stopping"
	StageVolumes     = "volumes"
	StageStarting    = "starting"
	StageCompressing = "compressing"
	StageVerifying   = "verifying"
	StageClearing    = "clearing"
	StagePulling     = "pulling"
)

const (
	SkippedDatabase = "database"
	SkippedUploads  = "uploads"
)

const (
	ScopeFull           = "full"
	ScopeWithoutUploads = "without-uploads"
	UploadsVolume       = "seaweedfs-data"
)

var (
	ErrNotBackup = errors.New("backup: not a rexctl backup")
	ErrDamaged   = errors.New("backup: damaged")
	ErrNewer     = errors.New("backup: made by a newer rexctl")
)

type Entry struct {
	Path   string `json:"path"`
	Size   int64  `json:"size"`
	SHA256 string `json:"sha256"`
}

type Manifest struct {
	Format    int         `json:"format"`
	Release   string      `json:"release"`
	Project   string      `json:"project"`
	Domain    string      `json:"domain"`
	CreatedAt time.Time   `json:"created_at"`
	Reason    string      `json:"reason,omitempty"`
	Database  string      `json:"database"`
	Volumes   []string    `json:"volumes"`
	Skipped   []string    `json:"skipped,omitempty"`
	Scope     string      `json:"scope,omitempty"`
	Uploads   *UploadsRef `json:"uploads,omitempty"`
	Entries   []Entry     `json:"entries"`
}

type UploadsRef struct {
	Volume     string `json:"volume,omitempty"`
	CreatedAt  string `json:"created_at,omitempty"`
	Bind       string `json:"bind,omitempty"`
	ID         string `json:"id,omitempty"`
	Inode      uint64 `json:"inode,omitempty"`
	Definition string `json:"definition,omitempty"`
}

func (m *Manifest) WithoutUploads() bool {
	return m.Scope == ScopeWithoutUploads
}

func (m *Manifest) HasSkipped(what string) bool {
	return slices.Contains(m.Skipped, what)
}

type Info struct {
	File      string    `json:"file"`
	Path      string    `json:"path"`
	CreatedAt time.Time `json:"created_at"`
	Release   string    `json:"release"`
	Reason    string    `json:"reason,omitempty"`
	Scope     string    `json:"scope,omitempty"`
	SizeBytes int64     `json:"size_bytes"`
	Domain    string    `json:"-"`
	Project   string    `json:"-"`
}

func (b Info) WithoutUploads() bool {
	return b.Scope == ScopeWithoutUploads
}

func Stat(path string) (*Info, error) {
	m, err := ReadManifest(path)
	if err != nil {
		return nil, err
	}
	fi, err := os.Stat(path)
	if err != nil {
		return nil, err
	}
	return infoFor(path, m, fi.Size()), nil
}

func infoFor(path string, m *Manifest, size int64) *Info {
	return &Info{File: filepath.Base(path), Path: path, CreatedAt: m.CreatedAt, Release: m.Release, Reason: m.Reason, Scope: m.Scope, SizeBytes: size, Domain: m.Domain, Project: m.Project}
}

func List(dir string) ([]Info, error) {
	ents, err := os.ReadDir(dir)
	if errors.Is(err, os.ErrNotExist) {
		return []Info{}, nil
	}
	if err != nil {
		return nil, err
	}
	out := []Info{}
	for _, e := range ents {
		name := e.Name()
		if e.IsDir() || !strings.HasSuffix(name, Extension) {
			continue
		}
		path := filepath.Join(dir, name)
		m, err := ReadManifest(path)
		if err != nil {
			continue
		}
		fi, err := e.Info()
		if err != nil {
			continue
		}
		out = append(out, *infoFor(path, m, fi.Size()))
	}
	sort.Slice(out, func(i, j int) bool { return out[i].CreatedAt.After(out[j].CreatedAt) })
	return out, nil
}

func NewestOf(list []Info, release string) *Info {
	var best *Info
	for i := range list {
		b := &list[i]
		if b.Release != release {
			continue
		}
		if best == nil || b.CreatedAt.After(best.CreatedAt) {
			best = b
		}
	}
	return best
}

func NewestWithUploads(list []Info) *Info {
	var best *Info
	for i := range list {
		b := &list[i]
		if b.WithoutUploads() {
			continue
		}
		if best == nil || b.CreatedAt.After(best.CreatedAt) {
			best = b
		}
	}
	return best
}

func Find(list []Info, path string) *Info {
	if path == "" {
		return nil
	}
	for i := range list {
		if samePath(list[i].Path, path) {
			return &list[i]
		}
	}
	return nil
}

func Prune(dir string, keep int, protect ...string) ([]Info, error) {
	list, err := List(dir)
	if err != nil || keep <= 0 || len(list) <= keep {
		return nil, err
	}
	var removed []Info
	for _, b := range list[keep:] {
		if slices.ContainsFunc(protect, func(p string) bool { return p != "" && samePath(p, b.Path) }) {
			continue
		}
		if err := os.Remove(b.Path); err != nil && !errors.Is(err, os.ErrNotExist) {
			return removed, err
		}
		removed = append(removed, b)
	}
	return removed, nil
}

func fileName(domain string, at time.Time, n int) string {
	var b strings.Builder
	for _, r := range strings.ToLower(domain) {
		switch {
		case r >= 'a' && r <= 'z', r >= '0' && r <= '9', r == '.', r == '-':
			b.WriteRune(r)
		default:
			b.WriteRune('-')
		}
	}
	d := strings.Trim(b.String(), ".-")
	if d == "" {
		d = "instance"
	}
	stamp := at.UTC().Format("20060102-150405")
	if n > 0 {
		return fmt.Sprintf("fluxer-%s-%s-%d%s", d, stamp, n, Extension)
	}
	return fmt.Sprintf("fluxer-%s-%s%s", d, stamp, Extension)
}

func newPath(dir, domain string, at time.Time) (string, error) {
	for n := 0; n < 100; n++ {
		p := filepath.Join(dir, fileName(domain, at, n))
		_, err := os.Lstat(p)
		if errors.Is(err, os.ErrNotExist) {
			_, err = os.Lstat(p + PartialSuffix)
			if errors.Is(err, os.ErrNotExist) {
				return p, nil
			}
		}
		if err != nil && !errors.Is(err, os.ErrNotExist) {
			return "", err
		}
	}
	return "", errors.New("backup: no free file name")
}

func removePartials(dir string) {
	ents, err := os.ReadDir(dir)
	if err != nil {
		return
	}
	for _, e := range ents {
		if strings.HasSuffix(e.Name(), PartialSuffix) {
			os.Remove(filepath.Join(dir, e.Name()))
		}
	}
}