Work on tests and query

database/storage/badger/badger.go

@@ -2,9 +2,12 @@ package badger
 
 import (
 	"errors"
+	"fmt"
+	"time"
 
 	"github.com/dgraph-io/badger"
 
+	"github.com/Safing/portbase/database/accessor"
 	"github.com/Safing/portbase/database/iterator"
 	"github.com/Safing/portbase/database/query"
 	"github.com/Safing/portbase/database/record"
@@ -38,24 +41,6 @@ func NewBadger(name, location string) (storage.Interface, error) {
 	}, nil
 }
 
-// Exists returns whether an entry with the given key exists.
-func (b *Badger) Exists(key string) (bool, error) {
-	err := b.db.View(func(txn *badger.Txn) error {
-		_, err := txn.Get([]byte(key))
-		if err != nil {
-			if err == badger.ErrKeyNotFound {
-				return nil
-			}
-			return err
-		}
-		return nil
-	})
-	if err == nil {
-		return true, nil
-	}
-	return false, nil
-}
-
 // Get returns a database record.
 func (b *Badger) Get(key string) (record.Record, error) {
 	var item *badger.Item
@@ -75,9 +60,10 @@ func (b *Badger) Get(key string) (record.Record, error) {
 		return nil, err
 	}
 
-	if item.IsDeletedOrExpired() {
-		return nil, storage.ErrNotFound
-	}
+	// DO NOT check for this, as we got our own machanism for that.
+	// if item.IsDeletedOrExpired() {
+	// 	return nil, storage.ErrNotFound
+	// }
 
 	data, err := item.ValueCopy(nil)
 	if err != nil {
@@ -92,14 +78,14 @@ func (b *Badger) Get(key string) (record.Record, error) {
 }
 
 // Put stores a record in the database.
-func (b *Badger) Put(m record.Record) error {
-	data, err := m.MarshalRecord()
+func (b *Badger) Put(r record.Record) error {
+	data, err := r.MarshalRecord(r)
 	if err != nil {
 		return err
 	}
 
 	err = b.db.Update(func(txn *badger.Txn) error {
-		return txn.Set([]byte(m.DatabaseKey()), data)
+		return txn.Set([]byte(r.DatabaseKey()), data)
 	})
 	return err
 }
@@ -117,7 +103,76 @@ func (b *Badger) Delete(key string) error {
 
 // Query returns a an iterator for the supplied query.
 func (b *Badger) Query(q *query.Query, local, internal bool) (*iterator.Iterator, error) {
-	return nil, errors.New("query not implemented by badger")
+	_, err := q.Check()
+	if err != nil {
+		return nil, fmt.Errorf("invalid query: %s", err)
+	}
+
+	queryIter := iterator.New()
+
+	go b.queryExecutor(queryIter, q, local, internal)
+	return queryIter, nil
+}
+
+func (b *Badger) queryExecutor(queryIter *iterator.Iterator, q *query.Query, local, internal bool) {
+	err := b.db.View(func(txn *badger.Txn) error {
+		it := txn.NewIterator(badger.DefaultIteratorOptions)
+		defer it.Close()
+		prefix := []byte(q.DatabaseKeyPrefix())
+		for it.Seek(prefix); it.ValidForPrefix(prefix); it.Next() {
+			item := it.Item()
+
+			data, err := item.Value()
+			if err != nil {
+				return err
+			}
+
+			r, err := record.NewRawWrapper(b.name, string(item.Key()), data)
+			if err != nil {
+				return err
+			}
+
+			if !r.Meta().CheckValidity() {
+				continue
+			}
+			if !r.Meta().CheckPermission(local, internal) {
+				continue
+			}
+
+			if len(r.Data) > 1 {
+				jsonData := r.Data[1:]
+				acc := accessor.NewJSONBytesAccessor(&jsonData)
+				if q.Matches(acc) {
+
+					copiedData, err := item.ValueCopy(nil)
+					if err != nil {
+						return err
+					}
+					new, err := record.NewRawWrapper(b.name, string(item.Key()), copiedData)
+					if err != nil {
+						return err
+					}
+					select {
+					case queryIter.Next <- new:
+					default:
+						select {
+						case queryIter.Next <- new:
+						case <-time.After(1 * time.Minute):
+							return errors.New("query timeout")
+						}
+					}
+
+				}
+			}
+
+		}
+		return nil
+	})
+
+	if err != nil {
+		queryIter.Error = err
+	}
+	close(queryIter.Next)
 }
 
 // ReadOnly returns whether the database is read only.
@@ -125,6 +180,11 @@ func (b *Badger) ReadOnly() bool {
 	return false
 }
 
+// Injected returns whether the database is injected.
+func (b *Badger) Injected() bool {
+	return false
+}
+
 // Maintain runs a light maintenance operation on the database.
 func (b *Badger) Maintain() error {
 	b.db.RunValueLogGC(0.7)

database/storage/badger/badger_test.go

@@ -3,6 +3,7 @@ package badger
 import (
 	"io/ioutil"
 	"os"
+	"reflect"
 	"sync"
 	"testing"
 
@@ -46,7 +47,22 @@ func TestBadger(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	a := &TestRecord{S: "banana"}
+	a := &TestRecord{
+		S:    "banana",
+		I:    42,
+		I8:   42,
+		I16:  42,
+		I32:  42,
+		I64:  42,
+		UI:   42,
+		UI8:  42,
+		UI16: 42,
+		UI32: 42,
+		UI64: 42,
+		F32:  42.42,
+		F64:  42.42,
+		B:    true,
+	}
 	a.SetMeta(&record.Meta{})
 	a.Meta().Update()
 	a.SetKey("test:A")
@@ -61,9 +77,38 @@ func TestBadger(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	a1 := r1.(*TestRecord)
+	a1 := &TestRecord{}
+	_, err = record.Unwrap(r1, a1)
+	if err != nil {
+		t.Fatal(err)
+	}
 
-	if a.S != a1.S {
-		t.Fatal("mismatch")
+	if !reflect.DeepEqual(a, a1) {
+		t.Fatalf("mismatch, got %v", a1)
+	}
+
+	err = db.Delete("A")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	_, err = db.Get("A")
+	if err == nil {
+		t.Fatal("should fail")
+	}
+
+	err = db.Maintain()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = db.MaintainThorough()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = db.Shutdown()
+	if err != nil {
+		t.Fatal(err)
 	}
 }