fstore/browser.go

@@ -3,11 +3,10 @@ package fstore
 import (
 	"embed"
 	"io"
+	"git.crumpington.com/public/jldb/fstore/pages"
 	"net/http"
 	"os"
 	"path/filepath"
-
-	"git.crumpington.com/public/jldb/fstore/pages"
 )
 
 //go:embed static/*

fstore/command.go

@@ -4,7 +4,6 @@ import (
 	"bytes"
 	"encoding/binary"
 	"io"
-
 	"git.crumpington.com/public/jldb/lib/errs"
 )
 

fstore/paths.go

@@ -1,10 +1,9 @@
 package fstore
 
 import (
+	"git.crumpington.com/public/jldb/lib/errs"
 	"path/filepath"
 	"strconv"
-
-	"git.crumpington.com/public/jldb/lib/errs"
 )
 
 func filesRootPath(rootDir string) string {

fstore/store-commands.go

@@ -1,12 +1,11 @@
 package fstore
 
 import (
+	"git.crumpington.com/public/jldb/lib/errs"
+	"git.crumpington.com/public/jldb/lib/idgen"
 	"log"
 	"os"
 	"path/filepath"
-
-	"git.crumpington.com/public/jldb/lib/errs"
-	"git.crumpington.com/public/jldb/lib/idgen"
 )
 
 func (s *Store) applyStoreFromReader(cmd command) error {

fstore/store-rep.go

@@ -5,13 +5,12 @@ import (
 	"errors"
 	"io"
 	"io/fs"
+	"git.crumpington.com/public/jldb/lib/errs"
+	"git.crumpington.com/public/jldb/lib/wal"
 	"net"
 	"os"
 	"path/filepath"
 	"time"
-
-	"git.crumpington.com/public/jldb/lib/errs"
-	"git.crumpington.com/public/jldb/lib/wal"
 )
 
 func (s *Store) repSendState(conn net.Conn) error {

fstore/store.go

@@ -3,16 +3,15 @@ package fstore
 import (
 	"bytes"
 	"io"
+	"git.crumpington.com/public/jldb/lib/errs"
+	"git.crumpington.com/public/jldb/lib/idgen"
+	"git.crumpington.com/public/jldb/lib/rep"
 	"net/http"
 	"os"
 	"path/filepath"
 	"strconv"
 	"sync"
 	"time"
-
-	"git.crumpington.com/public/jldb/lib/errs"
-	"git.crumpington.com/public/jldb/lib/idgen"
-	"git.crumpington.com/public/jldb/lib/rep"
 )
 
 type Config struct {

lib/atomicheader/atomicheader.go

@@ -3,10 +3,9 @@ package atomicheader
 import (
 	"encoding/binary"
 	"hash/crc32"
+	"git.crumpington.com/public/jldb/lib/errs"
 	"os"
 	"sync"
-
-	"git.crumpington.com/public/jldb/lib/errs"
 )
 
 const (

lib/httpconn/client.go

@@ -6,12 +6,11 @@ import (
 	"crypto/tls"
 	"errors"
 	"io"
+	"git.crumpington.com/public/jldb/lib/errs"
 	"net"
 	"net/http"
 	"net/url"
 	"time"
-
-	"git.crumpington.com/public/jldb/lib/errs"
 )
 
 var ErrInvalidStatus = errors.New("invalid status")

lib/rep/functions.go

@@ -0,0 +1,51 @@
+package rep
+
+import (
+	"encoding/binary"
+	"encoding/json"
+	"git.crumpington.com/public/jldb/lib/errs"
+	"net"
+	"path/filepath"
+	"time"
+)
+
+// ----------------------------------------------------------------------------
+
+func lockFilePath(rootDir string) string {
+	return filepath.Join(rootDir, "lock")
+}
+
+func walRootDir(rootDir string) string {
+	return filepath.Join(rootDir, "wal")
+}
+
+func stateFilePath(rootDir string) string {
+	return filepath.Join(rootDir, "state")
+}
+
+// ----------------------------------------------------------------------------
+
+func sendJSON(
+	item any,
+	conn net.Conn,
+	timeout time.Duration,
+) error {
+
+	buf := bufPoolGet()
+	defer bufPoolPut(buf)
+
+	if err := json.NewEncoder(buf).Encode(item); err != nil {
+		return errs.Unexpected.WithErr(err)
+	}
+
+	sizeBuf := make([]byte, 2)
+	binary.LittleEndian.PutUint16(sizeBuf, uint16(buf.Len()))
+
+	conn.SetWriteDeadline(time.Now().Add(timeout))
+	buffers := net.Buffers{sizeBuf, buf.Bytes()}
+	if _, err := buffers.WriteTo(conn); err != nil {
+		return errs.IO.WithErr(err)
+	}
+
+	return nil
+}

lib/rep/http-client.go

@@ -1,109 +1,178 @@
 package rep
 
 import (
+	"encoding/binary"
 	"encoding/json"
-	"net"
-	"net/http"
-	"strings"
-	"sync"
-	"time"
-
+	"io"
 	"git.crumpington.com/public/jldb/lib/errs"
 	"git.crumpington.com/public/jldb/lib/httpconn"
 	"git.crumpington.com/public/jldb/lib/wal"
+	"net"
+	"sync"
+	"time"
 )
 
 type client struct {
-	client *http.Client
+	// Mutex-protected variables.
+	lock   sync.Mutex
+	closed bool
+	conn   net.Conn
 
 	// The following are constant.
 	endpoint string
-	pskBytes [64]byte
+	psk      []byte
 	timeout  time.Duration
 
-	lock sync.Mutex
-	conn net.Conn
+	buf []byte
 }
 
 func newClient(endpoint, psk string, timeout time.Duration) *client {
-	httpClient := &http.Client{
-		Timeout: timeout,
-	}
-
-	if !strings.HasSuffix(endpoint, "/") {
-		endpoint += "/"
-	}
+	b := make([]byte, 256)
+	copy(b, []byte(psk))
 
 	return &client{
-		client:   httpClient,
 		endpoint: endpoint,
-		pskBytes: pskToBytes(psk),
+		psk:      b,
 		timeout:  timeout,
 	}
 }
 
 func (c *client) GetInfo() (info Info, err error) {
-	req, err := http.NewRequest(http.MethodGet, c.endpoint+pathGetInfo, nil)
-	if err != nil {
-		return info, errs.Unexpected.WithErr(err)
-	}
-	req.SetBasicAuth("", string(c.pskBytes[:]))
-
-	resp, err := c.client.Do(req)
-	if err != nil {
-		return info, errs.IO.WithErr(err)
-	}
-	defer resp.Body.Close()
-
-	if err := json.NewDecoder(resp.Body).Decode(&info); err != nil {
-		return info, errs.IO.WithErr(err)
-	}
-	return info, nil
+	err = c.withConn(cmdGetInfo, func(conn net.Conn) error {
+		return c.recvJSON(&info, conn, c.timeout)
+	})
+	return info, err
 }
 
 func (c *client) RecvState(recv func(net.Conn) error) error {
-	err := c.dialConnect(c.endpoint + pathSendState)
-	if err != nil {
-		return err
-	}
-	defer c.conn.Close()
-
-	return recv(c.conn)
+	return c.withConn(cmdSendState, recv)
 }
 
 func (c *client) StreamWAL(w *wal.WAL) error {
-	err := c.dialConnect(c.endpoint + pathStreamWAL)
-	if err != nil {
-		return err
-	}
-	defer c.conn.Close()
-
-	return w.Recv(c.conn, c.timeout)
+	return c.withConn(cmdStreamWAL, func(conn net.Conn) error {
+		return w.Recv(conn, c.timeout)
+	})
 }
 
 func (c *client) Close() {
 	c.lock.Lock()
 	defer c.lock.Unlock()
+	c.closed = true
+
 	if c.conn != nil {
 		c.conn.Close()
+		c.conn = nil
 	}
 }
 
 // ----------------------------------------------------------------------------
 
-func (c *client) dialConnect(endpoint string) error {
-	conn, err := httpconn.Dial(endpoint)
+func (c *client) writeCmd(cmd byte) error {
+	c.conn.SetWriteDeadline(time.Now().Add(c.timeout))
+	if _, err := c.conn.Write([]byte{cmd}); err != nil {
+		return errs.IO.WithErr(err)
+	}
+	return nil
+}
+
+func (c *client) dial() error {
+	c.conn = nil
+
+	conn, err := httpconn.Dial(c.endpoint)
 	if err != nil {
 		return err
 	}
 
 	conn.SetWriteDeadline(time.Now().Add(c.timeout))
-	if _, err := conn.Write(c.pskBytes[:]); err != nil {
+	if _, err := conn.Write(c.psk); err != nil {
+		conn.Close()
 		return errs.IO.WithErr(err)
 	}
 
-	c.lock.Lock()
-	defer c.lock.Unlock()
 	c.conn = conn
 	return nil
 }
+
+func (c *client) withConn(cmd byte, fn func(net.Conn) error) error {
+	conn, err := c.getConn(cmd)
+	if err != nil {
+		return err
+	}
+
+	if err := fn(conn); err != nil {
+		conn.Close()
+		return err
+	}
+	return nil
+}
+
+func (c *client) getConn(cmd byte) (net.Conn, error) {
+	c.lock.Lock()
+	defer c.lock.Unlock()
+
+	if c.closed {
+		return nil, errs.IO.WithErr(io.EOF)
+	}
+
+	dialed := false
+
+	if c.conn == nil {
+		if err := c.dial(); err != nil {
+			return nil, err
+		}
+		dialed = true
+	}
+
+	if err := c.writeCmd(cmd); err != nil {
+		if dialed {
+			c.conn = nil
+			return nil, err
+		}
+
+		if err := c.dial(); err != nil {
+			return nil, err
+		}
+
+		if err := c.writeCmd(cmd); err != nil {
+			return nil, err
+		}
+	}
+
+	return c.conn, nil
+}
+
+func (c *client) recvJSON(
+	item any,
+	conn net.Conn,
+	timeout time.Duration,
+) error {
+
+	if cap(c.buf) < 2 {
+		c.buf = make([]byte, 0, 1024)
+	}
+	buf := c.buf[:2]
+
+	conn.SetReadDeadline(time.Now().Add(timeout))
+
+	if _, err := io.ReadFull(conn, buf); err != nil {
+		return errs.IO.WithErr(err)
+	}
+
+	size := binary.LittleEndian.Uint16(buf)
+
+	if cap(buf) < int(size) {
+		buf = make([]byte, size)
+		c.buf = buf
+	}
+	buf = buf[:size]
+
+	if _, err := io.ReadFull(conn, buf); err != nil {
+		return errs.IO.WithErr(err)
+	}
+
+	if err := json.Unmarshal(buf, item); err != nil {
+		return errs.Unexpected.WithErr(err)
+	}
+
+	return nil
+}

lib/rep/http-handler-util.go

@@ -1,54 +0,0 @@
-package rep
-
-import (
-	"crypto/subtle"
-	"io"
-	"log"
-	"net"
-	"net/http"
-	"time"
-
-	"git.crumpington.com/public/jldb/lib/httpconn"
-)
-
-func (rep *Replicator) handlerLogf(pattern string, args ...any) {
-	log.Printf("[HTTP-HANDLER] "+pattern, args...)
-}
-
-// checkBasicAuth tests whether the caller has provided the appropriate basic auth
-// header. The caller should provide the PSK as the basic-auth password.
-func (rep *Replicator) checkBasicAuth(w http.ResponseWriter, r *http.Request) bool {
-	_, pwd, _ := r.BasicAuth()
-	if subtle.ConstantTimeCompare([]byte(pwd), rep.pskBytes[:]) != 1 {
-		rep.handlerLogf("PSK mismatch.")
-		http.Error(w, "not authorized", http.StatusUnauthorized)
-		return false
-	}
-	return true
-}
-
-// acceptConnect accepts a CONNECT request and checks the PSK.
-func (rep *Replicator) acceptConnect(w http.ResponseWriter, r *http.Request) net.Conn {
-	conn, err := httpconn.Accept(w, r)
-	if err != nil {
-		rep.handlerLogf("Failed to accept connection: %s", err)
-		return nil
-	}
-
-	psk := [64]byte{}
-
-	conn.SetReadDeadline(time.Now().Add(rep.conf.NetTimeout))
-	if _, err := io.ReadFull(conn, psk[:]); err != nil {
-		conn.Close()
-		rep.handlerLogf("Failed to read PSK: %v", err)
-		return nil
-	}
-
-	if subtle.ConstantTimeCompare(psk[:], rep.pskBytes[:]) != 1 {
-		conn.Close()
-		rep.handlerLogf("PSK mismatch.")
-		return nil
-	}
-
-	return conn
-}

lib/rep/http-handler.go

@@ -1,69 +1,79 @@
 package rep
 
 import (
-	"encoding/json"
+	"crypto/subtle"
+	"git.crumpington.com/public/jldb/lib/httpconn"
+	"log"
 	"net/http"
-	"path"
+	"time"
 )
 
 const (
-	pathGetInfo   = "get-info"
-	pathSendState = "send-state"
-	pathStreamWAL = "stream-wal"
+	cmdGetInfo   = 10
+	cmdSendState = 20
+	cmdStreamWAL = 30
 )
 
+// ---------------------------------------------------------------------------
+
 func (rep *Replicator) Handle(w http.ResponseWriter, r *http.Request) {
-	// We'll handle two types of requests: HTTP GET requests for JSON, or
-	// streaming requets for state or wall.
-
-	base := path.Base(r.URL.Path)
-	switch base {
-	case pathGetInfo:
-		rep.handleGetInfo(w, r)
-	case pathSendState:
-		rep.handleSendState(w, r)
-	case pathStreamWAL:
-		rep.handleStreamWAL(w, r)
-	default:
-		http.Error(w, "not found", http.StatusNotFound)
-	}
-}
-
-func (rep *Replicator) handleGetInfo(w http.ResponseWriter, r *http.Request) {
-	if !rep.checkBasicAuth(w, r) {
-		return
+	logf := func(pattern string, args ...any) {
+		log.Printf("[HTTP-HANDLER] "+pattern, args...)
 	}
 
-	w.Header().Set("Content-Type", "application/json")
-
-	if err := json.NewEncoder(w).Encode(rep.Info()); err != nil {
-		rep.handlerLogf("Failed to send info: %s", err)
-	}
-}
-
-func (rep *Replicator) handleSendState(w http.ResponseWriter, r *http.Request) {
-	conn := rep.acceptConnect(w, r)
-	if conn == nil {
+	conn, err := httpconn.Accept(w, r)
+	if err != nil {
+		logf("Failed to accept connection: %s", err)
 		return
 	}
 	defer conn.Close()
 
-	if err := rep.sendState(conn); err != nil {
-		if !rep.stopped() {
-			rep.handlerLogf("Failed to send state: %s", err)
+	psk := make([]byte, 256)
+
+	conn.SetReadDeadline(time.Now().Add(rep.conf.NetTimeout))
+	if _, err := conn.Read(psk); err != nil {
+		logf("Failed to read PSK: %v", err)
+		return
+	}
+
+	expected := rep.pskBytes
+	if subtle.ConstantTimeCompare(expected, psk) != 1 {
+		logf("PSK mismatch.")
+		return
+	}
+
+	cmd := make([]byte, 1)
+
+	for {
+		conn.SetReadDeadline(time.Now().Add(rep.conf.NetTimeout))
+		if _, err := conn.Read(cmd); err != nil {
+			logf("Read failed: %v", err)
+			return
+		}
+
+		switch cmd[0] {
+
+		case cmdGetInfo:
+			if err := sendJSON(rep.Info(), conn, rep.conf.NetTimeout); err != nil {
+				logf("Failed to send info: %s", err)
+				return
+			}
+
+		case cmdSendState:
+
+			if err := rep.sendState(conn); err != nil {
+				if !rep.stopped() {
+					logf("Failed to send state: %s", err)
+				}
+				return
+			}
+
+		case cmdStreamWAL:
+			err := rep.wal.Send(conn, rep.conf.NetTimeout)
+			if !rep.stopped() {
+				logf("Failed when sending WAL: %s", err)
+			}
+			return
 		}
 	}
 }
-
-func (rep *Replicator) handleStreamWAL(w http.ResponseWriter, r *http.Request) {
-	conn := rep.acceptConnect(w, r)
-	if conn == nil {
-		return
-	}
-	defer conn.Close()
-
-	err := rep.wal.Send(conn, rep.conf.NetTimeout)
-	if !rep.stopped() {
-		rep.handlerLogf("Failed when streaming WAL: %s", err)
-	}
-}

lib/rep/paths.go

@@ -1,17 +0,0 @@
-package rep
-
-import (
-	"path/filepath"
-)
-
-func lockFilePath(rootDir string) string {
-	return filepath.Join(rootDir, "lock")
-}
-
-func walRootDir(rootDir string) string {
-	return filepath.Join(rootDir, "wal")
-}
-
-func stateFilePath(rootDir string) string {
-	return filepath.Join(rootDir, "state")
-}

lib/rep/pools.go

@@ -0,0 +1,21 @@
+package rep
+
+import (
+	"bytes"
+	"sync"
+)
+
+var bufPool = sync.Pool{
+	New: func() any {
+		return &bytes.Buffer{}
+	},
+}
+
+func bufPoolGet() *bytes.Buffer {
+	return bufPool.Get().(*bytes.Buffer)
+}
+
+func bufPoolPut(b *bytes.Buffer) {
+	b.Reset()
+	bufPool.Put(b)
+}

lib/rep/psk.go

@@ -1,16 +0,0 @@
-package rep
-
-import (
-	"crypto/sha256"
-	"encoding/hex"
-)
-
-func pskToBytes(in string) [64]byte {
-	b := sha256.Sum256([]byte(in))
-	dst := [64]byte{}
-	i := hex.Encode(dst[:], b[:])
-	if i != 64 {
-		panic(i)
-	}
-	return dst
-}

lib/rep/rep-sendrecv.go

@@ -2,10 +2,9 @@ package rep
 
 import (
 	"io"
+	"git.crumpington.com/public/jldb/lib/errs"
 	"net"
 	"time"
-
-	"git.crumpington.com/public/jldb/lib/errs"
 )
 
 func (rep *Replicator) sendState(conn net.Conn) error {

lib/rep/replicator-open.go

@@ -1,13 +1,12 @@
 package rep
 
 import (
-	"os"
-	"time"
-
 	"git.crumpington.com/public/jldb/lib/atomicheader"
 	"git.crumpington.com/public/jldb/lib/errs"
 	"git.crumpington.com/public/jldb/lib/flock"
 	"git.crumpington.com/public/jldb/lib/wal"
+	"os"
+	"time"
 )
 
 func (rep *Replicator) loadConfigDefaults() {
@@ -27,7 +26,9 @@ func (rep *Replicator) loadConfigDefaults() {
 	}
 
 	rep.conf = conf
-	rep.pskBytes = pskToBytes(conf.ReplicationPSK)
+
+	rep.pskBytes = make([]byte, 256)
+	copy(rep.pskBytes, []byte(conf.ReplicationPSK))
 }
 
 func (rep *Replicator) initDirectories() error {

lib/rep/replicator-walrecvr.go

@@ -30,8 +30,9 @@ func (rep *Replicator) runWALRecvrOnce() {
 		log.Printf("[WAL-RECVR] "+pattern, args...)
 	}
 
-	err := rep.client.StreamWAL(rep.wal)
-	if !rep.stopped() {
-		logf("Recv failed: %v", err)
+	if err := rep.client.StreamWAL(rep.wal); err != nil {
+		if !rep.stopped() {
+			logf("Recv failed: %v", err)
+		}
 	}
 }

lib/rep/replicator.go

@@ -2,15 +2,14 @@ package rep
 
 import (
 	"io"
+	"git.crumpington.com/public/jldb/lib/atomicheader"
+	"git.crumpington.com/public/jldb/lib/errs"
+	"git.crumpington.com/public/jldb/lib/wal"
 	"net"
 	"os"
 	"sync"
 	"sync/atomic"
 	"time"
-
-	"git.crumpington.com/public/jldb/lib/atomicheader"
-	"git.crumpington.com/public/jldb/lib/errs"
-	"git.crumpington.com/public/jldb/lib/wal"
 )
 
 type Config struct {
@@ -60,9 +59,8 @@ type Replicator struct {
 	conf Config
 
 	lockFile *os.File
-	pskBytes [64]byte // 64 ascii characters. See pskToBytes.
-
-	wal *wal.WAL
+	pskBytes []byte
+	wal      *wal.WAL
 
 	appendNotify chan struct{}
 
@@ -163,6 +161,10 @@ func (rep *Replicator) Primary() bool {
 	return rep.conf.Primary
 }
 
+// TODO: Probably remove this.
+// The caller may call Ack after Apply to acknowledge that the change has also
+// been applied to the caller's application. Alternatively, the caller may use
+// follow to apply changes to their application state.
 func (rep *Replicator) ack(seqNum, timestampMS int64) error {
 	state := rep.getState()
 	state.SeqNum = seqNum

lib/rep/testapp_test.go

@@ -5,14 +5,12 @@ import (
 	"encoding/binary"
 	"encoding/json"
 	"io"
+	"git.crumpington.com/public/jldb/lib/wal"
 	"math/rand"
 	"net"
 	"sync"
 	"testing"
 	"time"
-
-	"git.crumpington.com/public/jldb/lib/errs"
-	"git.crumpington.com/public/jldb/lib/wal"
 )
 
 // ----------------------------------------------------------------------------
@@ -84,7 +82,7 @@ func newApp(t *testing.T, id int64, conf Config) *TestApp {
 		Apply:           a.apply,
 	}, conf)
 	if err != nil {
-		t.Fatal(errs.FmtDetails(err))
+		t.Fatal(err)
 	}
 
 	return a

lib/wal/corrupt_test.go

@@ -2,9 +2,8 @@ package wal
 
 import (
 	"io"
-	"testing"
-
 	"git.crumpington.com/public/jldb/lib/errs"
+	"testing"
 )
 
 func TestCorruptWAL(t *testing.T) {

lib/wal/generic_test.go

@@ -5,14 +5,13 @@ import (
 	"encoding/binary"
 	"errors"
 	"io"
+	"git.crumpington.com/public/jldb/lib/errs"
 	"math/rand"
 	"path/filepath"
 	"reflect"
 	"strings"
 	"testing"
 	"time"
-
-	"git.crumpington.com/public/jldb/lib/errs"
 )
 
 type waLog interface {

lib/wal/io.go

@@ -5,7 +5,6 @@ import (
 	"errors"
 	"hash/crc32"
 	"io"
-
 	"git.crumpington.com/public/jldb/lib/errs"
 )
 

lib/wal/record.go

@@ -4,7 +4,6 @@ import (
 	"encoding/binary"
 	"hash/crc32"
 	"io"
-
 	"git.crumpington.com/public/jldb/lib/errs"
 )
 

lib/wal/record_test.go

@@ -3,11 +3,10 @@ package wal
 import (
 	"bytes"
 	"io"
-	"math/rand"
-	"testing"
-
 	"git.crumpington.com/public/jldb/lib/errs"
 	"git.crumpington.com/public/jldb/lib/testutil"
+	"math/rand"
+	"testing"
 )
 
 func NewRecordForTesting() Record {

lib/wal/segment-iterator.go

@@ -1,11 +1,10 @@
 package wal
 
 import (
-	"os"
-	"time"
-
 	"git.crumpington.com/public/jldb/lib/atomicheader"
 	"git.crumpington.com/public/jldb/lib/errs"
+	"os"
+	"time"
 )
 
 type segmentIterator struct {

lib/wal/segment.go

@@ -3,12 +3,11 @@ package wal
 import (
 	"bufio"
 	"io"
+	"git.crumpington.com/public/jldb/lib/atomicheader"
+	"git.crumpington.com/public/jldb/lib/errs"
 	"os"
 	"sync"
 	"time"
-
-	"git.crumpington.com/public/jldb/lib/atomicheader"
-	"git.crumpington.com/public/jldb/lib/errs"
 )
 
 type segment struct {

lib/wal/segment_test.go

@@ -4,12 +4,11 @@ import (
 	"bytes"
 	crand "crypto/rand"
 	"io"
+	"git.crumpington.com/public/jldb/lib/atomicheader"
+	"git.crumpington.com/public/jldb/lib/errs"
 	"path/filepath"
 	"testing"
 	"time"
-
-	"git.crumpington.com/public/jldb/lib/atomicheader"
-	"git.crumpington.com/public/jldb/lib/errs"
 )
 
 func newSegmentForTesting(t *testing.T) *segment {

lib/wal/wal-iterator.go

@@ -1,9 +1,8 @@
 package wal
 
 import (
-	"time"
-
 	"git.crumpington.com/public/jldb/lib/errs"
+	"time"
 )
 
 type walIterator struct {

lib/wal/wal-recv.go

@@ -3,10 +3,9 @@ package wal
 import (
 	"encoding/binary"
 	"io"
+	"git.crumpington.com/public/jldb/lib/errs"
 	"net"
 	"time"
-
-	"git.crumpington.com/public/jldb/lib/errs"
 )
 
 func (wal *WAL) Recv(conn net.Conn, timeout time.Duration) error {

lib/wal/wal-send.go

@@ -2,10 +2,9 @@ package wal
 
 import (
 	"encoding/binary"
+	"git.crumpington.com/public/jldb/lib/errs"
 	"net"
 	"time"
-
-	"git.crumpington.com/public/jldb/lib/errs"
 )
 
 const (

lib/wal/wal-sendrecv_test.go

@@ -1,6 +1,8 @@
 package wal
 
 import (
+	"git.crumpington.com/public/jldb/lib/errs"
+	"git.crumpington.com/public/jldb/lib/testutil"
 	"log"
 	"math/rand"
 	"reflect"
@@ -9,9 +11,6 @@ import (
 	"sync/atomic"
 	"testing"
 	"time"
-
-	"git.crumpington.com/public/jldb/lib/errs"
-	"git.crumpington.com/public/jldb/lib/testutil"
 )
 
 func TestSendRecvHarness(t *testing.T) {

lib/wal/wal.go

@@ -2,14 +2,13 @@ package wal
 
 import (
 	"io"
+	"git.crumpington.com/public/jldb/lib/atomicheader"
+	"git.crumpington.com/public/jldb/lib/errs"
 	"os"
 	"path/filepath"
 	"strconv"
 	"sync"
 	"time"
-
-	"git.crumpington.com/public/jldb/lib/atomicheader"
-	"git.crumpington.com/public/jldb/lib/errs"
 )
 
 type Config struct {

mdb/change/binary.go

@@ -3,7 +3,6 @@ package change
 import (
 	"encoding/binary"
 	"io"
-
 	"git.crumpington.com/public/jldb/lib/errs"
 )
 

mdb/change/change.go

@@ -2,7 +2,6 @@ package change
 
 import (
 	"io"
-
 	"git.crumpington.com/public/jldb/lib/errs"
 )
 

mdb/collection.go

@@ -5,9 +5,8 @@ import (
 	"encoding/json"
 	"errors"
 	"hash/crc64"
-	"unsafe"
-
 	"git.crumpington.com/public/jldb/lib/errs"
+	"unsafe"
 
 	"github.com/google/btree"
 )
@@ -190,7 +189,7 @@ func (c Collection[T]) Insert(tx *Snapshot, userItem *T) error {
 
 	for i := range c.uniqueIndices {
 		if c.uniqueIndices[i].insertConflict(tx, item) {
-			return errs.Duplicate.WithCollection(c.name).WithIndex(c.uniqueIndices[i].name)
+			return ErrDuplicate.WithCollection(c.name).WithIndex(c.uniqueIndices[i].name)
 		}
 	}
 
@@ -217,12 +216,12 @@ func (c Collection[T]) Update(tx *Snapshot, userItem *T) error {
 
 	old, ok := c.ByID.get(tx, item)
 	if !ok {
-		return errs.NotFound
+		return ErrNotFound
 	}
 
 	for i := range c.uniqueIndices {
 		if c.uniqueIndices[i].updateConflict(tx, item) {
-			return errs.Duplicate.WithCollection(c.name).WithIndex(c.uniqueIndices[i].name)
+			return ErrDuplicate.WithCollection(c.name).WithIndex(c.uniqueIndices[i].name)
 		}
 	}
 
@@ -240,7 +239,7 @@ func (c Collection[T]) Upsert(tx *Snapshot, item *T) error {
 	if err == nil {
 		return nil
 	}
-	if errors.Is(err, errs.Duplicate) {
+	if errors.Is(err, ErrDuplicate) {
 		return c.Update(tx, item)
 	}
 	return err
@@ -262,7 +261,7 @@ func (c Collection[T]) getByID(tx *Snapshot, itemID uint64) (*T, bool) {
 
 func (c Collection[T]) ensureMutable(tx *Snapshot) error {
 	if !tx.writable() {
-		return errs.ReadOnly
+		return ErrReadOnly
 	}
 
 	state := c.getState(tx)
@@ -283,7 +282,7 @@ func (c Collection[T]) insertItem(tx *Snapshot, itemID uint64, data []byte) erro
 	// Check for insert conflict.
 	for _, index := range c.uniqueIndices {
 		if index.insertConflict(tx, item) {
-			return errs.Duplicate
+			return ErrDuplicate
 		}
 	}
 
@@ -298,7 +297,7 @@ func (c Collection[T]) insertItem(tx *Snapshot, itemID uint64, data []byte) erro
 func (c Collection[T]) deleteItem(tx *Snapshot, itemID uint64) error {
 	item, ok := c.getByID(tx, itemID)
 	if !ok {
-		return errs.NotFound
+		return ErrNotFound
 	}
 
 	tx.delete(c.collectionID, itemID)

mdb/crashconsistency_test.go

@@ -1,13 +1,12 @@
 package mdb
 
 import (
+	"git.crumpington.com/public/jldb/lib/errs"
 	"log"
 	"os"
 	"os/exec"
 	"testing"
 	"time"
-
-	"git.crumpington.com/public/jldb/lib/errs"
 )
 
 func TestCrashConsistency(t *testing.T) {

mdb/db-primary.go

@@ -0,0 +1,67 @@
+package mdb
+
+/*
+func (db *Database) openPrimary() (err error) {
+	wal, err := cwal.Open(db.walRootDir, cwal.Config{
+		SegMinCount:  db.conf.WALSegMinCount,
+		SegMaxAgeSec: db.conf.WALSegMaxAgeSec,
+	})
+
+	pFile, err := pfile.Open(db.pageFilePath,
+
+	pFile, err := openPageFileAndReplayWAL(db.rootDir)
+	if err != nil {
+		return err
+	}
+	defer pFile.Close()
+
+	pfHeader, err := pFile.ReadHeader()
+	if err != nil {
+		return err
+	}
+
+	tx := db.Snapshot()
+	tx.seqNum = pfHeader.SeqNum
+	tx.updatedAt = pfHeader.UpdatedAt
+
+	pIndex, err := pagefile.NewIndex(pFile)
+	if err != nil {
+		return err
+	}
+
+	err = pFile.IterateAllocated(pIndex, func(cID, iID uint64, data []byte) error {
+		return db.loadItem(tx, cID, iID, data)
+	})
+	if err != nil {
+		return err
+	}
+
+	w, err := cwal.OpenWriter(db.walRootDir, &cwal.WriterConfig{
+		SegMinCount:  db.conf.WALSegMinCount,
+		SegMaxAgeSec: db.conf.WALSegMaxAgeSec,
+	})
+	if err != nil {
+		return err
+	}
+
+	db.done.Add(1)
+	go txAggregator{
+		Stop:     db.stop,
+		Done:     db.done,
+		ModChan:  db.modChan,
+		W:        w,
+		Index:    pIndex,
+		Snapshot: db.snapshot,
+	}.Run()
+
+	db.done.Add(1)
+	go (&fileWriter{
+		Stop:         db.stop,
+		Done:         db.done,
+		PageFilePath: db.pageFilePath,
+		WALRootDir:   db.walRootDir,
+	}).Run()
+
+	return nil
+}
+*/

mdb/db-rep.go

@@ -1,14 +1,13 @@
 package mdb
 
 import (
-	"log"
-	"net"
-	"os"
-
 	"git.crumpington.com/public/jldb/lib/errs"
 	"git.crumpington.com/public/jldb/lib/wal"
 	"git.crumpington.com/public/jldb/mdb/change"
 	"git.crumpington.com/public/jldb/mdb/pfile"
+	"log"
+	"net"
+	"os"
 )
 
 func (db *Database) repSendState(conn net.Conn) error {

mdb/db-secondary.go

@@ -0,0 +1,129 @@
+package mdb
+
+/*
+func (db *Database) openSecondary() (err error) {
+	if db.shouldLoadFromPrimary() {
+		if err := db.loadFromPrimary(); err != nil {
+			return err
+		}
+	}
+
+	log.Printf("Opening page-file...")
+
+	pFile, err := openPageFileAndReplayWAL(db.rootDir)
+	if err != nil {
+		return err
+	}
+	defer pFile.Close()
+
+	pfHeader, err := pFile.ReadHeader()
+	if err != nil {
+		return err
+	}
+
+	log.Printf("Building page-file index...")
+
+	pIndex, err := pagefile.NewIndex(pFile)
+	if err != nil {
+		return err
+	}
+
+	tx := db.Snapshot()
+	tx.seqNum = pfHeader.SeqNum
+	tx.updatedAt = pfHeader.UpdatedAt
+
+	log.Printf("Loading data into memory...")
+
+	err = pFile.IterateAllocated(pIndex, func(cID, iID uint64, data []byte) error {
+		return db.loadItem(tx, cID, iID, data)
+	})
+	if err != nil {
+		return err
+	}
+
+	log.Printf("Creating writer...")
+
+	w, err := cswal.OpenWriter(db.walRootDir, &cswal.WriterConfig{
+		SegMinCount:  db.conf.WALSegMinCount,
+		SegMaxAgeSec: db.conf.WALSegMaxAgeSec,
+	})
+	if err != nil {
+		return err
+	}
+
+	db.done.Add(1)
+	go (&walFollower{
+		Stop:   db.stop,
+		Done:   db.done,
+		W:      w,
+		Client: NewClient(db.conf.PrimaryURL, db.conf.ReplicationPSK, db.conf.NetTimeout),
+	}).Run()
+
+	db.done.Add(1)
+	go (&follower{
+		Stop:         db.stop,
+		Done:         db.done,
+		WALRootDir:   db.walRootDir,
+		SeqNum:       pfHeader.SeqNum,
+		ApplyChanges: db.applyChanges,
+	}).Run()
+
+	db.done.Add(1)
+	go (&fileWriter{
+		Stop:         db.stop,
+		Done:         db.done,
+		PageFilePath: db.pageFilePath,
+		WALRootDir:   db.walRootDir,
+	}).Run()
+
+	return nil
+}
+
+func (db *Database) shouldLoadFromPrimary() bool {
+	if _, err := os.Stat(db.walRootDir); os.IsNotExist(err) {
+		log.Printf("WAL doesn't exist.")
+		return true
+	}
+	if _, err := os.Stat(db.pageFilePath); os.IsNotExist(err) {
+		log.Printf("Page-file doesn't exist.")
+		return true
+	}
+	return false
+}
+
+func (db *Database) loadFromPrimary() error {
+	client := NewClient(db.conf.PrimaryURL, db.conf.ReplicationPSK, db.conf.NetTimeout)
+	defer client.Disconnect()
+
+	log.Printf("Loading data from primary...")
+
+	if err := os.RemoveAll(db.pageFilePath); err != nil {
+		log.Printf("Failed to remove page-file: %s", err)
+		return errs.IO.WithErr(err) // Caller can retry.
+	}
+
+	if err := os.RemoveAll(db.walRootDir); err != nil {
+		log.Printf("Failed to remove WAL: %s", err)
+		return errs.IO.WithErr(err) // Caller can retry.
+	}
+
+	err := client.DownloadPageFile(db.pageFilePath+".tmp", db.pageFilePath)
+	if err != nil {
+		log.Printf("Failed to get page-file from primary: %s", err)
+		return err // Caller can retry.
+	}
+
+	pfHeader, err := pagefile.ReadHeader(db.pageFilePath)
+	if err != nil {
+		log.Printf("Failed to read page-file sequence number: %s", err)
+		return err // Caller can retry.
+	}
+
+	if err = cswal.CreateEx(db.walRootDir, pfHeader.SeqNum+1); err != nil {
+		log.Printf("Failed to initialize WAL: %s", err)
+		return err // Caller can retry.
+	}
+
+	return nil
+}
+*/

mdb/db-testcases_test.go

@@ -6,8 +6,6 @@ import (
 	"reflect"
 	"strings"
 	"testing"
-
-	"git.crumpington.com/public/jldb/lib/errs"
 )
 
 type DBTestCase struct {
@@ -56,7 +54,7 @@ var testDBTestCases = []DBTestCase{{
 		Update: func(t *testing.T, db TestDB, tx *Snapshot) error {
 			user, ok := db.Users.ByID.Get(tx, &User{ID: 1})
 			if !ok {
-				return errs.NotFound
+				return ErrNotFound
 			}
 			user.Name = "Bob"
 			user.Email = "b@c.com"
@@ -113,7 +111,7 @@ var testDBTestCases = []DBTestCase{{
 			return db.Users.Insert(tx, user2)
 		},
 
-		ExpectedUpdateError: errs.Duplicate,
+		ExpectedUpdateError: ErrDuplicate,
 
 		State: DBState{},
 	}},
@@ -133,7 +131,7 @@ var testDBTestCases = []DBTestCase{{
 			return db.Users.Insert(tx, user2)
 		},
 
-		ExpectedUpdateError: errs.Duplicate,
+		ExpectedUpdateError: ErrDuplicate,
 
 		State: DBState{},
 	}},
@@ -164,7 +162,7 @@ var testDBTestCases = []DBTestCase{{
 			return db.Users.Insert(tx, user)
 		},
 
-		ExpectedUpdateError: errs.Duplicate,
+		ExpectedUpdateError: ErrDuplicate,
 
 		State: DBState{
 			UsersByID:    []User{{ID: 1, Name: "Alice", Email: "a@b.com"}},
@@ -199,7 +197,7 @@ var testDBTestCases = []DBTestCase{{
 			return db.Users.Insert(tx, user)
 		},
 
-		ExpectedUpdateError: errs.Duplicate,
+		ExpectedUpdateError: ErrDuplicate,
 
 		State: DBState{
 			UsersByID:    []User{{ID: 1, Name: "Alice", Email: "a@b.com"}},
@@ -220,7 +218,7 @@ var testDBTestCases = []DBTestCase{{
 			return db.Users.Insert(db.Snapshot(), user)
 		},
 
-		ExpectedUpdateError: errs.ReadOnly,
+		ExpectedUpdateError: ErrReadOnly,
 	}},
 }, {
 
@@ -292,7 +290,7 @@ var testDBTestCases = []DBTestCase{{
 			return db.Users.Update(tx, user)
 		},
 
-		ExpectedUpdateError: errs.NotFound,
+		ExpectedUpdateError: ErrNotFound,
 
 		State: DBState{
 			UsersByID:    []User{{ID: 5, Name: "Alice", Email: "a@b.com"}},
@@ -325,14 +323,14 @@ var testDBTestCases = []DBTestCase{{
 		Update: func(t *testing.T, db TestDB, tx *Snapshot) error {
 			user, ok := db.Users.ByID.Get(tx, &User{ID: 1})
 			if !ok {
-				return errs.NotFound
+				return ErrNotFound
 			}
 			user.Name = "Bob"
 			user.Email = "b@c.com"
 			return db.Users.Update(db.Snapshot(), user)
 		},
 
-		ExpectedUpdateError: errs.ReadOnly,
+		ExpectedUpdateError: ErrReadOnly,
 
 		State: DBState{
 			UsersByID:    []User{{ID: 1, Name: "Alice", Email: "a@b.com"}},
@@ -453,7 +451,7 @@ var testDBTestCases = []DBTestCase{{
 			return db.Users.Update(tx, user2)
 		},
 
-		ExpectedUpdateError: errs.Duplicate,
+		ExpectedUpdateError: ErrDuplicate,
 
 		State: DBState{},
 	}},
@@ -495,14 +493,14 @@ var testDBTestCases = []DBTestCase{{
 		Update: func(t *testing.T, db TestDB, tx *Snapshot) error {
 			u, ok := db.Users.ByID.Get(tx, &User{ID: 2})
 			if !ok {
-				return errs.NotFound
+				return ErrNotFound
 			}
 
 			u.Email = "a@b.com"
 			return db.Users.Update(tx, u)
 		},
 
-		ExpectedUpdateError: errs.Duplicate,
+		ExpectedUpdateError: ErrDuplicate,
 
 		State: DBState{
 			UsersByID: []User{
@@ -544,7 +542,7 @@ var testDBTestCases = []DBTestCase{{
 			return db.Users.Delete(db.Snapshot(), 1)
 		},
 
-		ExpectedUpdateError: errs.ReadOnly,
+		ExpectedUpdateError: ErrReadOnly,
 
 		State: DBState{
 			UsersByID:    []User{{ID: 1, Name: "Alice", Email: "a@b.com"}},
@@ -577,7 +575,7 @@ var testDBTestCases = []DBTestCase{{
 			return db.Users.Delete(tx, 2)
 		},
 
-		ExpectedUpdateError: errs.NotFound,
+		ExpectedUpdateError: ErrNotFound,
 
 		State: DBState{
 			UsersByID:    []User{{ID: 1, Name: "Alice", Email: "a@b.com"}},
@@ -611,7 +609,7 @@ var testDBTestCases = []DBTestCase{{
 
 			u, ok := db.Users.ByID.Get(tx, &User{ID: 1})
 			if !ok {
-				return errs.NotFound
+				return ErrNotFound
 			}
 			if !reflect.DeepEqual(u, expected) {
 				return errors.New("Not equal (id)")
@@ -619,7 +617,7 @@ var testDBTestCases = []DBTestCase{{
 
 			u, ok = db.Users.ByEmail.Get(tx, &User{Email: "a@b.com"})
 			if !ok {
-				return errs.NotFound
+				return ErrNotFound
 			}
 			if !reflect.DeepEqual(u, expected) {
 				return errors.New("Not equal (email)")

mdb/db-txaggregator.go

@@ -2,7 +2,6 @@ package mdb
 
 import (
 	"bytes"
-
 	"git.crumpington.com/public/jldb/mdb/change"
 )
 

mdb/db.go

@@ -2,16 +2,15 @@ package mdb
 
 import (
 	"fmt"
+	"git.crumpington.com/public/jldb/lib/errs"
+	"git.crumpington.com/public/jldb/lib/rep"
+	"git.crumpington.com/public/jldb/mdb/change"
+	"git.crumpington.com/public/jldb/mdb/pfile"
 	"net/http"
 	"os"
 	"sync"
 	"sync/atomic"
 	"time"
-
-	"git.crumpington.com/public/jldb/lib/errs"
-	"git.crumpington.com/public/jldb/lib/rep"
-	"git.crumpington.com/public/jldb/mdb/change"
-	"git.crumpington.com/public/jldb/mdb/pfile"
 )
 
 type Config struct {

mdb/errors.go

@@ -0,0 +1,11 @@
+package mdb
+
+import (
+	"git.crumpington.com/public/jldb/lib/errs"
+)
+
+var (
+	ErrNotFound  = errs.NotFound
+	ErrReadOnly  = errs.ReadOnly
+	ErrDuplicate = errs.Duplicate
+)

mdb/pfile/change_test.go

@@ -2,9 +2,8 @@ package pfile
 
 import (
 	crand "crypto/rand"
-	"math/rand"
-
 	"git.crumpington.com/public/jldb/mdb/change"
+	"math/rand"
 )
 
 func randomChangeList() (changes []change.Change) {

mdb/pfile/main_test.go

@@ -3,11 +3,10 @@ package pfile
 import (
 	"bytes"
 	crand "crypto/rand"
-	"path/filepath"
-	"testing"
-
 	"git.crumpington.com/public/jldb/lib/wal"
 	"git.crumpington.com/public/jldb/mdb/change"
+	"path/filepath"
+	"testing"
 )
 
 func newForTesting(t *testing.T) (*File, *Index) {

mdb/pfile/page.go

@@ -2,9 +2,8 @@ package pfile
 
 import (
 	"hash/crc32"
-	"unsafe"
-
 	"git.crumpington.com/public/jldb/lib/errs"
+	"unsafe"
 )
 
 // ----------------------------------------------------------------------------
@@ -31,7 +30,7 @@ var emptyPage = func() dataPage {
 type pageHeader struct {
 	CRC          uint32 // IEEE CRC-32 checksum.
 	PageType     uint32 // One of the PageType* constants.
-	CollectionID uint64 //
+	CollectionID uint64  //
 	ItemID       uint64
 	DataSize     uint64
 	NextPage     uint64

mdb/pfile/page_test.go

@@ -3,10 +3,9 @@ package pfile
 import (
 	"bytes"
 	crand "crypto/rand"
+	"git.crumpington.com/public/jldb/lib/errs"
 	"math/rand"
 	"testing"
-
-	"git.crumpington.com/public/jldb/lib/errs"
 )
 
 func randomPage(t *testing.T) dataPage {

mdb/pfile/pagefile.go

@@ -6,13 +6,12 @@ import (
 	"compress/gzip"
 	"encoding/binary"
 	"io"
+	"git.crumpington.com/public/jldb/lib/errs"
+	"git.crumpington.com/public/jldb/mdb/change"
 	"net"
 	"os"
 	"sync"
 	"time"
-
-	"git.crumpington.com/public/jldb/lib/errs"
-	"git.crumpington.com/public/jldb/mdb/change"
 )
 
 type File struct {

mdb/pfile/record_test.go

@@ -2,7 +2,6 @@ package pfile
 
 import (
 	"bytes"
-
 	"git.crumpington.com/public/jldb/lib/wal"
 	"git.crumpington.com/public/jldb/mdb/change"
 )

mdb/snapshot.go

@@ -3,9 +3,8 @@ package mdb
 import (
 	"bytes"
 	"encoding/json"
-	"sync/atomic"
-
 	"git.crumpington.com/public/jldb/mdb/change"
+	"sync/atomic"
 )
 
 type Snapshot struct {

mdb/testing/crashconsistency/main.go

@@ -4,6 +4,7 @@ import (
 	"crypto/rand"
 	"errors"
 	"hash/crc32"
+	"git.crumpington.com/public/jldb/mdb"
 	"log"
 	mrand "math/rand"
 	"os"
@@ -12,8 +13,6 @@ import (
 	"sync"
 	"sync/atomic"
 	"time"
-
-	"git.crumpington.com/public/jldb/mdb"
 )
 
 type DataItem struct {