Implement v2 Protocol. Adding expectedVersion for optimistic concurrency and metadata.

This commit is contained in:
Nicolas Dextraze
2016-08-26 22:10:15 -07:00
parent d819fb7de6
commit 5549c9a135
13 changed files with 648 additions and 422 deletions

View File

@ -1,91 +1,139 @@
package actions
import (
"time"
"github.com/satori/go.uuid"
storage "../storage"
serializer "../serializer"
data "../data"
)
var mapLock chan int = make(chan int, 1)
var streamsLock map[string]chan int = make(map[string]chan int)
type ActionsHandler struct {
storage storage.Storage
serializer serializer.Serializer
}
func NewActionsHandler(storage storage.Storage, serializer serializer.Serializer) *ActionsHandler {
return &ActionsHandler{storage, serializer}
}
func lockStream(streamName string) {
mapLock <- 1
defer func(){
<-mapLock
}()
streamLock := streamsLock[streamName]
if streamLock == nil {
streamLock = make(chan int, 1)
streamsLock[streamName] = streamLock
}
streamLock <- 1
}
func unlockStream(streamName string) {
<-streamsLock[streamName]
}
func (me ActionsHandler) AddEvent(event data.Event) error {
streamName := event.AggregateId.String()
lockStream(streamName)
defer unlockStream(streamName)
serializedPayload, typeId, err := me.serializer.Serialize(event.Payload)
if err != nil {
return err
}
return me.storage.Write(&storage.StoredEvent{StreamId: event.AggregateId, CreationTime: time.Now(), TypeId: typeId, Data: serializedPayload})
}
func (me ActionsHandler) RetrieveFor(aggregateId uuid.UUID) ([]*data.Event, error) {
results, err := me.storage.ReadStream(aggregateId)
if err != nil {
return nil, err
}
events := make([]*data.Event, 0)
for _, storedEvent := range results {
event, err := me.serializer.Deserialize(storedEvent.Data, storedEvent.TypeId)
if err != nil {
return nil, err
}
events = append(events, &data.Event{AggregateId: storedEvent.StreamId, Payload: event})
}
return events, nil
}
func (me ActionsHandler) RetrieveAll() ([]*data.Event, error) {
results, err := me.storage.ReadAll()
if err != nil {
return nil, err
}
events := make([]*data.Event, 0)
for _, storedEvent := range results {
event, err := me.serializer.Deserialize(storedEvent.Data, storedEvent.TypeId)
if err != nil {
return nil, err
}
events = append(events, &data.Event{AggregateId: storedEvent.StreamId, Payload: event})
}
return events, nil
}
package actions
import (
data "../data"
serializer "../serializer"
storage "../storage"
"errors"
"fmt"
"github.com/satori/go.uuid"
"time"
)
const NO_EXPECTEDVERSION = uint32(0xFFFFFFFF)
var mapLock chan int = make(chan int, 1)
var streamsLock map[string]chan int = make(map[string]chan int)
type Handler interface {
AddEvent(data.Event, uint32) error
RetrieveFor(uuid.UUID) ([]*data.Event, error)
RetrieveAll() ([]*data.Event, error)
}
type ActionsHandler struct {
storage storage.Storage
serializer serializer.Serializer
}
func NewActionsHandler(storage storage.Storage, serializer serializer.Serializer) *ActionsHandler {
return &ActionsHandler{storage, serializer}
}
func lockStream(streamName string) {
mapLock <- 1
defer func() {
<-mapLock
}()
streamLock := streamsLock[streamName]
if streamLock == nil {
streamLock = make(chan int, 1)
streamsLock[streamName] = streamLock
}
streamLock <- 1
}
func unlockStream(streamName string) {
<-streamsLock[streamName]
}
func (me ActionsHandler) AddEvent(event data.Event, expectedVersion uint32) error {
streamName := event.AggregateId.String()
lockStream(streamName)
defer unlockStream(streamName)
serializedPayload, typeId, err := me.serializer.Serialize(event.Payload)
if err != nil {
return err
}
serializedMetadata, _, err := me.serializer.Serialize(event.Metadata)
if err != nil {
return err
}
if expectedVersion != NO_EXPECTEDVERSION {
ver, err := me.storage.StreamVersion(event.AggregateId)
if err != nil && err.Error()[0:9] != "NOT_FOUND" {
return err
}
if ver != expectedVersion {
return errors.New(fmt.Sprint("WrongExpectedVersion: expected ", expectedVersion, " got ", ver))
}
}
return me.storage.Write(&storage.StoredEvent{
StreamId: event.AggregateId,
CreationTime: time.Now(),
TypeId: typeId,
Data: serializedPayload,
Metadata: serializedMetadata})
}
func (me ActionsHandler) RetrieveFor(aggregateId uuid.UUID) ([]*data.Event, error) {
results, err := me.storage.ReadStream(aggregateId)
if err != nil && err.Error()[0:9] == "NOT_FOUND" {
return make([]*data.Event, 0), nil
}
if err != nil {
return nil, err
}
events := make([]*data.Event, 0)
for _, storedEvent := range results {
event, err := me.serializer.Deserialize(storedEvent.Data, storedEvent.TypeId)
if err != nil {
return nil, err
}
metadata, err := me.serializer.Deserialize(storedEvent.Metadata, storedEvent.MetadataTypeId)
if err != nil {
return nil, err
}
events = append(events, &data.Event{
AggregateId: storedEvent.StreamId,
CreationTime: storedEvent.CreationTime,
Payload: event,
Metadata: metadata})
}
return events, nil
}
func (me ActionsHandler) RetrieveAll() ([]*data.Event, error) {
results, err := me.storage.ReadAll()
if err != nil {
return nil, err
}
events := make([]*data.Event, 0)
for _, storedEvent := range results {
event, err := me.serializer.Deserialize(storedEvent.Data, storedEvent.TypeId)
if err != nil {
return nil, err
}
metadata, err := me.serializer.Deserialize(storedEvent.Metadata, storedEvent.MetadataTypeId)
if err != nil {
return nil, err
}
events = append(events, &data.Event{
AggregateId: storedEvent.StreamId,
CreationTime: storedEvent.CreationTime,
Payload: event,
Metadata: metadata})
}
return events, nil
}