From 4bf28fcd84c1071e67720125e4a8ae4cb25516b9 Mon Sep 17 00:00:00 2001 From: fiatjaf Date: Sat, 24 Aug 2024 00:24:57 -0300 Subject: [PATCH] delete bolt. aside from other bugs that have happened before, this one: https://cdn.satellite.earth/25a4bc5c9fd7617cdcba309a552d227283fb2d36aa75f47b12c0b83510c4de88.png is caused directly by bbolt's `unsafe` usage. something wrong is not right inside bbolt's codebase and I don't think it's worth trying to solve it. bolt is kinda annoying anyway, like it blocks the database and makes things hang forever, has some weird locking and stuff. so if people want a pure-go setup they can use badger, and if they want better read performance they should use LMDB. bolt is unnecessary. --- bluge/bluge_test.go | 6 +- bolt/count.go | 71 ---------- bolt/delete.go | 37 ----- bolt/helpers.go | 114 --------------- bolt/lib.go | 106 -------------- bolt/migration.go | 32 ----- bolt/query.go | 282 -------------------------------------- bolt/save.go | 58 -------- cmd/eventstore/helpers.go | 3 +- cmd/eventstore/main.go | 7 +- go.mod | 1 - test/db_fuzz_test.go | 6 - test/db_test.go | 6 - 13 files changed, 7 insertions(+), 722 deletions(-) delete mode 100644 bolt/count.go delete mode 100644 bolt/delete.go delete mode 100644 bolt/helpers.go delete mode 100644 bolt/lib.go delete mode 100644 bolt/migration.go delete mode 100644 bolt/query.go delete mode 100644 bolt/save.go diff --git a/bluge/bluge_test.go b/bluge/bluge_test.go index 170da04..af96523 100644 --- a/bluge/bluge_test.go +++ b/bluge/bluge_test.go @@ -5,16 +5,16 @@ import ( "os" "testing" - "github.com/fiatjaf/eventstore/bolt" + "github.com/fiatjaf/eventstore/badger" "github.com/nbd-wtf/go-nostr" "github.com/stretchr/testify/assert" ) func TestBlugeFlow(t *testing.T) { - os.RemoveAll("/tmp/blugetest-bolt") + os.RemoveAll("/tmp/blugetest-badger") os.RemoveAll("/tmp/blugetest-bluge") - bb := &bolt.BoltBackend{Path: "/tmp/blugetest-bolt"} + bb := &badger.BadgerBackend{Path: "/tmp/blugetest-badger"} bb.Init() defer bb.Close() diff --git a/bolt/count.go b/bolt/count.go deleted file mode 100644 index ec77a17..0000000 --- a/bolt/count.go +++ /dev/null @@ -1,71 +0,0 @@ -package bolt - -import ( - "bytes" - "context" - "encoding/binary" - "log" - - "github.com/nbd-wtf/go-nostr" - nostr_binary "github.com/nbd-wtf/go-nostr/binary" - bolt "go.etcd.io/bbolt" -) - -func (b *BoltBackend) CountEvents(ctx context.Context, filter nostr.Filter) (int64, error) { - var count int64 = 0 - - queries, extraFilter, since, err := prepareQueries(filter) - if err != nil { - return 0, err - } - - err = b.db.View(func(txn *bolt.Tx) error { - // actually iterate - for _, q := range queries { - bucket := txn.Bucket(q.bucket) - raw := txn.Bucket(bucketRaw) - - c := bucket.Cursor() - - key, _ := c.Seek(q.startingPoint) - if key == nil { - key, _ = c.Last() - } else { - key, _ = c.Prev() - } - - for ; key != nil && bytes.HasPrefix(key, q.prefix); key, _ = c.Prev() { - idxOffset := len(key) - 4 // this is where the idx actually starts - - // "id" indexes don't contain a timestamp - if !q.skipTimestamp { - createdAt := binary.BigEndian.Uint32(key[idxOffset-4 : idxOffset]) - if createdAt < since { - break - } - } - - if extraFilter == nil { - count++ - } else { - // fetch actual event - val := raw.Get(key[len(key)-4:]) - evt := &nostr.Event{} - if err := nostr_binary.Unmarshal(val, evt); err != nil { - log.Printf("bolt: value read error (id %x): %s\n", val[0:32], err) - break - } - - // check if this matches the other filters that were not part of the index before yielding - if extraFilter.Matches(evt) { - count++ - } - } - } - } - - return nil - }) - - return count, err -} diff --git a/bolt/delete.go b/bolt/delete.go deleted file mode 100644 index e12ff4d..0000000 --- a/bolt/delete.go +++ /dev/null @@ -1,37 +0,0 @@ -package bolt - -import ( - "context" - "encoding/hex" - - "github.com/nbd-wtf/go-nostr" - bolt "go.etcd.io/bbolt" - "golang.org/x/exp/slices" -) - -func (b *BoltBackend) DeleteEvent(ctx context.Context, evt *nostr.Event) error { - return b.db.Update(func(txn *bolt.Tx) error { - idPrefix8, _ := hex.DecodeString(evt.ID[0 : 8*2]) - bucket := txn.Bucket(bucketId) - - // check if we already do not have this - c := bucket.Cursor() - key, _ := c.Seek(idPrefix8) - if key == nil || !slices.Equal(key[0:8], idPrefix8) { - // already do not have it - return nil - } - - // seqb is the key where this event is stored at bucketRaw - seqb := key[8:] - - // calculate all index keys we have for this event and delete them - for _, k := range getIndexKeysForEvent(evt) { - bucket := txn.Bucket(k.bucket) - bucket.Delete(append(k.key, seqb...)) - } - - // delete the raw event - return txn.Bucket(bucketRaw).Delete(seqb) - }) -} diff --git a/bolt/helpers.go b/bolt/helpers.go deleted file mode 100644 index afc297e..0000000 --- a/bolt/helpers.go +++ /dev/null @@ -1,114 +0,0 @@ -package bolt - -import ( - "encoding/binary" - "encoding/hex" - - "github.com/fiatjaf/eventstore" - "github.com/nbd-wtf/go-nostr" - "golang.org/x/exp/slices" -) - -// returns -// - the bucket id where this will be saved -// - the key with full length for created_at and idx at the end, but not filled with these -// - the offset -- i.e. where the prefix ends and the created_at and idx would start -func getTagIndexPrefix(tagValue string) (bucket []byte, key []byte, offset int) { - if kind, pkb, d := eventstore.GetAddrTagElements(tagValue); len(pkb) == 32 { - // store value in the new special "a" tag index - key = make([]byte, 2+8+len(d)+4) - binary.BigEndian.PutUint16(key[1:], kind) - copy(key[2:], pkb[0:8]) - copy(key[2+8:], d) - offset = 2 + 8 + len(d) - bucket = bucketTagAddr - } else if vb, _ := hex.DecodeString(tagValue); len(vb) == 32 { - // store value as bytes - key = make([]byte, 8+4) - copy(key, vb[0:8]) - offset = 8 - bucket = bucketTag32 - } else { - // store whatever as utf-8 - key = make([]byte, len(tagValue)+4) - copy(key, tagValue) - offset = len(tagValue) - bucket = bucketTag - } - - return bucket, key, offset -} - -type keymeta struct { - bucket []byte - key []byte -} - -func getIndexKeysForEvent(evt *nostr.Event) []keymeta { - keys := make([]keymeta, 0, 24) - - // indexes - { - // ~ by id - idPrefix8, _ := hex.DecodeString(evt.ID[0 : 8*2]) - k := idPrefix8 - keys = append(keys, keymeta{bucket: bucketId, key: k}) - } - - { - // ~ by pubkey+date - pubkeyPrefix8, _ := hex.DecodeString(evt.PubKey[0 : 8*2]) - k := make([]byte, 8+4) - copy(k[:], pubkeyPrefix8) - binary.BigEndian.PutUint32(k[8:], uint32(evt.CreatedAt)) - keys = append(keys, keymeta{bucket: bucketPubkey, key: k}) - } - - { - // ~ by kind+date - k := make([]byte, 2+4) - binary.BigEndian.PutUint16(k[:], uint16(evt.Kind)) - binary.BigEndian.PutUint32(k[2:], uint32(evt.CreatedAt)) - keys = append(keys, keymeta{bucket: bucketKind, key: k}) - } - - { - // ~ by pubkey+kind+date - pubkeyPrefix8, _ := hex.DecodeString(evt.PubKey[0 : 8*2]) - k := make([]byte, 8+2+4) - copy(k[:], pubkeyPrefix8) - binary.BigEndian.PutUint16(k[8:], uint16(evt.Kind)) - binary.BigEndian.PutUint32(k[8+2:], uint32(evt.CreatedAt)) - keys = append(keys, keymeta{bucket: bucketPubkeyKind, key: k}) - } - - // ~ by tagvalue+date - for i, tag := range evt.Tags { - if len(tag) < 2 || len(tag[0]) != 1 || len(tag[1]) == 0 || len(tag[1]) > 100 { - // not indexable - continue - } - firstIndex := slices.IndexFunc(evt.Tags, func(t nostr.Tag) bool { return len(t) >= 2 && t[1] == tag[1] }) - if firstIndex != i { - // duplicate - continue - } - - // get key prefix (with full length) and offset where to write the created_at - bucket, k, offset := getTagIndexPrefix(tag[1]) - - // write the created_at - binary.BigEndian.PutUint32(k[offset:], uint32(evt.CreatedAt)) - - keys = append(keys, keymeta{bucket: bucket, key: k}) - } - - { - // ~ by date only - k := make([]byte, 4) - binary.BigEndian.PutUint32(k[:], uint32(evt.CreatedAt)) - keys = append(keys, keymeta{bucket: bucketCreatedAt, key: k}) - } - - return keys -} diff --git a/bolt/lib.go b/bolt/lib.go deleted file mode 100644 index d971a68..0000000 --- a/bolt/lib.go +++ /dev/null @@ -1,106 +0,0 @@ -package bolt - -import ( - "fmt" - "sync/atomic" - "time" - - "github.com/fiatjaf/eventstore" - bolt "go.etcd.io/bbolt" -) - -const ( - maxuint16 = 65535 - maxuint32 = 4294967295 -) - -var ( - bucketSettings = []byte{99} - bucketRaw = []byte{1} - bucketCreatedAt = []byte{2} - bucketId = []byte{3} - bucketKind = []byte{4} - bucketPubkey = []byte{5} - bucketPubkeyKind = []byte{6} - bucketTag = []byte{7} - bucketTag32 = []byte{8} - bucketTagAddr = []byte{9} -) - -var _ eventstore.Store = (*BoltBackend)(nil) - -type BoltBackend struct { - Path string - MaxLimit int - - db *bolt.DB - - lastId atomic.Uint32 -} - -func (b *BoltBackend) Init() error { - if b.MaxLimit == 0 { - b.MaxLimit = 500 - } - - // open boltdb - var db *bolt.DB - var err error - done := make(chan struct{}) - go func() { - db, err = bolt.Open(b.Path, 0644, nil) - done <- struct{}{} - }() - select { - case <-done: - case <-time.After(20 * time.Second): - return fmt.Errorf("taking too long to open the bolt database at '%s', please make sure that database is not being used elsewhere because there may be a lock in place there", b.Path) - } - if err != nil { - return err - } - b.db = db - - // open each bucket - if err := b.db.Update(func(txn *bolt.Tx) error { - if _, err := txn.CreateBucket(bucketSettings); err != nil && err != bolt.ErrBucketExists { - return err - } - if _, err := txn.CreateBucket(bucketRaw); err != nil && err != bolt.ErrBucketExists { - return err - } - if _, err := txn.CreateBucket(bucketCreatedAt); err != nil && err != bolt.ErrBucketExists { - return err - } - if _, err := txn.CreateBucket(bucketId); err != nil && err != bolt.ErrBucketExists { - return err - } - if _, err := txn.CreateBucket(bucketKind); err != nil && err != bolt.ErrBucketExists { - return err - } - if _, err := txn.CreateBucket(bucketPubkey); err != nil && err != bolt.ErrBucketExists { - return err - } - if _, err := txn.CreateBucket(bucketPubkeyKind); err != nil && err != bolt.ErrBucketExists { - return err - } - if _, err := txn.CreateBucket(bucketTag); err != nil && err != bolt.ErrBucketExists { - return err - } - if _, err := txn.CreateBucket(bucketTag32); err != nil && err != bolt.ErrBucketExists { - return err - } - if _, err := txn.CreateBucket(bucketTagAddr); err != nil && err != bolt.ErrBucketExists { - return err - } - return nil - }); err != nil { - return err - } - - return b.runMigrations() -} - -func (b *BoltBackend) Close() { - b.db.Close() -} diff --git a/bolt/migration.go b/bolt/migration.go deleted file mode 100644 index 28efe72..0000000 --- a/bolt/migration.go +++ /dev/null @@ -1,32 +0,0 @@ -package bolt - -import ( - "encoding/binary" - - bolt "go.etcd.io/bbolt" -) - -const ( - DB_VERSION byte = 'v' -) - -func (b *BoltBackend) runMigrations() error { - return b.db.Update(func(txn *bolt.Tx) error { - var version uint16 - v := txn.Bucket(bucketSettings).Get([]byte{DB_VERSION}) - if v == nil { - version = 0 - } else { - version = binary.BigEndian.Uint16(v) - } - - // do the migrations in increasing steps (there is no rollback) - // - - if version < 0 { - // ... - } - - return nil - }) -} diff --git a/bolt/query.go b/bolt/query.go deleted file mode 100644 index fd7978c..0000000 --- a/bolt/query.go +++ /dev/null @@ -1,282 +0,0 @@ -package bolt - -import ( - "bytes" - "container/heap" - "context" - "encoding/binary" - "encoding/hex" - "fmt" - "log" - - "github.com/nbd-wtf/go-nostr" - nostr_binary "github.com/nbd-wtf/go-nostr/binary" - bolt "go.etcd.io/bbolt" -) - -type query struct { - i int - bucket []byte - prefix []byte - startingPoint []byte - results chan *nostr.Event - skipTimestamp bool -} - -type queryEvent struct { - *nostr.Event - query int -} - -func (b *BoltBackend) QueryEvents(ctx context.Context, filter nostr.Filter) (chan *nostr.Event, error) { - ch := make(chan *nostr.Event) - - queries, extraFilter, since, err := prepareQueries(filter) - if err != nil { - return nil, err - } - - if filter.Search != "" { - close(ch) - return ch, nil - } - - // max number of events we'll return - limit := b.MaxLimit / 4 - if filter.Limit > 0 && filter.Limit < b.MaxLimit { - limit = filter.Limit - } - - go func() { - defer close(ch) - - for _, q := range queries { - q := q - pulled := 0 // this query will be hardcapped at this global limit - - go b.db.View(func(txn *bolt.Tx) error { - defer close(q.results) - - bucket := txn.Bucket(q.bucket) - raw := txn.Bucket(bucketRaw) - - c := bucket.Cursor() - - key, _ := c.Seek(q.startingPoint) - if key == nil { - key, _ = c.Last() - } else { - key, _ = c.Prev() - } - - for ; key != nil && bytes.HasPrefix(key, q.prefix); key, _ = c.Prev() { - idxOffset := len(key) - 4 // this is where the idx actually starts - - // "id" indexes don't contain a timestamp - if !q.skipTimestamp { - createdAt := binary.BigEndian.Uint32(key[idxOffset-4 : idxOffset]) - if createdAt < since { - break - } - } - - // fetch actual event - val := raw.Get(key[len(key)-4:]) - evt := &nostr.Event{} - if err := nostr_binary.Unmarshal(val, evt); err != nil { - log.Printf("bolt: value read error (id %x): %s\n", val[0:32], err) - return fmt.Errorf("error: %w", err) - } - - // check if this matches the other filters that were not part of the index before yielding - if extraFilter == nil || extraFilter.Matches(evt) { - select { - case q.results <- evt: - pulled++ - if pulled > limit { - return nil - } - case <-ctx.Done(): - return nil - } - } - } - - return nil - }) - } - - // receive results and ensure we only return the most recent ones always - emittedEvents := 0 - - // first pass - emitQueue := make(priorityQueue, 0, len(queries)) - for _, q := range queries { - evt, ok := <-q.results - if ok { - emitQueue = append(emitQueue, &queryEvent{Event: evt, query: q.i}) - } - } - - // queue may be empty here if we have literally nothing - if len(emitQueue) == 0 { - return - } - - heap.Init(&emitQueue) - - // iterate until we've emitted all events required - for { - // emit latest event in queue - latest := emitQueue[0] - select { - case ch <- latest.Event: - case <-ctx.Done(): - return - } - - // stop when reaching limit - emittedEvents++ - if emittedEvents >= limit { - break - } - - // fetch a new one from query results and replace the previous one with it - if evt, ok := <-queries[latest.query].results; ok { - emitQueue[0].Event = evt - heap.Fix(&emitQueue, 0) - } else { - // if this query has no more events we just remove this and proceed normally - heap.Remove(&emitQueue, 0) - - // check if the list is empty and end - if len(emitQueue) == 0 { - break - } - } - } - }() - - return ch, nil -} - -type priorityQueue []*queryEvent - -func (pq priorityQueue) Len() int { return len(pq) } - -func (pq priorityQueue) Less(i, j int) bool { - return pq[i].CreatedAt > pq[j].CreatedAt -} - -func (pq priorityQueue) Swap(i, j int) { - pq[i], pq[j] = pq[j], pq[i] -} - -func (pq *priorityQueue) Push(x any) { - item := x.(*queryEvent) - *pq = append(*pq, item) -} - -func (pq *priorityQueue) Pop() any { - old := *pq - n := len(old) - item := old[n-1] - old[n-1] = nil // avoid memory leak - *pq = old[0 : n-1] - return item -} - -func prepareQueries(filter nostr.Filter) (queries []query, extraFilter *nostr.Filter, since uint32, err error) { - if len(filter.IDs) > 0 { - queries = make([]query, len(filter.IDs)) - for i, idHex := range filter.IDs { - if len(idHex) != 64 { - return nil, nil, 0, fmt.Errorf("invalid id '%s'", idHex) - } - prefix, _ := hex.DecodeString(idHex[0 : 8*2]) - queries[i] = query{i: i, bucket: bucketId, prefix: prefix, skipTimestamp: true} - } - } else if len(filter.Authors) > 0 { - if len(filter.Kinds) == 0 { - queries = make([]query, len(filter.Authors)) - for i, pubkeyHex := range filter.Authors { - if len(pubkeyHex) != 64 { - return nil, nil, 0, fmt.Errorf("invalid pubkey '%s'", pubkeyHex) - } - prefix, _ := hex.DecodeString(pubkeyHex[0 : 8*2]) - queries[i] = query{i: i, bucket: bucketPubkey, prefix: prefix} - } - } else { - queries = make([]query, len(filter.Authors)*len(filter.Kinds)) - i := 0 - for _, pubkeyHex := range filter.Authors { - for _, kind := range filter.Kinds { - if len(pubkeyHex) != 64 { - return nil, nil, 0, fmt.Errorf("invalid pubkey '%s'", pubkeyHex) - } - pubkey, _ := hex.DecodeString(pubkeyHex[0 : 8*2]) - prefix := binary.BigEndian.AppendUint16(pubkey, uint16(kind)) - queries[i] = query{i: i, bucket: bucketPubkeyKind, prefix: prefix} - i++ - } - } - } - extraFilter = &nostr.Filter{Tags: filter.Tags} - } else if len(filter.Tags) > 0 { - // determine the size of the queries array by inspecting all tags sizes - size := 0 - for _, values := range filter.Tags { - size += len(values) - } - if size == 0 { - return nil, nil, 0, fmt.Errorf("empty tag filters") - } - - queries = make([]query, size) - - extraFilter = &nostr.Filter{Kinds: filter.Kinds} - i := 0 - for _, values := range filter.Tags { - for _, value := range values { - // get key prefix (with full length) and offset where to write the created_at - bucket, k, offset := getTagIndexPrefix(value) - // remove the last parts part to get just the prefix we want here - prefix := k[0:offset] - queries[i] = query{i: i, bucket: bucket, prefix: prefix} - i++ - } - } - } else if len(filter.Kinds) > 0 { - queries = make([]query, len(filter.Kinds)) - for i, kind := range filter.Kinds { - prefix := make([]byte, 2) - binary.BigEndian.PutUint16(prefix[:], uint16(kind)) - queries[i] = query{i: i, bucket: bucketKind, prefix: prefix} - } - } else { - queries = make([]query, 1) - prefix := make([]byte, 0) - queries[0] = query{i: 0, bucket: bucketCreatedAt, prefix: prefix} - extraFilter = nil - } - - var until uint32 = 4294967295 - if filter.Until != nil { - if fu := uint32(*filter.Until); fu < until { - until = fu + 1 - } - } - for i, q := range queries { - queries[i].startingPoint = binary.BigEndian.AppendUint32(q.prefix, uint32(until)) - queries[i].results = make(chan *nostr.Event, 12) - } - - // this is where we'll end the iteration - if filter.Since != nil { - if fs := uint32(*filter.Since); fs > since { - since = fs - } - } - - return queries, extraFilter, since, nil -} diff --git a/bolt/save.go b/bolt/save.go deleted file mode 100644 index 26001c1..0000000 --- a/bolt/save.go +++ /dev/null @@ -1,58 +0,0 @@ -package bolt - -import ( - "context" - "encoding/binary" - "encoding/hex" - "fmt" - - "github.com/fiatjaf/eventstore" - "github.com/nbd-wtf/go-nostr" - nostr_binary "github.com/nbd-wtf/go-nostr/binary" - bolt "go.etcd.io/bbolt" -) - -func (b *BoltBackend) SaveEvent(ctx context.Context, evt *nostr.Event) error { - // sanity checking - if evt.CreatedAt > maxuint32 || evt.Kind > maxuint16 { - return fmt.Errorf("event with values out of expected boundaries") - } - - return b.db.Update(func(txn *bolt.Tx) error { - id, _ := hex.DecodeString(evt.ID) - - // check if we already have this id - bucket := txn.Bucket(bucketId) - res := bucket.Get(id) - if res != nil { - return eventstore.ErrDupEvent - } - - // encode to binary form so we'll save it - bin, err := nostr_binary.Marshal(evt) - if err != nil { - return err - } - - // raw event store - raw := txn.Bucket(bucketRaw) - seq, err := raw.NextSequence() - if err != nil { - return fmt.Errorf("failed to get sequence when saving: %w", err) - } - - seqb := binary.BigEndian.AppendUint32(nil, uint32(seq)) - if err := raw.Put(seqb, bin); err != nil { - return err - } - - for _, km := range getIndexKeysForEvent(evt) { - bucket := txn.Bucket(km.bucket) - if err := bucket.Put(append(km.key, seqb...), nil); err != nil { - return err - } - } - - return nil - }) -} diff --git a/cmd/eventstore/helpers.go b/cmd/eventstore/helpers.go index 283c796..3d1fe07 100644 --- a/cmd/eventstore/helpers.go +++ b/cmd/eventstore/helpers.go @@ -30,7 +30,8 @@ func detect(dir string) (string, error) { if string(buf) == "SQLite format 3" { return "sqlite", nil } - return "bolt", nil + + return "", fmt.Errorf("unknown db format") } entries, err := os.ReadDir(dir) diff --git a/cmd/eventstore/main.go b/cmd/eventstore/main.go index 3874202..a417a08 100644 --- a/cmd/eventstore/main.go +++ b/cmd/eventstore/main.go @@ -6,16 +6,15 @@ import ( "os" "strings" + "github.com/fiatjaf/cli/v3" "github.com/fiatjaf/eventstore" "github.com/fiatjaf/eventstore/badger" - "github.com/fiatjaf/eventstore/bolt" "github.com/fiatjaf/eventstore/elasticsearch" "github.com/fiatjaf/eventstore/lmdb" "github.com/fiatjaf/eventstore/mysql" "github.com/fiatjaf/eventstore/postgresql" "github.com/fiatjaf/eventstore/sqlite3" "github.com/fiatjaf/eventstore/strfry" - "github.com/fiatjaf/cli/v3" ) var db eventstore.Store @@ -34,7 +33,7 @@ var app = &cli.Command{ &cli.StringFlag{ Name: "type", Aliases: []string{"t"}, - Usage: "store type ('sqlite', 'lmdb', 'bolt', 'badger', 'postgres', 'mysql', 'elasticsearch')", + Usage: "store type ('sqlite', 'lmdb', 'badger', 'postgres', 'mysql', 'elasticsearch')", }, }, Before: func(ctx context.Context, c *cli.Command) error { @@ -81,8 +80,6 @@ var app = &cli.Command{ } case "lmdb": db = &lmdb.LMDBBackend{Path: path, MaxLimit: 1_000_000} - case "bolt": - db = &bolt.BoltBackend{Path: path, MaxLimit: 1_000_000} case "badger": db = &badger.BadgerBackend{Path: path, MaxLimit: 1_000_000} case "postgres", "postgresql": diff --git a/go.mod b/go.mod index 3cf0bef..c81c2b1 100644 --- a/go.mod +++ b/go.mod @@ -19,7 +19,6 @@ require ( github.com/nbd-wtf/go-nostr v0.34.0 github.com/opensearch-project/opensearch-go/v4 v4.0.0 github.com/stretchr/testify v1.9.0 - go.etcd.io/bbolt v1.3.9 golang.org/x/exp v0.0.0-20231006140011-7918f672742d golang.org/x/text v0.15.0 ) diff --git a/test/db_fuzz_test.go b/test/db_fuzz_test.go index e5fbf76..01dc008 100644 --- a/test/db_fuzz_test.go +++ b/test/db_fuzz_test.go @@ -9,7 +9,6 @@ import ( embeddedpostgres "github.com/fergusstrange/embedded-postgres" "github.com/fiatjaf/eventstore" "github.com/fiatjaf/eventstore/badger" - "github.com/fiatjaf/eventstore/bolt" "github.com/fiatjaf/eventstore/lmdb" "github.com/fiatjaf/eventstore/postgresql" "github.com/fiatjaf/eventstore/slicestore" @@ -32,11 +31,6 @@ func FuzzBadger(f *testing.F) { runFuzzOn(f, &badger.BadgerBackend{Path: dbpath + "badger"}) } -func FuzzBolt(f *testing.F) { - os.RemoveAll(dbpath + "bolt") - runFuzzOn(f, &bolt.BoltBackend{Path: dbpath + "bolt"}) -} - func FuzzSQLite(f *testing.F) { os.RemoveAll(dbpath + "sqlite") runFuzzOn(f, &sqlite3.SQLite3Backend{DatabaseURL: dbpath + "sqlite"}) diff --git a/test/db_test.go b/test/db_test.go index f8cb710..0c82a25 100644 --- a/test/db_test.go +++ b/test/db_test.go @@ -10,7 +10,6 @@ import ( embeddedpostgres "github.com/fergusstrange/embedded-postgres" "github.com/fiatjaf/eventstore" "github.com/fiatjaf/eventstore/badger" - "github.com/fiatjaf/eventstore/bolt" "github.com/fiatjaf/eventstore/lmdb" "github.com/fiatjaf/eventstore/postgresql" "github.com/fiatjaf/eventstore/slicestore" @@ -39,11 +38,6 @@ func TestBadger(t *testing.T) { runTestOn(t, &badger.BadgerBackend{Path: dbpath + "badger"}) } -func TestBolt(t *testing.T) { - os.RemoveAll(dbpath + "bolt") - runTestOn(t, &bolt.BoltBackend{Path: dbpath + "bolt"}) -} - func TestSQLite(t *testing.T) { os.RemoveAll(dbpath + "sqlite") runTestOn(t, &sqlite3.SQLite3Backend{DatabaseURL: dbpath + "sqlite"})