bbgo_origin/pkg/bbgo/trader.go

366 lines
10 KiB
Go
Raw Normal View History

2020-07-10 13:34:39 +00:00
package bbgo
import (
"context"
2020-12-07 03:43:17 +00:00
"fmt"
"reflect"
2020-11-12 06:50:08 +00:00
"sync"
2020-07-13 04:57:18 +00:00
2021-02-16 07:58:21 +00:00
"github.com/pkg/errors"
2020-07-13 04:57:18 +00:00
log "github.com/sirupsen/logrus"
2020-10-11 08:46:15 +00:00
"github.com/c9s/bbgo/pkg/types"
_ "github.com/go-sql-driver/mysql"
2020-07-10 13:34:39 +00:00
)
2021-03-15 10:51:29 +00:00
var SupportedExchanges = []types.ExchangeName{"binance", "max", "ftx"}
2020-10-16 02:09:30 +00:00
// SingleExchangeStrategy represents the single Exchange strategy
type SingleExchangeStrategy interface {
2021-02-03 01:08:05 +00:00
ID() string
Run(ctx context.Context, orderExecutor OrderExecutor, session *ExchangeSession) error
2020-07-14 06:54:23 +00:00
}
type ExchangeSessionSubscriber interface {
Subscribe(session *ExchangeSession)
}
type CrossExchangeSessionSubscriber interface {
CrossSubscribe(sessions map[string]*ExchangeSession)
}
type CrossExchangeStrategy interface {
2021-02-03 01:08:05 +00:00
ID() string
CrossRun(ctx context.Context, orderExecutionRouter OrderExecutionRouter, sessions map[string]*ExchangeSession) error
}
2020-11-12 06:50:08 +00:00
//go:generate callbackgen -type Graceful
type Graceful struct {
shutdownCallbacks []func(ctx context.Context, wg *sync.WaitGroup)
}
func (g *Graceful) Shutdown(ctx context.Context) {
var wg sync.WaitGroup
2020-11-12 06:59:47 +00:00
wg.Add(len(g.shutdownCallbacks))
go g.EmitShutdown(ctx, &wg)
2020-11-12 06:50:08 +00:00
wg.Wait()
}
2020-11-09 08:34:35 +00:00
type Logging interface {
EnableLogging()
DisableLogging()
}
type Logger interface {
Warnf(message string, args ...interface{})
Errorf(message string, args ...interface{})
Infof(message string, args ...interface{})
}
type SilentLogger struct{}
func (logger *SilentLogger) Infof(message string, args ...interface{}) {}
func (logger *SilentLogger) Warnf(message string, args ...interface{}) {}
func (logger *SilentLogger) Errorf(message string, args ...interface{}) {}
type Trader struct {
environment *Environment
2020-09-28 07:01:10 +00:00
riskControls *RiskControls
crossExchangeStrategies []CrossExchangeStrategy
exchangeStrategies map[string][]SingleExchangeStrategy
2020-11-09 08:34:35 +00:00
logger Logger
2020-11-12 06:50:08 +00:00
Graceful Graceful
2020-07-13 05:25:48 +00:00
}
func NewTrader(environ *Environment) *Trader {
2020-09-07 06:20:03 +00:00
return &Trader{
environment: environ,
exchangeStrategies: make(map[string][]SingleExchangeStrategy),
2020-11-09 08:34:35 +00:00
logger: log.StandardLogger(),
2020-09-07 06:20:03 +00:00
}
}
2020-11-09 08:34:35 +00:00
func (trader *Trader) EnableLogging() {
trader.logger = log.StandardLogger()
}
func (trader *Trader) DisableLogging() {
trader.logger = &SilentLogger{}
}
func (trader *Trader) Configure(userConfig *Config) error {
if userConfig.RiskControls != nil {
trader.SetRiskControls(userConfig.RiskControls)
}
for _, entry := range userConfig.ExchangeStrategies {
for _, mount := range entry.Mounts {
log.Infof("attaching strategy %T on %s...", entry.Strategy, mount)
2021-03-15 10:51:29 +00:00
if err := trader.AttachStrategyOn(mount, entry.Strategy); err != nil {
return err
}
}
}
for _, strategy := range userConfig.CrossExchangeStrategies {
log.Infof("attaching cross exchange strategy %T", strategy)
trader.AttachCrossExchangeStrategy(strategy)
}
for _, report := range userConfig.PnLReporters {
if len(report.AverageCostBySymbols) > 0 {
log.Infof("setting up average cost pnl reporter on symbols: %v", report.AverageCostBySymbols)
trader.ReportPnL().
AverageCostBySymbols(report.AverageCostBySymbols...).
Of(report.Of...).
When(report.When...)
} else {
return fmt.Errorf("unsupported PnL reporter: %+v", report)
}
}
return nil
}
// AttachStrategyOn attaches the single exchange strategy on an exchange Session.
// Single exchange strategy is the default behavior.
2021-01-09 11:47:21 +00:00
func (trader *Trader) AttachStrategyOn(session string, strategies ...SingleExchangeStrategy) error {
if len(trader.environment.sessions) == 0 {
return fmt.Errorf("you don't have any session configured, please check your environment variable or config file")
}
if _, ok := trader.environment.sessions[session]; !ok {
2021-01-09 11:47:21 +00:00
var keys []string
for k := range trader.environment.sessions {
keys = append(keys, k)
}
return fmt.Errorf("session %s is not defined, valid sessions are: %v", session, keys)
}
2020-09-19 03:25:48 +00:00
for _, s := range strategies {
trader.exchangeStrategies[session] = append(trader.exchangeStrategies[session], s)
}
2020-10-16 05:52:18 +00:00
2021-01-09 11:47:21 +00:00
return nil
}
2020-09-28 07:01:10 +00:00
// AttachCrossExchangeStrategy attaches the cross exchange strategy
2020-10-16 05:52:18 +00:00
func (trader *Trader) AttachCrossExchangeStrategy(strategy CrossExchangeStrategy) *Trader {
trader.crossExchangeStrategies = append(trader.crossExchangeStrategies, strategy)
2020-10-16 05:52:18 +00:00
return trader
}
2020-09-28 07:01:10 +00:00
// TODO: provide a more DSL way to configure risk controls
func (trader *Trader) SetRiskControls(riskControls *RiskControls) {
trader.riskControls = riskControls
}
2021-02-01 09:13:54 +00:00
func (trader *Trader) Subscribe() {
// pre-subscribe the data
for sessionName, strategies := range trader.exchangeStrategies {
session := trader.environment.sessions[sessionName]
for _, strategy := range strategies {
if subscriber, ok := strategy.(ExchangeSessionSubscriber); ok {
subscriber.Subscribe(session)
2021-03-21 04:43:41 +00:00
} else {
log.Errorf("strategy %s does not implement ExchangeSessionSubscriber", strategy.ID())
}
}
}
for _, strategy := range trader.crossExchangeStrategies {
if subscriber, ok := strategy.(CrossExchangeSessionSubscriber); ok {
subscriber.CrossSubscribe(trader.environment.sessions)
2021-03-21 04:43:41 +00:00
} else {
log.Errorf("strategy %s does not implement CrossExchangeSessionSubscriber", strategy.ID())
}
}
2021-02-01 09:13:54 +00:00
}
2021-02-16 08:12:00 +00:00
func (trader *Trader) RunSingleExchangeStrategy(ctx context.Context, strategy SingleExchangeStrategy, session *ExchangeSession, orderExecutor OrderExecutor) error {
rs := reflect.ValueOf(strategy)
2021-02-10 16:21:56 +00:00
2021-02-16 08:12:00 +00:00
// get the struct element
rs = rs.Elem()
2021-02-16 08:12:00 +00:00
if rs.Kind() != reflect.Struct {
return errors.New("strategy object is not a struct")
}
2021-02-16 08:12:00 +00:00
if err := trader.injectCommonServices(rs); err != nil {
return err
}
2021-02-16 08:12:00 +00:00
if err := injectField(rs, "OrderExecutor", orderExecutor, false); err != nil {
return errors.Wrapf(err, "failed to inject OrderExecutor on %T", strategy)
}
2021-02-16 08:12:00 +00:00
if symbol, ok := isSymbolBasedStrategy(rs); ok {
log.Debugf("found symbol based strategy from %s", rs.Type())
if _, ok := hasField(rs, "Market"); ok {
if market, ok := session.Market(symbol); ok {
// let's make the market object passed by pointer
if err := injectField(rs, "Market", &market, false); err != nil {
return errors.Wrapf(err, "failed to inject Market on %T", strategy)
}
}
}
2021-02-16 08:12:00 +00:00
// StandardIndicatorSet
if _, ok := hasField(rs, "StandardIndicatorSet"); ok {
if indicatorSet, ok := session.StandardIndicatorSet(symbol); ok {
if err := injectField(rs, "StandardIndicatorSet", indicatorSet, true); err != nil {
return errors.Wrapf(err, "failed to inject StandardIndicatorSet on %T", strategy)
}
2021-02-16 07:58:21 +00:00
}
2021-02-16 08:12:00 +00:00
}
2020-11-09 08:47:29 +00:00
2021-02-16 08:12:00 +00:00
if _, ok := hasField(rs, "MarketDataStore"); ok {
if store, ok := session.MarketDataStore(symbol); ok {
if err := injectField(rs, "MarketDataStore", store, true); err != nil {
return errors.Wrapf(err, "failed to inject MarketDataStore on %T", strategy)
}
2021-02-16 07:58:21 +00:00
}
2021-02-16 08:12:00 +00:00
}
}
2021-02-16 08:12:00 +00:00
return strategy.Run(ctx, orderExecutor, session)
}
2021-02-16 08:12:00 +00:00
func (trader *Trader) getSessionOrderExecutor(sessionName string) OrderExecutor {
var session = trader.environment.sessions[sessionName]
2021-02-16 08:12:00 +00:00
// default to base order executor
var orderExecutor OrderExecutor = session.orderExecutor
2021-02-16 08:12:00 +00:00
// Since the risk controls are loaded from the config file
if trader.riskControls != nil && trader.riskControls.SessionBasedRiskControl != nil {
if control, ok := trader.riskControls.SessionBasedRiskControl[sessionName]; ok {
2021-02-16 08:12:00 +00:00
control.SetBaseOrderExecutor(session.orderExecutor)
// pick the wrapped order executor
if control.OrderExecutor != nil {
return control.OrderExecutor
}
2021-02-16 08:12:00 +00:00
}
}
return orderExecutor
}
2021-02-16 08:12:00 +00:00
func (trader *Trader) RunAllSingleExchangeStrategy(ctx context.Context) error {
// load and run Session strategies
for sessionName, strategies := range trader.exchangeStrategies {
var session = trader.environment.sessions[sessionName]
var orderExecutor = trader.getSessionOrderExecutor(sessionName)
for _, strategy := range strategies {
if err := trader.RunSingleExchangeStrategy(ctx, strategy, session, orderExecutor); err != nil {
2020-09-28 07:01:10 +00:00
return err
}
}
}
2020-09-28 07:01:10 +00:00
2021-02-16 08:12:00 +00:00
return nil
}
func (trader *Trader) Run(ctx context.Context) error {
trader.Subscribe()
if err := trader.environment.Init(ctx); err != nil {
return err
}
if err := trader.RunAllSingleExchangeStrategy(ctx); err != nil {
return err
}
router := &ExchangeOrderExecutionRouter{
2020-10-30 21:21:17 +00:00
Notifiability: trader.environment.Notifiability,
2020-10-16 02:09:30 +00:00
sessions: trader.environment.sessions,
}
for _, strategy := range trader.crossExchangeStrategies {
rs := reflect.ValueOf(strategy)
2021-02-16 07:49:57 +00:00
// get the struct element from the struct pointer
rs = rs.Elem()
2021-02-16 07:58:21 +00:00
if rs.Kind() != reflect.Struct {
continue
}
if err := trader.injectCommonServices(rs); err != nil {
2021-02-16 07:49:57 +00:00
return err
2020-08-04 11:05:20 +00:00
}
2020-07-13 05:25:48 +00:00
if err := strategy.CrossRun(ctx, router, trader.environment.sessions); err != nil {
return err
2020-07-13 05:25:48 +00:00
}
}
2020-07-13 05:25:48 +00:00
return trader.environment.Connect(ctx)
2020-07-10 13:34:39 +00:00
}
2021-02-16 07:58:21 +00:00
func (trader *Trader) injectCommonServices(rs reflect.Value) error {
if err := injectField(rs, "Graceful", &trader.Graceful, true); err != nil {
return errors.Wrap(err, "failed to inject Graceful")
}
if err := injectField(rs, "Logger", &trader.logger, false); err != nil {
return errors.Wrap(err, "failed to inject Logger")
}
if err := injectField(rs, "Notifiability", &trader.environment.Notifiability, false); err != nil {
return errors.Wrap(err, "failed to inject Notifiability")
}
if trader.environment.TradeService != nil {
2021-02-16 08:30:01 +00:00
if err := injectField(rs, "TradeService", trader.environment.TradeService, true); err != nil {
return errors.Wrap(err, "failed to inject TradeService")
}
}
if field, ok := hasField(rs, "Persistence"); ok {
if trader.environment.PersistenceServiceFacade == nil {
log.Warnf("strategy has Persistence field but persistence service is not defined")
} else {
if field.IsNil() {
field.Set(reflect.ValueOf(&Persistence{
PersistenceSelector: &PersistenceSelector{
StoreID: "default",
Type: "memory",
},
Facade: trader.environment.PersistenceServiceFacade,
}))
} else {
elem := field.Elem()
if elem.Kind() != reflect.Struct {
return fmt.Errorf("field Persistence is not a struct element")
}
if err := injectField(elem, "Facade", trader.environment.PersistenceServiceFacade, true); err != nil {
return errors.Wrap(err, "failed to inject Persistence")
}
}
}
}
2021-02-16 07:58:21 +00:00
return nil
}
2020-10-26 08:44:05 +00:00
// ReportPnL configure and set the PnLReporter with the given notifier
func (trader *Trader) ReportPnL() *PnLReporterManager {
2020-10-30 21:21:17 +00:00
return NewPnLReporter(&trader.environment.Notifiability)
2020-10-22 07:57:50 +00:00
}