saga

Documentation

Index

• type Def
  • func (sd *Def) HandleEvent(exchange, topic string, event gbus.Message, handler gbus.MessageHandler) error
  • func (sd *Def) HandleMessage(message gbus.Message, handler gbus.MessageHandler) error
  • func (sd *Def) String() string
• type Glue
  • func NewGlue(bus gbus.Bus, sagaStore Store, svcName string, txp gbus.TxProvider) *Glue
  • func (imsm *Glue) RegisterSaga(saga gbus.Saga, conf ...gbus.SagaConfFn) error
• type Instance
  • func NewInstance(sagaType reflect.Type, msgToMethodMap []*MsgToFuncPair) *Instance
  • func (si *Instance) String() string
• type MsgToFuncPair
• type Store
• type TimeoutManager
  • func (tm *TimeoutManager) RequestTimeout(svcName, sagaID string, duration time.Duration)

Types

type Def

type Def struct {
	// contains filtered or unexported fields
}

Def defines a saga type

func (*Def) HandleEvent

func (sd *Def) HandleEvent(exchange, topic string, event gbus.Message, handler gbus.MessageHandler) error

HandleEvent implements HandlerRegister interface

func (*Def) HandleMessage

func (sd *Def) HandleMessage(message gbus.Message, handler gbus.MessageHandler) error

HandleMessage implements HandlerRegister interface

func (*Def) String

func (sd *Def) String() string

type Glue

type Glue struct {
	// contains filtered or unexported fields
}

Glue ties the incoming messages from the Bus with the needed Saga instances

func NewGlue

func NewGlue(bus gbus.Bus, sagaStore Store, svcName string, txp gbus.TxProvider) *Glue

NewGlue creates a new Sagamanager

func (*Glue) RegisterSaga

func (imsm *Glue) RegisterSaga(saga gbus.Saga, conf ...gbus.SagaConfFn) error

RegisterSaga registers the saga instance with the Bus

type Instance

type Instance struct {
	ID                 string
	ConcurrencyCtrl    int
	UnderlyingInstance gbus.Saga
	MsgToMethodMap     []*MsgToFuncPair
}

Instance represent a living instance of a saga of a particular definition

func NewInstance

func NewInstance(sagaType reflect.Type, msgToMethodMap []*MsgToFuncPair) *Instance

func (*Instance) String

func (si *Instance) String() string

type MsgToFuncPair

type MsgToFuncPair struct {
	Filter       *gbus.MessageFilter
	SagaFuncName string
}

type Store

type Store interface {
	RegisterSagaType(saga gbus.Saga)
	GetSagaByID(tx *sql.Tx, sagaID string) (*Instance, error)
	GetSagasByType(tx *sql.Tx, sagaType reflect.Type) ([]*Instance, error)
	SaveNewSaga(tx *sql.Tx, sagaType reflect.Type, newInstance *Instance) error
	UpdateSaga(tx *sql.Tx, instance *Instance) error
	DeleteSaga(tx *sql.Tx, instance *Instance) error
	Purge() error
}

Store abtracts the way sagas get persisted

type TimeoutManager

type TimeoutManager struct {
	// contains filtered or unexported fields
}

TimeoutManager manages timeouts for sagas TODO:Make it persistent

func (*TimeoutManager) RequestTimeout

func (tm *TimeoutManager) RequestTimeout(svcName, sagaID string, duration time.Duration)

RequestTimeout requests a timeout from the timeout manager