Compare commits
10 Commits
Author | SHA1 | Date | |
---|---|---|---|
|
c2828592ac | ||
|
13e53f0c88 | ||
|
54c9e89c3e | ||
|
875957f662 | ||
|
b251368b09 | ||
|
c2a1a7f247 | ||
|
9785637b3b | ||
|
728b34b684 | ||
|
8be663a0a0 | ||
|
6da018353a |
@@ -4,6 +4,7 @@ Replicated in-memory database and file store.
|
||||
|
||||
## TODO
|
||||
|
||||
* [ ] mdb: Tests for using `nil` snapshots ?
|
||||
* [ ] mdb: tests for sanitize and validate functions
|
||||
* [ ] Test: lib/wal iterator w/ corrupt file (random corruptions)
|
||||
* [ ] Test: lib/wal io.go
|
||||
|
@@ -8,26 +8,27 @@ import (
|
||||
)
|
||||
|
||||
type Error struct {
|
||||
msg string
|
||||
code int64
|
||||
Code int64
|
||||
Msg string
|
||||
StackTrace string
|
||||
|
||||
collection string
|
||||
index string
|
||||
stackTrace string
|
||||
err error // Wrapped error
|
||||
}
|
||||
|
||||
func NewErr(code int64, msg string) *Error {
|
||||
return &Error{
|
||||
msg: msg,
|
||||
code: code,
|
||||
Code: code,
|
||||
Msg: msg,
|
||||
}
|
||||
}
|
||||
|
||||
func (e *Error) Error() string {
|
||||
if e.collection != "" || e.index != "" {
|
||||
return fmt.Sprintf(`[%d] (%s/%s) %s`, e.code, e.collection, e.index, e.msg)
|
||||
return fmt.Sprintf(`[%d] (%s/%s) %s`, e.Code, e.collection, e.index, e.Msg)
|
||||
} else {
|
||||
return fmt.Sprintf("[%d] %s", e.code, e.msg)
|
||||
return fmt.Sprintf("[%d] %s", e.Code, e.Msg)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -36,11 +37,15 @@ func (e *Error) Is(rhs error) bool {
|
||||
if !ok {
|
||||
return false
|
||||
}
|
||||
return e.code == e2.code
|
||||
return e.Code == e2.Code
|
||||
}
|
||||
|
||||
func (e *Error) Unwrap() error {
|
||||
return e.err
|
||||
}
|
||||
|
||||
func (e *Error) WithErr(err error) *Error {
|
||||
if e2, ok := err.(*Error); ok && e2.code == e.code {
|
||||
if e2, ok := err.(*Error); ok && e2.Code == e.Code {
|
||||
return e2
|
||||
}
|
||||
|
||||
@@ -49,18 +54,11 @@ func (e *Error) WithErr(err error) *Error {
|
||||
return e2
|
||||
}
|
||||
|
||||
func (e *Error) Unwrap() error {
|
||||
if e.err != nil {
|
||||
return e.err
|
||||
}
|
||||
return e
|
||||
}
|
||||
|
||||
func (e *Error) WithMsg(msg string, args ...any) *Error {
|
||||
err := *e
|
||||
err.msg += ": " + fmt.Sprintf(msg, args...)
|
||||
if len(err.stackTrace) == 0 {
|
||||
err.stackTrace = string(debug.Stack())
|
||||
err.Msg += ": " + fmt.Sprintf(msg, args...)
|
||||
if len(err.StackTrace) == 0 {
|
||||
err.StackTrace = string(debug.Stack())
|
||||
}
|
||||
return &err
|
||||
}
|
||||
@@ -78,16 +76,16 @@ func (e *Error) WithIndex(s string) *Error {
|
||||
}
|
||||
|
||||
func (e *Error) msgTruncacted() string {
|
||||
if len(e.msg) > 255 {
|
||||
return e.msg[:255]
|
||||
if len(e.Msg) > 255 {
|
||||
return e.Msg[:255]
|
||||
}
|
||||
return e.msg
|
||||
return e.Msg
|
||||
}
|
||||
|
||||
func (e *Error) Write(w io.Writer) error {
|
||||
msg := e.msgTruncacted()
|
||||
|
||||
if err := binary.Write(w, binary.LittleEndian, e.code); err != nil {
|
||||
if err := binary.Write(w, binary.LittleEndian, e.Code); err != nil {
|
||||
return IO.WithErr(err)
|
||||
}
|
||||
|
||||
@@ -103,7 +101,7 @@ func (e *Error) Read(r io.Reader) error {
|
||||
size uint8
|
||||
)
|
||||
|
||||
if err := binary.Read(r, binary.LittleEndian, &e.code); err != nil {
|
||||
if err := binary.Read(r, binary.LittleEndian, &e.Code); err != nil {
|
||||
return IO.WithErr(err)
|
||||
}
|
||||
|
||||
@@ -116,6 +114,6 @@ func (e *Error) Read(r io.Reader) error {
|
||||
return IO.WithErr(err)
|
||||
}
|
||||
|
||||
e.msg = string(msgBuf)
|
||||
e.Msg = string(msgBuf)
|
||||
return nil
|
||||
}
|
||||
|
@@ -10,12 +10,12 @@ func FmtDetails(err error) string {
|
||||
|
||||
var s string
|
||||
if e.collection != "" || e.index != "" {
|
||||
s = fmt.Sprintf(`[%d] (%s/%s) %s`, e.code, e.collection, e.index, e.msg)
|
||||
s = fmt.Sprintf(`[%d] (%s/%s) %s`, e.Code, e.collection, e.index, e.Msg)
|
||||
} else {
|
||||
s = fmt.Sprintf("[%d] %s", e.code, e.msg)
|
||||
s = fmt.Sprintf("[%d] %s", e.Code, e.Msg)
|
||||
}
|
||||
if len(e.stackTrace) != 0 {
|
||||
s += "\n\nStack Trace:\n" + e.stackTrace + "\n"
|
||||
if len(e.StackTrace) != 0 {
|
||||
s += "\n\nStack Trace:\n" + e.StackTrace + "\n"
|
||||
}
|
||||
|
||||
return s
|
||||
|
@@ -12,6 +12,7 @@ const (
|
||||
pathStreamWAL = "stream-wal"
|
||||
)
|
||||
|
||||
// TODO: Remove this!
|
||||
func (rep *Replicator) Handle(w http.ResponseWriter, r *http.Request) {
|
||||
// We'll handle two types of requests: HTTP GET requests for JSON, or
|
||||
// streaming requets for state or wall.
|
||||
|
@@ -15,7 +15,7 @@ func (rep *Replicator) runWALGC() {
|
||||
select {
|
||||
case <-ticker.C:
|
||||
state := rep.getState()
|
||||
before := time.Now().Unix() - rep.conf.WALSegMaxAgeSec
|
||||
before := time.Now().Unix() - rep.conf.WALSegGCAgeSec
|
||||
if err := rep.wal.DeleteBefore(before, state.SeqNum); err != nil {
|
||||
log.Printf("[WAL-GC] failed to delete wal segments: %v", err)
|
||||
}
|
||||
|
@@ -2,6 +2,7 @@ package rep
|
||||
|
||||
import (
|
||||
"io"
|
||||
"log"
|
||||
"net"
|
||||
"os"
|
||||
"sync"
|
||||
@@ -94,41 +95,49 @@ func Open(app App, conf Config) (*Replicator, error) {
|
||||
rep.client = newClient(rep.conf.PrimaryEndpoint, rep.conf.ReplicationPSK, rep.conf.NetTimeout)
|
||||
|
||||
if err := rep.initDirectories(); err != nil {
|
||||
log.Printf("Failed to init directories: %v", err)
|
||||
return nil, err
|
||||
}
|
||||
|
||||
if err := rep.acquireLock(); err != nil {
|
||||
rep.Close()
|
||||
log.Printf("Failed to acquire lock: %v", err)
|
||||
return nil, err
|
||||
}
|
||||
|
||||
if err := rep.loadLocalState(); err != nil {
|
||||
rep.Close()
|
||||
log.Printf("Failed to load local state: %v", err)
|
||||
return nil, err
|
||||
}
|
||||
|
||||
if err := rep.openWAL(); err != nil {
|
||||
rep.Close()
|
||||
log.Printf("Failed to open WAL: %v", err)
|
||||
return nil, err
|
||||
}
|
||||
|
||||
if err := rep.recvStateIfNecessary(); err != nil {
|
||||
rep.Close()
|
||||
log.Printf("Failed to recv state: %v", err)
|
||||
return nil, err
|
||||
}
|
||||
|
||||
if err := rep.app.InitStorage(); err != nil {
|
||||
rep.Close()
|
||||
log.Printf("Failed to init storage: %v", err)
|
||||
return nil, err
|
||||
}
|
||||
|
||||
if err := rep.replay(); err != nil {
|
||||
rep.Close()
|
||||
log.Printf("Failed to replay: %v", err)
|
||||
return nil, err
|
||||
}
|
||||
|
||||
if err := rep.app.LoadFromStorage(); err != nil {
|
||||
rep.Close()
|
||||
log.Printf("Failed to load from storage: %v", err)
|
||||
return nil, err
|
||||
}
|
||||
|
||||
|
@@ -237,6 +237,27 @@ func (c *Collection[T]) update(tx *Snapshot, userItem *T) error {
|
||||
return nil
|
||||
}
|
||||
|
||||
func (c *Collection[T]) UpdateFunc(tx *Snapshot, id uint64, update func(item *T) error) error {
|
||||
if tx == nil {
|
||||
return c.db.Update(func(tx *Snapshot) error {
|
||||
return c.updateFunc(tx, id, update)
|
||||
})
|
||||
}
|
||||
return c.updateFunc(tx, id, update)
|
||||
}
|
||||
|
||||
func (c *Collection[T]) updateFunc(tx *Snapshot, id uint64, update func(item *T) error) error {
|
||||
item := c.Get(tx, id)
|
||||
if item == nil {
|
||||
return errs.NotFound
|
||||
}
|
||||
if err := update(item); err != nil {
|
||||
return err
|
||||
}
|
||||
c.setID(item, id) // Don't allow the ID to change.
|
||||
return c.update(tx, item)
|
||||
}
|
||||
|
||||
func (c *Collection[T]) Upsert(tx *Snapshot, item *T) error {
|
||||
if tx == nil {
|
||||
return c.db.Update(func(tx *Snapshot) error {
|
||||
@@ -275,6 +296,9 @@ func (c *Collection[T]) delete(tx *Snapshot, itemID uint64) error {
|
||||
}
|
||||
|
||||
func (c *Collection[T]) Count(tx *Snapshot) int {
|
||||
if tx == nil {
|
||||
tx = c.db.Snapshot()
|
||||
}
|
||||
return c.ByID.Count(tx)
|
||||
}
|
||||
|
||||
|
@@ -1,138 +0,0 @@
|
||||
package mdb
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"reflect"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestDBList(t *testing.T) {
|
||||
db := NewTestDBPrimary(t, t.TempDir())
|
||||
|
||||
var (
|
||||
user1 = User{
|
||||
ID: NewID(),
|
||||
Name: "User1",
|
||||
Email: "user1@gmail.com",
|
||||
}
|
||||
|
||||
user2 = User{
|
||||
ID: NewID(),
|
||||
Name: "User2",
|
||||
Email: "user2@gmail.com",
|
||||
}
|
||||
|
||||
user3 = User{
|
||||
ID: NewID(),
|
||||
Name: "User3",
|
||||
Email: "user3@gmail.com",
|
||||
}
|
||||
user1Data = make([]UserDataItem, 10)
|
||||
user2Data = make([]UserDataItem, 4)
|
||||
user3Data = make([]UserDataItem, 8)
|
||||
)
|
||||
|
||||
err := db.Update(func(tx *Snapshot) error {
|
||||
if err := db.Users.Insert(tx, &user1); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
if err := db.Users.Insert(tx, &user2); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
for i := range user1Data {
|
||||
user1Data[i] = UserDataItem{
|
||||
ID: NewID(),
|
||||
UserID: user1.ID,
|
||||
Name: fmt.Sprintf("Name1: %d", i),
|
||||
Data: fmt.Sprintf("Data: %d", i),
|
||||
}
|
||||
|
||||
if err := db.UserData.Insert(tx, &user1Data[i]); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
|
||||
for i := range user2Data {
|
||||
user2Data[i] = UserDataItem{
|
||||
ID: NewID(),
|
||||
UserID: user2.ID,
|
||||
Name: fmt.Sprintf("Name2: %d", i),
|
||||
Data: fmt.Sprintf("Data: %d", i),
|
||||
}
|
||||
|
||||
if err := db.UserData.Insert(tx, &user2Data[i]); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
|
||||
for i := range user3Data {
|
||||
user3Data[i] = UserDataItem{
|
||||
ID: NewID(),
|
||||
UserID: user3.ID,
|
||||
Name: fmt.Sprintf("Name3: %d", i),
|
||||
Data: fmt.Sprintf("Data: %d", i),
|
||||
}
|
||||
|
||||
if err := db.UserData.Insert(tx, &user3Data[i]); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
|
||||
return nil
|
||||
})
|
||||
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
type TestCase struct {
|
||||
Name string
|
||||
Args ListArgs[UserDataItem]
|
||||
Expected []UserDataItem
|
||||
}
|
||||
|
||||
cases := []TestCase{
|
||||
{
|
||||
Name: "User1 all",
|
||||
Args: ListArgs[UserDataItem]{
|
||||
After: &UserDataItem{
|
||||
UserID: user1.ID,
|
||||
},
|
||||
While: func(item *UserDataItem) bool {
|
||||
return item.UserID == user1.ID
|
||||
},
|
||||
},
|
||||
Expected: user1Data,
|
||||
}, {
|
||||
Name: "User1 limited",
|
||||
Args: ListArgs[UserDataItem]{
|
||||
After: &UserDataItem{
|
||||
UserID: user1.ID,
|
||||
},
|
||||
While: func(item *UserDataItem) bool {
|
||||
return item.UserID == user1.ID
|
||||
},
|
||||
Limit: 4,
|
||||
},
|
||||
Expected: user1Data[:4],
|
||||
},
|
||||
}
|
||||
|
||||
for _, tc := range cases {
|
||||
t.Run(tc.Name, func(t *testing.T) {
|
||||
tx := db.Snapshot()
|
||||
l := db.UserData.ByName.List(tx, &tc.Args, nil)
|
||||
if len(l) != len(tc.Expected) {
|
||||
t.Fatal(tc.Name, l)
|
||||
}
|
||||
|
||||
for i := range l {
|
||||
if !reflect.DeepEqual(*l[i], tc.Expected[i]) {
|
||||
t.Fatal(tc.Name, l)
|
||||
}
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
@@ -73,6 +73,10 @@ type Database struct {
|
||||
}
|
||||
|
||||
func New(conf Config) *Database {
|
||||
if conf.NetTimeout <= 0 {
|
||||
conf.NetTimeout = time.Minute
|
||||
}
|
||||
|
||||
if conf.MaxConcurrentUpdates <= 0 {
|
||||
conf.MaxConcurrentUpdates = 32
|
||||
}
|
||||
|
53
mdb/index.go
53
mdb/index.go
@@ -139,59 +139,6 @@ func (i *Index[T]) DescendAfter(tx *Snapshot, after *T, each func(*T) bool) {
|
||||
})
|
||||
}
|
||||
|
||||
type ListArgs[T any] struct {
|
||||
Desc bool // True for descending order, otherwise ascending.
|
||||
After *T // If after is given, iterate after (and including) the value.
|
||||
While func(*T) bool // Continue iterating until While is false.
|
||||
Limit int // Maximum number of items to return. 0 => All.
|
||||
}
|
||||
|
||||
func (i *Index[T]) List(tx *Snapshot, args *ListArgs[T], out []*T) []*T {
|
||||
tx = i.ensureSnapshot(tx)
|
||||
if args == nil {
|
||||
args = &ListArgs[T]{}
|
||||
}
|
||||
|
||||
if args.Limit < 0 {
|
||||
return nil
|
||||
}
|
||||
|
||||
if args.While == nil {
|
||||
args.While = func(*T) bool { return true }
|
||||
}
|
||||
|
||||
size := args.Limit
|
||||
if size == 0 {
|
||||
size = 32 // Why not?
|
||||
}
|
||||
|
||||
items := out[:0]
|
||||
|
||||
each := func(item *T) bool {
|
||||
if !args.While(item) {
|
||||
return false
|
||||
}
|
||||
items = append(items, item)
|
||||
return args.Limit == 0 || len(items) < args.Limit
|
||||
}
|
||||
|
||||
if args.Desc {
|
||||
if args.After != nil {
|
||||
i.DescendAfter(tx, args.After, each)
|
||||
} else {
|
||||
i.Descend(tx, each)
|
||||
}
|
||||
} else {
|
||||
if args.After != nil {
|
||||
i.AscendAfter(tx, args.After, each)
|
||||
} else {
|
||||
i.Ascend(tx, each)
|
||||
}
|
||||
}
|
||||
|
||||
return items
|
||||
}
|
||||
|
||||
func (i *Index[T]) Count(tx *Snapshot) int {
|
||||
tx = i.ensureSnapshot(tx)
|
||||
return i.btree(tx).Len()
|
||||
|
@@ -51,6 +51,10 @@ func (f *freeList) Push(pages ...uint64) {
|
||||
}
|
||||
}
|
||||
|
||||
func (f *freeList) SetNextPage(nextPage uint64) {
|
||||
f.nextPage = nextPage
|
||||
}
|
||||
|
||||
func (f *freeList) Pop(count int, out []uint64) []uint64 {
|
||||
out = out[:0]
|
||||
|
||||
|
@@ -13,14 +13,19 @@ type Index struct {
|
||||
}
|
||||
|
||||
func NewIndex(f *File) (*Index, error) {
|
||||
firstPage, err := f.pageCount()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
idx := &Index{
|
||||
fList: newFreeList(0),
|
||||
fList: newFreeList(firstPage),
|
||||
aList: *newAllocList(),
|
||||
seen: map[[2]uint64]struct{}{},
|
||||
mask: []bool{},
|
||||
}
|
||||
|
||||
err := f.iterate(func(pageID uint64, page dataPage) error {
|
||||
err = f.iterate(func(pageID uint64, page dataPage) error {
|
||||
header := page.Header()
|
||||
switch header.PageType {
|
||||
case pageTypeHead:
|
||||
|
@@ -134,6 +134,21 @@ func (pf *File) writePage(page dataPage, id uint64) error {
|
||||
// Reading
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
func (pf *File) pageCount() (uint64, error) {
|
||||
fi, err := pf.f.Stat()
|
||||
if err != nil {
|
||||
return 0, errs.IO.WithErr(err)
|
||||
}
|
||||
|
||||
fileSize := fi.Size()
|
||||
if fileSize%pageSize != 0 {
|
||||
return 0, errs.Corrupt.WithMsg("File size isn't a multiple of page size.")
|
||||
}
|
||||
|
||||
maxPage := uint64(fileSize / pageSize)
|
||||
return maxPage, nil
|
||||
}
|
||||
|
||||
func (pf *File) iterate(each func(pageID uint64, page dataPage) error) error {
|
||||
pf.lock.RLock()
|
||||
defer pf.lock.RUnlock()
|
||||
|
Reference in New Issue
Block a user