basic ops

Author: spekulant

README.md

@@ -0,0 +1,29 @@
+## TBKV key-val store
+
+You're looking at a simple zero-dependency in-memory key-value store for Golang. 
+
+All operations (Get/Set/Delete) are executed in a single, buffered loop, so the store provides some thread safety.
+
+### Usage
+
+
+```Golang
+kvs := NewStore()
+
+kvs.Set("key", "value")
+
+val, err := kvs.Get("key")
+if err != nil {
+    return err
+}
+
+// val == "value"
+
+kvs.Delete("key")
+
+val, err := kvs.Get("key")
+if err != nil {
+    // err == ErrNotFound
+    return err
+}
+```

errors.go

@@ -0,0 +1,5 @@
+package tbkv
+
+import "errors"
+
+var ErrNotFound = errors.New("key not found")

go.mod

@@ -0,0 +1,3 @@
+module github.com/tech-branch/tbkv
+
+go 1.17

store.go

@@ -0,0 +1,89 @@
+package tbkv
+
+type KVStore struct {
+	data   map[string]string
+	save   chan ItemRequest
+	fetch  chan Request
+	delete chan Request
+}
+
+func (s *KVStore) Get(key string) (string, error) {
+	request := Request{
+		Key:    key,
+		Result: make(chan Result, 1),
+	}
+	s.fetch <- request
+	result := <-request.Result
+	if !result.Ok {
+		return "", ErrNotFound
+	}
+	return result.Value, nil
+}
+
+func (s *KVStore) Set(key, value string) {
+	setItemRequest := ItemRequest{
+		Item: Item{
+			Key:   key,
+			Value: value,
+		},
+		Ok: make(chan bool, 1),
+	}
+	s.save <- setItemRequest
+	<-setItemRequest.Ok
+}
+
+func (s *KVStore) Delete(key string) {
+	request := Request{
+		Key:    key,
+		Result: make(chan Result, 1),
+	}
+	s.delete <- request
+	<-request.Result
+}
+
+// NewStore creates a new KVStore.
+// requestBufferSize is the size of the request buffer.
+// If requestBufferSize is 0, it will use a default of 20.
+func NewStore(requestBufferSize uint8) KVStore {
+	var buffer uint8
+	if requestBufferSize == 0 {
+		buffer = 20
+	} else {
+		buffer = requestBufferSize
+	}
+	kvs := KVStore{}
+	kvs.data = make(map[string]string)
+	kvs.save = make(chan ItemRequest, buffer)
+	kvs.fetch = make(chan Request, buffer)
+	kvs.delete = make(chan Request, buffer)
+	go kvs.loop() // starts listening for requests
+	return kvs
+}
+
+// NewDefaultStore is a convenience function for creating a KVStore with sensible defaults.
+// It will create a KVStore with a request buffer size of 20.
+func NewDefaultStore() KVStore {
+	return NewStore(0)
+}
+
+func (s *KVStore) loop() error {
+	for {
+		select {
+		case setRequest := <-s.save:
+			s.data[setRequest.Item.Key] = setRequest.Item.Value
+			setRequest.Ok <- true // cannot fail
+		case getRequest := <-s.fetch:
+			val, ok := s.data[getRequest.Key]
+			getRequest.Result <- Result{
+				Value: val,
+				Ok:    ok,
+			}
+		case delRequest := <-s.delete:
+			delete(s.data, delRequest.Key)
+			delRequest.Result <- Result{
+				Value: delRequest.Key,
+				Ok:    true, // cannot fail
+			}
+		}
+	}
+}

store_test.go

@@ -0,0 +1,72 @@
+package tbkv
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestKVStore_Set(t *testing.T) {
+	// testing the usual Set/Get flow
+	kvs := NewDefaultStore()
+	kvs.Set("key", "value")
+	val, err := kvs.Get("key")
+	if err != nil {
+		t.Error(err)
+	}
+	if val != "value" {
+		t.Errorf("Expected value to be 'value', got '%s'", val)
+	}
+}
+
+func TestKVStore_SetLargeBuffer(t *testing.T) {
+	// testing the same Set/Get flow but with a bigger buffer
+	kvs := NewStore(255)
+	kvs.Set("key", "value")
+	val, err := kvs.Get("key")
+	if err != nil {
+		t.Error(err)
+	}
+	if val != "value" {
+		t.Errorf("Expected value to be 'value', got '%s'", val)
+	}
+}
+
+func TestKVStore_DoubleSet(t *testing.T) {
+	// I want to overwrite entries without an issue
+	kvs := NewDefaultStore()
+	kvs.Set("key", "value1")
+	kvs.Set("key", "value2")
+}
+
+func TestKVStore_SetMultiple(t *testing.T) {
+	// lets try with multiple consecutive sets
+	kvs := NewDefaultStore()
+	for i := 0; i < 20; i++ {
+		kvs.Set(fmt.Sprint(i), fmt.Sprint(i*i))
+	}
+	val, err := kvs.Get("19")
+	if err != nil {
+		t.Error(err)
+	}
+	if val != "361" {
+		t.Errorf("Expected value to be '361', got '%s'", val)
+	}
+}
+
+func TestKVStore_Delete(t *testing.T) {
+	// I want to delete entries without an issue
+	// I don't want to handle an error if entry does not exist, assume Ok
+	kvs := NewDefaultStore()
+	for i := 0; i < 20; i++ {
+		kvs.Set(fmt.Sprint(i), fmt.Sprint(i*i))
+	}
+	kvs.Delete("19")
+	// this is a no-op because the key doesn't exist
+	kvs.Delete("19")
+
+	_, err := kvs.Get("19")
+	if err != ErrNotFound {
+		t.Errorf("Expected ErrNotFound, got '%s'", err)
+	}
+
+}

types.go

@@ -0,0 +1,21 @@
+package tbkv
+
+type Item struct {
+	Key   string
+	Value string
+}
+
+type ItemRequest struct {
+	Item Item
+	Ok   chan bool
+}
+
+type Request struct {
+	Key    string
+	Result chan Result
+}
+
+type Result struct {
+	Value string
+	Ok    bool
+}