changed serialization logic to json strings, added batch compaction

batch/batch.go

@@ -4,13 +4,13 @@ import (
 	"fmt"
 	"github.com/vocdoni/dvote-relay/types"
 	"github.com/vocdoni/dvote-relay/db"
+	"encoding/json"
 )
 
 var rdb *db.LevelDbStorage
 var bdb *db.LevelDbStorage
 var BatchSignal chan bool
 var BatchSize int
-var currentBatchSize int
 var err error
 
 func Setup(l *db.LevelDbStorage) {
@@ -20,27 +20,33 @@ func Setup(l *db.LevelDbStorage) {
 
 
 //add (queue for counting)
-func Add(p types.Ballot) error {
+func Add(ballot types.Ballot) error {
-	err := bdb.Put([]byte(fmt.Sprintf("%v", p.Nullifier)),[]byte(fmt.Sprintf("%v", p)))
+	//this is probably adding []
+	//err := bdb.Put(fmt.Sprintf("%v", p.Nullifier)),[]byte(fmt.Sprintf("%v", p)))
+	var b []byte
+	var n []byte
+	var err error
+	b, err = json.Marshal(ballot)
+	n, err = json.Marshal(ballot.Nullifier)
+	err = bdb.Put(n,b)
 	if err != nil {
 		return err
 	}
 
 	//this actually needs to see if it was added
-	currentBatchSize++
+	if bdb.Count() >= BatchSize {
-	fmt.Println(bdb.Info())
-	if currentBatchSize >= BatchSize {
 		BatchSignal <- true
 	}
 	return nil
 }
 
 //create (return batch)
-//k is []byte nullifier
+//k is []byte 'batch_' + nullifier
 //v is []byte package
-func Create() []byte {
+//returns slice of nullifiers, batch json
-	var b []byte
+func Create() ([]string, []string) {
-	var i int
+	var n []string
+	var b []string
 	iter := bdb.Iter()
 	for iter.Next() {
 		k := iter.Key()
@@ -49,14 +55,30 @@ func Create() []byte {
 		if err != nil {
 			panic(err)
 		}
-		fmt.Println(i)
+		n = append(n, string(k[6:]))
-		fmt.Println(string(k))
+		b = append(b, string(v))
-		fmt.Println(string(v))
-		i++
-		//put p in batch
-		//rdb.Put(iter.Key(), iter.Val(), nil)
-		//bdb.Delete(iter.Key(), nil)
 	}
 	iter.Release()
-	return b
+//	jn, err := json.Marshal(n)
+//	if err != nil {
+//		panic(err)
+//	}
+//	jb, err := json.Marshal(b)
+//	if err != nil {
+//		panic(err)
+//	}
+	return n, b
+}
+
+//move from bdb to rdb once pinned
+func Compact(n []string) {
+	for _, k := range n {
+		fmt.Println(k)
+		v, err := bdb.Get([]byte(k))
+		if err != nil {
+			fmt.Println(err.Error())
+		}
+		rdb.Put([]byte(k), v)
+		bdb.Delete([]byte(k))
+	}
 }

db/leveldb.go

@@ -33,10 +33,26 @@ type storageInfo struct {
 	KeyCount int
 }
 
+func (l *LevelDbStorage) Count() int {
+
+	keycount := 0
+	db := l.ldb
+	iter := db.NewIterator(util.BytesPrefix(l.prefix), nil)
+	for iter.Next() {
+		keycount++
+	}
+	iter.Release()
+	if err := iter.Error(); err != nil {
+		panic(err)
+	}
+	return keycount
+}
+
 func (l *LevelDbStorage) Info() string {
 
 	keycount := 0
-	iter := l.ldb.NewIterator(nil, nil)
+	db := l.ldb
+	iter := db.NewIterator(util.BytesPrefix(l.prefix), nil)
 	for iter.Next() {
 		keycount++
 	}

main.go

@@ -45,7 +45,12 @@ func main() {
 		case signal := <-batchSignal:
 			if signal == true {
 				fmt.Println("Signal triggered")
-				batch.Create()
+				n, b := batch.Create()
+				fmt.Println("Nullifiers:")
+				fmt.Println(n)
+				fmt.Println("Batch:")
+				fmt.Println(b)
+				batch.Compact(n)
 			}
 		default:
 			continue

net/net.go

@@ -45,6 +45,9 @@ func parse(rw http.ResponseWriter, request *http.Request) {
 	}
 
 	j, err := json.Marshal(e)
+	if err != nil {
+		panic(err)
+	}
 	io.WriteString(rw, string(j))
 }