chore: move apps to go.sour.is/tools
This commit is contained in:
402
driver/disk-store/disk-store.go
Normal file
402
driver/disk-store/disk-store.go
Normal file
@@ -0,0 +1,402 @@
|
||||
// package diskstore provides a driver that reads and writes events to disk.
|
||||
|
||||
package diskstore
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"fmt"
|
||||
"hash/fnv"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
|
||||
"github.com/tidwall/wal"
|
||||
"go.opentelemetry.io/otel/attribute"
|
||||
"go.opentelemetry.io/otel/metric"
|
||||
"go.uber.org/multierr"
|
||||
|
||||
"go.sour.is/pkg/cache"
|
||||
"go.sour.is/pkg/lg"
|
||||
"go.sour.is/pkg/locker"
|
||||
|
||||
"go.sour.is/ev"
|
||||
"go.sour.is/ev/driver"
|
||||
"go.sour.is/ev/event"
|
||||
)
|
||||
|
||||
const CachSize = 1000
|
||||
|
||||
const AppendOnly = ev.AppendOnly
|
||||
const AllEvents = ev.AllEvents
|
||||
|
||||
type lockedWal = locker.Locked[wal.Log]
|
||||
type openlogs struct {
|
||||
logs *cache.Cache[string, *lockedWal]
|
||||
}
|
||||
type diskStore struct {
|
||||
path string
|
||||
openlogs *locker.Locked[openlogs]
|
||||
|
||||
m_disk_open metric.Int64Counter
|
||||
m_disk_evict metric.Int64Counter
|
||||
m_disk_read metric.Int64Counter
|
||||
m_disk_write metric.Int64Counter
|
||||
}
|
||||
|
||||
var _ driver.Driver = (*diskStore)(nil)
|
||||
|
||||
func Init(ctx context.Context) error {
|
||||
ctx, span := lg.Span(ctx)
|
||||
defer span.End()
|
||||
|
||||
d := &diskStore{}
|
||||
|
||||
m := lg.Meter(ctx)
|
||||
var err, errs error
|
||||
|
||||
d.m_disk_open, err = m.Int64Counter("disk_open")
|
||||
errs = multierr.Append(errs, err)
|
||||
|
||||
d.m_disk_evict, err = m.Int64Counter("disk_evict")
|
||||
errs = multierr.Append(errs, err)
|
||||
|
||||
d.m_disk_read, err = m.Int64Counter("disk_read")
|
||||
errs = multierr.Append(errs, err)
|
||||
|
||||
d.m_disk_write, err = m.Int64Counter("disk_write")
|
||||
errs = multierr.Append(errs, err)
|
||||
|
||||
ev.Register(ctx, "file", d)
|
||||
|
||||
return errs
|
||||
}
|
||||
|
||||
func (d *diskStore) Open(ctx context.Context, dsn string) (driver.Driver, error) {
|
||||
_, span := lg.Span(ctx)
|
||||
defer span.End()
|
||||
|
||||
span.SetAttributes(
|
||||
attribute.String("args.dsn", dsn),
|
||||
)
|
||||
|
||||
scheme, path, ok := strings.Cut(dsn, ":")
|
||||
if !ok {
|
||||
return nil, fmt.Errorf("expected scheme")
|
||||
}
|
||||
|
||||
if scheme != "file" {
|
||||
return nil, fmt.Errorf("expeted scheme=file, got=%s", scheme)
|
||||
}
|
||||
|
||||
if _, err := os.Stat(path); os.IsNotExist(err) {
|
||||
err = os.MkdirAll(path, 0700)
|
||||
if err != nil {
|
||||
span.RecordError(err)
|
||||
return nil, err
|
||||
}
|
||||
}
|
||||
c, err := cache.NewWithEvict(CachSize, func(ctx context.Context, s string, l *lockedWal) {
|
||||
ctx, span := lg.Span(ctx)
|
||||
defer span.End()
|
||||
|
||||
l.Use(ctx, func(ctx context.Context, w *wal.Log) error {
|
||||
ctx, span := lg.Span(ctx)
|
||||
defer span.End()
|
||||
|
||||
d.m_disk_evict.Add(ctx, 1)
|
||||
|
||||
err := w.Close()
|
||||
if err != nil {
|
||||
span.RecordError(err)
|
||||
return err
|
||||
}
|
||||
return nil
|
||||
})
|
||||
})
|
||||
if err != nil {
|
||||
span.RecordError(err)
|
||||
return nil, err
|
||||
}
|
||||
logs := &openlogs{logs: c}
|
||||
return &diskStore{
|
||||
path: path,
|
||||
openlogs: locker.New(logs),
|
||||
m_disk_open: d.m_disk_open,
|
||||
m_disk_evict: d.m_disk_evict,
|
||||
m_disk_read: d.m_disk_read,
|
||||
m_disk_write: d.m_disk_write,
|
||||
}, nil
|
||||
}
|
||||
func (d *diskStore) EventLog(ctx context.Context, streamID string) (driver.EventLog, error) {
|
||||
ctx, span := lg.Span(ctx)
|
||||
defer span.End()
|
||||
|
||||
span.SetAttributes(
|
||||
attribute.String("args.streamID", streamID),
|
||||
attribute.String("path", d.path),
|
||||
)
|
||||
|
||||
el := &eventLog{streamID: streamID, diskStore: d}
|
||||
|
||||
return el, d.openlogs.Use(ctx, func(ctx context.Context, openlogs *openlogs) error {
|
||||
ctx, span := lg.Span(ctx)
|
||||
defer span.End()
|
||||
|
||||
if events, ok := openlogs.logs.Get(streamID); ok {
|
||||
el.events = *events
|
||||
return nil
|
||||
}
|
||||
|
||||
d.m_disk_open.Add(ctx, 1)
|
||||
|
||||
// migrate streams into dir friendly subdirs
|
||||
hashPart := mkDirName(streamID)
|
||||
oldPath := filepath.Join(d.path, streamID)
|
||||
newPath := filepath.Join(d.path, hashPart, streamID)
|
||||
if _, err := os.Stat(oldPath); !os.IsNotExist(err) {
|
||||
os.MkdirAll(filepath.Join(d.path, hashPart), 0700)
|
||||
os.Rename(oldPath, newPath)
|
||||
}
|
||||
|
||||
l, err := wal.Open(newPath, wal.DefaultOptions)
|
||||
if err != nil {
|
||||
span.RecordError(err)
|
||||
return err
|
||||
}
|
||||
|
||||
el.events = locker.New(l)
|
||||
openlogs.logs.Add(ctx, streamID, el.events)
|
||||
return nil
|
||||
})
|
||||
}
|
||||
|
||||
type eventLog struct {
|
||||
streamID string
|
||||
events *locker.Locked[wal.Log]
|
||||
diskStore *diskStore
|
||||
}
|
||||
|
||||
var _ driver.EventLog = (*eventLog)(nil)
|
||||
|
||||
func (e *eventLog) Append(ctx context.Context, events event.Events, version uint64) (uint64, error) {
|
||||
ctx, span := lg.Span(ctx)
|
||||
defer span.End()
|
||||
|
||||
span.SetAttributes(
|
||||
attribute.Int("args.events", len(events)),
|
||||
attribute.Int64("args.version", int64(version)),
|
||||
attribute.String("streamID", e.streamID),
|
||||
attribute.String("path", e.diskStore.path),
|
||||
)
|
||||
|
||||
event.SetStreamID(e.streamID, events...)
|
||||
|
||||
var count uint64
|
||||
err := e.events.Use(ctx, func(ctx context.Context, l *wal.Log) error {
|
||||
ctx, span := lg.Span(ctx)
|
||||
defer span.End()
|
||||
|
||||
last, err := l.LastIndex()
|
||||
if err != nil {
|
||||
span.RecordError(err)
|
||||
return err
|
||||
}
|
||||
|
||||
if version != AppendOnly && version != last {
|
||||
err = fmt.Errorf("%w: current version wrong %d != %d", ev.ErrWrongVersion, version, last)
|
||||
span.RecordError(err)
|
||||
return err
|
||||
}
|
||||
|
||||
var b []byte
|
||||
|
||||
batch := &wal.Batch{}
|
||||
for i, e := range events {
|
||||
span.AddEvent(fmt.Sprintf("append event %d of %d", i, len(events)))
|
||||
|
||||
b, err = event.MarshalBinary(e)
|
||||
if err != nil {
|
||||
span.RecordError(err)
|
||||
|
||||
return err
|
||||
}
|
||||
pos := last + uint64(i) + 1
|
||||
event.SetPosition(e, pos)
|
||||
|
||||
batch.Write(pos, b)
|
||||
}
|
||||
|
||||
count = uint64(len(events))
|
||||
e.diskStore.m_disk_write.Add(ctx, int64(len(events)))
|
||||
|
||||
return l.WriteBatch(batch)
|
||||
})
|
||||
span.RecordError(err)
|
||||
|
||||
return count, err
|
||||
}
|
||||
func (e *eventLog) ReadN(ctx context.Context, index ...uint64) (event.Events, error) {
|
||||
ctx, span := lg.Span(ctx)
|
||||
defer span.End()
|
||||
|
||||
lis := make([]int64, len(index))
|
||||
for i := range index {
|
||||
lis[i] = int64(index[i])
|
||||
}
|
||||
|
||||
span.SetAttributes(
|
||||
attribute.Int64Slice("args.index", lis),
|
||||
attribute.String("streamID", e.streamID),
|
||||
attribute.String("path", e.diskStore.path),
|
||||
)
|
||||
|
||||
var events event.Events
|
||||
err := e.events.Use(ctx, func(ctx context.Context, stream *wal.Log) error {
|
||||
var err error
|
||||
|
||||
events, err = readStreamN(ctx, stream, index...)
|
||||
|
||||
return err
|
||||
})
|
||||
|
||||
return events, err
|
||||
}
|
||||
func (e *eventLog) Read(ctx context.Context, after, count int64) (event.Events, error) {
|
||||
ctx, span := lg.Span(ctx)
|
||||
defer span.End()
|
||||
span.SetAttributes(
|
||||
attribute.Int64("args.after", after),
|
||||
attribute.Int64("args.count", count),
|
||||
attribute.String("streamID", e.streamID),
|
||||
attribute.String("path", e.diskStore.path),
|
||||
)
|
||||
|
||||
var events event.Events
|
||||
err := e.events.Use(ctx, func(ctx context.Context, stream *wal.Log) error {
|
||||
ctx, span := lg.Span(ctx)
|
||||
defer span.End()
|
||||
|
||||
first, err := stream.FirstIndex()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
last, err := stream.LastIndex()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
streamIDs, err := driver.GenerateStreamIDs(first, last, after, count)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
events, err = readStreamN(ctx, stream, streamIDs...)
|
||||
event.SetStreamID(e.streamID, events...)
|
||||
return err
|
||||
})
|
||||
if err != nil {
|
||||
span.RecordError(err)
|
||||
return nil, err
|
||||
}
|
||||
|
||||
e.diskStore.m_disk_read.Add(ctx, int64(len(events)))
|
||||
|
||||
return events, nil
|
||||
}
|
||||
func (e *eventLog) FirstIndex(ctx context.Context) (uint64, error) {
|
||||
ctx, span := lg.Span(ctx)
|
||||
defer span.End()
|
||||
|
||||
span.SetAttributes(
|
||||
attribute.String("streamID", e.streamID),
|
||||
attribute.String("path", e.diskStore.path),
|
||||
)
|
||||
|
||||
var idx uint64
|
||||
var err error
|
||||
|
||||
err = e.events.Use(ctx, func(ctx context.Context, events *wal.Log) error {
|
||||
idx, err = events.FirstIndex()
|
||||
return err
|
||||
})
|
||||
|
||||
return idx, err
|
||||
}
|
||||
func (e *eventLog) LastIndex(ctx context.Context) (uint64, error) {
|
||||
ctx, span := lg.Span(ctx)
|
||||
defer span.End()
|
||||
|
||||
span.SetAttributes(
|
||||
attribute.String("streamID", e.streamID),
|
||||
attribute.String("path", e.diskStore.path),
|
||||
)
|
||||
|
||||
var idx uint64
|
||||
var err error
|
||||
|
||||
err = e.events.Use(ctx, func(ctx context.Context, events *wal.Log) error {
|
||||
idx, err = events.LastIndex()
|
||||
return err
|
||||
})
|
||||
|
||||
return idx, err
|
||||
}
|
||||
func (e *eventLog) Truncate(ctx context.Context, index int64) error {
|
||||
ctx, span := lg.Span(ctx)
|
||||
defer span.End()
|
||||
|
||||
span.SetAttributes(
|
||||
attribute.Int64("args.index", index),
|
||||
attribute.String("streamID", e.streamID),
|
||||
attribute.String("path", e.diskStore.path),
|
||||
)
|
||||
|
||||
if index == 0 {
|
||||
return nil
|
||||
}
|
||||
return e.events.Use(ctx, func(ctx context.Context, events *wal.Log) error {
|
||||
if index < 0 {
|
||||
return events.TruncateBack(uint64(-index))
|
||||
}
|
||||
return events.TruncateFront(uint64(index))
|
||||
})
|
||||
}
|
||||
func readStreamN(ctx context.Context, stream *wal.Log, index ...uint64) (event.Events, error) {
|
||||
ctx, span := lg.Span(ctx)
|
||||
defer span.End()
|
||||
|
||||
lis := make([]int64, len(index))
|
||||
for i := range index {
|
||||
lis[i] = int64(index[i])
|
||||
}
|
||||
|
||||
span.SetAttributes(
|
||||
attribute.Int64Slice("args.index", lis),
|
||||
)
|
||||
|
||||
var b []byte
|
||||
var err error
|
||||
events := make(event.Events, len(index))
|
||||
for i, idx := range index {
|
||||
b, err = stream.Read(idx)
|
||||
if err != nil {
|
||||
if errors.Is(err, wal.ErrNotFound) || errors.Is(err, wal.ErrOutOfRange) {
|
||||
err = fmt.Errorf("%w: empty", ev.ErrNotFound)
|
||||
}
|
||||
|
||||
span.RecordError(err)
|
||||
return nil, err
|
||||
}
|
||||
events[i], err = event.UnmarshalBinary(ctx, b, idx)
|
||||
if err != nil {
|
||||
span.RecordError(err)
|
||||
return nil, err
|
||||
}
|
||||
span.AddEvent(fmt.Sprintf("read event %d of %d - %d", i, len(events), events[i].EventMeta().ActualPosition))
|
||||
}
|
||||
return events, err
|
||||
}
|
||||
func mkDirName(name string) string {
|
||||
h := fnv.New32a()
|
||||
fmt.Fprint(h, name)
|
||||
return fmt.Sprintf("%x/%x/%x", h.Sum32()>>24&0xff, h.Sum32()>>16&0xff, h.Sum32()&0xffff)
|
||||
}
|
||||
Reference in New Issue
Block a user