133 lines
2.4 KiB
Go
133 lines
2.4 KiB
Go
package local
|
|
|
|
import (
|
|
"errors"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"sync"
|
|
|
|
"git.tswf.io/infra/go-synapse-backupper/pkg/domain"
|
|
)
|
|
|
|
// NewLocalSink creates a new local filesystem sink that writes into the given directory.
|
|
func NewLocalSink(dir string) domain.Sink {
|
|
return &localSink{dir: dir}
|
|
}
|
|
|
|
type localSink struct {
|
|
dir string
|
|
}
|
|
|
|
func (sink *localSink) Begin(key string) (domain.SinkTx, error) {
|
|
tmpPath := filepath.Join(sink.dir, key+".tmp")
|
|
finalPath := filepath.Join(sink.dir, key)
|
|
|
|
file, err := os.Create(tmpPath)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return &localSinkTx{
|
|
file: file,
|
|
tmpPath: tmpPath,
|
|
finalPath: finalPath,
|
|
}, nil
|
|
}
|
|
|
|
func (sink *localSink) List(prefix string) ([]string, error) {
|
|
entries, err := os.ReadDir(sink.dir)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
keys := make([]string, 0, len(entries))
|
|
for _, entry := range entries {
|
|
if entry.IsDir() {
|
|
continue
|
|
}
|
|
name := entry.Name()
|
|
if prefix != "" && !strings.HasPrefix(name, prefix) {
|
|
continue
|
|
}
|
|
keys = append(keys, name)
|
|
}
|
|
|
|
return keys, nil
|
|
}
|
|
|
|
func (sink *localSink) Remove(key string) error {
|
|
path := filepath.Join(sink.dir, key)
|
|
return os.Remove(path)
|
|
}
|
|
|
|
type localSinkTx struct {
|
|
file *os.File
|
|
tmpPath string
|
|
finalPath string
|
|
committed bool
|
|
aborted bool
|
|
mu sync.Mutex
|
|
}
|
|
|
|
func (transaction *localSinkTx) Write(p []byte) (int, error) {
|
|
transaction.mu.Lock()
|
|
defer transaction.mu.Unlock()
|
|
|
|
if transaction.committed || transaction.aborted {
|
|
return 0, errors.New("transaction already finished")
|
|
}
|
|
|
|
return transaction.file.Write(p)
|
|
}
|
|
|
|
func (transaction *localSinkTx) Commit() error {
|
|
transaction.mu.Lock()
|
|
defer transaction.mu.Unlock()
|
|
|
|
if transaction.committed || transaction.aborted {
|
|
return nil
|
|
}
|
|
|
|
transaction.committed = true
|
|
|
|
if err := transaction.file.Sync(); err != nil {
|
|
return err
|
|
}
|
|
if err := transaction.file.Close(); err != nil {
|
|
return err
|
|
}
|
|
|
|
if err := os.Rename(transaction.tmpPath, transaction.finalPath); err != nil {
|
|
return err
|
|
}
|
|
|
|
parent, err := os.Open(filepath.Dir(transaction.tmpPath))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer parent.Close()
|
|
|
|
if err := parent.Sync(); err != nil {
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (transaction *localSinkTx) Abort() error {
|
|
transaction.mu.Lock()
|
|
defer transaction.mu.Unlock()
|
|
|
|
if transaction.committed || transaction.aborted {
|
|
return nil
|
|
}
|
|
|
|
transaction.aborted = true
|
|
|
|
_ = transaction.file.Close()
|
|
_ = os.Remove(transaction.tmpPath)
|
|
|
|
return nil
|
|
}
|