Trying to figure out this dang thing

Now for loading them

bolteasable.go

@@ -0,0 +1,189 @@
+package boltease
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+)
+
+type any interface{}
+
+func (b *DB) Load(path []string, dest any) error {
+	destValue := reflect.ValueOf(dest)
+	fmt.Println("Loading:", path, destValue)
+	if destValue.Kind() != reflect.Pointer {
+		return errors.New("Destination must be a pointer")
+	}
+	d := reflect.Indirect(destValue)
+	fmt.Println(">> d.Kind() ->", d.Kind())
+	if d.Kind() != reflect.Struct {
+		fmt.Println(">> Kind != Struct; GetForInterface")
+		path, name := path[:len(path)-1], path[len(path)-1]
+		return b.GetForInterface(path, name, dest)
+	}
+
+	entityType := reflect.TypeOf(dest).Elem()
+	var ret error
+	for i := 0; i < entityType.NumField(); i++ {
+		structFld := entityType.Field(i)
+		fldName := FieldName(structFld)
+		fmt.Println("Loading Field:", fldName, "->", structFld.Type.Kind())
+		switch structFld.Type.Kind() {
+		case reflect.Pointer, reflect.Struct:
+			fmt.Println("Getting Pointer or Struct")
+			var wrk interface{}
+			var wrkV reflect.Value
+			if structFld.Type.Kind() == reflect.Pointer {
+				fmt.Println("  It's a pointer to something")
+				wrkV = reflect.New(structFld.Type).Elem()
+			} else {
+				fmt.Println("  It's a struct itself")
+				wrkV = reflect.New(reflect.TypeOf(structFld))
+			}
+			wrk = wrkV.Interface()
+			fmt.Println("-> Recurse (struct)", reflect.TypeOf(wrk))
+			err := b.Load(append(path, fldName), &wrk)
+			if err != nil {
+				fmt.Println("-> -> Error loading.", err.Error())
+				if ret == nil {
+					ret = err
+				}
+			} else {
+				// Set the value
+				reflect.ValueOf(dest).Elem().FieldByName(structFld.Name).Set(reflect.ValueOf(wrk))
+			}
+
+		case reflect.String:
+			fmt.Println("Getting String")
+			var wrk string
+			err := b.GetForInterface(path, fldName, &wrk)
+			if err != nil {
+				if ret == nil {
+					ret = err
+				}
+			} else {
+				// Set the value
+				reflect.ValueOf(dest).Elem().FieldByName(structFld.Name).Set(reflect.ValueOf(wrk))
+			}
+
+		case reflect.Bool:
+			fmt.Println("Getting Boolean")
+			var wrk bool
+			err := b.GetForInterface(path, fldName, &wrk)
+			if err != nil {
+				if ret == nil {
+					ret = err
+				}
+			} else {
+				// Set the value
+				reflect.ValueOf(dest).Elem().FieldByName(structFld.Name).Set(reflect.ValueOf(wrk))
+			}
+
+		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+			fmt.Println("Getting Integer")
+			var wrk int
+			err := b.GetForInterface(path, fldName, &wrk)
+			if err != nil {
+				if ret == nil {
+					ret = err
+				}
+			} else {
+				// Set the value
+				reflect.ValueOf(dest).Elem().FieldByName(structFld.Name).Set(reflect.ValueOf(wrk))
+			}
+		}
+
+		/*
+			setField := reflect.ValueOf(dest).Elem().Field(i)
+			value := entityType.Field(i)
+			fldName := FieldName(value)
+			if value.Type.Kind() == reflect.Struct {
+				b.LoadStruct(append(path, fldName), setField.Interface())
+			} else {
+				err := b.GetForInterface(path, fldName, &value)
+				if err != nil {
+					fmt.Println(err)
+					return err
+				}
+				fmt.Println("value:", value)
+			}
+		*/
+
+		/*
+			if value.Type.Kind() == reflect.Struct {
+				b.LoadStruct(append(path, fldName), setField.Interface())
+			} else {
+				v, err := b.GetForType(path, fldName, value)
+				if err != nil {
+					return err
+				}
+				setField.Set(reflect.ValueOf(v))
+			}
+		*/
+	}
+	return ret
+}
+
+func (b *DB) Save(path []string, src any) error {
+	t := reflect.TypeOf(src)
+	if t.Kind() == reflect.Pointer {
+		// Save the actual struct
+		elem := reflect.ValueOf(src).Elem()
+		return b.Save(path, elem.Interface())
+	}
+
+	if t.Kind() == reflect.Struct {
+		fields := reflect.VisibleFields(t)
+		r := reflect.ValueOf(src)
+		for _, fld := range fields {
+			f := r.FieldByName(fld.Name)
+			if (f.Kind() == reflect.Struct || f.Kind() == reflect.Pointer) && f != src {
+				if f.CanInterface() {
+					err := b.Save(append(path, FieldName(fld)), f.Interface())
+					if err != nil {
+						return err
+					}
+				} else {
+					err := b.Save(append(path, FieldName(fld)), reflect.Indirect(f))
+					if err != nil {
+						return err
+					}
+				}
+			} else {
+				if err := b.Set(path, FieldName(fld), f); err != nil {
+					return err
+				}
+			}
+		}
+	} else {
+		return b.Set(path[:len(path)-1], path[len(path)-1], src)
+	}
+	return nil
+}
+
+func FieldName(fld reflect.StructField) string {
+	nm := fld.Name
+	tag := fld.Tag.Get("boltease")
+	if tag != "" {
+		nm = tag
+	}
+	return nm
+}
+func FieldIgnored(fld reflect.StructField) bool {
+	return fld.Tag.Get("boltease") == "-"
+}
+
+func ReflectValueToInterface(val reflect.Value) interface{} {
+	switch val.Kind() {
+	case reflect.Pointer:
+		return ReflectValueToInterface(reflect.Indirect(val))
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		return val.Int()
+	case reflect.Bool:
+		return val.Bool()
+	case reflect.String:
+		return val.String()
+	default:
+		return val.Bytes()
+	}
+}

