brian/boltbrowser
1
0
Fork 0
Code Issues Pull Requests Releases 2 Wiki Activity

Commit and run

Browse Source
This commit is contained in:
Brian Buller 2019-10-24 11:11:09 -05:00
parent 4ab1f201c5
commit 7b683d5c71
6 changed files with 364 additions and 172 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

281
bolt_model.go
View File

@ -5,6 +5,7 @@ import (
"fmt"
"os"
"strings"
"bytes"
"github.com/boltdb/bolt"
)
@ -16,29 +17,70 @@ type BoltDB struct {
buckets []BoltBucket
}
type PathNode struct {
name []byte
dataType Datatype
}
/*
BoltBucket is just a struct representation of a Bucket in the Bolt DB
*/
type BoltBucket struct {
name string
pairs []BoltPair
buckets []BoltBucket
parent *BoltBucket
expanded bool
errorFlag bool
name []byte
nameDatatype Datatype
pairs []BoltPair
buckets []BoltBucket
parent *BoltBucket
expanded bool
errorFlag bool
}
func (b *BoltBucket) SetName(nm []byte) {
b.name = nm
for _, dtk := range dataTypeNameSlice {
if _, err := datatypes[dtk].ToString(nm); err == nil {
b.nameDatatype = datatypes[dtk]
break
}
}
}
/*
BoltPair is just a struct representation of a Pair in the Bolt DB
*/
type BoltPair struct {
parent *BoltBucket
key string
val string
dataType *Datatype
parent *BoltBucket
key []byte
val []byte
keyDatatype Datatype
valDatatype Datatype
}
func (bd *BoltDB) getGenericFromPath(path []string) (*BoltBucket, *BoltPair, error) {
func NewBoltPair(parent *BoltBucket, key, val []byte) *BoltPair {
tp := BoltPair{
key: key,
val: val,
}
for _, dtk := range dataTypeNameSlice {
if _, err := datatypes[dtk].ToString(key); err == nil {
tp.keyDatatype = datatypes[dtk]
break
}
}
for _, dtk := range dataTypeNameSlice {
if _, err := datatypes[dtk].ToString(val); err == nil {
tp.valDatatype = datatypes[dtk]
break
}
}
return &tp
}
func (bd *BoltDB) getGenericFromStringPath(path []string) (*BoltBucket, *BoltPair, error) {
return bd.getGenericFromPath(stringPathToBytePath(path))
}
func (bd *BoltDB) getGenericFromPath(path []PathNode) (*BoltBucket, *BoltPair, error) {
// Check if 'path' leads to a pair
p, err := bd.getPairFromPath(path)
if err == nil {
@ -53,19 +95,19 @@ func (bd *BoltDB) getGenericFromPath(path []string) (*BoltBucket, *BoltPair, err
return nil, nil, errors.New("Invalid Path")
}
func (bd *BoltDB) getBucketFromPath(path []string) (*BoltBucket, error) {
func (bd *BoltDB) getBucketFromPath(path []PathNode) (*BoltBucket, error) {
if len(path) > 0 {
// Find the BoltBucket with a path == path
var b *BoltBucket
var err error
// Find the root bucket
b, err = memBolt.getBucket(path[0])
b, err = memBolt.getBucket(path[0].name)
if err != nil {
return nil, err
}
if len(path) > 1 {
for p := 1; p < len(path); p++ {
b, err = b.getBucket(path[p])
b, err = b.getBucket(path[p].name)
if err != nil {
return nil, err
}
@ -76,7 +118,7 @@ func (bd *BoltDB) getBucketFromPath(path []string) (*BoltBucket, error) {
return nil, errors.New("Invalid Path")
}
func (bd *BoltDB) getPairFromPath(path []string) (*BoltPair, error) {
func (bd *BoltDB) getPairFromPath(path []PathNode) (*BoltPair, error) {
if len(path) <= 0 {
return nil, errors.New("No Path")
}
@ -85,11 +127,11 @@ func (bd *BoltDB) getPairFromPath(path []string) (*BoltPair, error) {
return nil, err
}
// Found the bucket, pull out the pair
p, err := b.getPair(path[len(path)-1])
p, err := b.getPair(path[len(path)-1].name)
return p, err
}
func (bd *BoltDB) getVisibleItemCount(path []string) (int, error) {
func (bd *BoltDB) getVisibleItemCount(path []PathNode) (int, error) {
vis := 0
var retErr error
if len(path) == 0 {
@ -124,12 +166,12 @@ func (bd *BoltDB) getVisibleItemCount(path []string) (int, error) {
return vis, retErr
}
func (bd *BoltDB) buildVisiblePathSlice() ([][]string, error) {
func (bd *BoltDB) buildVisiblePathSlice() ([][]PathNode, error) {
var retSlice [][]string
var retErr error
// The root path, recurse for root buckets
for i := range bd.buckets {
bktS, bktErr := bd.buckets[i].buildVisiblePathSlice([]string{})
bktS, bktErr := bd.buckets[i].buildVisiblePathSlice([]PathNode{})
if bktErr == nil {
retSlice = append(retSlice, bktS...)
} else {
@ -140,7 +182,7 @@ func (bd *BoltDB) buildVisiblePathSlice() ([][]string, error) {
return retSlice, retErr
}
func (bd *BoltDB) getPrevVisiblePath(path []string) []string {
func (bd *BoltDB) getPrevVisiblePath(path []PathNode) []PathNode {
visPaths, err := bd.buildVisiblePathSlice()
if path == nil {
if len(visPaths) > 0 {
@ -152,7 +194,7 @@ func (bd *BoltDB) getPrevVisiblePath(path []string) []string {
for idx, pth := range visPaths {
isCurPath := true
for i := range path {
if len(pth) <= i || path[i] != pth[i] {
if len(pth) <= i || !bytes.Equal(path[i].name, pth[i].name) {
isCurPath = false
break
}
@ -164,7 +206,7 @@ func (bd *BoltDB) getPrevVisiblePath(path []string) []string {
}
return nil
}
func (bd *BoltDB) getNextVisiblePath(path []string) []string {
func (bd *BoltDB) getNextVisiblePath(path []PathNode) []PathNode {
visPaths, err := bd.buildVisiblePathSlice()
if path == nil {
if len(visPaths) > 0 {
@ -176,7 +218,7 @@ func (bd *BoltDB) getNextVisiblePath(path []string) []string {
for idx, pth := range visPaths {
isCurPath := true
for i := range path {
if len(pth) <= i || path[i] != pth[i] {
if len(pth) <= i || !bytes.Equal(path[i].name, pth[i].name) {
isCurPath = false
break
}
@ -189,7 +231,7 @@ func (bd *BoltDB) getNextVisiblePath(path []string) []string {
return nil
}
func (bd *BoltDB) toggleOpenBucket(path []string) error {
func (bd *BoltDB) toggleOpenBucket(path []PathNode) error {
// Find the BoltBucket with a path == path
b, err := bd.getBucketFromPath(path)
if err == nil {
@ -198,7 +240,7 @@ func (bd *BoltDB) toggleOpenBucket(path []string) error {
return err
}
func (bd *BoltDB) closeBucket(path []string) error {
func (bd *BoltDB) closeBucket(path []PathNode) error {
// Find the BoltBucket with a path == path
b, err := bd.getBucketFromPath(path)
if err == nil {
@ -207,7 +249,7 @@ func (bd *BoltDB) closeBucket(path []string) error {
return err
}
func (bd *BoltDB) openBucket(path []string) error {
func (bd *BoltDB) openBucket(path []PathNode) error {
// Find the BoltBucket with a path == path
b, err := bd.getBucketFromPath(path)
if err == nil {
@ -216,9 +258,9 @@ func (bd *BoltDB) openBucket(path []string) error {
return err
}
func (bd *BoltDB) getBucket(k string) (*BoltBucket, error) {
func (bd *BoltDB) getBucket(k []byte) (*BoltBucket, error) {
for i := range bd.buckets {
if bd.buckets[i].name == k {
if bytes.Equal(bd.buckets[i].name, k) {
return &bd.buckets[i], nil
}
}
@ -236,7 +278,7 @@ func (bd *BoltDB) syncOpenBuckets(shadow *BoltDB) {
// First test this bucket
for i := range bd.buckets {
for j := range shadow.buckets {
if bd.buckets[i].name == shadow.buckets[j].name {
if bytes.Equal(bd.buckets[i].name, shadow.buckets[j].name) {
bd.buckets[i].syncOpenBuckets(&shadow.buckets[j])
}
}
@ -250,7 +292,7 @@ func (bd *BoltDB) refreshDatabase() *BoltDB {
return tx.ForEach(func(nm []byte, b *bolt.Bucket) error {
bb, err := readBucket(b)
if err == nil {
bb.name = string(nm)
bb.SetName(nm)
bb.expanded = false
memBolt.buckets = append(memBolt.buckets, *bb)
return nil
@ -262,27 +304,40 @@ func (bd *BoltDB) refreshDatabase() *BoltDB {
}
/*
GetPath returns the database path leading to this BoltBucket
GetStringName returns the name of the bucket after passing it through it's
Datatype ToString function
*/
func (b *BoltBucket) GetPath() []string {
if b.parent != nil {
return append(b.parent.GetPath(), b.name)
}
return []string{b.name}
func (b *BoltBucket) GetStringName() string {
ret, err := b.nameDatatype.ToString(b.name)
if err != nil {
return stringify(b.name)
}
return ret
}
/*
buildVisiblePathSlice builds a slice of string slices containing all visible paths in this bucket
GetPath returns the database path leading to this BoltBucket
*/
func (b *BoltBucket) GetPath() [][]byte {
if b.parent != nil {
return append(b.parent.GetPath(), b.name)
}
return [][]byte{b.name}
}
/*
buildVisiblePathSlice builds a slice of PathNode slices containing all visible paths in this bucket
The passed prefix is the path leading to the current bucket
*/
func (b *BoltBucket) buildVisiblePathSlice(prefix []string) ([][]string, error) {
var retSlice [][]string
func (b *BoltBucket) buildVisiblePathSlice(prefix []PathNode) ([][]PathNode, error) {
var retSlice [][]PathNode
var retErr error
retSlice = append(retSlice, append(prefix, b.name))
bucketNode := PathNode{b.name, b.nameDatatype}
retSlice = append(retSlice, append(prefix, bucketNode))
if b.expanded {
// Add subbuckets
for i := range b.buckets {
bktS, bktErr := b.buckets[i].buildVisiblePathSlice(append(prefix, b.name))
bktS, bktErr := b.buckets[i].buildVisiblePathSlice(append(prefix, bucketNode))
if bktErr != nil {
return retSlice, bktErr
}
@ -290,7 +345,7 @@ func (b *BoltBucket) buildVisiblePathSlice(prefix []string) ([][]string, error)
}
// Add pairs
for i := range b.pairs {
retSlice = append(retSlice, append(append(prefix, b.name), b.pairs[i].key))
retSlice = append(retSlice, append(append(prefix, bucketNode, PathNode{b.pairs[i].key, b.pairs[i].keyDatatype})))
}
}
return retSlice, retErr
@ -301,7 +356,7 @@ func (b *BoltBucket) syncOpenBuckets(shadow *BoltBucket) {
b.expanded = shadow.expanded
for i := range b.buckets {
for j := range shadow.buckets {
if b.buckets[i].name == shadow.buckets[j].name {
if bytes.Equal(b.buckets[i].name, shadow.buckets[j].name) {
b.buckets[i].syncOpenBuckets(&shadow.buckets[j])
}
}
@ -315,28 +370,50 @@ func (b *BoltBucket) openAllBuckets() {
}
}
func (b *BoltBucket) getBucket(k string) (*BoltBucket, error) {
func (b *BoltBucket) getBucket(k []byte) (*BoltBucket, error) {
for i := range b.buckets {
if b.buckets[i].name == k {
if bytes.Equal(b.buckets[i].name, k) {
return &b.buckets[i], nil
}
}
return nil, errors.New("Bucket Not Found")
}
func (b *BoltBucket) getPair(k string) (*BoltPair, error) {
func (b *BoltBucket) getPair(k []byte) (*BoltPair, error) {
for i := range b.pairs {
if b.pairs[i].key == k {
if bytes.Equal(b.pairs[i].key, k) {
return &b.pairs[i], nil
}
}
return nil, errors.New("Pair Not Found")
}
/*
GetStringKey returns the key of the pair after passing it through it's
Datatype ToString function
*/
func (p *BoltPair) GetStringKey() string {
ret, err := p.keyDatatype.ToString(p.key)
if err != nil {
return stringify(p.key)
}
return ret
}
/*
GetStringVal returns the val of the pair after passing it through it's
Datatype ToString function
*/
func (p *BoltPair) GetStringVal() string {
ret, err := p.valDatatype.ToString(p.val)
if err != nil {
return stringify(p.val)
}
return ret
}
/*
GetPath Returns the path of the BoltPair
*/
func (p *BoltPair) GetPath() []string {
func (p *BoltPair) GetPath() [][]byte {
return append(p.parent.GetPath(), p.key)
}
@ -347,7 +424,7 @@ func (p *BoltPair) GetPath() []string {
* Mainly used for moving a bucket from one path to another
* as in the 'renameBucket' function below.
*/
func addBucketFromBoltBucket(path []string, bb *BoltBucket) error {
func addBucketFromBoltBucket(path [][]byte, bb *BoltBucket) error {
if err := insertBucket(path, bb.name); err == nil {
bucketPath := append(path, bb.name)
for i := range bb.pairs {
@ -364,7 +441,7 @@ func addBucketFromBoltBucket(path []string, bb *BoltBucket) error {
return nil
}
func deleteKey(path []string) error {
func deleteKey(path [][]byte) error {
if AppArgs.ReadOnly {
return errors.New("DB is in Read-Only Mode")
}
@ -373,13 +450,13 @@ func deleteKey(path []string) error {
// the rest are buckets leading to that key
if len(path) == 1 {
// Deleting a root bucket
return tx.DeleteBucket([]byte(path[0]))
return tx.DeleteBucket(path[0])
}
b := tx.Bucket([]byte(path[0]))
b := tx.Bucket(path[0])
if b != nil {
if len(path) > 1 {
for i := range path[1 : len(path)-1] {
b = b.Bucket([]byte(path[i+1]))
b = b.Bucket(path[i+1])
if b == nil {
return errors.New("deleteKey: Invalid Path")
}
@ -387,11 +464,11 @@ func deleteKey(path []string) error {
}
// Now delete the last key in the path
var err error
if deleteBkt := b.Bucket([]byte(path[len(path)-1])); deleteBkt == nil {
if deleteBkt := b.Bucket(path[len(path)-1]); deleteBkt == nil {
// Must be a pair
err = b.Delete([]byte(path[len(path)-1]))
err = b.Delete(path[len(path)-1])
} else {
err = b.DeleteBucket([]byte(path[len(path)-1]))
err = b.DeleteBucket(path[len(path)-1])
}
return err
}
@ -400,6 +477,8 @@ func deleteKey(path []string) error {
return err
}
// Recursively read a bucket and pairs from the DB
// We assume all datatypes are string
func readBucket(b *bolt.Bucket) (*BoltBucket, error) {
bb := new(BoltBucket)
b.ForEach(func(k, v []byte) error {
@ -407,21 +486,19 @@ func readBucket(b *bolt.Bucket) (*BoltBucket, error) {
tb, err := readBucket(b.Bucket(k))
tb.parent = bb
if err == nil {
tb.name = string(k)
tb.SetName(k)
bb.buckets = append(bb.buckets, *tb)
}
} else {
tp := BoltPair{key: string(k), val: string(v)}
tp.parent = bb
bb.pairs = append(bb.pairs, tp)
bb.pairs = append(bb.pairs, *NewBoltPair(bb, k, v))
}
return nil
})
return bb, nil
}
func renameBucket(path []string, name string) error {
if name == path[len(path)-1] {
func renameBucket(path [][]byte, name []byte) error {
if bytes.Equal(name, path[len(path)-1]) {
// No change requested
return nil
}
@ -429,11 +506,11 @@ func renameBucket(path []string, name string) error {
err := db.View(func(tx *bolt.Tx) error {
// len(b.path)-1 is the key we need to delete,
// the rest are buckets leading to that key
b := tx.Bucket([]byte(path[0]))
b := tx.Bucket(path[0])
if b != nil {
if len(path) > 1 {
for i := range path[1:len(path)] {
b = b.Bucket([]byte(path[i+1]))
b = b.Bucket(path[i+1])
if b == nil {
return errors.New("renameBucket: Invalid Path")
}
@ -462,7 +539,7 @@ func renameBucket(path []string, name string) error {
return err
}
// Rechristen our cached bucket
bb.name = name
bb.SetName(name)
// And re-add it
parentPath := path[:len(path)-1]
@ -472,29 +549,29 @@ func renameBucket(path []string, name string) error {
return nil
}
func updatePairKey(path []string, k string) error {
func updatePairKey(path [][]byte, k []byte) error {
if AppArgs.ReadOnly {
return errors.New("DB is in Read-Only Mode")
}
err := db.Update(func(tx *bolt.Tx) error {
// len(b.path)-1 is the key for the pair we're updating,
// the rest are buckets leading to that key
b := tx.Bucket([]byte(path[0]))
b := tx.Bucket(path[0])
if b != nil {
if len(path) > 0 {
for i := range path[1 : len(path)-1] {
b = b.Bucket([]byte(path[i+1]))
b = b.Bucket(path[i+1])
if b == nil {
return errors.New("updatePairValue: Invalid Path")
}
}
}
bk := []byte(path[len(path)-1])
bk := path[len(path)-1]
v := b.Get(bk)
err := b.Delete(bk)
if err == nil {
// Old pair has been deleted, now add the new one
err = b.Put([]byte(k), v)
err = b.Put(k, v)
}
// Now update the last key in the path
return err
@ -504,25 +581,25 @@ func updatePairKey(path []string, k string) error {
return err
}
func updatePairValue(path []string, v string) error {
func updatePairValue(path [][]byte, v []byte) error {
if AppArgs.ReadOnly {
return errors.New("DB is in Read-Only Mode")
}
err := db.Update(func(tx *bolt.Tx) error {
// len(b.GetPath())-1 is the key for the pair we're updating,
// the rest are buckets leading to that key
b := tx.Bucket([]byte(path[0]))
b := tx.Bucket(path[0])
if b != nil {
if len(path) > 0 {
for i := range path[1 : len(path)-1] {
b = b.Bucket([]byte(path[i+1]))
b = b.Bucket(path[i+1])
if b == nil {
return errors.New("updatePairValue: Invalid Path")
}
}
}
// Now update the last key in the path
err := b.Put([]byte(path[len(path)-1]), []byte(v))
err := b.Put(path[len(path)-1], v)
return err
}
return errors.New("updatePairValue: Invalid Path")
@ -530,7 +607,7 @@ func updatePairValue(path []string, v string) error {
return err
}
func insertBucket(path []string, n string) error {
func insertBucket(path [][]byte, n []byte) error {
if AppArgs.ReadOnly {
return errors.New("DB is in Read-Only Mode")
}
@ -538,18 +615,18 @@ func insertBucket(path []string, n string) error {
err := db.Update(func(tx *bolt.Tx) error {
if len(path) == 0 {
// insert at root
_, err := tx.CreateBucket([]byte(n))
_, err := tx.CreateBucket(n)
if err != nil {
return fmt.Errorf("insertBucket: %s", err)
}
} else {
rootBucket, path := path[0], path[1:]
b := tx.Bucket([]byte(rootBucket))
b := tx.Bucket(rootBucket)
if b != nil {
for len(path) > 0 {
tstBucket := ""
var tstBucket []byte
tstBucket, path = path[0], path[1:]
nB := b.Bucket([]byte(tstBucket))
nB := b.Bucket(tstBucket)
if nB == nil {
// Not a bucket, if we're out of path, just move on
if len(path) != 0 {
@ -560,7 +637,7 @@ func insertBucket(path []string, n string) error {
b = nB
}
}
_, err := b.CreateBucket([]byte(n))
_, err := b.CreateBucket(n)
return err
}
return fmt.Errorf("insertBucket: Invalid Path %s", rootBucket)
@ -570,7 +647,7 @@ func insertBucket(path []string, n string) error {
return err
}
func insertPair(path []string, k string, v string) error {
func insertPair(path [][]byte, k []byte, v []byte) error {
if AppArgs.ReadOnly {
return errors.New("DB is in Read-Only Mode")
}
@ -581,17 +658,17 @@ func insertPair(path []string, k string, v string) error {
return errors.New("insertPair: Cannot insert pair at root")
}
var err error
b := tx.Bucket([]byte(path[0]))
b := tx.Bucket(path[0])
if b != nil {
if len(path) > 0 {
for i := 1; i < len(path); i++ {
b = b.Bucket([]byte(path[i]))
b = b.Bucket(path[i])
if b == nil {
return fmt.Errorf("insertPair: %s", err)
}
}
}
err := b.Put([]byte(k), []byte(v))
err := b.Put(k, v)
if err != nil {
return fmt.Errorf("insertPair: %s", err)
}
@ -601,21 +678,37 @@ func insertPair(path []string, k string, v string) error {
return err
}
func exportValue(path []string, fName string) error {
func stringPathToBytePath(path []string) [][]byte {
var ret [][]byte
for _, v := range path {
ret = append(ret, []byte(v))
}
return ret
}
func bytePathToStringPath(path [][]byte) []string {
var ret []string
for _, v := range path {
ret = append(ret, string(v))
}
return ret
}
func exportValue(path [][]byte, fName string) error {
return db.View(func(tx *bolt.Tx) error {
// len(b.path)-1 is the key whose value we want to export
// the rest are buckets leading to that key
b := tx.Bucket([]byte(path[0]))
b := tx.Bucket(path[0])
if b != nil {
if len(path) > 1 {
for i := range path[1 : len(path)-1] {
b = b.Bucket([]byte(path[i+1]))
b = b.Bucket(path[i+1])
if b == nil {
return errors.New("exportValue: Invalid Path: " + strings.Join(path, "/"))
return errors.New("exportValue: Invalid Path: " + strings.Join(bytePathToStringPath(path), "/"))
}
}
}
bk := []byte(path[len(path)-1])
bk := path[len(path)-1]
v := b.Get(bk)
return writeToFile(fName, string(v)+"\n", os.O_CREATE|os.O_WRONLY|os.O_TRUNC)
}
@ -623,21 +716,21 @@ func exportValue(path []string, fName string) error {
})
}
func exportJSON(path []string, fName string) error {
func exportJSON(path [][]byte, fName string) error {
return db.View(func(tx *bolt.Tx) error {
// len(b.path)-1 is the key whose value we want to export
// the rest are buckets leading to that key
b := tx.Bucket([]byte(path[0]))
b := tx.Bucket(path[0])
if b != nil {
if len(path) > 1 {
for i := range path[1 : len(path)-1] {
b = b.Bucket([]byte(path[i+1]))
b = b.Bucket(path[i+1])
if b == nil {
return errors.New("exportValue: Invalid Path: " + strings.Join(path, "/"))
return errors.New("exportValue: Invalid Path: " + strings.Join(bytePathToStringPath(path), "/"))
}
}
}
bk := []byte(path[len(path)-1])
bk := path[len(path)-1]
if v := b.Get(bk); v != nil {
return writeToFile(fName, "{\""+string(bk)+"\":\""+string(v)+"\"}", os.O_CREATE|os.O_WRONLY|os.O_TRUNC)
}

50
datatype_int.go
View File

@ -1,37 +1,39 @@
package main
import (
"fmt"
"encoding/binary"
"errors"
"strconv"
)
// Datatype_Uint64 manages the uint64 data type
// All conversions just use the binary package
type Datatype_Uint64 struct{}
// Datatype_Int manages the int data type
type Datatype_Int64 struct{}
func (t *Datatype_Uint64) Name() string {
return "uint64"
func (t *Datatype_Int64) Name() string {
return "int"
}
func (t *Datatype_Uint64) ToString(data []byte) (string, error) {
ret, bt := binary.Uvarint(data)
if bt == 0 {
return "", errors.New("Byte Buffer too small")
} else if bt < 0 {
return "", errors.New("Value larger than 64 bits")
}
return strconv.FormatUint(ret, 10), nil
func (t *Datatype_Int64) ToString(data []byte) (string, error) {
return fmt.Sprintf("%d", t.btoi(data)), nil
}
func (t *Datatype_Uint64) FromString(val string) ([]byte, error) {
var err error
var u uint64
buf := make([]byte, binary.MaxVarintLen64)
u, err = strconv.ParseUint(val, 10, 64)
if err != nil {
return nil, err
}
binary.PutUvarint(buf, u)
return buf, nil
func (t *Datatype_Int64) FromString(val string) ([]byte, error) {
v, err := strconv.ParseInt(val, 10, 64)
if err != nil {
return []byte{}, err
}
return t.itob(v), nil
}
func (t *Datatype_Int64) itob(v int64) []byte {
b := make([]byte, 8)
binary.BigEndian.PutUint64(b, uint64(v))
return b
}
func (t *Datatype_Int64) btoi(b []byte) int64 {
if len(b) < 8 {
return 0
}
return int64(binary.BigEndian.Uint64(b))
}

37
datatype_uint.go Normal file
View File

@ -0,0 +1,37 @@
package main
import (
"encoding/binary"
"errors"
"strconv"
)
// Datatype_Uint64 manages the uint64 data type
// All conversions just use the binary package
type Datatype_Uint64 struct{}
func (t *Datatype_Uint64) Name() string {
return "uint64"
}
func (t *Datatype_Uint64) ToString(data []byte) (string, error) {
ret, bt := binary.Uvarint(data)
if bt == 0 {
return "", errors.New("Byte Buffer too small")
} else if bt < 0 {
return "", errors.New("Value larger than 64 bits")
}
return strconv.FormatUint(ret, 10), nil
}
func (t *Datatype_Uint64) FromString(val string) ([]byte, error) {
var err error
var u uint64
buf := make([]byte, binary.MaxVarintLen64)
u, err = strconv.ParseUint(val, 10, 64)
if err != nil {
return nil, err
}
binary.PutUvarint(buf, u)
return buf, nil
}

3
main.go
View File

@ -19,6 +19,7 @@ var db *bolt.DB
var memBolt *BoltDB
var datatypes map[string]Datatype
var dataTypeNameSlice []string
var currentFilename string
@ -142,8 +143,10 @@ func initDataTypes() {
datatypes = make(map[string]Datatype)
for _, t := range []Datatype{
&Datatype_String{},
&Datatype_Int64{},
&Datatype_Uint64{},
} {
dataTypeNameSlice = append(dataTypeNameSlice, t.Name())
datatypes[t.Name()] = t
}
}

150
screen_browser.go
View File

@ -28,7 +28,7 @@ type BrowserScreen struct {
leftViewPort ViewPort
rightViewPort ViewPort
queuedCommand string
currentPath []string
currentPath []PathNode
currentType int
message string
mode BrowserMode
@ -39,6 +39,8 @@ type BrowserScreen struct {
leftPaneBuffer []Line
rightPaneBuffer []Line
niceLog []string
}
/*
@ -149,7 +151,7 @@ func (screen *BrowserScreen) handleBrowseKeyEvent(event termbox.Event) int {
screen.startInsertItemAtParent(typeBucket)
} else if event.Ch == 'e' {
b, p, _ := screen.db.getGenericFromPath(screen.currentPath)
b, p, _ := screen.db.getGenericFromStringPath(screen.currentPath)
if b != nil {
screen.setMessage("Cannot edit a bucket, did you mean to (r)ename?")
} else if p != nil {
@ -160,18 +162,18 @@ func (screen *BrowserScreen) handleBrowseKeyEvent(event termbox.Event) int {
screen.startRenameItem()
} else if event.Key == termbox.KeyEnter {
b, p, _ := screen.db.getGenericFromPath(screen.currentPath)
b, p, _ := screen.db.getGenericFromStringPath(screen.currentPath)
if b != nil {
screen.db.toggleOpenBucket(screen.currentPath)
screen.db.toggleOpenBucket(stringPathToBytePath(screen.currentPath))
} else if p != nil {
screen.startEditItem()
}
} else if event.Ch == 'l' || event.Key == termbox.KeyArrowRight {
b, p, _ := screen.db.getGenericFromPath(screen.currentPath)
b, p, _ := screen.db.getGenericFromStringPath(screen.currentPath)
// Select the current item
if b != nil {
screen.db.toggleOpenBucket(screen.currentPath)
screen.db.toggleOpenBucket(stringPathToBytePath(screen.currentPath))
} else if p != nil {
screen.startEditItem()
} else {
@ -180,19 +182,19 @@ func (screen *BrowserScreen) handleBrowseKeyEvent(event termbox.Event) int {
} else if event.Ch == 'h' || event.Key == termbox.KeyArrowLeft {
// If we are _on_ a bucket that's open, close it
b, _, e := screen.db.getGenericFromPath(screen.currentPath)
b, _, e := screen.db.getGenericFromStringPath(screen.currentPath)
if e == nil && b != nil && b.expanded {
screen.db.closeBucket(screen.currentPath)
screen.db.closeBucket(stringPathToBytePath(screen.currentPath))
} else {
if len(screen.currentPath) > 1 {
parentBucket, err := screen.db.getBucketFromPath(screen.currentPath[:len(screen.currentPath)-1])
parentBucket, err := screen.db.getBucketFromPath(stringPathToBytePath(screen.currentPath[:len(screen.currentPath)-1]))
if err == nil {
screen.db.closeBucket(parentBucket.GetPath())
// Figure out how far up we need to move the cursor
screen.currentPath = parentBucket.GetPath()
screen.currentPath = bytePathToStringPath(parentBucket.GetPath())
}
} else {
screen.db.closeBucket(screen.currentPath)
screen.db.closeBucket(stringPathToBytePath(screen.currentPath))
}
}
@ -207,7 +209,24 @@ func (screen *BrowserScreen) handleBrowseKeyEvent(event termbox.Event) int {
} else if event.Ch == 't' {
// TODO: change the type of the pair value being viewed
p, err := screen.db.getPairFromPath(stringPathToBytePath(screen.currentPath))
if err != nil {
screen.setMessage("Cannot change pair type (did you mean 'T': Change pair key/bucket name type?)")
return BrowserScreenIndex
}
p.valDatatype = findNextDatatype(p.valDatatype.Name())
} else if event.Ch == 'T' {
b, p, err := screen.db.getGenericFromStringPath(screen.currentPath)
if err != nil {
screen.setMessage("Error reading path... Not sure what to do.")
return BrowserScreenIndex
}
if b != nil {
b.nameDatatype = findNextDatatype(b.nameDatatype.Name())
} else if p != nil {
p.keyDatatype = findNextDatatype(p.keyDatatype.Name())
}
}
return BrowserScreenIndex
}
@ -219,15 +238,15 @@ func (screen *BrowserScreen) handleInputKeyEvent(event termbox.Event) int {
} else {
screen.inputModal.HandleEvent(event)
if screen.inputModal.IsDone() {
b, p, _ := screen.db.getGenericFromPath(screen.currentPath)
b, p, _ := screen.db.getGenericFromStringPath(screen.currentPath)
if b != nil {
if screen.mode == modeChangeKey {
newName := screen.inputModal.GetValue()
if renameBucket(screen.currentPath, newName) != nil {
if renameBucket(stringPathToBytePath(screen.currentPath), []byte(newName)) != nil {
screen.setMessage("Error renaming bucket.")
} else {
b.name = newName
screen.currentPath[len(screen.currentPath)-1] = b.name
b.name = []byte(newName)
screen.currentPath[len(screen.currentPath)-1] = newName
screen.setMessage("Bucket Renamed!")
screen.refreshDatabase()
}
@ -235,20 +254,20 @@ func (screen *BrowserScreen) handleInputKeyEvent(event termbox.Event) int {
} else if p != nil {
if screen.mode == modeChangeKey {
newKey := screen.inputModal.GetValue()
if updatePairKey(screen.currentPath, newKey) != nil {
if updatePairKey(stringPathToBytePath(screen.currentPath), []byte(newKey)) != nil {
screen.setMessage("Error occurred updating Pair.")
} else {
p.key = newKey
screen.currentPath[len(screen.currentPath)-1] = p.key
p.key = []byte(newKey)
screen.currentPath[len(screen.currentPath)-1] = newKey
screen.setMessage("Pair updated!")
screen.refreshDatabase()
}
} else if screen.mode == modeChangeVal {
newVal := screen.inputModal.GetValue()
if updatePairValue(screen.currentPath, newVal) != nil {
if updatePairValue(stringPathToBytePath(screen.currentPath), []byte(newVal)) != nil {
screen.setMessage("Error occurred updating Pair.")
} else {
p.val = newVal
p.val = []byte(newVal)
screen.setMessage("Pair updated!")
screen.refreshDatabase()
}
@ -267,7 +286,7 @@ func (screen *BrowserScreen) handleDeleteKeyEvent(event termbox.Event) int {
if screen.confirmModal.IsAccepted() {
holdNextPath := screen.db.getNextVisiblePath(screen.currentPath)
holdPrevPath := screen.db.getPrevVisiblePath(screen.currentPath)
if deleteKey(screen.currentPath) == nil {
if deleteKey(stringPathToBytePath(screen.currentPath)) == nil {
screen.refreshDatabase()
// Move the current path endpoint appropriately
//found_new_path := false
@ -312,7 +331,7 @@ func (screen *BrowserScreen) handleInsertKeyEvent(event termbox.Event) int {
screen.inputModal.Clear()
var insertPath []string
if len(screen.currentPath) > 0 {
_, p, e := screen.db.getGenericFromPath(screen.currentPath)
_, p, e := screen.db.getGenericFromStringPath(screen.currentPath)
if e != nil {
screen.setMessage("Error Inserting new item. Invalid Path.")
}
@ -331,9 +350,9 @@ func (screen *BrowserScreen) handleInsertKeyEvent(event termbox.Event) int {
}
}
parentB, _, _ := screen.db.getGenericFromPath(insertPath)
parentB, _, _ := screen.db.getGenericFromStringPath(insertPath)
if screen.mode&modeInsertBucket == modeInsertBucket {
err := insertBucket(insertPath, newVal)
err := insertBucket(stringPathToBytePath(insertPath), []byte(newVal))
if err != nil {
screen.setMessage(fmt.Sprintf("%s => %s", err, insertPath))
} else {
@ -347,7 +366,7 @@ func (screen *BrowserScreen) handleInsertKeyEvent(event termbox.Event) int {
screen.mode = modeBrowse
screen.inputModal.Clear()
} else if screen.mode&modeInsertPair == modeInsertPair {
err := insertPair(insertPath, newVal, "")
err := insertPair(stringPathToBytePath(insertPath), []byte(newVal), []byte{})
if err != nil {
screen.setMessage(fmt.Sprintf("%s => %s", err, insertPath))
screen.refreshDatabase()
@ -374,12 +393,12 @@ func (screen *BrowserScreen) handleExportKeyEvent(event termbox.Event) int {
} else {
screen.inputModal.HandleEvent(event)
if screen.inputModal.IsDone() {
b, p, _ := screen.db.getGenericFromPath(screen.currentPath)
b, p, _ := screen.db.getGenericFromStringPath(screen.currentPath)
fileName := screen.inputModal.GetValue()
if screen.mode&modeExportValue == modeExportValue {
// Exporting the value
if p != nil {
if err := exportValue(screen.currentPath, fileName); err != nil {
if err := exportValue(stringPathToBytePath(screen.currentPath), fileName); err != nil {
//screen.setMessage("Error Exporting to file " + fileName + ".")
screen.setMessage(err.Error())
} else {
@ -388,7 +407,7 @@ func (screen *BrowserScreen) handleExportKeyEvent(event termbox.Event) int {
}
} else if screen.mode&modeExportJSON == modeExportJSON {
if b != nil || p != nil {
if exportJSON(screen.currentPath, fileName) != nil {
if exportJSON(stringPathToBytePath(screen.currentPath), fileName) != nil {
screen.setMessage("Error Exporting to file " + fileName + ".")
} else {
screen.setMessage("Value exported to file: " + fileName)
@ -583,7 +602,15 @@ func (screen *BrowserScreen) drawLeftPane(style Style) {
func (screen *BrowserScreen) buildRightPane(style Style) {
screen.rightPaneBuffer = nil
b, p, err := screen.db.getGenericFromPath(screen.currentPath)
screen.niceLog = []string{}
var logstr string
for _, v := range screen.currentPath {
logstr = fmt.Sprintf("%s / %s", logstr, stringify([]byte(v)))
}
screen.niceLog = append(screen.niceLog, logstr)
b, p, err := screen.db.getGenericFromStringPath(screen.currentPath)
if err == nil {
if b != nil {
screen.rightPaneBuffer = append(screen.rightPaneBuffer,
@ -596,12 +623,12 @@ func (screen *BrowserScreen) buildRightPane(style Style) {
screen.rightPaneBuffer = append(screen.rightPaneBuffer,
Line{fmt.Sprintf("Path: %s", strings.Join(stringifyPath(p.GetPath()), " → ")), style.defaultFg, style.defaultBg})
screen.rightPaneBuffer = append(screen.rightPaneBuffer,
Line{fmt.Sprintf("Key: %s", stringify([]byte(p.key))), style.defaultFg, style.defaultBg})
Line{fmt.Sprintf("Key (%s): %s", p.keyDatatype.Name(), stringify([]byte(p.key))), style.defaultFg, style.defaultBg})
value := strings.Split(string(formatValue([]byte(p.val))), "\n")
if len(value) == 1 {
screen.rightPaneBuffer = append(screen.rightPaneBuffer,
Line{fmt.Sprintf("Value: %s", value[0]), style.defaultFg, style.defaultBg})
Line{fmt.Sprintf("Value (%s): %s", p.valDatatype.Name(), value[0]), style.defaultFg, style.defaultBg})
} else {
screen.rightPaneBuffer = append(screen.rightPaneBuffer,
Line{"Value:", style.defaultFg, style.defaultBg})
@ -613,10 +640,18 @@ func (screen *BrowserScreen) buildRightPane(style Style) {
}
} else {
screen.rightPaneBuffer = append(screen.rightPaneBuffer,
Line{fmt.Sprintf("Path: %s", strings.Join(stringifyPath(screen.currentPath), " → ")), style.defaultFg, style.defaultBg})
Line{fmt.Sprintf("Path: %s", strings.Join(stringifyStringPath(screen.currentPath), " → ")), style.defaultFg, style.defaultBg})
screen.rightPaneBuffer = append(screen.rightPaneBuffer,
Line{err.Error(), termbox.ColorRed, termbox.ColorBlack})
}
screen.rightPaneBuffer = append(screen.rightPaneBuffer,
Line{"", style.defaultFg, style.defaultBg})
screen.rightPaneBuffer = append(screen.rightPaneBuffer,
Line{"== Log ==", style.defaultBg, style.defaultFg})
for _, v := range screen.niceLog {
screen.rightPaneBuffer = append(screen.rightPaneBuffer,
Line{v, style.defaultFg, style.defaultBg})
}
}
func (screen *BrowserScreen) drawRightPane(style Style) {
@ -673,32 +708,32 @@ func formatValueJSON(val []byte) ([]byte, error) {
func (screen *BrowserScreen) bucketToLines(bkt *BoltBucket, style Style) []Line {
var ret []Line
bfg, bbg := style.defaultFg, style.defaultBg
if comparePaths(screen.currentPath, bkt.GetPath()) {
if comparePaths(screen.currentPath, bytePathToStringPath(bkt.GetPath())) {
bfg, bbg = style.cursorFg, style.cursorBg
}
bktPrefix := strings.Repeat(" ", len(bkt.GetPath())*2)
if bkt.expanded {
ret = append(ret, Line{bktPrefix + "- " + stringify([]byte(bkt.name)), bfg, bbg})
ret = append(ret, Line{bktPrefix + "- " + bkt.GetStringName(), bfg, bbg})
for i := range bkt.buckets {
ret = append(ret, screen.bucketToLines(&bkt.buckets[i], style)...)
}
for _, bp := range bkt.pairs {
pfg, pbg := style.defaultFg, style.defaultBg
if comparePaths(screen.currentPath, bp.GetPath()) {
if comparePaths(screen.currentPath, bytePathToStringPath(bp.GetPath())) {
pfg, pbg = style.cursorFg, style.cursorBg
}
prPrefix := strings.Repeat(" ", len(bp.GetPath())*2)
pairString := fmt.Sprintf("%s%s: %s", prPrefix, stringify([]byte(bp.key)), stringify([]byte(bp.val)))
pairString := fmt.Sprintf("%s%s: %s", prPrefix, bp.GetStringKey(), bp.GetStringVal())
ret = append(ret, Line{pairString, pfg, pbg})
}
} else {
ret = append(ret, Line{bktPrefix + "+ " + stringify([]byte(bkt.name)), bfg, bbg})
ret = append(ret, Line{bktPrefix + "+ " + bkt.GetStringName(), bfg, bbg})
}
return ret
}
func (screen *BrowserScreen) startDeleteItem() bool {
b, p, e := screen.db.getGenericFromPath(screen.currentPath)
b, p, e := screen.db.getGenericFromStringPath(screen.currentPath)
if e == nil {
w, h := termbox.Size()
inpW, inpH := (w / 2), 6
@ -719,7 +754,7 @@ func (screen *BrowserScreen) startDeleteItem() bool {
}
func (screen *BrowserScreen) startEditItem() bool {
_, p, e := screen.db.getGenericFromPath(screen.currentPath)
_, p, e := screen.db.getGenericFromStringPath(screen.currentPath)
if e == nil {
w, h := termbox.Size()
inpW, inpH := (w / 2), 6
@ -727,7 +762,7 @@ func (screen *BrowserScreen) startEditItem() bool {
mod := termboxUtil.CreateInputModal("", inpX, inpY, inpW, inpH, termbox.ColorWhite, termbox.ColorBlack)
if p != nil {
mod.SetTitle(termboxUtil.AlignText(fmt.Sprintf("Input new value for '%s'", p.key), inpW, termboxUtil.AlignCenter))
mod.SetValue(p.val)
mod.SetValue(p.GetStringVal())
}
mod.Show()
screen.inputModal = mod
@ -738,18 +773,18 @@ func (screen *BrowserScreen) startEditItem() bool {
}
func (screen *BrowserScreen) startRenameItem() bool {
b, p, e := screen.db.getGenericFromPath(screen.currentPath)
b, p, e := screen.db.getGenericFromStringPath(screen.currentPath)
if e == nil {
w, h := termbox.Size()
inpW, inpH := (w / 2), 6
inpX, inpY := ((w / 2) - (inpW / 2)), ((h / 2) - inpH)
mod := termboxUtil.CreateInputModal("", inpX, inpY, inpW, inpH, termbox.ColorWhite, termbox.ColorBlack)
if b != nil {
mod.SetTitle(termboxUtil.AlignText(fmt.Sprintf("Rename Bucket '%s' to:", b.name), inpW, termboxUtil.AlignCenter))
mod.SetValue(b.name)
mod.SetTitle(termboxUtil.AlignText(fmt.Sprintf("Rename Bucket '%s' to:", b.GetStringName()), inpW, termboxUtil.AlignCenter))
mod.SetValue(b.GetStringName())
} else if p != nil {
mod.SetTitle(termboxUtil.AlignText(fmt.Sprintf("Rename Key '%s' to:", p.key), inpW, termboxUtil.AlignCenter))
mod.SetValue(p.key)
mod.SetTitle(termboxUtil.AlignText(fmt.Sprintf("Rename Key '%s' to:", p.GetStringKey()), inpW, termboxUtil.AlignCenter))
mod.SetValue(p.GetStringKey())
}
mod.Show()
screen.inputModal = mod
@ -778,7 +813,7 @@ func (screen *BrowserScreen) startInsertItemAtParent(tp BoltType) bool {
}
} else {
var insPath string
_, p, e := screen.db.getGenericFromPath(screen.currentPath[:len(screen.currentPath)-1])
_, p, e := screen.db.getGenericFromStringPath(screen.currentPath[:len(screen.currentPath)-1])
if e == nil && p != nil {
insPath = strings.Join(screen.currentPath[:len(screen.currentPath)-2], " → ") + " → "
} else {
@ -821,7 +856,7 @@ func (screen *BrowserScreen) startInsertItem(tp BoltType) bool {
//mod.SetInputWrap(true)
screen.inputModal = mod
var insPath string
_, p, e := screen.db.getGenericFromPath(screen.currentPath)
_, p, e := screen.db.getGenericFromStringPath(screen.currentPath)
if e == nil && p != nil {
insPath = strings.Join(screen.currentPath[:len(screen.currentPath)-1], " → ") + " → "
} else {
@ -853,7 +888,7 @@ func (screen *BrowserScreen) startInsertItem(tp BoltType) bool {
}
func (screen *BrowserScreen) startExportValue() bool {
_, p, e := screen.db.getGenericFromPath(screen.currentPath)
_, p, e := screen.db.getGenericFromStringPath(screen.currentPath)
if e == nil && p != nil {
w, h := termbox.Size()
inpW, inpH := (w / 2), 6
@ -871,7 +906,7 @@ func (screen *BrowserScreen) startExportValue() bool {
}
func (screen *BrowserScreen) startExportJSON() bool {
b, p, e := screen.db.getGenericFromPath(screen.currentPath)
b, p, e := screen.db.getGenericFromStringPath(screen.currentPath)
if e == nil {
w, h := termbox.Size()
inpW, inpH := (w / 2), 6
@ -918,6 +953,23 @@ func (screen *BrowserScreen) refreshDatabase() {
screen.db.syncOpenBuckets(shadowDB)
}
func findNextDatatype(curr string) Datatype {
var first Datatype
var found bool
for k, v := range datatypes {
if first == nil {
first = v
}
if found {
return v
}
if k == curr {
found = true
}
}
return first
}
func comparePaths(p1, p2 []string) bool {
return strings.Join(p1, " → ") == strings.Join(p2, " → ")
}

15
stringify.go
View File

@ -31,9 +31,14 @@ func stringify(v []byte) string {
return fmt.Sprintf("%x", v)
}
func stringifyPath(path []string) []string {
for k, v := range path {
path[k] = stringify([]byte(v))
}
return path
func stringifyStringPath(path []string) []string {
return stringifyPath(stringPathToBytePath(path))
}
func stringifyPath(path [][]byte) []string {
var ret []string
for _, v := range path {
ret = append(ret, stringify(v))
}
return ret
}