package server import ( "context" "fmt" "io/ioutil" "math/rand" "net" "net/http" "os" "regexp" "strconv" "time" "github.com/gin-contrib/cors" "github.com/gin-gonic/gin" "github.com/joho/godotenv" "github.com/sirupsen/logrus" "github.com/c9s/bbgo/pkg/bbgo" "github.com/c9s/bbgo/pkg/fixedpoint" "github.com/c9s/bbgo/pkg/service" "github.com/c9s/bbgo/pkg/types" ) const DefaultBindAddress = "localhost:8080" type Setup struct { // Context is the trader context Context context.Context // Cancel is the trader context cancel function you want to cancel Cancel context.CancelFunc // Token is used for setup api authentication Token string BeforeRestart func() } type Server struct { Config *bbgo.Config Environ *bbgo.Environment Trader *bbgo.Trader Setup *Setup OpenInBrowser bool srv *http.Server } func (s *Server) newEngine() *gin.Engine { r := gin.Default() r.Use(cors.New(cors.Config{ AllowOrigins: []string{"*"}, AllowHeaders: []string{"Origin", "Content-Type"}, ExposeHeaders: []string{"Content-Length"}, AllowMethods: []string{"GET", "POST", "PUT", "DELETE"}, AllowWebSockets: true, AllowCredentials: true, MaxAge: 12 * time.Hour, })) r.GET("/api/ping", s.ping) if s.Setup != nil { r.POST("/api/setup/test-db", s.setupTestDB) r.POST("/api/setup/configure-db", s.setupConfigureDB) r.POST("/api/setup/strategy/single/:id/session/:session", s.setupAddStrategy) r.POST("/api/setup/save", s.setupSaveConfig) r.POST("/api/setup/restart", s.setupRestart) } r.GET("/api/environment/syncing", func(c *gin.Context) { c.JSON(http.StatusOK, gin.H{ "syncing": s.Environ.IsSyncing(), }) }) r.POST("/api/environment/sync", func(c *gin.Context) { go func() { if err := s.Environ.Sync(context.Background()); err != nil { logrus.WithError(err).Error("sync error") } }() c.JSON(http.StatusOK, gin.H{ "success": true, }) }) r.GET("/api/trades", func(c *gin.Context) { if s.Environ.TradeService == nil { c.JSON(http.StatusInternalServerError, gin.H{"error": "database is not configured"}) return } exchange := c.Query("exchange") symbol := c.Query("symbol") gidStr := c.DefaultQuery("gid", "0") lastGID, err := strconv.ParseInt(gidStr, 10, 64) if err != nil { logrus.WithError(err).Error("last gid parse error") c.Status(http.StatusBadRequest) return } trades, err := s.Environ.TradeService.Query(service.QueryTradesOptions{ Exchange: types.ExchangeName(exchange), Symbol: symbol, LastGID: lastGID, Ordering: "DESC", }) if err != nil { c.Status(http.StatusBadRequest) logrus.WithError(err).Error("order query error") return } c.JSON(http.StatusOK, gin.H{ "trades": trades, }) }) r.GET("/api/orders/closed", s.listClosedOrders) r.GET("/api/trading-volume", s.tradingVolume) r.POST("/api/sessions/test", func(c *gin.Context) { var session bbgo.ExchangeSession if err := c.BindJSON(&session); err != nil { c.JSON(http.StatusInternalServerError, gin.H{ "error": err.Error(), }) return } err := session.InitExchange(session.ExchangeName.String(), nil) if err != nil { c.JSON(http.StatusInternalServerError, gin.H{ "error": err.Error(), }) return } var anyErr error _, openOrdersErr := session.Exchange.QueryOpenOrders(c, "BTCUSDT") if openOrdersErr != nil { anyErr = openOrdersErr } _, balanceErr := session.Exchange.QueryAccountBalances(c) if balanceErr != nil { anyErr = balanceErr } c.JSON(http.StatusOK, gin.H{ "success": anyErr == nil, "error": anyErr, "balance": balanceErr == nil, "openOrders": openOrdersErr == nil, }) }) r.GET("/api/sessions", func(c *gin.Context) { var sessions []*bbgo.ExchangeSession for _, session := range s.Environ.Sessions() { sessions = append(sessions, session) } if len(sessions) == 0 { c.JSON(http.StatusOK, gin.H{"sessions": []int{}}) } c.JSON(http.StatusOK, gin.H{"sessions": sessions}) }) r.POST("/api/sessions", func(c *gin.Context) { var session bbgo.ExchangeSession if err := c.BindJSON(&session); err != nil { c.JSON(http.StatusInternalServerError, gin.H{ "error": err.Error(), }) return } if err := session.InitExchange(session.ExchangeName.String(), nil); err != nil { c.JSON(http.StatusInternalServerError, gin.H{ "error": err.Error(), }) return } if s.Config.Sessions == nil { s.Config.Sessions = make(map[string]*bbgo.ExchangeSession) } s.Config.Sessions[session.Name] = &session s.Environ.AddExchangeSession(session.Name, &session) if err := session.Init(c, s.Environ); err != nil { c.JSON(http.StatusInternalServerError, gin.H{ "error": err.Error(), }) return } c.JSON(http.StatusOK, gin.H{"success": true}) }) r.GET("/api/assets", s.listAssets) r.GET("/api/sessions/:session", s.listSessions) r.GET("/api/sessions/:session/trades", s.listSessionTrades) r.GET("/api/sessions/:session/open-orders", s.listSessionOpenOrders) r.GET("/api/sessions/:session/account", s.getSessionAccount) r.GET("/api/sessions/:session/account/balances", s.getSessionAccountBalance) r.GET("/api/sessions/:session/symbols", s.listSessionSymbols) r.GET("/api/sessions/:session/pnl", func(c *gin.Context) { c.JSON(200, gin.H{"message": "pong"}) }) r.GET("/api/sessions/:session/market/:symbol/open-orders", func(c *gin.Context) { c.JSON(200, gin.H{"message": "pong"}) }) r.GET("/api/sessions/:session/market/:symbol/trades", func(c *gin.Context) { c.JSON(200, gin.H{"message": "pong"}) }) r.GET("/api/sessions/:session/market/:symbol/pnl", func(c *gin.Context) { c.JSON(200, gin.H{"message": "pong"}) }) r.GET("/api/strategies/single", s.listStrategies) r.NoRoute(s.assetsHandler) return r } func (s *Server) RunWithListener(ctx context.Context, l net.Listener) error { r := s.newEngine() bind := l.Addr().String() if s.OpenInBrowser { openBrowser(ctx, bind) } s.srv = newServer(r, bind) return serve(s.srv, l) } func (s *Server) Run(ctx context.Context, bindArgs ...string) error { r := s.newEngine() bind := resolveBind(bindArgs) if s.OpenInBrowser { openBrowser(ctx, bind) } s.srv = newServer(r, bind) return listenAndServe(s.srv) } func (s *Server) ping(c *gin.Context) { c.JSON(http.StatusOK, gin.H{"message": "pong"}) } func (s *Server) listClosedOrders(c *gin.Context) { if s.Environ.OrderService == nil { c.JSON(http.StatusInternalServerError, gin.H{"error": "database is not configured"}) return } exchange := c.Query("exchange") symbol := c.Query("symbol") gidStr := c.DefaultQuery("gid", "0") lastGID, err := strconv.ParseInt(gidStr, 10, 64) if err != nil { logrus.WithError(err).Error("last gid parse error") c.Status(http.StatusBadRequest) return } orders, err := s.Environ.OrderService.Query(service.QueryOrdersOptions{ Exchange: types.ExchangeName(exchange), Symbol: symbol, LastGID: lastGID, Ordering: "DESC", }) if err != nil { c.Status(http.StatusBadRequest) logrus.WithError(err).Error("order query error") return } c.JSON(http.StatusOK, gin.H{ "orders": orders, }) } func (s *Server) listStrategies(c *gin.Context) { var stashes []map[string]interface{} for _, mount := range s.Config.ExchangeStrategies { stash, err := mount.Map() if err != nil { c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()}) return } stash["strategy"] = mount.Strategy.ID() stashes = append(stashes, stash) } if len(stashes) == 0 { c.JSON(http.StatusOK, gin.H{"strategies": []int{}}) } c.JSON(http.StatusOK, gin.H{"strategies": stashes}) } func (s *Server) listSessions(c *gin.Context) { sessionName := c.Param("session") session, ok := s.Environ.Session(sessionName) if !ok { c.JSON(http.StatusNotFound, gin.H{"error": fmt.Sprintf("session %s not found", sessionName)}) return } c.JSON(http.StatusOK, gin.H{"session": session}) } func (s *Server) listSessionSymbols(c *gin.Context) { sessionName := c.Param("session") session, ok := s.Environ.Session(sessionName) if !ok { c.JSON(http.StatusNotFound, gin.H{"error": fmt.Sprintf("session %s not found", sessionName)}) return } var symbols []string for symbol := range session.Markets() { symbols = append(symbols, symbol) } c.JSON(http.StatusOK, gin.H{"symbols": symbols}) } func (s *Server) listSessionTrades(c *gin.Context) { sessionName := c.Param("session") session, ok := s.Environ.Session(sessionName) if !ok { c.JSON(http.StatusNotFound, gin.H{"error": fmt.Sprintf("session %s not found", sessionName)}) return } c.JSON(http.StatusOK, gin.H{"trades": session.Trades}) } func (s *Server) getSessionAccount(c *gin.Context) { sessionName := c.Param("session") session, ok := s.Environ.Session(sessionName) if !ok { c.JSON(http.StatusNotFound, gin.H{"error": fmt.Sprintf("session %s not found", sessionName)}) return } c.JSON(http.StatusOK, gin.H{"account": session.Account}) } func (s *Server) getSessionAccountBalance(c *gin.Context) { sessionName := c.Param("session") session, ok := s.Environ.Session(sessionName) if !ok { c.JSON(http.StatusNotFound, gin.H{"error": fmt.Sprintf("session %s not found", sessionName)}) return } if session.Account == nil { c.JSON(http.StatusNotFound, gin.H{"error": fmt.Sprintf("the account of session %s is nil", sessionName)}) return } c.JSON(http.StatusOK, gin.H{"balances": session.Account.Balances()}) } func (s *Server) listSessionOpenOrders(c *gin.Context) { sessionName := c.Param("session") session, ok := s.Environ.Session(sessionName) if !ok { c.JSON(http.StatusNotFound, gin.H{"error": fmt.Sprintf("session %s not found", sessionName)}) return } marketOrders := make(map[string][]types.Order) for symbol, orderStore := range session.OrderStores() { marketOrders[symbol] = orderStore.Orders() } c.JSON(http.StatusOK, gin.H{"orders": marketOrders}) } func genFakeAssets() types.AssetMap { totalAssets := types.AssetMap{} balances := types.BalanceMap{ "BTC": types.Balance{Currency: "BTC", Available: fixedpoint.NewFromFloat(10.0 * rand.Float64())}, "BCH": types.Balance{Currency: "BCH", Available: fixedpoint.NewFromFloat(0.01 * rand.Float64())}, "LTC": types.Balance{Currency: "LTC", Available: fixedpoint.NewFromFloat(200.0 * rand.Float64())}, "ETH": types.Balance{Currency: "ETH", Available: fixedpoint.NewFromFloat(50.0 * rand.Float64())}, "SAND": types.Balance{Currency: "SAND", Available: fixedpoint.NewFromFloat(11500.0 * rand.Float64())}, "BNB": types.Balance{Currency: "BNB", Available: fixedpoint.NewFromFloat(1000.0 * rand.Float64())}, "GRT": types.Balance{Currency: "GRT", Available: fixedpoint.NewFromFloat(1000.0 * rand.Float64())}, "MAX": types.Balance{Currency: "MAX", Available: fixedpoint.NewFromFloat(200000.0 * rand.Float64())}, "COMP": types.Balance{Currency: "COMP", Available: fixedpoint.NewFromFloat(100.0 * rand.Float64())}, } assets := balances.Assets(map[string]fixedpoint.Value{ "BTCUSDT": fixedpoint.NewFromFloat(38000.0), "BCHUSDT": fixedpoint.NewFromFloat(478.0), "LTCUSDT": fixedpoint.NewFromFloat(150.0), "COMPUSDT": fixedpoint.NewFromFloat(450.0), "ETHUSDT": fixedpoint.NewFromFloat(1700.0), "BNBUSDT": fixedpoint.NewFromFloat(70.0), "GRTUSDT": fixedpoint.NewFromFloat(0.89), "DOTUSDT": fixedpoint.NewFromFloat(20.0), "SANDUSDT": fixedpoint.NewFromFloat(0.13), "MAXUSDT": fixedpoint.NewFromFloat(0.122), }) for currency, asset := range assets { totalAssets[currency] = asset } return totalAssets } func (s *Server) listAssets(c *gin.Context) { if ok, err := strconv.ParseBool(os.Getenv("USE_FAKE_ASSETS")); err == nil && ok { c.JSON(http.StatusOK, gin.H{"assets": genFakeAssets()}) return } totalAssets := types.AssetMap{} for _, session := range s.Environ.Sessions() { balances := session.Account.Balances() if err := session.UpdatePrices(c); err != nil { logrus.WithError(err).Error("price update failed") c.Status(http.StatusInternalServerError) return } assets := balances.Assets(session.LastPrices()) for currency, asset := range assets { totalAssets[currency] = asset } } c.JSON(http.StatusOK, gin.H{"assets": totalAssets}) } func (s *Server) setupSaveConfig(c *gin.Context) { if len(s.Config.Sessions) == 0 { c.JSON(http.StatusBadRequest, gin.H{"error": "session is not configured"}) return } envVars, err := collectSessionEnvVars(s.Config.Sessions) if err != nil { c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()}) return } if s.Environ.DatabaseService != nil { envVars["DB_DRIVER"] = s.Environ.DatabaseService.Driver envVars["DB_DSN"] = s.Environ.DatabaseService.DSN } dotenvFile := ".env.local" if err := moveFileToBackup(dotenvFile); err != nil { c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()}) return } if err := godotenv.Write(envVars, dotenvFile); err != nil { c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()}) return } out, err := s.Config.YAML() if err != nil { c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()}) return } fmt.Println("config file") fmt.Println("=================================================") fmt.Println(string(out)) fmt.Println("=================================================") filename := "bbgo.yaml" if err := moveFileToBackup(filename); err != nil { c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()}) return } if err := ioutil.WriteFile(filename, out, 0666); err != nil { c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()}) return } c.JSON(http.StatusOK, gin.H{"success": true}) } var pageRoutePattern = regexp.MustCompile("/[a-z]+$") func moveFileToBackup(filename string) error { stat, err := os.Stat(filename) if err == nil && stat != nil { err := os.Rename(filename, filename+"."+time.Now().Format("20060102_150405_07_00")) if err != nil { return err } } return nil } func (s *Server) tradingVolume(c *gin.Context) { if s.Environ.TradeService == nil { c.JSON(http.StatusInternalServerError, gin.H{"error": "database is not configured"}) return } period := c.DefaultQuery("period", "day") segment := c.DefaultQuery("segment", "exchange") startTimeStr := c.Query("start-time") var startTime time.Time if startTimeStr != "" { v, err := time.Parse(time.RFC3339, startTimeStr) if err != nil { c.Status(http.StatusBadRequest) logrus.WithError(err).Error("start-time format incorrect") return } startTime = v } else { switch period { case "day": startTime = time.Now().AddDate(0, 0, -30) case "month": startTime = time.Now().AddDate(0, -6, 0) case "year": startTime = time.Now().AddDate(-2, 0, 0) default: startTime = time.Now().AddDate(0, 0, -7) } } rows, err := s.Environ.TradeService.QueryTradingVolume(startTime, service.TradingVolumeQueryOptions{ SegmentBy: segment, GroupByPeriod: period, }) if err != nil { logrus.WithError(err).Error("trading volume query error") c.Status(http.StatusInternalServerError) return } c.JSON(http.StatusOK, gin.H{"tradingVolumes": rows}) return } func newServer(r http.Handler, bind string) *http.Server { return &http.Server{ Addr: bind, Handler: r, } } func serve(srv *http.Server, l net.Listener) (err error) { defer func() { if err != nil && err != http.ErrServerClosed { logrus.WithError(err).Error("unexpected http server error") } }() err = srv.Serve(l) if err != http.ErrServerClosed { return err } return nil } func listenAndServe(srv *http.Server) error { var err error defer func() { if err != nil && err != http.ErrServerClosed { logrus.WithError(err).Error("unexpected http server error") } }() err = srv.ListenAndServe() if err != http.ErrServerClosed { return err } return nil }