boltease.go

@@ -1,8 +1,10 @@
 package boltease
 
 import (
+	"encoding/binary"
 	"fmt"
 	"os"
+	"reflect"
 	"strconv"
 	"strings"
 	"time"
@@ -99,10 +101,160 @@ func (b *DB) MkBucketPath(path []string) error {
 	return err
 }
 
-// GetValue returns the value at path
+func (b *DB) Set(path []string, key string, val interface{}) error {
+	switch v := val.(type) {
+	case reflect.Value:
+		return b.Set(path, key, ReflectValueToInterface(v))
+	case string:
+		return b.SetString(path, key, v)
+	case int:
+		return b.SetInt(path, key, v)
+	case int8:
+		return b.SetInt(path, key, int(v))
+	case int16:
+		return b.SetInt(path, key, int(v))
+	case int32:
+		return b.SetInt(path, key, int(v))
+	case int64:
+		return b.SetInt(path, key, int(v))
+	case bool:
+		return b.SetBool(path, key, v)
+	case []byte:
+		return b.SetBytes(path, key, v)
+	default:
+		return fmt.Errorf("Unknown Data Type: %v", v)
+	}
+}
+func (b *DB) GetForInterface(path []string, key string, val interface{}) error {
+	var err error
+	switch v := val.(type) {
+	case *string:
+		*v, err = b.GetString(path, key)
+	case *int:
+		*v, err = b.GetInt(path, key)
+	case *int8:
+		var wrk int
+		wrk, err = b.GetInt(path, key)
+		*v = int8(wrk)
+	case *int16:
+		var wrk int
+		wrk, err = b.GetInt(path, key)
+		*v = int16(wrk)
+	case *int32:
+		var wrk int
+		wrk, err = b.GetInt(path, key)
+		*v = int32(wrk)
+	case *int64:
+		var wrk int
+		wrk, err = b.GetInt(path, key)
+		*v = int64(wrk)
+	case *bool:
+		*v, err = b.GetBool(path, key)
+	case *[]byte:
+		*v, err = b.GetBytes(path, key)
+	default:
+		return fmt.Errorf("Unknown Data Type: %v", v)
+	}
+	return err
+}
+func (b *DB) LoadInto(path []string, key string, into interface{}) error {
+	var err error
+	switch v := into.(type) {
+	case string:
+		i := new(string)
+		*i, err = b.GetString(path, key)
+		fmt.Printf("Loading String: %v\n", i)
+		into = i
+	case int, int8, int16, int32, int64:
+		i := new(int)
+		*i, err = b.GetInt(path, key)
+		fmt.Printf("Loading Int: %v\n", i)
+		into = i
+	case bool:
+		i := new(bool)
+		*i, err = b.GetBool(path, key)
+		fmt.Printf("Loading Bool: %v\n", i)
+		into = i
+	case []byte:
+		i := new([]byte)
+		*i, err = b.GetBytes(path, key)
+		fmt.Printf("Loading []byte: %v\n", i)
+		into = i
+	default:
+		return fmt.Errorf("Unknown Data Type: %v", v)
+	}
+	return err
+}
+
+func (b *DB) GetBytes(path []string, key string) ([]byte, error) {
+	var err error
+	var ret []byte
+	if !b.dbIsOpen {
+		if err = b.OpenDB(); err != nil {
+			return nil, err
+		}
+		defer b.CloseDB()
+	}
+	err = b.boltDB.View(func(tx *bolt.Tx) error {
+		bkt := tx.Bucket([]byte(path[0]))
+		if bkt == nil {
+			return fmt.Errorf("Couldn't find bucket " + path[0])
+		}
+		for idx := 1; idx < len(path); idx++ {
+			bkt = bkt.Bucket([]byte(path[idx]))
+			if bkt == nil {
+				return fmt.Errorf("Couldn't find bucket " + strings.Join(path[:idx+1], "/"))
+			}
+		}
+		// newBkt should have the last bucket in the path
+		val := bkt.Get([]byte(key))
+		if val == nil {
+			return fmt.Errorf("Couldn't find value")
+		}
+		ret = make([]byte, len(val))
+		copy(ret, val)
+		return nil
+	})
+	if err != nil {
+		return nil, err
+	}
+	return ret, nil
+}
+
+func (b *DB) SetBytes(path []string, key string, val []byte) error {
+	var err error
+	if !b.dbIsOpen {
+		if err = b.OpenDB(); err != nil {
+			return err
+		}
+		defer b.CloseDB()
+	}
+
+	err = b.MkBucketPath(path)
+	if err != nil {
+		return err
+	}
+	err = b.boltDB.Update(func(tx *bolt.Tx) error {
+		bkt := tx.Bucket([]byte(path[0]))
+		if bkt == nil {
+			return fmt.Errorf("Couldn't find bucket " + path[0])
+		}
+		for idx := 1; idx < len(path); idx++ {
+			bkt, err = bkt.CreateBucketIfNotExists([]byte(path[idx]))
+			if err != nil {
+				return err
+			}
+		}
+		// bkt should have the last bucket in the path
+		return bkt.Put([]byte(key), val)
+	})
+	return err
+}
+
+// GetString returns the value at path
 // path is a slice of strings
 // key is the key to get
-func (b *DB) GetValue(path []string, key string) (string, error) {
+func (b *DB) GetString(path []string, key string) (string, error) {
 	var err error
 	var ret string
 	if !b.dbIsOpen {
@@ -119,7 +271,7 @@ func (b *DB) GetValue(path []string, key string) (string, error) {
 		for idx := 1; idx < len(path); idx++ {
 			bkt = bkt.Bucket([]byte(path[idx]))
 			if bkt == nil {
-				return fmt.Errorf("Couldn't find bucket " + strings.Join(path[:idx], "/"))
+				return fmt.Errorf("Couldn't find bucket " + strings.Join(path[:idx+1], "/"))
 			}
 		}
 		// newBkt should have the last bucket in the path
@@ -129,9 +281,9 @@ func (b *DB) GetValue(path []string, key string) (string, error) {
 	return ret, err
 }
 
-// SetValue sets the value of key at path to val
+// SetString sets the value of key at path to val
 // path is a slice of tokens
-func (b *DB) SetValue(path []string, key, val string) error {
+func (b *DB) SetString(path []string, key, val string) error {
 	var err error
 	if !b.dbIsOpen {
 		if err = b.OpenDB(); err != nil {
@@ -165,7 +317,7 @@ func (b *DB) SetValue(path []string, key, val string) error {
 // If the value cannot be parsed as an int, error
 func (b *DB) GetInt(path []string, key string) (int, error) {
 	var ret int
-	r, err := b.GetValue(path, key)
+	r, err := b.GetString(path, key)
 	if err == nil {
 		ret, err = strconv.Atoi(r)
 	}
@@ -174,7 +326,7 @@ func (b *DB) GetInt(path []string, key string) (int, error) {
 
 // SetInt Sets an integer value
 func (b *DB) SetInt(path []string, key string, val int) error {
-	return b.SetValue(path, key, strconv.Itoa(val))
+	return b.SetString(path, key, strconv.Itoa(val))
 }
 
 // GetBool returns the value at 'path'
@@ -182,7 +334,7 @@ func (b *DB) SetInt(path []string, key string, val int) error {
 // We check 'true/false' and '1/0', else error
 func (b *DB) GetBool(path []string, key string) (bool, error) {
 	var ret bool
-	r, err := b.GetValue(path, key)
+	r, err := b.GetString(path, key)
 	if err == nil {
 		if r == "true" || r == "1" {
 			ret = true
@@ -196,15 +348,15 @@ func (b *DB) GetBool(path []string, key string) (bool, error) {
 // SetBool Sets a boolean value
 func (b *DB) SetBool(path []string, key string, val bool) error {
 	if val {
-		return b.SetValue(path, key, "true")
+		return b.SetString(path, key, "true")
 	}
-	return b.SetValue(path, key, "false")
+	return b.SetString(path, key, "false")
 }
 
 // GetTimestamp returns the value at 'path'
 // If the value cannot be parsed as a RFC3339, error
 func (b *DB) GetTimestamp(path []string, key string) (time.Time, error) {
-	r, err := b.GetValue(path, key)
+	r, err := b.GetString(path, key)
 	if err == nil {
 		return time.Parse(time.RFC3339, r)
 	}
@@ -213,7 +365,7 @@ func (b *DB) GetTimestamp(path []string, key string) (time.Time, error) {
 
 // SetTimestamp saves a timestamp into the db
 func (b *DB) SetTimestamp(path []string, key string, val time.Time) error {
-	return b.SetValue(path, key, val.Format(time.RFC3339))
+	return b.SetString(path, key, val.Format(time.RFC3339))
 }
 
 // GetBucketList returns a list of all sub-buckets at path
@@ -237,7 +389,7 @@ func (b *DB) GetBucketList(path []string) ([]string, error) {
 			for idx := 1; idx < len(path); idx++ {
 				bkt = bkt.Bucket([]byte(path[idx]))
 				if bkt == nil {
-					return fmt.Errorf("Couldn't find bucket " + strings.Join(path[:idx], " / "))
+					return fmt.Errorf("Couldn't find bucket " + strings.Join(path[:idx+1], " / "))
 				}
 			}
 		}
@@ -360,8 +512,8 @@ func (b *DB) DeleteBucket(path []string, key string) error {
 	return err
 }
 
-// GetValueList returns a string slice of all values in the bucket at path
-func (b *DB) GetValueList(path []string) ([]string, error) {
+// GetStringList returns a string slice of all values in the bucket at path
+func (b *DB) GetStringList(path []string) ([]string, error) {
 	var err error
 	var ret []string
 	if !b.dbIsOpen {
@@ -371,6 +523,85 @@ func (b *DB) GetValueList(path []string) ([]string, error) {
 		defer b.CloseDB()
 	}
 
+	err = b.boltDB.Update(func(tx *bolt.Tx) error {
+		bkt := tx.Bucket([]byte(path[0]))
+		if bkt == nil {
+			return fmt.Errorf("Couldn't find bucket " + path[0])
+		}
+		var berr error
+		if len(path) > 1 {
+			for idx := 1; idx < len(path); idx++ {
+				bkt = bkt.Bucket([]byte(path[idx]))
+				if bkt == nil {
+					return fmt.Errorf("Couldn't find bucket " + strings.Join(path[:idx+1], " / "))
+				}
+			}
+		}
+
+		// bkt should have the last bucket in the path
+		berr = bkt.ForEach(func(k, v []byte) error {
+			if v != nil {
+				// Must be a key
+				ret = append(ret, string(v))
+			}
+			return nil
+		})
+		return berr
+	})
+	return ret, err
+}
+
+// SetStringList puts a string slice into the bucket at path
+func (b *DB) SetStringList(path, values []string) error {
+	var err error
+	if !b.dbIsOpen {
+		if err = b.OpenDB(); err != nil {
+			return err
+		}
+		defer b.CloseDB()
+	}
+
+	err = b.MkBucketPath(path)
+	if err != nil {
+		return err
+	}
+	err = b.boltDB.Update(func(tx *bolt.Tx) error {
+		bkt := tx.Bucket([]byte(path[0]))
+		if bkt == nil {
+			return fmt.Errorf("Couldn't find bucket " + path[0])
+		}
+		for idx := 1; idx < len(path); idx++ {
+			bkt, err = bkt.CreateBucketIfNotExists([]byte(path[idx]))
+			if err != nil {
+				return err
+			}
+		}
+		// bkt should have the last bucket in the path
+		for _, v := range values {
+			id, _ := bkt.NextSequence()
+			bId := make([]byte, 8)
+			binary.BigEndian.PutUint64(bId, id)
+			err = bkt.Put(bId, []byte(v))
+			if err != nil {
+				return err
+			}
+		}
+		return nil
+	})
+	return err
+}
+
+// GetKeyValueMap returns a map of all key/value pairs in the bucket at path
+func (b *DB) GetKeyValueMap(path []string) (map[string][]byte, error) {
+	var err error
+	ret := make(map[string][]byte)
+	if !b.dbIsOpen {
+		if err = b.OpenDB(); err != nil {
+			return ret, err
+		}
+		defer b.CloseDB()
+	}
+
 	err = b.boltDB.Update(func(tx *bolt.Tx) error {
 		bkt := tx.Bucket([]byte(path[0]))
 		if bkt == nil {
@@ -390,7 +621,7 @@ func (b *DB) GetValueList(path []string) ([]string, error) {
 		berr = bkt.ForEach(func(k, v []byte) error {
 			if v != nil {
 				// Must be a key
-				ret = append(ret, string(v))
+				ret[string(k)] = v
 			}
 			return nil
 		})
@@ -398,3 +629,62 @@ func (b *DB) GetValueList(path []string) ([]string, error) {
 	})
 	return ret, err
 }
+
+// GetKeyValueStringMap returns all key/value pairs at path as a map
+func (b *DB) GetKeyValueStringMap(path []string) (map[string]string, error) {
+	ret := make(map[string]string)
+	btMap, err := b.GetKeyValueMap(path)
+	if err != nil {
+		return ret, err
+	}
+	for k, v := range btMap {
+		ret[k] = string(v)
+	}
+	return ret, err
+}
+
+// SetKeyValueMap puts all key/value pairs into the bucket at path
+func (b *DB) SetKeyValueMap(path []string, kvMap map[string][]byte) error {
+	var err error
+	if !b.dbIsOpen {
+		if err = b.OpenDB(); err != nil {
+			return err
+		}
+		defer b.CloseDB()
+	}
+
+	err = b.MkBucketPath(path)
+	if err != nil {
+		return err
+	}
+	err = b.boltDB.Update(func(tx *bolt.Tx) error {
+		bkt := tx.Bucket([]byte(path[0]))
+		if bkt == nil {
+			return fmt.Errorf("Couldn't find bucket " + path[0])
+		}
+		for idx := 1; idx < len(path); idx++ {
+			bkt, err = bkt.CreateBucketIfNotExists([]byte(path[idx]))
+			if err != nil {
+				return err
+			}
+		}
+		// bkt should have the last bucket in the path
+		for k, v := range kvMap {
+			err = bkt.Put([]byte(k), v)
+			if err != nil {
+				return err
+			}
+		}
+		return nil
+	})
+	return err
+}
+
+// SetKeyValueStringMap takes a map[string]string and puts all key/value pairs into the bucket at path
+func (b *DB) SetKeyValueStringMap(path []string, kvMap map[string]string) error {
+	chain := make(map[string][]byte)
+	for k, v := range kvMap {
+		chain[k] = []byte(v)
+	}
+	return b.SetKeyValueMap(path, chain)
+}

example/.gitignore

@@ -0,0 +1,2 @@
+example
+example.db

example/main.go

@@ -0,0 +1,136 @@
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+
+	"git.bullercodeworks.com/brian/boltease"
+)
+
+func main() {
+	//example1()
+	//fmt.Println()
+	example2()
+}
+
+func example1() {
+	fmt.Println("# Example 1")
+	db, err := boltease.Create("example.db", 0600, nil)
+	if err != nil {
+		fmt.Printf("Error Opening File: %s\n", err.Error())
+		os.Exit(1)
+	}
+
+	fmt.Println("## Saving Struct")
+	err = db.Save(
+		[]string{"examples", "example1"},
+		ExampleType{
+			Name: "Example 1",
+			Age:  5,
+		})
+	if err != nil {
+		fmt.Printf("Error saving struct: %s\n", err.Error())
+		os.Exit(1)
+	}
+
+	fmt.Println("## Example 1-1: Simple")
+	var v string
+	err = db.GetForInterface([]string{"examples", "example1"}, "name", &v)
+	if err != nil {
+		fmt.Println("Error:", err.Error())
+	}
+	fmt.Println("Name:", v)
+	var age int
+	err = db.GetForInterface([]string{"examples", "example1"}, "age", &age)
+	if err != nil {
+		fmt.Println("Error:", err.Error())
+	}
+	fmt.Println("Age:", age)
+	fmt.Println("")
+
+	fmt.Println("## Example 1-2: LoadStruct, simple")
+	var name string
+	err = db.Load(
+		[]string{"examples", "example1", "name"},
+		&name,
+	)
+	fmt.Println("Name:", name)
+	if err != nil {
+		fmt.Println("Err:", err)
+	}
+	fmt.Println("")
+
+	fmt.Println("## Example 1-3: Struct")
+	fmt.Println("Loading into Struct")
+	newStruct := ExampleType{}
+	err = db.Load(
+		[]string{"examples", "example1"},
+		&newStruct,
+	)
+	fmt.Println(newStruct)
+}
+
+func example2() {
+	fmt.Println("# Example 2")
+	db, err := boltease.Create("example.db", 0600, nil)
+	if err != nil {
+		fmt.Printf("Error Opening File: %s\n", err.Error())
+		os.Exit(1)
+	}
+	fmt.Println("## Saving Struct")
+	num := 12345
+	err = db.Save(
+		[]string{"examples", "example2"},
+		&ExampleType2{
+			Name: "Example 2",
+			Age:  20,
+			SubTypePtr: &ExampleSubType{
+				SubName: "Example SubType Pointer",
+			},
+			SubType: ExampleSubType{
+				SubName: "Example SubType",
+			},
+			Number: &num,
+		})
+	if err != nil {
+		fmt.Printf("Error saving struct: %s\n", err.Error())
+		os.Exit(1)
+	}
+
+	newStruct := ExampleType2{}
+	err = db.Load([]string{"examples", "example2"}, &newStruct)
+	fmt.Println(newStruct)
+}
+
+type ExampleType struct {
+	Name string `boltease:"name"`
+	Age  int    `boltease:"age"`
+}
+
+func (e ExampleType) String() string {
+	r, _ := json.Marshal(e)
+	return string(r)
+}
+
+type ExampleType2 struct {
+	Name       string          `boltease:"name"`
+	Age        int             `boltease:"age"`
+	SubTypePtr *ExampleSubType `boltease:"subtypeptr"`
+	SubType    ExampleSubType  `boltease:"subtype"`
+	Number     *int            `boltease:"number"`
+}
+
+func (e ExampleType2) String() string {
+	r, _ := json.Marshal(e)
+	return string(r)
+}
+
+type ExampleSubType struct {
+	SubName string `boltease:"subname"`
+}
+
+func (e ExampleSubType) String() string {
+	r, _ := json.Marshal(e)
+	return string(r)
+}

go.mod

@@ -0,0 +1,8 @@
+module git.bullercodeworks.com/brian/boltease
+
+go 1.16
+
+require (
+	github.com/boltdb/bolt v1.3.1
+	golang.org/x/sys v0.0.0-20210823070655-63515b42dcdf // indirect
+)

go.sum

@@ -0,0 +1,4 @@
+github.com/boltdb/bolt v1.3.1 h1:JQmyP4ZBrce+ZQu0dY660FMfatumYDLun9hBCUVIkF4=
+github.com/boltdb/bolt v1.3.1/go.mod h1:clJnj/oiGkjum5o1McbSZDSLxVThjynRyGBgiAx27Ps=
+golang.org/x/sys v0.0.0-20210823070655-63515b42dcdf h1:2ucpDCmfkl8Bd/FsLtiD653Wf96cW37s+iGx93zsu4k=
+golang.org/x/sys v0.0.0-20210823070655-63515b42dcdf/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=