matching

Documentation

Index

• Constants
• func Get(m []byte, i int64) bool
• func GetBit(b byte, i int64) bool
• func Len(m []byte) int
• func NewSlice(l int64) []byte
• func Set(m []byte, i int64, v bool)
• func SetBit(b byte, i int64, v bool) byte
• func StartEngine()
• type Base
• type Bitmap
  • func New(l int64) Bitmap
  • func (b Bitmap) Data(copy bool) []byte
  • func (b Bitmap) Get(i int64) bool
  • func (b Bitmap) Len() int
  • func (b Bitmap) Set(i int64, v bool)
• type BookOrder
• type DoneLog
  • func (l *DoneLog) GetSeq() int64
• type Engine
  • func NewEngine(product *entities.Product, orderReader OrderReader, logStore LogStore, ...) *Engine
  • func (e *Engine) Start()
• type KafkaLogReader
  • func (r *KafkaLogReader) GetProductId() string
  • func (r *KafkaLogReader) RegisterObserver(observer LogObserver)
  • func (r *KafkaLogReader) Run(seq, offset int64)
• type KafkaLogStore
  • func NewKafkaLogStore(productId string, brokers []string) *KafkaLogStore
  • func (s *KafkaLogStore) Store(logs []interface{}) error
• type KafkaOrderReader
  • func NewKafkaOrderReader(productId string, brokers []string) *KafkaOrderReader
  • func (s *KafkaOrderReader) FetchOrder() (offset int64, order *entities.Order, err error)
  • func (s *KafkaOrderReader) SetOffset(offset int64) error
• type Log
• type LogObserver
• type LogReader
  • func NewKafkaLogReader(readerId string, productId string, brokers []string) LogReader
• type LogStore
• type LogType
• type MatchLog
  • func (l *MatchLog) GetSeq() int64
• type OffsetOrder
• type OpenLog
  • func (l *OpenLog) GetSeq() int64
• type OrderBook
  • func NewOrderBook(product *entities.Product) *OrderBook
  • func (o *OrderBook) ApplyOrder(order *entities.Order) (logs []Log)
  • func (o *OrderBook) CancelOrder(order *entities.Order) (logs []Log)
  • func (o *OrderBook) Restore(snapshot *orderBooSnapShot)
  • func (o *OrderBook) Snapshot() orderBooSnapShot
• type OrderReader
• type ReceivedLog
  • func (l *ReceivedLog) GetSeq() int64
• type RedisSnapshotStore
  • func (s *RedisSnapshotStore) GetLatest() (*Snapshot, error)
  • func (s *RedisSnapshotStore) Store(snapshot *Snapshot) error
• type Snapshot
• type SnapshotStore
  • func NewRedisSnapShotStore(productId string) SnapshotStore
• type Window

Constants

const (
	LogTypeMatch = LogType("match")
	LogTypeOpen  = LogType("open")
	LogTypeDone  = LogType("done")
)

const (
	TopicOrderPrefix = "matching_order_"
)

Functions

func Get

func Get(m []byte, i int64) bool

func GetBit

func GetBit(b byte, i int64) bool

func Len

func Len(m []byte) int

func NewSlice

func NewSlice(l int64) []byte

func Set

func Set(m []byte, i int64, v bool)

func SetBit

func SetBit(b byte, i int64, v bool) byte

func StartEngine

func StartEngine()

Types

type Base

type Base struct {
	Type      LogType
	Sequence  int64
	ProductId int64
	Time      time.Time
}

type Bitmap

type Bitmap []byte

func New

func New(l int64) Bitmap

func (Bitmap) Data

func (b Bitmap) Data(copy bool) []byte

func (Bitmap) Get

func (b Bitmap) Get(i int64) bool

func (Bitmap) Len

func (b Bitmap) Len() int

func (Bitmap) Set

func (b Bitmap) Set(i int64, v bool)

type BookOrder

type BookOrder struct {
	OrderId int64
	Size    decimal.Decimal
	Funds   decimal.Decimal
	Price   decimal.Decimal
	Side    entities.Side
	Type    entities.OrderType
}

type DoneLog

type DoneLog struct {
	Base
	OrderId       int64
	Price         decimal.Decimal
	RemainingSize decimal.Decimal
	Reason        entities.DoneReason
	Side          entities.Side
}

func (*DoneLog) GetSeq

func (l *DoneLog) GetSeq() int64

type Engine

type Engine struct {
	OrderBook *OrderBook

	OrderReader OrderReader

	OrderOffset int64

	OrderCh chan *OffsetOrder

	LogStore LogStore

	LogCh chan Log

	SnapshotReqCh chan *Snapshot

	SnapshotApproveReqCh chan *Snapshot

	SnapshotCh chan *Snapshot

	SnapShotStore SnapshotStore
	// contains filtered or unexported fields
}

