Initial version of log

Author: krasun

LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2021 Dmytro Krasun
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
+OR OTHER DEALINGS IN THE SOFTWARE.

README.md

@@ -0,0 +1,5 @@
+# appendy
+
+## License 
+
+appendy is released under [the MIT license](LICENSE).

encode.go

@@ -0,0 +1,64 @@
+package main
+
+import (
+	"encoding/binary"
+)
+
+func encodePut(key []byte, value []byte) []byte {
+	encodedKeyLen := encodeLen(len(key))
+	encodedValueLen := encodeLen(len(value))
+	len := len(encodedKeyLen) + len(key) + len(encodedValueLen) + len(value)
+	data := make([]byte, 0, len)
+
+	encodedLen := encodeLen(len)
+
+	data = append(data, encodedLen...)
+	data = append(data, encodedKeyLen...)
+	data = append(data, key...)
+	data = append(data, encodedValueLen...)
+	data = append(data, value...)
+
+	return data
+}
+
+func encodeLen(len int) []byte {
+	var encoded [8]byte
+	binary.LittleEndian.PutUint64(encoded[:], uint64(len))
+
+	return encoded[:]
+}
+
+func decodeLen(encoded []byte) int {
+	return int(binary.LittleEndian.Uint64(encoded))
+}
+
+func decode(encoded []byte) ([]byte, []byte, bool) {
+	keyLen := decodeLen(encoded[0:8])
+	key := encoded[8 : 8+keyLen]
+	keyPartLen := 8 + keyLen
+
+	if keyPartLen+1 == len(encoded) {
+		return key, nil, true
+	}
+
+	valueLenStart := 8 + keyLen
+	value := encoded[valueLenStart+8:]
+
+	return key, value, false
+}
+
+func encodeDelete(key []byte) []byte {
+	encodedKeyLen := encodeLen(len(key))
+	len := len(encodedKeyLen) + len(key) + 1
+	data := make([]byte, 0, len)
+
+	encodedLen := encodeLen(len)
+
+	data = append(data, encodedLen...)
+	data = append(data, encodedKeyLen...)
+	data = append(data, key...)
+	// mark deletion
+	data = append(data, 0)
+
+	return data
+}

file.go

@@ -0,0 +1,68 @@
+package main
+
+import (
+	"fmt"
+	"io"
+	"os"
+)
+
+func putEntry(file *os.File, key []byte, value []byte) error {
+	return appendToFile(file, encodePut(key, value))
+}
+
+func deleteEntry(file *os.File, key []byte) error {
+	return appendToFile(file, encodeDelete(key))
+}
+
+func appendToFile(file *os.File, data []byte) error {
+	if _, err := file.Seek(0, 2); err != nil {
+		return fmt.Errorf("failed to seek to the end: %w", err)
+	}
+
+	if _, err := file.Write(data); err != nil {
+		return fmt.Errorf("failed to write to the file: %w", err)
+	}
+
+	if err := file.Sync(); err != nil {
+		return fmt.Errorf("failed to sync the file: %w", err)
+	}
+
+	return nil
+}
+
+func loadEntries(file *os.File) ([]entry, error) {
+	entries := make([]entry, 0)
+	deleteKeys := make([][]byte, 0)
+	offset := 0
+	for {
+		var encodedEntryLen [8]byte
+		n, err := file.ReadAt(encodedEntryLen[:], int64(offset))
+		if err != nil && err != io.EOF {
+			return nil, fmt.Errorf("failed to read: %w", err)
+		}
+		if n < 8 && err == io.EOF {
+			for _, deleteKey := range deleteKeys {
+				entries = deleteByKey(entries, deleteKey)
+			}
+
+			return entries, nil
+		}
+		offset += n
+
+		entryLen := decodeLen(encodedEntryLen[:])
+		encodedEntry := make([]byte, entryLen, entryLen)
+		n, err = file.ReadAt(encodedEntry, int64(offset))
+
+		if n < entryLen {
+			return nil, fmt.Errorf("the file is corrupted, failed to read entry: %w", err)
+		}
+		offset += n
+
+		key, value, deleted := decode(encodedEntry)
+		if deleted {
+			deleteKeys = append(deleteKeys, key)
+		} else {
+			entries = append(entries, entry{key, value})
+		}
+	}
+}

go.mod

@@ -0,0 +1,3 @@
+module github.com/krasun/appendy
+
+go 1.14

main.go

@@ -0,0 +1,23 @@
+package main
+
+import (
+	"fmt"
+)
+
+func main() {
+	s, _ := Open("test.db")
+
+	s.Put([]byte("test"), []byte("val1"))
+	s.Put([]byte("test1"), []byte("val1"))
+	s.Delete([]byte("test"))
+
+	val, ok, _ := s.Get([]byte("test1"))
+	fmt.Println(string(val))
+	fmt.Println(ok)
+
+	val2, ok, _ := s.Get([]byte("test"))
+	fmt.Println(val2)
+	fmt.Println(ok)
+	fmt.Println(len(val2))
+	fmt.Println(nil == val2)
+}

storage.go

@@ -0,0 +1,73 @@
+package main
+
+import (
+	"bytes"
+	"fmt"
+	"os"
+)
+
+type Storage struct {
+	entries []entry
+	file    *os.File
+}
+
+type entry struct {
+	key   []byte
+	value []byte
+}
+
+func Open(path string) (*Storage, error) {
+	file, err := os.OpenFile(path, os.O_RDWR|os.O_CREATE, 0600)
+	if err != nil {
+		return nil, fmt.Errorf("failed to open file %s: %w", path, err)
+	}
+
+	entries, err := loadEntries(file)
+	if err != nil {
+		return nil, fmt.Errorf("failed to load entries from %s: %w", path, err)
+	}
+
+	return &Storage{file: file, entries: entries}, nil
+}
+
+func (s *Storage) Close() error {
+	if err := s.file.Close(); err != nil {
+		return fmt.Errorf("failed to close file %s: %w", s.file.Name(), err)
+	}
+
+	return nil
+}
+
+func (s *Storage) Put(key []byte, value []byte) error {
+	if key == nil || value == nil {
+		return fmt.Errorf("key/value can not be nil")
+	}
+
+	if err := putEntry(s.file, key, value); err != nil {
+		return fmt.Errorf("failed to append to file %s: %w", s.file.Name(), err)
+	}
+
+	s.entries = append(s.entries, entry{key, value})
+
+	return nil
+}
+
+func (s *Storage) Get(key []byte) ([]byte, bool, error) {
+	for _, entry := range s.entries {
+		if bytes.Equal(entry.key, key) {
+			return entry.value, true, nil
+		}
+	}
+
+	return nil, false, nil
+}
+
+func (s *Storage) Delete(key []byte) error {
+	if err := deleteEntry(s.file, key); err != nil {
+		return fmt.Errorf("failed to append to file %s: %w", s.file.Name(), err)
+	}
+
+	s.entries = deleteByKey(s.entries, key)
+
+	return nil
+}

util.go

@@ -0,0 +1,18 @@
+package main
+
+import "bytes"
+
+func deleteByKey(entries []entry, key []byte) []entry {
+	b := entries[:0]
+	for _, entry := range entries {
+		if !bytes.Equal(entry.key, key) {
+			b = append(b, entry)
+		}
+	}
+
+	return b
+}
+
+func delete(slice []entry, i int) []entry {
+	return append(slice[:i], slice[i+1:]...)
+}