140 lines
3.3 KiB
Go
140 lines
3.3 KiB
Go
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
|
|
}
|