120 lines
3.0 KiB
Go
120 lines
3.0 KiB
Go
package mmm
|
|
|
|
import (
|
|
"encoding/binary"
|
|
"fmt"
|
|
"log"
|
|
|
|
"fiatjaf.com/nostr"
|
|
"github.com/PowerDNS/lmdb-go/lmdb"
|
|
)
|
|
|
|
const target = 2
|
|
|
|
func (il *IndexingLayer) migrate() error {
|
|
return il.lmdbEnv.Update(func(txn *lmdb.Txn) error {
|
|
val, err := txn.Get(il.settings, []byte("version"))
|
|
if err != nil && !lmdb.IsNotFound(err) {
|
|
return fmt.Errorf("failed to get db version: %w", err)
|
|
}
|
|
|
|
var version uint16 = target
|
|
if err == nil {
|
|
version = binary.BigEndian.Uint16(val)
|
|
}
|
|
|
|
// do the migrations in increasing steps (there is no rollback)
|
|
if version < target {
|
|
log.Printf("[mmm/%s] migration %d: reindex everything\n", il.name, target)
|
|
|
|
if err := txn.Drop(il.indexKind, false); err != nil {
|
|
return err
|
|
}
|
|
if err := txn.Drop(il.indexPubkey, false); err != nil {
|
|
return err
|
|
}
|
|
if err := txn.Drop(il.indexPubkeyKind, false); err != nil {
|
|
return err
|
|
}
|
|
if err := txn.Drop(il.indexTag, false); err != nil {
|
|
return err
|
|
}
|
|
if err := txn.Drop(il.indexTag32, false); err != nil {
|
|
return err
|
|
}
|
|
if err := txn.Drop(il.indexTagAddr, false); err != nil {
|
|
return err
|
|
}
|
|
if err := txn.Drop(il.indexPTagKind, false); err != nil {
|
|
return err
|
|
}
|
|
|
|
// we can't just iterate this layer's events because we don't have this index
|
|
// so we must iterate all events in the mmap file and check if they belong to this layer
|
|
mmmtxn, err := il.mmmm.lmdbEnv.BeginTxn(nil, lmdb.Readonly)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer mmmtxn.Abort()
|
|
|
|
cursor, err := mmmtxn.OpenCursor(il.mmmm.indexId)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to open cursor in migration %d: %w", target, err)
|
|
}
|
|
defer cursor.Close()
|
|
|
|
var evt nostr.Event
|
|
var id, val []byte
|
|
|
|
for {
|
|
id, val, err = cursor.Get(nil, nil, lmdb.Next)
|
|
if lmdb.IsNotFound(err) {
|
|
break
|
|
}
|
|
if err != nil {
|
|
return fmt.Errorf("failed to get next in migration %d: %w", target, err)
|
|
}
|
|
|
|
// check if this event belongs to this layer
|
|
belongs := false
|
|
for i := 12; i < len(val); i += 2 {
|
|
ilid := binary.BigEndian.Uint16(val[i : i+2])
|
|
if ilid == il.id {
|
|
belongs = true
|
|
break
|
|
}
|
|
}
|
|
if !belongs {
|
|
continue
|
|
}
|
|
|
|
// load event and reindex
|
|
pos := positionFromBytes(val[0:12])
|
|
if err := il.mmmm.loadEvent(pos, &evt); err != nil {
|
|
log.Printf("failed to load event %x for reindexing on layer %s: %s", id, il.name, err)
|
|
continue
|
|
}
|
|
|
|
for key := range il.getIndexKeysForEvent(evt) {
|
|
if err := txn.Put(key.dbi, key.key, val[0:12], 0); err != nil {
|
|
return fmt.Errorf("failed to save index for event %s on migration %d: %w", evt.ID, target, err)
|
|
}
|
|
}
|
|
}
|
|
|
|
// bump version
|
|
if err := il.setVersion(txn, target); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
return nil
|
|
})
|
|
}
|
|
|
|
func (il *IndexingLayer) setVersion(txn *lmdb.Txn, v uint16) error {
|
|
var newVersion [2]byte
|
|
binary.BigEndian.PutUint16(newVersion[:], v)
|
|
return txn.Put(il.settings, []byte("version"), newVersion[:], 0)
|
|
}
|