8 |
26 | {{end}}
27 |
--------------------------------------------------------------------------------
/pkg/rangedbui/templates/aggregate-types.gohtml:
--------------------------------------------------------------------------------
1 | {{- /*gotype: github.com/inklabs/rangedb/pkg/rangedbui.aggregateTypesTemplateVars*/ -}}
2 |
3 | {{template "base" .}}
4 | {{define "pageTitle" }}Aggregate Types{{end}}
5 |
6 | {{define "content"}}
7 |
9 |
25 |
10 |
21 | {{template "records" .Records}}
22 | {{template "pagination" .PaginationLinks}}
23 |
24 |
8 |
41 | {{end}}
42 |
--------------------------------------------------------------------------------
/pkg/rangedbui/templates/layout/base.gohtml:
--------------------------------------------------------------------------------
1 | {{define "base"}}
2 |
3 |
4 |
5 |
6 |
7 |
9 |
40 |
10 |
20 |
21 |
22 |
36 |
39 | | Type | 24 |Total Events | 25 |
|---|---|
| {{.Name}} | 31 |{{.TotalEvents | formatUint64}} | 32 |
-
37 |
17 |
31 |
32 |
18 |
25 |
30 |
19 |
20 | 
21 | RangeDB
22 |
23 |
24 |
21 | RangeDB
22 |
23 |
33 | {{block "content" .}}{{end}}
34 |
35 |
36 |
47 |
48 | {{block "extraEndBody" .}}{{end}}
49 |
50 |
51 |
52 | {{end}}
53 |
--------------------------------------------------------------------------------
/pkg/rangedbui/templates/layout/pagination.gohtml:
--------------------------------------------------------------------------------
1 | {{- /*gotype: github.com/inklabs/rangedb/pkg/paging.Links*/ -}}
2 |
3 | {{define "pagination"}}
4 |
18 | {{end}}
19 |
--------------------------------------------------------------------------------
/pkg/rangedbui/templates/layout/records.gohtml:
--------------------------------------------------------------------------------
1 | {{define "records"}}
2 | | GSN | 6 |SSN | 7 |Event Type | 8 |Aggregate Type | 9 |Stream | 10 |Insert Date | 11 |Data | 12 |
|---|---|---|---|---|---|---|
| {{.GlobalSequenceNumber}} | 20 |{{.StreamSequenceNumber}} | 21 |{{.EventType}} | 22 |{{.AggregateType}} | 23 |{{.StreamName}} | 24 |{{formatDate .InsertTimestamp "Jan 02, 2006 15:04:05 UTC"}} | 25 |{{formatJson .Data}} | 26 |
8 |
22 | {{end}}
23 |
--------------------------------------------------------------------------------
/pkg/rangedbws/helper_test.go:
--------------------------------------------------------------------------------
1 | package rangedbws_test
2 |
3 | import (
4 | "fmt"
5 | "io"
6 | )
7 |
8 | func Close(c io.Closer) {
9 | err := c.Close()
10 | if err != nil {
11 | fmt.Printf("failed closing: %v", err)
12 | }
13 | }
14 |
15 | func PrintError(errors ...error) {
16 | for _, err := range errors {
17 | if err != nil {
18 | fmt.Println(err)
19 | }
20 | }
21 | }
22 |
23 | func IgnoreFirstNumber(_ uint64, err error) error {
24 | return err
25 | }
26 |
--------------------------------------------------------------------------------
/pkg/rangedbws/websocket_private_test.go:
--------------------------------------------------------------------------------
1 | package rangedbws
2 |
3 | import (
4 | "bytes"
5 | "fmt"
6 | "log"
7 | "math"
8 | "testing"
9 |
10 | "github.com/stretchr/testify/assert"
11 | "github.com/stretchr/testify/require"
12 |
13 | "github.com/inklabs/rangedb"
14 | "github.com/inklabs/rangedb/provider/inmemorystore"
15 | "github.com/inklabs/rangedb/rangedbtest"
16 | )
17 |
18 | func Test_Private_broadcastRecord(t *testing.T) {
19 | t.Run("when unable to marshal json", func(t *testing.T) {
20 | // Given
21 | var logBuffer bytes.Buffer
22 | logger := log.New(&logBuffer, "", 0)
23 | api, err := New(
24 | WithStore(inmemorystore.New()),
25 | WithLogger(logger),
26 | )
27 | require.NoError(t, err)
28 | t.Cleanup(api.Stop)
29 | record := &rangedb.Record{
30 | Data: math.Inf(1),
31 | }
32 |
33 | // When
34 | err = api.broadcastRecord(nil, record)
35 |
36 | // Then
37 | assert.EqualError(t, err, "unable to marshal record: json: unsupported value: +Inf")
38 | assert.Equal(t, "unable to marshal record: json: unsupported value: +Inf\n", logBuffer.String())
39 | })
40 |
41 | t.Run("when unable to send message to client", func(t *testing.T) {
42 | // Given
43 | var logBuffer bytes.Buffer
44 | logger := log.New(&logBuffer, "", 0)
45 | api, err := New(
46 | WithStore(inmemorystore.New()),
47 | WithLogger(logger),
48 | )
49 | require.NoError(t, err)
50 | t.Cleanup(api.Stop)
51 | record := rangedbtest.DummyRecord()
52 | failingMessageWriter := newFailingMessageWriter()
53 |
54 | // When
55 | err = api.broadcastRecord(failingMessageWriter, record)
56 |
57 | // Then
58 | assert.EqualError(t, err, "unable to send record to WebSocket client: failingMessageWriter.WriteMessage")
59 | assert.Equal(t, "unable to send record to WebSocket client: failingMessageWriter.WriteMessage\n", logBuffer.String())
60 | })
61 | }
62 |
63 | type failingMessageWriter struct{}
64 |
65 | func newFailingMessageWriter() *failingMessageWriter {
66 | return &failingMessageWriter{}
67 | }
68 |
69 | func (f failingMessageWriter) WriteMessage(_ int, _ []byte) error {
70 | return fmt.Errorf("failingMessageWriter.WriteMessage")
71 | }
72 |
--------------------------------------------------------------------------------
/pkg/recordsubscriber/config.go:
--------------------------------------------------------------------------------
1 | package recordsubscriber
2 |
3 | import (
4 | "context"
5 |
6 | "github.com/inklabs/rangedb"
7 | "github.com/inklabs/rangedb/pkg/broadcast"
8 | )
9 |
10 | // Config defines a record subscription configuration.
11 | type Config struct {
12 | BufferSize int
13 | GetRecords GetRecordsIteratorFunc
14 | ConsumeRecord ConsumeRecordFunc
15 | Subscribe SubscribeFunc
16 | Unsubscribe SubscribeFunc
17 | Ctx context.Context
18 | }
19 |
20 | // AllEventsConfig returns a configuration to subscribe to all events.
21 | func AllEventsConfig(ctx context.Context, store rangedb.Store, broadcaster broadcast.Broadcaster, bufferLength int, consumeRecord ConsumeRecordFunc) Config {
22 | return Config{
23 | BufferSize: bufferLength,
24 | Ctx: ctx,
25 | Subscribe: func(subscriber broadcast.RecordSubscriber) {
26 | broadcaster.SubscribeAllEvents(subscriber)
27 | },
28 | Unsubscribe: func(subscriber broadcast.RecordSubscriber) {
29 | broadcaster.UnsubscribeAllEvents(subscriber)
30 | },
31 | GetRecords: func(globalSequenceNumber uint64) rangedb.RecordIterator {
32 | return store.Events(ctx, globalSequenceNumber)
33 | },
34 | ConsumeRecord: consumeRecord,
35 | }
36 | }
37 |
38 | // AggregateTypesConfig returns a configuration to subscribe to events by aggregate types.
39 | func AggregateTypesConfig(ctx context.Context, store rangedb.Store, broadcaster broadcast.Broadcaster, bufferLength int, aggregateTypes []string, consumeRecord ConsumeRecordFunc) Config {
40 | return Config{
41 | BufferSize: bufferLength,
42 | Ctx: ctx,
43 | Subscribe: func(subscriber broadcast.RecordSubscriber) {
44 | broadcaster.SubscribeAggregateTypes(subscriber, aggregateTypes...)
45 | },
46 | Unsubscribe: func(subscriber broadcast.RecordSubscriber) {
47 | broadcaster.UnsubscribeAggregateTypes(subscriber, aggregateTypes...)
48 | },
49 | GetRecords: func(globalSequenceNumber uint64) rangedb.RecordIterator {
50 | return store.EventsByAggregateTypes(ctx, globalSequenceNumber, aggregateTypes...)
51 | },
52 | ConsumeRecord: consumeRecord,
53 | }
54 | }
55 |
--------------------------------------------------------------------------------
/pkg/recordsubscriber/config_test.go:
--------------------------------------------------------------------------------
1 | package recordsubscriber_test
2 |
3 | import (
4 | "context"
5 | "testing"
6 | "time"
7 |
8 | "github.com/stretchr/testify/assert"
9 |
10 | "github.com/inklabs/rangedb"
11 | "github.com/inklabs/rangedb/pkg/broadcast"
12 | "github.com/inklabs/rangedb/pkg/recordsubscriber"
13 | "github.com/inklabs/rangedb/provider/inmemorystore"
14 | )
15 |
16 | func TestConfig(t *testing.T) {
17 | // Given
18 | ctx := context.Background()
19 | store := inmemorystore.New()
20 | broadcaster := broadcast.New(1, time.Nanosecond)
21 | bufferLength := 1
22 | consumeRecord := func(record *rangedb.Record) error {
23 | return nil
24 | }
25 | var aggregateTypes []string
26 |
27 | // When
28 | allEventsConfig := recordsubscriber.AllEventsConfig(ctx, store, broadcaster, bufferLength, consumeRecord)
29 | aggregateTypesConfig := recordsubscriber.AggregateTypesConfig(ctx, store, broadcaster, bufferLength, aggregateTypes, consumeRecord)
30 |
31 | // Then
32 | assert.IsType(t, recordsubscriber.Config{}, allEventsConfig)
33 | assert.IsType(t, recordsubscriber.Config{}, aggregateTypesConfig)
34 | }
35 |
--------------------------------------------------------------------------------
/pkg/shortuuid/short_uuid.go:
--------------------------------------------------------------------------------
1 | package shortuuid
2 |
3 | import (
4 | "encoding/hex"
5 |
6 | "github.com/google/uuid"
7 | )
8 |
9 | // ShortUUID is a type that can stringify a UUID without hyphens.
10 | type ShortUUID uuid.UUID
11 |
12 | // New constructs a ShortUUID object.
13 | func New() ShortUUID {
14 | return ShortUUID(uuid.New())
15 | }
16 |
17 | func (u ShortUUID) String() string {
18 | buf := make([]byte, 32)
19 | hex.Encode(buf[:], u[:])
20 | return string(buf)
21 | }
22 |
23 | type Generator interface {
24 | // New returns a new ShortUUID string
25 | New() string
26 | }
27 |
28 | type uuidGenerator struct{}
29 |
30 | func NewUUIDGenerator() *uuidGenerator {
31 | return &uuidGenerator{}
32 | }
33 |
34 | func (g *uuidGenerator) New() string {
35 | return New().String()
36 | }
37 |
--------------------------------------------------------------------------------
/pkg/shortuuid/short_uuid_test.go:
--------------------------------------------------------------------------------
1 | package shortuuid_test
2 |
3 | import (
4 | "fmt"
5 | "testing"
6 |
7 | "github.com/inklabs/rangedb/rangedbtest"
8 | "github.com/stretchr/testify/assert"
9 |
10 | "github.com/inklabs/rangedb/pkg/shortuuid"
11 | )
12 |
13 | func Test_NewToString(t *testing.T) {
14 | // Given
15 | rangedbtest.SetRand(100)
16 | u := shortuuid.New()
17 |
18 | // When
19 | output := u.String()
20 |
21 | // Then
22 | assert.Equal(t, "d2ba8e70072943388203c438d4e94bf3", output)
23 | }
24 |
25 | func ExampleShortUUID_String() {
26 | // Given
27 | rangedbtest.SetRand(101)
28 | u := shortuuid.New()
29 |
30 | // When
31 | fmt.Println(u.String())
32 |
33 | // Output:
34 | // b03b2442c5de4e58b6c62e8094847f3d
35 | }
36 |
--------------------------------------------------------------------------------
/pkg/structparser/struct_names.go:
--------------------------------------------------------------------------------
1 | package structparser
2 |
3 | import (
4 | "fmt"
5 | "go/ast"
6 | "go/parser"
7 | "go/token"
8 | "io"
9 | )
10 |
11 | // GetStructNames loads struct names from an io.Reader.
12 | func GetStructNames(file io.Reader) ([]string, error) {
13 | node, err := parser.ParseFile(token.NewFileSet(), "", file, parser.ParseComments)
14 | if err != nil {
15 | return nil, fmt.Errorf("failed parsing: %v", err)
16 | }
17 |
18 | structVisitor := &structVisitor{}
19 | ast.Walk(structVisitor, node)
20 |
21 | return structVisitor.Names, nil
22 | }
23 |
24 | type structVisitor struct {
25 | Names []string
26 | }
27 |
28 | func (v *structVisitor) Visit(node ast.Node) (w ast.Visitor) {
29 | switch n := node.(type) {
30 | case *ast.TypeSpec:
31 | if _, ok := n.Type.(*ast.StructType); ok {
32 | v.Names = append(v.Names, n.Name.String())
33 | }
34 | }
35 |
36 | return v
37 | }
38 |
--------------------------------------------------------------------------------
/pkg/structparser/struct_names_test.go:
--------------------------------------------------------------------------------
1 | package structparser_test
2 |
3 | import (
4 | "strings"
5 | "testing"
6 |
7 | "github.com/stretchr/testify/assert"
8 | "github.com/stretchr/testify/require"
9 |
10 | "github.com/inklabs/rangedb/pkg/structparser"
11 | )
12 |
13 | func TestGetStructNames(t *testing.T) {
14 | t.Run("returns empty list", func(t *testing.T) {
15 | // Given
16 | code := `package test`
17 | content := strings.NewReader(code)
18 |
19 | // When
20 | structNames, err := structparser.GetStructNames(content)
21 |
22 | // Then
23 | require.NoError(t, err)
24 | assert.Equal(t, 0, len(structNames))
25 | })
26 |
27 | t.Run("returns one struct name with other keywords present", func(t *testing.T) {
28 | // Given
29 | code := `package test
30 | type Struct1 struct {}
31 | type Interface1 interface {}
32 | func Func1() {}`
33 | content := strings.NewReader(code)
34 |
35 | // When
36 | structNames, err := structparser.GetStructNames(content)
37 |
38 | // Then
39 | require.NoError(t, err)
40 | assert.Equal(t, 1, len(structNames))
41 | assert.Equal(t, []string{"Struct1"}, structNames)
42 | })
43 |
44 | t.Run("returns two struct names", func(t *testing.T) {
45 | // Given
46 | code := `package test
47 | type Struct1 struct {}
48 | type Struct2 struct{}`
49 | content := strings.NewReader(code)
50 |
51 | // When
52 | structNames, err := structparser.GetStructNames(content)
53 |
54 | // Then
55 | require.NoError(t, err)
56 | assert.Equal(t, []string{"Struct1", "Struct2"}, structNames)
57 | })
58 |
59 | t.Run("fails with empty reader", func(t *testing.T) {
60 | // Given
61 | emptyReader := strings.NewReader("")
62 |
63 | // When
64 | structNames, err := structparser.GetStructNames(emptyReader)
65 |
66 | // Then
67 | assert.Nil(t, structNames)
68 | assert.EqualError(t, err, "failed parsing: 1:1: expected 'package', found 'EOF'")
69 | })
70 | }
71 |
--------------------------------------------------------------------------------
/provider/encryptedstore/decrypting_record_iterator.go:
--------------------------------------------------------------------------------
1 | package encryptedstore
2 |
3 | import (
4 | "context"
5 |
6 | "github.com/inklabs/rangedb"
7 | "github.com/inklabs/rangedb/pkg/crypto"
8 | )
9 |
10 | type decryptingRecordIterator struct {
11 | parent rangedb.RecordIterator
12 | eventEncryptor crypto.EventEncryptor
13 | currentErr error
14 | }
15 |
16 | // NewDecryptingRecordIterator constructs a new rangedb.Record iterator that decrypts events
17 | func NewDecryptingRecordIterator(parent rangedb.RecordIterator, eventEncryptor crypto.EventEncryptor) *decryptingRecordIterator {
18 | return &decryptingRecordIterator{
19 | parent: parent,
20 | eventEncryptor: eventEncryptor,
21 | }
22 | }
23 |
24 | func (i *decryptingRecordIterator) Next() bool {
25 | if i.currentErr != nil {
26 | return false
27 | }
28 |
29 | return i.parent.Next()
30 | }
31 |
32 | func (i *decryptingRecordIterator) NextContext(ctx context.Context) bool {
33 | if i.currentErr != nil {
34 | return false
35 | }
36 |
37 | return i.parent.NextContext(ctx)
38 | }
39 |
40 | func (i *decryptingRecordIterator) Record() *rangedb.Record {
41 | record := i.parent.Record()
42 |
43 | if record == nil {
44 | return nil
45 | }
46 |
47 | if rangedbEvent, ok := record.Data.(rangedb.Event); ok {
48 | err := i.eventEncryptor.Decrypt(rangedbEvent)
49 | if err != nil {
50 | i.currentErr = err
51 | return nil
52 | }
53 | }
54 |
55 | return record
56 | }
57 |
58 | func (i *decryptingRecordIterator) Err() error {
59 | if i.currentErr != nil {
60 | return i.currentErr
61 | }
62 |
63 | return i.parent.Err()
64 | }
65 |
--------------------------------------------------------------------------------
/provider/encryptedstore/decrypting_record_subscriber.go:
--------------------------------------------------------------------------------
1 | package encryptedstore
2 |
3 | import (
4 | "github.com/inklabs/rangedb"
5 | "github.com/inklabs/rangedb/pkg/crypto"
6 | )
7 |
8 | type decryptingRecordSubscriber struct {
9 | parent rangedb.RecordSubscriber
10 | eventEncryptor crypto.EventEncryptor
11 | }
12 |
13 | // NewDecryptingRecordSubscriber decrypts records on Accept
14 | func NewDecryptingRecordSubscriber(parent rangedb.RecordSubscriber, eventEncryptor crypto.EventEncryptor) *decryptingRecordSubscriber {
15 | return &decryptingRecordSubscriber{
16 | parent: parent,
17 | eventEncryptor: eventEncryptor,
18 | }
19 | }
20 |
21 | func (d *decryptingRecordSubscriber) Accept(record *rangedb.Record) {
22 | if rangedbEvent, ok := record.Data.(rangedb.Event); ok {
23 | _ = d.eventEncryptor.Decrypt(rangedbEvent)
24 | }
25 |
26 | d.parent.Accept(record)
27 | }
28 |
--------------------------------------------------------------------------------
/provider/encryptedstore/encrypt_event_test.go:
--------------------------------------------------------------------------------
1 | package encryptedstore_test
2 |
3 | import (
4 | "context"
5 | "fmt"
6 | "math/rand"
7 |
8 | "github.com/inklabs/rangedb"
9 | "github.com/inklabs/rangedb/pkg/crypto/aes"
10 | "github.com/inklabs/rangedb/pkg/crypto/cryptotest"
11 | "github.com/inklabs/rangedb/pkg/crypto/eventencryptor"
12 | "github.com/inklabs/rangedb/pkg/crypto/provider/inmemorykeystore"
13 | "github.com/inklabs/rangedb/provider/encryptedstore"
14 | "github.com/inklabs/rangedb/provider/inmemorystore"
15 | )
16 |
17 | func ExampleNew_automatically_encrypt_decrypt() {
18 | // Given
19 | seededRandReader := rand.New(rand.NewSource(100))
20 | aesEncryptor := aes.NewGCM()
21 | aesEncryptor.SetRandReader(seededRandReader)
22 | keyStore := inmemorykeystore.New()
23 | eventEncryptor := eventencryptor.New(keyStore, aesEncryptor)
24 | eventEncryptor.SetRandReader(seededRandReader)
25 | event := &cryptotest.CustomerSignedUp{
26 | ID: "fe65ac8d8c3a45e9b3cee407f10ee518",
27 | Name: "John Doe",
28 | Email: "john@example.com",
29 | Status: "active",
30 | }
31 | inMemoryStore := inmemorystore.New()
32 | encryptedStore := encryptedstore.New(inMemoryStore, eventEncryptor)
33 | encryptedStore.Bind(&cryptotest.CustomerSignedUp{})
34 | streamName := rangedb.GetEventStream(event)
35 |
36 | ctx := context.Background()
37 |
38 | // When
39 | _, err := encryptedStore.Save(ctx, streamName, &rangedb.EventRecord{Event: event})
40 | PrintError(err)
41 |
42 | fmt.Println("Auto Decrypted Event:")
43 | recordIterator := encryptedStore.Events(ctx, 0)
44 | for recordIterator.Next() {
45 | PrintEvent(recordIterator.Record().Data.(rangedb.Event))
46 | }
47 |
48 | fmt.Println("Raw Encrypted Event:")
49 | rawRecordIterator := inMemoryStore.Events(ctx, 0)
50 | for rawRecordIterator.Next() {
51 | PrintEvent(rawRecordIterator.Record().Data.(rangedb.Event))
52 | }
53 |
54 | // Output:
55 | // Auto Decrypted Event:
56 | // {
57 | // "ID": "fe65ac8d8c3a45e9b3cee407f10ee518",
58 | // "Name": "John Doe",
59 | // "Email": "john@example.com",
60 | // "Status": "active"
61 | // }
62 | // Raw Encrypted Event:
63 | // {
64 | // "ID": "fe65ac8d8c3a45e9b3cee407f10ee518",
65 | // "Name": "Lp5pGK8QGYw3NJyJVBsW49HESSf+NEraAQoBmpLXboZvsN/L",
66 | // "Email": "o1H9t1BClYc5UcyUV+Roe3wz5gwRZRjgBI/xzwZs8ueQGQ5L8uGnbrTGrh8=",
67 | // "Status": "active"
68 | // }
69 | }
70 |
--------------------------------------------------------------------------------
/provider/encryptedstore/helper_test.go:
--------------------------------------------------------------------------------
1 | package encryptedstore_test
2 |
3 | import (
4 | "encoding/json"
5 | "fmt"
6 |
7 | "github.com/inklabs/rangedb"
8 | "github.com/inklabs/rangedb/pkg/jsontools"
9 | )
10 |
11 | func PrintError(errors ...error) {
12 | for _, err := range errors {
13 | if err != nil {
14 | fmt.Println(err)
15 | }
16 | }
17 | }
18 |
19 | func PrintEvent(event rangedb.Event) {
20 | body, err := json.Marshal(event)
21 | PrintError(err)
22 |
23 | fmt.Println(jsontools.PrettyJSON(body))
24 | }
25 |
--------------------------------------------------------------------------------
/provider/eventstore/README.md:
--------------------------------------------------------------------------------
1 |
2 | # EventStoreDB Implementation
3 |
4 | ## Run locally for tests
5 |
6 | ```bash
7 | docker run -it -p 2113:2113 -p 1113:1113 eventstore/eventstore:21.10.0-bionic --insecure --mem-db
8 | ```
9 |
10 | ## Run locally with functional UI features
11 |
12 | ```bash
13 | docker run -it -p 2113:2113 -p 1113:1113 eventstore/eventstore:21.10.0-bionic --insecure --run-projections=All --enable-atom-pub-over-http=true
14 | ```
15 |
--------------------------------------------------------------------------------
/provider/eventstore/eventstore_test.go:
--------------------------------------------------------------------------------
1 | package eventstore_test
2 |
3 | import (
4 | "fmt"
5 | "sync"
6 | "testing"
7 | "time"
8 |
9 | "github.com/inklabs/rangedb/pkg/shortuuid"
10 |
11 | "github.com/stretchr/testify/require"
12 |
13 | "github.com/inklabs/rangedb"
14 | "github.com/inklabs/rangedb/pkg/clock"
15 | "github.com/inklabs/rangedb/provider/eventstore"
16 | "github.com/inklabs/rangedb/rangedbtest"
17 | )
18 |
19 | func Test_EventStore_VerifyStoreInterface(t *testing.T) {
20 | config := getConfigFromEnvironment(t)
21 |
22 | esStore, err := eventstore.New(config)
23 | require.NoError(t, err)
24 | err = esStore.Ping()
25 | if err != nil {
26 | t.Skip("EventStoreDB not found. Run: docker run -it -p 2113:2113 -p 1113:1113 eventstore/eventstore:21.10.0-bionic --insecure --run-projections=All --enable-atom-pub-over-http=true")
27 | }
28 |
29 | verifier := rangedbtest.NewStoreVerifier(rangedbtest.GSNStyleMonotonicSequence)
30 | verifier.Verify(t, func(t *testing.T, clock clock.Clock, uuidGenerator shortuuid.Generator) rangedb.Store {
31 | streamPrefixer := newIncrementingStreamPrefixer()
32 | esStore, err := eventstore.New(config,
33 | eventstore.WithClock(clock),
34 | eventstore.WithUUIDGenerator(uuidGenerator),
35 | eventstore.WithStreamPrefix(streamPrefixer),
36 | eventstore.RecordDeletedStreams(),
37 | )
38 |
39 | require.NoError(t, err)
40 | rangedbtest.BindEvents(esStore)
41 |
42 | t.Cleanup(func() {
43 | streamPrefixer.TickVersion()
44 | require.NoError(t, err)
45 | require.NoError(t, esStore.Close())
46 | })
47 |
48 | return esStore
49 | })
50 | }
51 |
52 | type incrementingStreamPrefixer struct {
53 | mux sync.RWMutex
54 | version int64
55 | }
56 |
57 | func newIncrementingStreamPrefixer() *incrementingStreamPrefixer {
58 | return &incrementingStreamPrefixer{
59 | version: time.Now().UnixNano(),
60 | }
61 | }
62 |
63 | func (p *incrementingStreamPrefixer) WithPrefix(name string) string {
64 | p.mux.RLock()
65 | defer p.mux.RUnlock()
66 |
67 | return fmt.Sprintf("%d-%s", p.version, name)
68 | }
69 |
70 | func (p *incrementingStreamPrefixer) GetPrefix() string {
71 | p.mux.RLock()
72 | defer p.mux.RUnlock()
73 |
74 | return fmt.Sprintf("%d-", p.version)
75 | }
76 |
77 | func (p *incrementingStreamPrefixer) TickVersion() {
78 | p.mux.Lock()
79 | p.version++
80 | p.mux.Unlock()
81 | }
82 |
83 | func getConfigFromEnvironment(t *testing.T) eventstore.Config {
84 | config, err := eventstore.NewConfigFromEnvironment()
85 | if err != nil {
86 | // docker run -p 8200:8200 -e 'VAULT_DEV_ROOT_TOKEN_ID=testroot' vault:1.9.1
87 | t.Skip(err.Error(), "ESDB_IP_ADDR, ESDB_USERNAME, and ESDB_PASSWORD are required")
88 | }
89 |
90 | return config
91 | }
92 |
--------------------------------------------------------------------------------
/provider/inmemorystore/inmemory_store_test.go:
--------------------------------------------------------------------------------
1 | package inmemorystore_test
2 |
3 | import (
4 | "bytes"
5 | "log"
6 | "testing"
7 |
8 | "github.com/stretchr/testify/assert"
9 |
10 | "github.com/inklabs/rangedb/pkg/shortuuid"
11 |
12 | "github.com/inklabs/rangedb"
13 | "github.com/inklabs/rangedb/pkg/clock"
14 | "github.com/inklabs/rangedb/provider/inmemorystore"
15 | "github.com/inklabs/rangedb/rangedbtest"
16 | )
17 |
18 | func Test_InMemory_VerifyStoreInterface(t *testing.T) {
19 | verifier := rangedbtest.NewStoreVerifier(rangedbtest.GSNStyleExact)
20 | verifier.Verify(t, func(t *testing.T, clock clock.Clock, uuidGenerator shortuuid.Generator) rangedb.Store {
21 | store := inmemorystore.New(
22 | inmemorystore.WithClock(clock),
23 | inmemorystore.WithUUIDGenerator(uuidGenerator),
24 | )
25 | rangedbtest.BindEvents(store)
26 |
27 | return store
28 | })
29 | }
30 |
31 | func BenchmarkInMemoryStore(b *testing.B) {
32 | rangedbtest.StoreBenchmark(b, func(b *testing.B) rangedb.Store {
33 | store := inmemorystore.New()
34 | rangedbtest.BindEvents(store)
35 | return store
36 | })
37 | }
38 |
39 | func Test_Failures(t *testing.T) {
40 | t.Run("SaveEvent fails when serialize fails", func(t *testing.T) {
41 | // Given
42 | store := inmemorystore.New(
43 | inmemorystore.WithSerializer(rangedbtest.NewFailingSerializer()),
44 | )
45 | event := rangedbtest.ThingWasDone{}
46 | streamName := rangedb.GetEventStream(event)
47 | ctx := rangedbtest.TimeoutContext(t)
48 |
49 | // When
50 | lastStreamSequenceNumber, err := store.Save(ctx, streamName, &rangedb.EventRecord{Event: event})
51 |
52 | // Then
53 | assert.EqualError(t, err, "failingSerializer.Serialize")
54 | assert.Equal(t, uint64(0), lastStreamSequenceNumber)
55 | })
56 |
57 | t.Run("EventsByStream errors when deserialize fails", func(t *testing.T) {
58 | // Given
59 | var logBuffer bytes.Buffer
60 | logger := log.New(&logBuffer, "", 0)
61 | store := inmemorystore.New(
62 | inmemorystore.WithSerializer(rangedbtest.NewFailingDeserializer()),
63 | inmemorystore.WithLogger(logger),
64 | )
65 | event := rangedbtest.ThingWasDone{}
66 | ctx := rangedbtest.TimeoutContext(t)
67 | streamName := rangedb.GetEventStream(event)
68 | rangedbtest.SaveEvents(t, store, streamName, &rangedb.EventRecord{Event: event})
69 |
70 | // When
71 | recordIterator := store.EventsByStream(ctx, 0, rangedb.GetEventStream(event))
72 |
73 | // Then
74 | assert.False(t, recordIterator.Next())
75 | assert.EqualError(t, recordIterator.Err(), "failed to deserialize record: failingDeserializer.Deserialize")
76 | assert.Nil(t, recordIterator.Record())
77 | assert.Equal(t, "failingDeserializer.Deserialize\nfailed to deserialize record: failingDeserializer.Deserialize\n", logBuffer.String())
78 | })
79 | }
80 |
--------------------------------------------------------------------------------
/provider/jsonrecordiostream/json_record_io_stream.go:
--------------------------------------------------------------------------------
1 | package jsonrecordiostream
2 |
3 | import (
4 | "encoding/json"
5 | "fmt"
6 | "io"
7 | "reflect"
8 |
9 | "github.com/inklabs/rangedb"
10 | "github.com/inklabs/rangedb/provider/jsonrecordserializer"
11 | )
12 |
13 | type jsonRecordIoStream struct {
14 | eventIdentifier rangedb.EventTypeIdentifier
15 | }
16 |
17 | // New constructs a jsonRecordIoStream.
18 | func New() *jsonRecordIoStream {
19 | return &jsonRecordIoStream{
20 | eventIdentifier: rangedb.NewEventIdentifier(),
21 | }
22 | }
23 |
24 | func (s *jsonRecordIoStream) Write(writer io.Writer, recordIterator rangedb.RecordIterator) <-chan error {
25 | errors := make(chan error)
26 |
27 | go func() {
28 | defer close(errors)
29 |
30 | _, _ = fmt.Fprint(writer, "[")
31 |
32 | totalSaved := 0
33 | for recordIterator.Next() {
34 | if recordIterator.Err() != nil {
35 | errors <- recordIterator.Err()
36 | return
37 | }
38 |
39 | data, err := json.Marshal(recordIterator.Record())
40 | if err != nil {
41 | errors <- fmt.Errorf("failed marshalling event: %v", err)
42 | return
43 | }
44 |
45 | if totalSaved > 0 {
46 | _, _ = fmt.Fprint(writer, ",")
47 | }
48 |
49 | _, _ = fmt.Fprintf(writer, "%s", data)
50 |
51 | totalSaved++
52 | }
53 | _, _ = fmt.Fprint(writer, "]")
54 | }()
55 |
56 | return errors
57 | }
58 |
59 | func (s *jsonRecordIoStream) Read(reader io.Reader) rangedb.RecordIterator {
60 | resultRecords := make(chan rangedb.ResultRecord)
61 |
62 | go func() {
63 | defer close(resultRecords)
64 |
65 | decoder := json.NewDecoder(reader)
66 | decoder.UseNumber()
67 |
68 | _, err := decoder.Token()
69 | if err != nil {
70 | if err == io.EOF {
71 | return
72 | }
73 | resultRecords <- rangedb.ResultRecord{
74 | Record: nil,
75 | Err: err,
76 | }
77 | return
78 | }
79 |
80 | for decoder.More() {
81 | record, err := jsonrecordserializer.UnmarshalRecord(decoder, s)
82 | if err != nil {
83 | resultRecords <- rangedb.ResultRecord{
84 | Record: nil,
85 | Err: err,
86 | }
87 | return
88 | }
89 |
90 | // TODO: Add cancel context to avoid deadlock
91 | resultRecords <- rangedb.ResultRecord{
92 | Record: record,
93 | Err: nil,
94 | }
95 | }
96 | }()
97 |
98 | return rangedb.NewRecordIterator(resultRecords)
99 | }
100 |
101 | func (s *jsonRecordIoStream) Bind(events ...rangedb.Event) {
102 | s.eventIdentifier.Bind(events...)
103 | }
104 |
105 | func (s *jsonRecordIoStream) EventTypeLookup(eventTypeName string) (r reflect.Type, b bool) {
106 | return s.eventIdentifier.EventTypeLookup(eventTypeName)
107 | }
108 |
--------------------------------------------------------------------------------
/provider/jsonrecordserializer/json_record_serializer.go:
--------------------------------------------------------------------------------
1 | package jsonrecordserializer
2 |
3 | import (
4 | "bytes"
5 | "encoding/json"
6 | "fmt"
7 | "io"
8 | "reflect"
9 |
10 | "github.com/inklabs/rangedb"
11 | )
12 |
13 | type jsonSerializer struct {
14 | eventIdentifier rangedb.EventTypeIdentifier
15 | }
16 |
17 | // New constructs a jsonSerializer.
18 | func New() *jsonSerializer {
19 | return &jsonSerializer{
20 | eventIdentifier: rangedb.NewEventIdentifier(),
21 | }
22 | }
23 |
24 | func (s *jsonSerializer) Bind(events ...rangedb.Event) {
25 | s.eventIdentifier.Bind(events...)
26 | }
27 |
28 | func (s *jsonSerializer) Serialize(record *rangedb.Record) ([]byte, error) {
29 | data, err := json.Marshal(record)
30 | if err != nil {
31 | return nil, fmt.Errorf("failed marshalling record: %v", err)
32 | }
33 |
34 | return data, nil
35 | }
36 |
37 | func (s *jsonSerializer) Deserialize(serializedData []byte) (*rangedb.Record, error) {
38 | decoder := json.NewDecoder(bytes.NewReader(serializedData))
39 | decoder.UseNumber()
40 |
41 | return UnmarshalRecord(decoder, s.eventIdentifier)
42 | }
43 |
44 | func (s *jsonSerializer) EventTypeLookup(eventTypeName string) (reflect.Type, bool) {
45 | return s.eventIdentifier.EventTypeLookup(eventTypeName)
46 | }
47 |
48 | // UnmarshalRecord decodes a Record using the supplied JSON decoder.
49 | //
50 | // Event data will be parsed into a struct if supplied by getEventType.
51 | func UnmarshalRecord(decoder *json.Decoder, eventTypeIdentifier rangedb.EventTypeIdentifier) (*rangedb.Record, error) {
52 | var rawEvent json.RawMessage
53 | record := rangedb.Record{
54 | Data: &rawEvent,
55 | }
56 | err := decoder.Decode(&record)
57 | if err != nil {
58 | return nil, fmt.Errorf("failed unmarshalling record: %v", err)
59 | }
60 |
61 | data, err := DecodeJsonData(record.EventType, bytes.NewReader(rawEvent), eventTypeIdentifier)
62 | if err != nil {
63 | return nil, fmt.Errorf("failed unmarshalling event within record: %v", err)
64 | }
65 |
66 | record.Data = data
67 |
68 | return &record, nil
69 | }
70 |
71 | // DecodeJsonData decodes raw json into a struct or interface{}.
72 | //
73 | // Event data will be parsed into a struct if supplied by getEventType.
74 | func DecodeJsonData(eventTypeName string, rawJsonData io.Reader, eventTypeIdentifier rangedb.EventTypeIdentifier) (interface{}, error) {
75 | dataDecoder := json.NewDecoder(rawJsonData)
76 | dataDecoder.UseNumber()
77 |
78 | eventType, ok := eventTypeIdentifier.EventTypeLookup(eventTypeName)
79 | if !ok {
80 | var data interface{}
81 | err := dataDecoder.Decode(&data)
82 | if err != nil {
83 | return nil, err
84 | }
85 |
86 | return data, nil
87 | }
88 |
89 | data := reflect.New(eventType).Interface()
90 | err := dataDecoder.Decode(&data)
91 | if err != nil {
92 | return nil, err
93 | }
94 |
95 | return data, nil
96 | }
97 |
--------------------------------------------------------------------------------
/provider/msgpackrecordiostream/msgpack_record_io_stream.go:
--------------------------------------------------------------------------------
1 | package msgpackrecordiostream
2 |
3 | import (
4 | "io"
5 | "reflect"
6 |
7 | "github.com/vmihailenco/msgpack/v4"
8 |
9 | "github.com/inklabs/rangedb"
10 | "github.com/inklabs/rangedb/provider/msgpackrecordserializer"
11 | )
12 |
13 | type msgpackRecordIoStream struct {
14 | eventIdentifier rangedb.EventTypeIdentifier
15 | }
16 |
17 | // New constructs a msgpackRecordIoStream.
18 | func New() *msgpackRecordIoStream {
19 | return &msgpackRecordIoStream{
20 | eventIdentifier: rangedb.NewEventIdentifier(),
21 | }
22 | }
23 |
24 | func (s *msgpackRecordIoStream) Bind(events ...rangedb.Event) {
25 | s.eventIdentifier.Bind(events...)
26 | }
27 |
28 | func (s *msgpackRecordIoStream) Write(writer io.Writer, recordIterator rangedb.RecordIterator) <-chan error {
29 | errors := make(chan error)
30 |
31 | go func() {
32 | defer close(errors)
33 |
34 | for recordIterator.Next() {
35 | if recordIterator.Err() != nil {
36 | errors <- recordIterator.Err()
37 | return
38 | }
39 |
40 | serializedRecord, err := msgpackrecordserializer.MarshalRecord(recordIterator.Record())
41 | if err != nil {
42 | errors <- err
43 | return
44 | }
45 |
46 | _, _ = writer.Write(serializedRecord)
47 | }
48 | }()
49 |
50 | return errors
51 | }
52 |
53 | func (s *msgpackRecordIoStream) Read(reader io.Reader) rangedb.RecordIterator {
54 | resultRecords := make(chan rangedb.ResultRecord)
55 |
56 | go func() {
57 | defer close(resultRecords)
58 |
59 | decoder := msgpack.NewDecoder(reader)
60 | decoder.UseJSONTag(true)
61 |
62 | for {
63 | record, err := msgpackrecordserializer.UnmarshalRecord(decoder, s.eventIdentifier)
64 | if err != nil {
65 | if err == msgpackrecordserializer.ErrorEOF {
66 | return
67 | }
68 |
69 | resultRecords <- rangedb.ResultRecord{
70 | Record: nil,
71 | Err: err,
72 | }
73 | return
74 | }
75 |
76 | // TODO: Add cancel context to avoid deadlock
77 | resultRecords <- rangedb.ResultRecord{
78 | Record: record,
79 | Err: nil,
80 | }
81 | }
82 | }()
83 |
84 | return rangedb.NewRecordIterator(resultRecords)
85 | }
86 |
87 | func (s *msgpackRecordIoStream) EventTypeLookup(eventTypeName string) (r reflect.Type, b bool) {
88 | return s.eventIdentifier.EventTypeLookup(eventTypeName)
89 | }
90 |
--------------------------------------------------------------------------------
/provider/ndjsonrecordiostream/ndjson_record_io_stream.go:
--------------------------------------------------------------------------------
1 | package ndjsonrecordiostream
2 |
3 | import (
4 | "encoding/json"
5 | "fmt"
6 | "io"
7 | "reflect"
8 |
9 | "github.com/inklabs/rangedb"
10 | "github.com/inklabs/rangedb/provider/jsonrecordserializer"
11 | )
12 |
13 | type ndJSONRecordIoStream struct {
14 | eventIdentifier rangedb.EventTypeIdentifier
15 | }
16 |
17 | // New constructs an ndjson implementation of rangedb.RecordIoStream.
18 | func New() *ndJSONRecordIoStream {
19 | return &ndJSONRecordIoStream{
20 | eventIdentifier: rangedb.NewEventIdentifier(),
21 | }
22 | }
23 |
24 | func (s *ndJSONRecordIoStream) Write(writer io.Writer, recordIterator rangedb.RecordIterator) <-chan error {
25 | errors := make(chan error)
26 |
27 | go func() {
28 | defer close(errors)
29 |
30 | totalSaved := 0
31 | for recordIterator.Next() {
32 | if recordIterator.Err() != nil {
33 | errors <- recordIterator.Err()
34 | return
35 | }
36 |
37 | if totalSaved > 0 {
38 | _, _ = fmt.Fprint(writer, "\n")
39 | }
40 |
41 | data, err := json.Marshal(recordIterator.Record())
42 | if err != nil {
43 | errors <- fmt.Errorf("failed marshalling event: %v", err)
44 | return
45 | }
46 |
47 | _, _ = fmt.Fprintf(writer, "%s", data)
48 |
49 | totalSaved++
50 | }
51 | }()
52 |
53 | return errors
54 | }
55 |
56 | func (s *ndJSONRecordIoStream) Read(reader io.Reader) rangedb.RecordIterator {
57 | resultRecords := make(chan rangedb.ResultRecord)
58 |
59 | go func() {
60 | defer close(resultRecords)
61 |
62 | decoder := json.NewDecoder(reader)
63 | decoder.UseNumber()
64 |
65 | for decoder.More() {
66 | record, err := jsonrecordserializer.UnmarshalRecord(decoder, s)
67 | if err != nil {
68 | resultRecords <- rangedb.ResultRecord{
69 | Record: nil,
70 | Err: err,
71 | }
72 | return
73 | }
74 |
75 | // TODO: Add cancel context to avoid deadlock
76 | resultRecords <- rangedb.ResultRecord{
77 | Record: record,
78 | Err: nil,
79 | }
80 | }
81 | }()
82 |
83 | return rangedb.NewRecordIterator(resultRecords)
84 | }
85 |
86 | func (s *ndJSONRecordIoStream) Bind(events ...rangedb.Event) {
87 | s.eventIdentifier.Bind(events...)
88 | }
89 |
90 | func (s *ndJSONRecordIoStream) EventTypeLookup(eventTypeName string) (r reflect.Type, b bool) {
91 | return s.eventIdentifier.EventTypeLookup(eventTypeName)
92 | }
93 |
--------------------------------------------------------------------------------
/provider/postgresstore/config.go:
--------------------------------------------------------------------------------
1 | package postgresstore
2 |
3 | import (
4 | "fmt"
5 | "os"
6 | )
7 |
8 | // Config holds the state for a PostgreSQL DB config.
9 | type Config struct {
10 | Host string
11 | Port int
12 | User string
13 | Password string
14 | DBName string
15 | SearchPath string
16 | }
17 |
18 | // DataSourceName returns the DSN for a PostgreSQL DB.
19 | func (c Config) DataSourceName() string {
20 | searchPath := ""
21 | if c.SearchPath != "" {
22 | searchPath = fmt.Sprintf(" search_path=%s", c.SearchPath)
23 | }
24 |
25 | return fmt.Sprintf("host=%s port=%d user=%s password=%s dbname=%s sslmode=disable%s",
26 | c.Host, c.Port, c.User, c.Password, c.DBName, searchPath)
27 | }
28 |
29 | // NewConfigFromEnvironment loads a Postgres config from environment variables.
30 | func NewConfigFromEnvironment() (*Config, error) {
31 | pgHost := os.Getenv("PG_HOST")
32 | pgUser := os.Getenv("PG_USER")
33 | pgPassword := os.Getenv("PG_PASSWORD")
34 | pgDBName := os.Getenv("PG_DBNAME")
35 | pgSearchPath := os.Getenv("PG_SEARCH_PATH")
36 |
37 | if pgHost == "" || pgUser == "" || pgDBName == "" {
38 | return nil, fmt.Errorf("postgreSQL DB has not been configured via environment variables")
39 | }
40 |
41 | return &Config{
42 | Host: pgHost,
43 | Port: 5432,
44 | User: pgUser,
45 | Password: pgPassword,
46 | DBName: pgDBName,
47 | SearchPath: pgSearchPath,
48 | }, nil
49 | }
50 |
--------------------------------------------------------------------------------
/provider/postgresstore/config_test.go:
--------------------------------------------------------------------------------
1 | package postgresstore_test
2 |
3 | import (
4 | "os"
5 | "testing"
6 |
7 | "github.com/stretchr/testify/assert"
8 | "github.com/stretchr/testify/require"
9 |
10 | "github.com/inklabs/rangedb/provider/postgresstore"
11 | )
12 |
13 | func TestConfig(t *testing.T) {
14 | t.Run("new config errors", func(t *testing.T) {
15 | // Given
16 | key := "PG_HOST"
17 | origValue := os.Getenv(key)
18 | require.NoError(t, os.Setenv(key, ""))
19 | t.Cleanup(func() {
20 | require.NoError(t, os.Setenv(key, origValue))
21 | })
22 |
23 | // When
24 | config, err := postgresstore.NewConfigFromEnvironment()
25 |
26 | // Then
27 | require.EqualError(t, err, "postgreSQL DB has not been configured via environment variables")
28 | assert.Nil(t, config)
29 | })
30 |
31 | t.Run("returns correct DSN", func(t *testing.T) {
32 | // Given
33 | config := &postgresstore.Config{
34 | Host: "host",
35 | Port: 8080,
36 | User: "user",
37 | Password: "password",
38 | DBName: "dbname",
39 | }
40 |
41 | // When
42 | dsn := config.DataSourceName()
43 |
44 | // Then
45 | assert.Equal(t, "host=host port=8080 user=user password=password dbname=dbname sslmode=disable", dsn)
46 | })
47 |
48 | t.Run("returns correct DSN", func(t *testing.T) {
49 | // Given
50 | config := &postgresstore.Config{
51 | Host: "host",
52 | Port: 8080,
53 | User: "user",
54 | Password: "password",
55 | DBName: "dbname",
56 | SearchPath: "searchpath",
57 | }
58 |
59 | // When
60 | dsn := config.DataSourceName()
61 |
62 | // Then
63 | assert.Equal(t, "host=host port=8080 user=user password=password dbname=dbname sslmode=disable search_path=searchpath", dsn)
64 | })
65 | }
66 |
--------------------------------------------------------------------------------
/provider/postgresstore/postgres_store_private_test.go:
--------------------------------------------------------------------------------
1 | package postgresstore
2 |
3 | import (
4 | "context"
5 | "database/sql"
6 | "fmt"
7 | "testing"
8 |
9 | "github.com/stretchr/testify/assert"
10 | "github.com/stretchr/testify/require"
11 |
12 | "github.com/inklabs/rangedb/rangedbtest"
13 | )
14 |
15 | func TestPrivate(t *testing.T) {
16 | t.Run("lockStream errors when obtaining advisory lock", func(t *testing.T) {
17 | // Given
18 | config := configFromEnvironment(t)
19 | store, err := New(config)
20 | require.NoError(t, err)
21 | const aggregateID = "9a483cf6fc1c45b2a126c146498f519b"
22 | failingDB := newFailingDBExecAble()
23 | ctx := rangedbtest.TimeoutContext(t)
24 |
25 | // When
26 | err = store.lockStream(ctx, failingDB, aggregateID)
27 |
28 | // Then
29 | assert.EqualError(t, err, "unable to obtain lock: failingDBExecAble.ExecContext")
30 | })
31 |
32 | t.Run("batchInsert errors from closed context", func(t *testing.T) {
33 | config := configFromEnvironment(t)
34 | store, err := New(config)
35 | require.NoError(t, err)
36 | failingDB := newFailingDBQueryable()
37 | ctx := rangedbtest.TimeoutContext(t)
38 |
39 | // When
40 | ints, lastStreamSequenceNumber, err := store.batchInsert(ctx, failingDB, nil)
41 |
42 | // Then
43 | assert.EqualError(t, err, "unable to insert: failingDBQueryable.QueryContext")
44 | assert.Empty(t, ints)
45 | assert.Equal(t, uint64(0), lastStreamSequenceNumber)
46 | })
47 |
48 | }
49 |
50 | type failingDBQueryable struct{}
51 |
52 | func newFailingDBQueryable() *failingDBQueryable {
53 | return &failingDBQueryable{}
54 | }
55 |
56 | func (f failingDBQueryable) QueryContext(_ context.Context, _ string, _ ...interface{}) (*sql.Rows, error) {
57 | return nil, fmt.Errorf("failingDBQueryable.QueryContext")
58 | }
59 |
60 | type failingDBExecAble struct{}
61 |
62 | func newFailingDBExecAble() *failingDBExecAble {
63 | return &failingDBExecAble{}
64 | }
65 |
66 | func (f failingDBExecAble) ExecContext(_ context.Context, _ string, _ ...interface{}) (sql.Result, error) {
67 | return nil, fmt.Errorf("failingDBExecAble.ExecContext")
68 | }
69 |
70 | func configFromEnvironment(t *testing.T) *Config {
71 | config, err := NewConfigFromEnvironment()
72 | if err != nil {
73 | t.Skip("Postgres DB has not been configured via environment variables to run integration tests")
74 | }
75 |
76 | return config
77 | }
78 |
--------------------------------------------------------------------------------
/publish_record.go:
--------------------------------------------------------------------------------
1 | package rangedb
2 |
3 | import (
4 | "context"
5 | "time"
6 | )
7 |
8 | // PublishRecordOrCancel publishes a Record to a ResultRecord channel, or times out.
9 | func PublishRecordOrCancel(ctx context.Context, resultRecords chan ResultRecord, record *Record, timeout time.Duration) bool {
10 | select {
11 | case <-ctx.Done():
12 | select {
13 | case <-time.After(timeout):
14 | case resultRecords <- ResultRecord{Err: ctx.Err()}:
15 | }
16 | return false
17 |
18 | default:
19 | }
20 |
21 | select {
22 | case <-ctx.Done():
23 | select {
24 | case <-time.After(timeout):
25 | case resultRecords <- ResultRecord{Err: ctx.Err()}:
26 | }
27 | return false
28 |
29 | case resultRecords <- ResultRecord{Record: record}:
30 | }
31 |
32 | return true
33 | }
34 |
--------------------------------------------------------------------------------
/rangedbtest/benchmark_record_serializer.go:
--------------------------------------------------------------------------------
1 | package rangedbtest
2 |
3 | import (
4 | "testing"
5 |
6 | "github.com/stretchr/testify/require"
7 |
8 | "github.com/inklabs/rangedb"
9 | )
10 |
11 | // RecordSerializerBenchmark benchmarks the rangedb.RecordSerializer interface.
12 | func RecordSerializerBenchmark(b *testing.B, newSerializer func() rangedb.RecordSerializer) {
13 | b.Helper()
14 |
15 | serializer := newSerializer()
16 | BindEvents(serializer)
17 | record := &rangedb.Record{
18 | StreamName: "thing-c2077176843a49189ae0d746eb131e05",
19 | AggregateType: "thing",
20 | AggregateID: "c2077176843a49189ae0d746eb131e05",
21 | GlobalSequenceNumber: 1,
22 | StreamSequenceNumber: 1,
23 | InsertTimestamp: 0,
24 | EventID: "0899fed048964c2f9c398d7ef623f0c7",
25 | EventType: "ThingWasDone",
26 | Data: ThingWasDone{
27 | ID: "c2077176843a49189ae0d746eb131e05",
28 | Number: 100,
29 | },
30 | Metadata: nil,
31 | }
32 | serializedRecord, err := serializer.Serialize(record)
33 | require.NoError(b, err)
34 |
35 | b.Run("Serialize", func(b *testing.B) {
36 | for i := 0; i < b.N; i++ {
37 | _, err := serializer.Serialize(record)
38 | if err != nil {
39 | require.NoError(b, err)
40 | }
41 | }
42 | })
43 |
44 | b.Run("Deserialize", func(b *testing.B) {
45 | for i := 0; i < b.N; i++ {
46 | _, err := serializer.Deserialize(serializedRecord)
47 | if err != nil {
48 | require.NoError(b, err)
49 | }
50 | }
51 | })
52 | }
53 |
--------------------------------------------------------------------------------
/rangedbtest/bind_events_gen.go:
--------------------------------------------------------------------------------
1 | // Code generated by go generate; DO NOT EDIT.
2 | // This file was generated at
3 | // 2021-01-20 15:37:20.832346 -0800 PST m=+0.001145698
4 | package rangedbtest
5 |
6 | import "github.com/inklabs/rangedb"
7 |
8 | func BindEvents(binder rangedb.EventBinder) {
9 | binder.Bind(
10 | &ThingWasDone{},
11 | &AnotherWasComplete{},
12 | &ThatWasDone{},
13 | &FloatWasDone{},
14 | &StringWasDone{},
15 | )
16 | }
17 |
--------------------------------------------------------------------------------
/rangedbtest/blocking_subscriber.go:
--------------------------------------------------------------------------------
1 | package rangedbtest
2 |
3 | import (
4 | "github.com/inklabs/rangedb"
5 | )
6 |
7 | type blockingSubscriber struct {
8 | Records chan *rangedb.Record
9 | parent rangedb.RecordSubscriber
10 | }
11 |
12 | // NewBlockingSubscriber constructs a RecordSubscriber that blocks on Accept into Records.
13 | func NewBlockingSubscriber(parent rangedb.RecordSubscriber) *blockingSubscriber {
14 | return &blockingSubscriber{
15 | Records: make(chan *rangedb.Record, 10),
16 | parent: parent,
17 | }
18 | }
19 |
20 | func (b blockingSubscriber) Accept(record *rangedb.Record) {
21 | if b.parent != nil {
22 | b.parent.Accept(record)
23 | }
24 | b.Records <- record
25 | }
26 |
--------------------------------------------------------------------------------
/rangedbtest/cmd/random-data/main.go:
--------------------------------------------------------------------------------
1 | package main
2 |
3 | import (
4 | "context"
5 | "flag"
6 | "fmt"
7 | "log"
8 | "math/rand"
9 | "os"
10 | "os/signal"
11 |
12 | "google.golang.org/grpc"
13 |
14 | "github.com/inklabs/rangedb/pkg/grpc/rangedbpb"
15 | "github.com/inklabs/rangedb/pkg/shortuuid"
16 | )
17 |
18 | func main() {
19 | host := flag.String("host", "127.0.0.1:8081", "RangeDB gRPC host address")
20 | flag.Parse()
21 |
22 | conn, err := grpc.Dial(*host, grpc.WithInsecure())
23 | if err != nil {
24 | log.Fatalf("unable to dial (%s): %v", *host, err)
25 | }
26 |
27 | rangeDBClient := rangedbpb.NewRangeDBClient(conn)
28 | ctx := context.Background()
29 |
30 | done := make(chan struct{}, 1)
31 | stop := make(chan os.Signal, 1)
32 | signal.Notify(stop, os.Interrupt)
33 |
34 | totalEvents := uint32(0)
35 |
36 | go func() {
37 | defer close(done)
38 |
39 | aggregateType := "foo"
40 | aggregateID := shortuuid.New().String()
41 | for {
42 | request := &rangedbpb.SaveRequest{
43 | StreamName: fmt.Sprintf("%s-%s", aggregateType, aggregateID),
44 | Events: getRandomEvents(aggregateType, aggregateID),
45 | }
46 |
47 | response, err := rangeDBClient.Save(ctx, request)
48 | if err != nil {
49 | log.Println(err)
50 | return
51 | }
52 |
53 | fmt.Println(response)
54 |
55 | totalEvents += response.EventsSaved
56 |
57 | select {
58 | case <-stop:
59 | return
60 | default:
61 | }
62 | }
63 | }()
64 |
65 | <-done
66 |
67 | fmt.Printf("Sent %d events\n", totalEvents)
68 | }
69 |
70 | func getRandomEvents(aggregateType, aggregateID string) []*rangedbpb.Event {
71 | total := rand.Intn(99) + 1
72 | events := make([]*rangedbpb.Event, total)
73 | for i := range events {
74 | events[i] = &rangedbpb.Event{
75 | AggregateType: aggregateType,
76 | AggregateID: aggregateID,
77 | EventType: "FooBar",
78 | Data: fmt.Sprintf(`{"number":%d}`, i),
79 | Metadata: "",
80 | }
81 | }
82 |
83 | return events
84 | }
85 |
--------------------------------------------------------------------------------
/rangedbtest/context.go:
--------------------------------------------------------------------------------
1 | package rangedbtest
2 |
3 | import (
4 | "context"
5 | "time"
6 | )
7 |
8 | type cleaner interface {
9 | Cleanup(f func())
10 | }
11 |
12 | // TimeoutContext returns a context that will timeout.
13 | func TimeoutContext(c cleaner) context.Context {
14 | ctx, done := context.WithTimeout(context.Background(), 5*time.Second)
15 | c.Cleanup(done)
16 | return ctx
17 | }
18 |
--------------------------------------------------------------------------------
/rangedbtest/failing_event_store.go:
--------------------------------------------------------------------------------
1 | package rangedbtest
2 |
3 | import (
4 | "context"
5 | "fmt"
6 |
7 | "github.com/inklabs/rangedb"
8 | )
9 |
10 | type failingEventStore struct{}
11 |
12 | // NewFailingEventStore constructs a failing event store for testing.
13 | func NewFailingEventStore() *failingEventStore {
14 | return &failingEventStore{}
15 | }
16 |
17 | func (f failingEventStore) Bind(_ ...rangedb.Event) {}
18 |
19 | func (f failingEventStore) Events(_ context.Context, _ uint64) rangedb.RecordIterator {
20 | return getFailingIterator("Events")
21 | }
22 |
23 | func (f failingEventStore) EventsByAggregateTypes(_ context.Context, _ uint64, _ ...string) rangedb.RecordIterator {
24 | return getFailingIterator("EventsByAggregateTypes")
25 | }
26 |
27 | func (f failingEventStore) EventsByStream(_ context.Context, _ uint64, _ string) rangedb.RecordIterator {
28 | return getFailingIterator("EventsByStream")
29 | }
30 |
31 | func (f failingEventStore) OptimisticDeleteStream(_ context.Context, _ uint64, _ string) error {
32 | return fmt.Errorf("failingEventStore.OptimisitDeleteStream")
33 | }
34 |
35 | func (f failingEventStore) OptimisticSave(_ context.Context, _ uint64, _ string, _ ...*rangedb.EventRecord) (uint64, error) {
36 | return 0, fmt.Errorf("failingEventStore.OptimisticSave")
37 | }
38 |
39 | func (f failingEventStore) Save(_ context.Context, _ string, _ ...*rangedb.EventRecord) (uint64, error) {
40 | return 0, fmt.Errorf("failingEventStore.Save")
41 | }
42 |
43 | func (f failingEventStore) AllEventsSubscription(_ context.Context, _ int, _ rangedb.RecordSubscriber) rangedb.RecordSubscription {
44 | return &dummyRecordSubscription{}
45 | }
46 |
47 | func (f failingEventStore) AggregateTypesSubscription(_ context.Context, _ int, _ rangedb.RecordSubscriber, _ ...string) rangedb.RecordSubscription {
48 | return &dummyRecordSubscription{}
49 | }
50 |
51 | func (f failingEventStore) TotalEventsInStream(_ context.Context, _ string) (uint64, error) {
52 | return 0, fmt.Errorf("failingEventStore.TotalEventsInStream")
53 | }
54 |
55 | func getFailingIterator(name string) rangedb.RecordIterator {
56 | recordResults := make(chan rangedb.ResultRecord, 1)
57 | recordResults <- rangedb.ResultRecord{
58 | Record: nil,
59 | Err: fmt.Errorf("failingEventStore.%s", name),
60 | }
61 | close(recordResults)
62 | return rangedb.NewRecordIterator(recordResults)
63 | }
64 |
--------------------------------------------------------------------------------
/rangedbtest/failing_serializer.go:
--------------------------------------------------------------------------------
1 | package rangedbtest
2 |
3 | import (
4 | "fmt"
5 |
6 | "github.com/inklabs/rangedb"
7 | "github.com/inklabs/rangedb/provider/jsonrecordserializer"
8 | )
9 |
10 | type failingSerializer struct{}
11 |
12 | // NewFailingSerializer constructs a failing rangedb.RecordSerializer.
13 | func NewFailingSerializer() *failingSerializer {
14 | return &failingSerializer{}
15 | }
16 |
17 | // Serialize always fails when called.
18 | func (f *failingSerializer) Serialize(_ *rangedb.Record) ([]byte, error) {
19 | return nil, fmt.Errorf("failingSerializer.Serialize")
20 | }
21 |
22 | // Deserialize uses the json record serializer to deserialize.
23 | func (f *failingSerializer) Deserialize(data []byte) (*rangedb.Record, error) {
24 | return jsonrecordserializer.New().Deserialize(data)
25 | }
26 |
27 | func (f *failingSerializer) Bind(_ ...rangedb.Event) {}
28 |
29 | type failingDeserializer struct{}
30 |
31 | // NewFailingDeserializer constructs a failing rangedb.RecordSerializer.
32 | func NewFailingDeserializer() *failingDeserializer {
33 | return &failingDeserializer{}
34 | }
35 |
36 | // Serialize uses the json record serializer to serialize.
37 | func (f *failingDeserializer) Serialize(record *rangedb.Record) ([]byte, error) {
38 | return jsonrecordserializer.New().Serialize(record)
39 | }
40 |
41 | // Deserialize always fails when called.
42 | func (f *failingDeserializer) Deserialize(_ []byte) (*rangedb.Record, error) {
43 | return nil, fmt.Errorf("failingDeserializer.Deserialize")
44 | }
45 |
46 | func (f *failingDeserializer) Bind(_ ...rangedb.Event) {}
47 |
--------------------------------------------------------------------------------
/rangedbtest/failing_serializer_test.go:
--------------------------------------------------------------------------------
1 | package rangedbtest_test
2 |
3 | import (
4 | "testing"
5 |
6 | "github.com/stretchr/testify/assert"
7 | "github.com/stretchr/testify/require"
8 |
9 | "github.com/inklabs/rangedb"
10 | "github.com/inklabs/rangedb/provider/jsonrecordserializer"
11 | "github.com/inklabs/rangedb/rangedbtest"
12 | )
13 |
14 | func Test_FailingSerializer(t *testing.T) {
15 | t.Run("deserializes correctly", func(t *testing.T) {
16 | // Given
17 | record := &rangedb.Record{Data: &rangedbtest.ThingWasDone{}}
18 | jsonSerializer := jsonrecordserializer.New()
19 | serializedData, err := jsonSerializer.Serialize(record)
20 | require.NoError(t, err)
21 | serializer := rangedbtest.NewFailingSerializer()
22 | serializer.Bind(&rangedbtest.ThingWasDone{})
23 |
24 | // When
25 | actualRecord, err := serializer.Deserialize(serializedData)
26 |
27 | // Then
28 | require.NoError(t, err)
29 | reSerializedData, err := jsonSerializer.Serialize(actualRecord)
30 | require.NoError(t, err)
31 | assert.Equal(t, serializedData, reSerializedData)
32 | })
33 | }
34 |
35 | func Test_FailingDeserializer(t *testing.T) {
36 | t.Run("serializes correctly", func(t *testing.T) {
37 | // Given
38 | record := &rangedb.Record{Data: &rangedbtest.ThingWasDone{}}
39 | jsonSerializer := jsonrecordserializer.New()
40 | serializedData, err := jsonSerializer.Serialize(record)
41 | require.NoError(t, err)
42 | serializer := rangedbtest.NewFailingDeserializer()
43 | serializer.Bind(&rangedbtest.ThingWasDone{})
44 |
45 | // When
46 | actualSerializedData, err := serializer.Serialize(record)
47 |
48 | // Then
49 | require.NoError(t, err)
50 | assert.Equal(t, serializedData, actualSerializedData)
51 | })
52 | }
53 |
--------------------------------------------------------------------------------
/rangedbtest/failing_subscribe_store.go:
--------------------------------------------------------------------------------
1 | package rangedbtest
2 |
3 | import (
4 | "context"
5 | "fmt"
6 |
7 | "github.com/inklabs/rangedb"
8 | )
9 |
10 | type failingSubscribeEventStore struct{}
11 |
12 | // NewFailingSubscribeEventStore constructs a failing event store for testing.
13 | func NewFailingSubscribeEventStore() *failingSubscribeEventStore {
14 | return &failingSubscribeEventStore{}
15 | }
16 |
17 | func (f failingSubscribeEventStore) Bind(_ ...rangedb.Event) {}
18 |
19 | func (f failingSubscribeEventStore) Events(_ context.Context, _ uint64) rangedb.RecordIterator {
20 | return getEmptyIterator()
21 | }
22 |
23 | func (f failingSubscribeEventStore) EventsByAggregateTypes(_ context.Context, _ uint64, _ ...string) rangedb.RecordIterator {
24 | return getEmptyIterator()
25 | }
26 |
27 | func (f failingSubscribeEventStore) EventsByStream(_ context.Context, _ uint64, _ string) rangedb.RecordIterator {
28 | return getEmptyIterator()
29 | }
30 |
31 | func (f failingSubscribeEventStore) OptimisticDeleteStream(_ context.Context, _ uint64, _ string) error {
32 | return nil
33 | }
34 |
35 | func (f failingSubscribeEventStore) OptimisticSave(_ context.Context, _ uint64, _ string, _ ...*rangedb.EventRecord) (uint64, error) {
36 | return 0, nil
37 | }
38 |
39 | func (f failingSubscribeEventStore) Save(_ context.Context, _ string, _ ...*rangedb.EventRecord) (uint64, error) {
40 | return 0, nil
41 | }
42 |
43 | func (f failingSubscribeEventStore) AllEventsSubscription(_ context.Context, _ int, _ rangedb.RecordSubscriber) rangedb.RecordSubscription {
44 | return &failingRecordSubscription{}
45 | }
46 |
47 | func (f failingSubscribeEventStore) AggregateTypesSubscription(_ context.Context, _ int, _ rangedb.RecordSubscriber, _ ...string) rangedb.RecordSubscription {
48 | return &failingRecordSubscription{}
49 | }
50 |
51 | func (f failingSubscribeEventStore) TotalEventsInStream(_ context.Context, _ string) (uint64, error) {
52 | return 0, nil
53 | }
54 |
55 | func getEmptyIterator() rangedb.RecordIterator {
56 | recordResults := make(chan rangedb.ResultRecord)
57 | return rangedb.NewRecordIterator(recordResults)
58 | }
59 |
60 | type failingRecordSubscription struct{}
61 |
62 | func (f failingRecordSubscription) Start() error {
63 | return fmt.Errorf("failingRecordSubscription.Start")
64 | }
65 |
66 | func (f failingRecordSubscription) StartFrom(_ uint64) error {
67 | return fmt.Errorf("failingRecordSubscription.StartFrom")
68 | }
69 |
70 | func (f failingRecordSubscription) Stop() {}
71 |
72 | type dummyRecordSubscription struct{}
73 |
74 | func (f dummyRecordSubscription) Start() error {
75 | return nil
76 | }
77 |
78 | func (f dummyRecordSubscription) StartFrom(_ uint64) error {
79 | return nil
80 | }
81 |
82 | func (f dummyRecordSubscription) Stop() {}
83 |
--------------------------------------------------------------------------------
/rangedbtest/seeded_uuid_generator.go:
--------------------------------------------------------------------------------
1 | package rangedbtest
2 |
3 | import (
4 | "math/rand"
5 | "sync"
6 |
7 | "github.com/google/uuid"
8 |
9 | "github.com/inklabs/rangedb/pkg/shortuuid"
10 | )
11 |
12 | type seededUUIDGenerator struct {
13 | mux sync.RWMutex
14 | generatedUUIDs []string
15 | }
16 |
17 | func NewSeededUUIDGenerator() *seededUUIDGenerator {
18 | return &seededUUIDGenerator{}
19 | }
20 |
21 | func (g *seededUUIDGenerator) New() string {
22 | newUUID := shortuuid.New().String()
23 |
24 | g.mux.Lock()
25 | g.generatedUUIDs = append(g.generatedUUIDs, newUUID)
26 | g.mux.Unlock()
27 |
28 | return newUUID
29 | }
30 |
31 | func (g *seededUUIDGenerator) Get(index int) string {
32 | g.mux.RLock()
33 | defer g.mux.RUnlock()
34 |
35 | if len(g.generatedUUIDs) < index {
36 | return ""
37 | }
38 |
39 | return g.generatedUUIDs[index-1]
40 | }
41 |
42 | func SetRand(seed int64) {
43 | uuid.SetRand(rand.New(rand.NewSource(seed)))
44 | }
45 |
--------------------------------------------------------------------------------
/rangedbtest/total_events_subscriber.go:
--------------------------------------------------------------------------------
1 | package rangedbtest
2 |
3 | import (
4 | "sync"
5 |
6 | "github.com/inklabs/rangedb"
7 | )
8 |
9 | type totalEventsSubscriber struct {
10 | sync sync.RWMutex
11 | totalEvents int
12 | }
13 |
14 | // NewTotalEventsSubscriber constructs a projection to count total events received.
15 | func NewTotalEventsSubscriber() *totalEventsSubscriber {
16 | return &totalEventsSubscriber{}
17 | }
18 |
19 | // Accept receives a Record.
20 | func (s *totalEventsSubscriber) Accept(_ *rangedb.Record) {
21 | s.sync.Lock()
22 | s.totalEvents++
23 | s.sync.Unlock()
24 | }
25 |
26 | // TotalEvents returns the total number of events received.
27 | func (s *totalEventsSubscriber) TotalEvents() int {
28 | s.sync.RLock()
29 | defer s.sync.RUnlock()
30 |
31 | return s.totalEvents
32 | }
33 |
--------------------------------------------------------------------------------
/record_io_stream.go:
--------------------------------------------------------------------------------
1 | package rangedb
2 |
3 | import (
4 | "io"
5 | )
6 |
7 | // RecordIoStream is the interface that (de)serializes a stream of Records.
8 | type RecordIoStream interface {
9 | Read(io.Reader) RecordIterator
10 | Write(io.Writer, RecordIterator) <-chan error
11 | Bind(events ...Event)
12 | }
13 |
--------------------------------------------------------------------------------
/record_iterator.go:
--------------------------------------------------------------------------------
1 | package rangedb
2 |
3 | import (
4 | "context"
5 | )
6 |
7 | type recordIterator struct {
8 | resultRecords <-chan ResultRecord
9 | current ResultRecord
10 | }
11 |
12 | // NewRecordIterator constructs a new rangedb.Record iterator
13 | func NewRecordIterator(recordResult <-chan ResultRecord) *recordIterator {
14 | return &recordIterator{resultRecords: recordResult}
15 | }
16 |
17 | func (i *recordIterator) Next() bool {
18 | if i.current.Err != nil {
19 | return false
20 | }
21 |
22 | i.current = <-i.resultRecords
23 |
24 | return i.current.Record != nil
25 | }
26 |
27 | func (i *recordIterator) NextContext(ctx context.Context) bool {
28 | if i.current.Err != nil {
29 | return false
30 | }
31 |
32 | select {
33 | case i.current = <-i.resultRecords:
34 | case <-ctx.Done():
35 | i.current = ResultRecord{
36 | Record: nil,
37 | Err: ctx.Err(),
38 | }
39 | }
40 |
41 | return i.current.Record != nil
42 | }
43 |
44 | func (i *recordIterator) Record() *Record {
45 | return i.current.Record
46 | }
47 |
48 | func (i *recordIterator) Err() error {
49 | return i.current.Err
50 | }
51 |
52 | func NewRecordIteratorWithError(err error) *recordIterator {
53 | records := make(chan ResultRecord, 1)
54 | records <- ResultRecord{Err: err}
55 | close(records)
56 | return NewRecordIterator(records)
57 | }
58 |
--------------------------------------------------------------------------------
/record_serializer.go:
--------------------------------------------------------------------------------
1 | package rangedb
2 |
3 | import (
4 | "reflect"
5 | )
6 |
7 | // RecordSerializer is the interface that (de)serializes Records.
8 | type RecordSerializer interface {
9 | Serialize(record *Record) ([]byte, error)
10 | Deserialize(data []byte) (*Record, error)
11 | Bind(events ...Event)
12 | }
13 |
14 | // EventTypeIdentifier is the interface for retrieving an event type.
15 | type EventTypeIdentifier interface {
16 | EventBinder
17 | EventTypeLookup(eventTypeName string) (reflect.Type, bool)
18 | }
19 |
--------------------------------------------------------------------------------
9 |
21 |
10 |
17 | {{template "records" .Records}}
18 | {{template "pagination" .PaginationLinks}}
19 |
20 |