Refactor keyValStore logger initialization for better organization an…

…d consistency

OuroborosDB_test.go

@@ -4,9 +4,10 @@ import (
 	"OuroborosDB"
 	"OuroborosDB/internal/storage"
 	"testing"
+	"time"
 )
 
-func setupIndex(t testing.TB, rows int) *OuroborosDB.OuroborosDB {
+func setupIndex(t testing.TB, rowsIn1k int) *OuroborosDB.OuroborosDB {
 	ou, err := OuroborosDB.NewOuroborosDB(OuroborosDB.Config{
 		Paths:                     []string{t.TempDir()},
 		MinimumFreeGB:             1,
@@ -16,53 +17,50 @@ func setupIndex(t testing.TB, rows int) *OuroborosDB.OuroborosDB {
 		t.Errorf("NewOuroborosDB failed with error: %v", err)
 	}
 
-	rev, err := ou.DB.CreateRootEvent("root1")
-	if err != nil {
-		t.Errorf("CreateRootEvent failed with error: %v", err)
-	}
-
-	rev2, err := ou.DB.CreateRootEvent("root2")
-	if err != nil {
-		t.Errorf("CreateRootEvent failed with error: %v", err)
-	}
+	parents := rowsIn1k / 500
 
-	for i := 0; i < rows; i++ {
-		_, err := ou.DB.CreateNewEvent(storage.EventOptions{
-			HashOfParentEvent: rev.EventHash,
-		})
+	for i := 0; i < parents; i++ {
+		rootEv, err := ou.DB.CreateRootEvent(time.Now().String())
 		if err != nil {
-			t.Errorf("CreateNewEvent failed with error: %v", err)
+			t.Errorf("CreateRootEvent failed with error: %v", err)
 		}
-	}
 
-	for i := 0; i < rows; i++ {
-		_, err := ou.DB.CreateNewEvent(storage.EventOptions{
-			HashOfParentEvent: rev2.EventHash,
-		})
-		if err != nil {
-			t.Errorf("CreateNewEvent failed with error: %v", err)
+		for j := 0; j < 499; j++ {
+			_, err := ou.DB.CreateNewEvent(storage.EventOptions{
+				HashOfParentEvent: rootEv.EventHash,
+			})
+			if err != nil {
+				t.Errorf("CreateNewEvent failed with error: %v", err)
+			}
 		}
 	}
 
+	time.Sleep(1 * time.Second)
+
 	return ou
 }
 
 func TestIndex_RebuildIndex(t *testing.T) {
-	ou := setupIndex(t, 10)
+	testEvs := 1000
+	ou := setupIndex(t, testEvs)
 
 	// Rebuild the index
-	err := ou.Index.RebuildIndex()
+	indexedRows, err := ou.Index.RebuildIndex()
 	if err != nil {
 		t.Errorf("RebuildIndex failed with error: %v", err)
 	}
+
+	if indexedRows != uint64(testEvs) {
+		t.Errorf("RebuildIndex failed, expected %d, got %d", testEvs, indexedRows)
+	}
 }
 
 func BenchmarkRebuildingIndex10kRows(b *testing.B) {
-	ou := setupIndex(b, 5000)
+	ou := setupIndex(b, 10000)
 
 	b.Run("RebuildIndex", func(b *testing.B) {
 		for i := 0; i < b.N; i++ {
-			err := ou.Index.RebuildIndex()
+			_, err := ou.Index.RebuildIndex()
 			if err != nil {
 				b.Errorf("RebuildIndex failed with error: %v", err)
 			}

internal/index/index.go

@@ -22,11 +22,11 @@ func NewIndex(ss *storage.Storage) *Index {
 	return i
 }
 
-func (i *Index) RebuildIndex() error {
+func (i *Index) RebuildIndex() (uint64, error) {
 	// get every event
 	events, err := i.ss.GetAllEvents()
 	if err != nil {
-		return err
+		return 0, err
 	}
 
 	i.evParentToChildLock.Lock()
@@ -40,7 +40,7 @@ func (i *Index) RebuildIndex() error {
 		i.evParentToChild[event.HashOfParentEvent] = append(i.evParentToChild[event.HashOfParentEvent], event.EventHash)
 	}
 
-	return nil
+	return uint64(len(events)), nil
 }
 
 func (i *Index) GetChildrenHashesOfEvent(event storage.Event) [][64]byte {

internal/keyValStore/keyValStore.go

@@ -78,11 +78,13 @@ func (k *KeyValStore) StartTransactionCounter(paths []string, minimumFreeSpace i
 
 func (k *KeyValStore) Write(key []byte, content []byte) error {
 	atomic.AddUint64(&k.writeCounter, 1)
+
 	err := k.badgerDB.Update(func(txn *badger.Txn) error {
 		return txn.Set(key, content)
 	})
 	if err != nil {
 		log.Fatal(err)
+		return err
 	}
 	return err
 }

internal/storage/normalEvent.go

@@ -3,6 +3,7 @@ package storage
 import (
 	"bytes"
 	"crypto/sha512"
+	"encoding/binary"
 	"encoding/gob"
 	"encoding/hex"
 	"errors"
@@ -79,7 +80,6 @@ func (ss *Storage) CreateNewEvent(options EventOptions) (Event, error) {
 	}
 
 	// Write the EventChainItem to the keyValStore
-
 	err = ss.kv.Write(item.Key, buf.Bytes())
 	if err != nil {
 		log.Fatalf("Error writing item: %v", err)
@@ -89,26 +89,48 @@ func (ss *Storage) CreateNewEvent(options EventOptions) (Event, error) {
 	return item, err
 }
 
+const (
+	TrueStr  = "true"
+	FalseStr = "false"
+)
+
 func (item *Event) CreateDetailsMetaHash() [64]byte {
-	// create a buffer, put all bytes into the buffer and hash it
-	buffer := make([]byte, 0)
+	// Pre-allocate a buffer to make the hashing process more efficient
+	var buffer bytes.Buffer
 
-	buffer = append(buffer, byte(item.Level))
+	// Append Level as an int64 using binary encoding
+	levelBytes := make([]byte, 8)
+	binary.LittleEndian.PutUint64(levelBytes, uint64(item.Level))
+	buffer.Write(levelBytes)
+
+	// Append all content hashes
 	for _, hash := range item.ContentHashes {
-		buffer = append(buffer, hash[:]...)
+		buffer.Write(hash[:])
 	}
+
+	// Append all metadata hashes
 	for _, hash := range item.MetadataHashes {
-		buffer = append(buffer, hash[:]...)
+		buffer.Write(hash[:])
 	}
-	buffer = append(buffer, item.HashOfParentEvent[:]...)
-	buffer = append(buffer, item.HashOfRootEvent[:]...)
+
+	// Append parent event and root event hashes
+	buffer.Write(item.HashOfParentEvent[:])
+	buffer.Write(item.HashOfRootEvent[:])
+
+	// Append the boolean flags as "true"/"false" strings
 	if item.Temporary {
-		buffer = append(buffer, []byte("true")...)
+		buffer.WriteString(TrueStr)
+	} else {
+		buffer.WriteString(FalseStr)
+	}
+
+	if item.FullTextSearch {
+		buffer.WriteString(TrueStr)
 	} else {
-		buffer = append(buffer, []byte("false")...)
+		buffer.WriteString(FalseStr)
 	}
 
-	return sha512.Sum512(buffer)
+	return sha512.Sum512(buffer.Bytes())
 }
 
 func (ss *Storage) GetEvent(key []byte) (Event, error) {

pkg/api/api.go

@@ -15,7 +15,7 @@ type DB interface {
 }
 
 type Index interface {
-	RebuildIndex() error
+	RebuildIndex() (uint64, error)
 	GetChildrenHashesOfEvent(event storage.Event) [][64]byte
 	GetChildrenOfEvent(event storage.Event) ([]storage.Event, error)
 }