stealing

storage/db.go

@@ -0,0 +1,9 @@
+package storage
+
+import "local/rproxy3/storage/packable"
+
+type DB interface {
+	Get(string, string, packable.Packable) error
+	Set(string, string, packable.Packable) error
+	Close() error
+}

storage/db_test.go

@@ -0,0 +1,46 @@
+package storage
+
+import (
+	"local/rproxy3/storage/packable"
+	"os"
+	"testing"
+)
+
+func TestDB(t *testing.T) {
+	dbPath := "./fake_db_path"
+	defer os.Remove(dbPath)
+
+	cases := []func() DB{
+		func() DB {
+			return DB(NewMap())
+		},
+	}
+
+	raw := "hello world"
+	for _, c := range cases {
+		os.Remove(dbPath)
+
+		s := packable.NewString(raw)
+		db := c()
+		if err := db.Set("ns", "key", s); err != nil {
+			t.Errorf("cannot save: %v", err)
+		}
+
+		r := packable.NewString("")
+		if err := db.Get("ns", "key", r); err != nil {
+			t.Errorf("cannot load: %v", err)
+		}
+
+		if s.String() != r.String() {
+			t.Errorf("set/get values not equal: %v vs %v", s, r)
+		}
+
+		if s.String() != raw {
+			t.Errorf("set/get values not equal to raw: %v vs %v", s, raw)
+		}
+
+		if err := db.Close(); err != nil {
+			t.Errorf("cannot close bolt: %v", err)
+		}
+	}
+}

storage/map.go

@@ -0,0 +1,64 @@
+package storage
+
+import (
+	"errors"
+	"fmt"
+	"local/rproxy3/storage/packable"
+)
+
+type Map map[string]map[string][]byte
+
+func NewMap() Map {
+	m := make(map[string]map[string][]byte)
+	n := Map(m)
+	return n
+}
+
+func (m Map) String() string {
+	s := ""
+	for k, v := range m {
+		if k == "clients" {
+			if s != "" {
+				s += ",\n"
+			}
+			s += fmt.Sprintf("[%s]:[%v]", k, v)
+		} else {
+			for k1, _ := range v {
+				if s != "" {
+					s += ",\n"
+				}
+				str := packable.NewString("")
+				m.Get(k, k1, str)
+				s += fmt.Sprintf("[%s:%s]:[%v]", k, k1, str)
+			}
+		}
+	}
+	return s
+}
+
+func (m Map) Close() error {
+	m = nil
+	return nil
+}
+
+func (m Map) Get(ns, key string, value packable.Packable) error {
+	if _, ok := m[ns]; !ok {
+		m[ns] = make(map[string][]byte)
+	}
+	if _, ok := m[ns][key]; !ok {
+		return errors.New("not found")
+	}
+	return value.Decode(m[ns][key])
+}
+
+func (m Map) Set(ns, key string, value packable.Packable) error {
+	if _, ok := m[ns]; !ok {
+		m[ns] = make(map[string][]byte)
+	}
+	b, err := value.Encode()
+	if err != nil {
+		return err
+	}
+	m[ns][key] = b
+	return nil
+}

storage/packable/packable.go

@@ -0,0 +1,26 @@
+package packable
+
+type Packable interface {
+	Encode() ([]byte, error)
+	Decode([]byte) error
+}
+
+type String string
+
+func (s *String) String() string {
+	return string(*s)
+}
+
+func (s *String) Encode() ([]byte, error) {
+	return []byte(*s), nil
+}
+
+func (s *String) Decode(b []byte) error {
+	*s = String(string(b))
+	return nil
+}
+
+func NewString(s string) *String {
+	w := String(s)
+	return &w
+}

storage/packable/packable_test.go

@@ -0,0 +1,23 @@
+package packable
+
+import "testing"
+
+func TestPackableString(t *testing.T) {
+	raw := "hello"
+	s := NewString(raw)
+	if s.String() != raw {
+		t.Errorf("cannot convert string to String: %v vs %v", s, raw)
+	}
+
+	packed, err := s.Encode()
+	if err != nil {
+		t.Errorf("cannot encode String: %v", err)
+	}
+
+	x := NewString("")
+	if err := x.Decode(packed); err != nil {
+		t.Errorf("cannot decode string: %v", err)
+	} else if x.String() != raw {
+		t.Errorf("wrong decoded string: %v vs %v", x, raw)
+	}
+}