backup

func (*Repository) lock(flag int) (*repoLock, error)
{
	lockPath := filepath.Join(r.Root, ".repo.lock")
	f, err := os.OpenFile(lockPath, os.O_CREATE|os.O_RDWR, 0o600)
	if err != nil {
		return nil, err
	}
	if err := syscall.Flock(int(f.Fd()), flag); err != nil {
		_ = f.Close()
		return nil, err
	}
	return &repoLock{f: f}, nil
}

func (*Repository) CreateSnapshot(sourcePath string, opts CreateSnapshotOptions) (*Snapshot, error)
{
	l, err := r.lockExclusive()
	if err != nil {
		return nil, err
	}
	defer func() { _ = l.Close() }()

	id := opts.ID
	if id == "" {
		id = newSnapshotID()
	}

	finalPath := filepath.Join(r.SnapshotsDir, id)
	tmpBase := filepath.Join(r.SnapshotsDir, ".tmp")
	tmpPath := filepath.Join(tmpBase, id)
	treePath := filepath.Join(tmpPath, "tree")

	if err := os.MkdirAll(tmpBase, 0o755); err != nil {
		return nil, err
	}
	_ = os.RemoveAll(tmpPath)
	if err := os.MkdirAll(treePath, 0o755); err != nil {
		return nil, err
	}

	copyOpts := opts.CopyOptions
	if copyOpts.Workers == 0 {
		copyOpts = DefaultCopyOptions()
	}
	if err := fs.CopyTree(sourcePath, treePath, copyOpts); err != nil {
		_ = os.RemoveAll(tmpPath)
		return nil, err
	}

	if opts.Deduplicate {
		workers := opts.DedupWorkers
		if workers <= 0 {
			workers = 2
		}

		s, err := storage.NewStorage(storage.StorageOptions{Root: r.ObjectsDir, WithMetadata: opts.DedupWithMetadata})
		if err != nil {
			_ = os.RemoveAll(tmpPath)
			return nil, err
		}
		h := hash.NewSHA256Generator()
		p := processor.NewDedupProcessor(treePath, "", s, h, workers)
		d := dabadee.NewDaBaDee(p, false)
		if err := d.Run(); err != nil {
			_ = os.RemoveAll(tmpPath)
			return nil, err
		}
	}

	m := SnapshotManifest{
		ID:          id,
		CreatedAt:   time.Now().UTC(),
		SourcePath:  sourcePath,
		Deduplicate: opts.Deduplicate,
	}
	if err := writeManifest(filepath.Join(tmpPath, "manifest.json"), m); err != nil {
		_ = os.RemoveAll(tmpPath)
		return nil, err
	}

	if _, err := os.Stat(finalPath); err == nil {
		_ = os.RemoveAll(tmpPath)
		return nil, fmt.Errorf("snapshot already exists: %s", id)
	}
	if err := os.Rename(tmpPath, finalPath); err != nil {
		_ = os.RemoveAll(tmpPath)
		return nil, err
	}

	return &Snapshot{Manifest: m, Path: finalPath, TreePath: filepath.Join(finalPath, "tree")}, nil
}

func (*Repository) RestoreSnapshot(snapshotID, destination string, copyOpts fs.CopyTreeOptions) error
{
	l, err := r.lockShared()
	if err != nil {
		return err
	}
	defer func() { _ = l.Close() }()

	tree := filepath.Join(r.SnapshotsDir, snapshotID, "tree")
	if _, err := os.Stat(tree); err != nil {
		return err
	}
	if copyOpts.Workers == 0 {
		copyOpts = DefaultCopyOptions()
	}
	return fs.CopyTree(tree, destination, copyOpts)
}

func (*Repository) ListSnapshots() ([]SnapshotManifest, error)
{
	l, err := r.lockShared()
	if err != nil {
		return nil, err
	}
	defer func() { _ = l.Close() }()

	entries, err := os.ReadDir(r.SnapshotsDir)
	if err != nil {
		return nil, err
	}

	snaps := make([]SnapshotManifest, 0)
	for _, e := range entries {
		if !e.IsDir() {
			continue
		}
		m, err := readManifest(filepath.Join(r.SnapshotsDir, e.Name(), "manifest.json"))
		if err != nil {
			continue
		}
		snaps = append(snaps, m)
	}

	sort.Slice(snaps, func(i, j int) bool { return snaps[i].CreatedAt.After(snaps[j].CreatedAt) })
	return snaps, nil
}

func (*Repository) listSnapshotsUnlocked() ([]SnapshotManifest, error)
{
	entries, err := os.ReadDir(r.SnapshotsDir)
	if err != nil {
		return nil, err
	}

	snaps := make([]SnapshotManifest, 0)
	for _, e := range entries {
		if !e.IsDir() {
			continue
		}
		m, err := readManifest(filepath.Join(r.SnapshotsDir, e.Name(), "manifest.json"))
		if err != nil {
			continue
		}
		snaps = append(snaps, m)
	}

	sort.Slice(snaps, func(i, j int) bool { return snaps[i].CreatedAt.After(snaps[j].CreatedAt) })
	return snaps, nil
}

func (*Repository) PruneKeepLast(keepLast int) ([]string, error)
{
	l, err := r.lockExclusive()
	if err != nil {
		return nil, err
	}
	defer func() { _ = l.Close() }()

	if keepLast < 0 {
		return nil, fmt.Errorf("keepLast must be >= 0")
	}

	snaps, err := r.listSnapshotsUnlocked()
	if err != nil {
		return nil, err
	}

	if len(snaps) <= keepLast {
		return nil, nil
	}

	removed := make([]string, 0)
	for _, s := range snaps[keepLast:] {
		_ = os.RemoveAll(filepath.Join(r.SnapshotsDir, s.ID))
		removed = append(removed, s.ID)
	}

	// Best-effort object cleanup if DaBaDee storage exists.
	if _, err := os.Stat(filepath.Join(r.ObjectsDir, ".dabadee")); err == nil {
		if st, err := storage.NewStorage(storage.StorageOptions{Root: r.ObjectsDir}); err == nil {
			_ = st.RemoveOrphans()
		}
	}

	return removed, nil
}