func NewEngine

func NewEngine(product *entities.Product, orderReader OrderReader, logStore LogStore, snapshotStore SnapshotStore) *Engine

func (*Engine) Start

func (e *Engine) Start()

type KafkaLogReader

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

func (*KafkaLogReader) GetProductId

func (r *KafkaLogReader) GetProductId() string

func (*KafkaLogReader) RegisterObserver

func (r *KafkaLogReader) RegisterObserver(observer LogObserver)

func (*KafkaLogReader) Run

func (r *KafkaLogReader) Run(seq, offset int64)

type KafkaLogStore

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

func NewKafkaLogStore

func NewKafkaLogStore(productId string, brokers []string) *KafkaLogStore

func (*KafkaLogStore) Store

func (s *KafkaLogStore) Store(logs []interface{}) error

type KafkaOrderReader

type KafkaOrderReader struct {
	OrderReader *kafka.Reader
}

func NewKafkaOrderReader

func NewKafkaOrderReader(productId string, brokers []string) *KafkaOrderReader

func (*KafkaOrderReader) FetchOrder

func (s *KafkaOrderReader) FetchOrder() (offset int64, order *entities.Order, err error)

func (*KafkaOrderReader) SetOffset

func (s *KafkaOrderReader) SetOffset(offset int64) error

type Log

type Log interface {
	GetSeq() int64
}

type LogObserver

type LogObserver interface {
	OnOpenLOg(log *OpenLog, offset int64)

	OnMatchLog(log *MatchLog, offset int64)

	OnDoneLog(log *DoneLog, offset int64)
}

type LogReader

type LogReader interface {
	GetProductId() string
	RegisterObserver(observer LogObserver)

	Run(seq, offset int64)
}

func NewKafkaLogReader

func NewKafkaLogReader(readerId string, productId string, brokers []string) LogReader

type LogStore

type LogStore interface {
	Store(logs []interface{}) error
}

type LogType

type LogType string

type MatchLog

type MatchLog struct {
	Base
	TradeId      int64
	TakerOrderId int64
	MakerOrderId int64
	Side         entities.Side
	Price        decimal.Decimal
	Size         decimal.Decimal
}

func (*MatchLog) GetSeq

func (l *MatchLog) GetSeq() int64

type OffsetOrder

type OffsetOrder struct {
	Offset int64
	Order  *entities.Order
}

type OpenLog

type OpenLog struct {
	Base
	OrderId       int64
	RemainingSize decimal.Decimal
	Price         decimal.Decimal
	Side          entities.Side
}

func (*OpenLog) GetSeq

func (l *OpenLog) GetSeq() int64

type OrderBook

type OrderBook struct {

	// stricly continiously increasing log SEQ, used to write matching log
	LogSeq int64
	// contains filtered or unexported fields
}

func NewOrderBook

func NewOrderBook(product *entities.Product) *OrderBook

func (*OrderBook) ApplyOrder

func (o *OrderBook) ApplyOrder(order *entities.Order) (logs []Log)

func (*OrderBook) CancelOrder

func (o *OrderBook) CancelOrder(order *entities.Order) (logs []Log)

func (*OrderBook) Restore

func (o *OrderBook) Restore(snapshot *orderBooSnapShot)

func (*OrderBook) Snapshot

func (o *OrderBook) Snapshot() orderBooSnapShot

type OrderReader

type OrderReader interface {
	SetOffset(offset int64) error

	FetchOrder() (offset int64, order *entities.Order, err error)
}

type ReceivedLog

type ReceivedLog struct {
	Base
	OrderId   int64
	Size      decimal.Decimal
	Price     decimal.Decimal
	Side      entities.Side
	OrderType entities.OrderType
}

func (*ReceivedLog) GetSeq

func (l *ReceivedLog) GetSeq() int64

type RedisSnapshotStore

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

func (*RedisSnapshotStore) GetLatest

func (s *RedisSnapshotStore) GetLatest() (*Snapshot, error)

func (*RedisSnapshotStore) Store

func (s *RedisSnapshotStore) Store(snapshot *Snapshot) error

type Snapshot

type Snapshot struct {
	OrderBookSnapshot orderBooSnapShot
	OrderOffset       int64
}

type SnapshotStore

type SnapshotStore interface {
	Store(snapshot *Snapshot) error

	GetLatest() (*Snapshot, error)
}

func NewRedisSnapShotStore

func NewRedisSnapShotStore(productId string) SnapshotStore

type Window

type Window struct {
	Min    int64
	Max    int64
	Cap    int64
	Bitmap Bitmap
}