d0zingcat/gocryptotrader
1
0
Fork 0
mirror of https://github.com/d0zingcat/gocryptotrader.git synced 2026-05-24 23:16:52 +00:00
Code Issues Packages Projects Releases Wiki Activity

exchanges: Initial context propagation (#744)

Browse Source 
* gct: phase one context awareness pass

* exchanges: context propagation pass

* common/requester: force context requirement

* gctcli/exchanges: linter fix

* rpcserver: fix test using dummy rpc server

* backtester: fix comments

* grpc: add correct cancel and timeout for commands

* rpcserver_test: add comment on dummy server

* common: deprecated SendHTTPGetRequest

* linter: fix

* linter: turn on no context check

* apichecker: fix context linter issue

* binance: use param context

* common: remove checks as this gets executed before main

* common: change mutex to RW as clients can be used by multiple go routines.

* common: remove init and JIT default client. Unexport global variables and add protection.

* common: Add comments

* bithumb: after dinner mints fix
This commit is contained in:
Ryan O'Hara-Reid
2021-09-11 13:52:07 +10:00
committed by GitHub
parent 72516f7268
commit d636049fb2
168 changed files with 8085 additions and 6996 deletions
Download Patch File Download Diff File Expand all files Collapse all files

103
cmd/apichecker/apicheck.go
View File

@@ -71,9 +71,11 @@ const (
)
var (
verbose, add, create, testMode bool
apiKey, apiToken, trelloBoardID, trelloBoardName, trelloListID, trelloChecklistID, trelloCardID, exchangeName, checkType, tokenData, key, val, tokenDataEnd, textTokenData, dateFormat, regExp, checkString, path string
configData, testConfigData, usageData Config
verbose, add, create, testMode bool
apiKey, apiToken, trelloBoardID, trelloBoardName, trelloListID,
trelloChecklistID, trelloCardID, exchangeName, checkType, tokenData,
key, val, tokenDataEnd, textTokenData, dateFormat, regExp, path string
configData, testConfigData, usageData Config
)
func main() {
@@ -606,9 +608,9 @@ func fillData(exchName, checkType string, data interface{}) (ExchangeInfo, error
// htmlScrapeDefault gets check string data for the default cases
func htmlScrapeDefault(htmlData *HTMLScrapingData) ([]string, error) {
var resp []string
temp, err := http.Get(htmlData.Path)
temp, err := sendHTTPGetRequest(htmlData.Path, nil)
if err != nil {
return resp, err
return nil, err
}
defer temp.Body.Close()
tokenizer := html.NewTokenizer(temp.Body)
@@ -660,13 +662,14 @@ loop:
// htmlScrapeBTSE gets the check string for BTSE exchange
func htmlScrapeBTSE(htmlData *HTMLScrapingData) ([]string, error) {
var resp []string
temp, err := http.Get(htmlData.Path)
temp, err := sendHTTPGetRequest(htmlData.Path, nil)
if err != nil {
return resp, err
return nil, err
}
defer temp.Body.Close()
tokenizer := html.NewTokenizer(temp.Body)
var resp []string
loop:
for {
next := tokenizer.Next()
@@ -693,9 +696,9 @@ loop:
// htmlScrapeBitmex gets the check string for Bitmex exchange
func htmlScrapeBitmex(htmlData *HTMLScrapingData) ([]string, error) {
var resp []string
temp, err := http.Get(htmlData.Path)
temp, err := sendHTTPGetRequest(htmlData.Path, nil)
if err != nil {
return resp, err
return nil, err
}
defer temp.Body.Close()
tokenizer := html.NewTokenizer(temp.Body)
@@ -731,11 +734,12 @@ loop:
// htmlScrapeHitBTC gets the check string for HitBTC Exchange
func htmlScrapeHitBTC(htmlData *HTMLScrapingData) ([]string, error) {
temp, err := http.Get(htmlData.Path)
temp, err := sendHTTPGetRequest(htmlData.Path, nil)
if err != nil {
return nil, err
}
defer temp.Body.Close()
a, err := ioutil.ReadAll(temp.Body)
if err != nil {
return nil, err
@@ -766,9 +770,9 @@ func htmlScrapeHitBTC(htmlData *HTMLScrapingData) ([]string, error) {
// htmlScrapeBTCMarkets gets the check string for BTCMarkets exchange
func htmlScrapeBTCMarkets(htmlData *HTMLScrapingData) ([]string, error) {
var resp []string
temp, err := http.Get(htmlData.Path)
temp, err := sendHTTPGetRequest(htmlData.Path, nil)
if err != nil {
return resp, err
return nil, err
}
defer temp.Body.Close()
tempData, err := ioutil.ReadAll(temp.Body)
@@ -787,9 +791,9 @@ func htmlScrapeBTCMarkets(htmlData *HTMLScrapingData) ([]string, error) {
// htmlScrapeOk gets the check string for Okex
func htmlScrapeOk(htmlData *HTMLScrapingData) ([]string, error) {
var resp []string
temp, err := http.Get(htmlData.Path)
temp, err := sendHTTPGetRequest(htmlData.Path, nil)
if err != nil {
return resp, err
return nil, err
}
defer temp.Body.Close()
tokenizer := html.NewTokenizer(temp.Body)
@@ -841,11 +845,12 @@ loop:
// htmlScrapeANX gets the check string for BTCMarkets exchange
func htmlScrapeANX(htmlData *HTMLScrapingData) ([]string, error) {
temp, err := http.Get(htmlData.Path)
temp, err := sendHTTPGetRequest(htmlData.Path, nil)
if err != nil {
return nil, err
}
defer temp.Body.Close()
a, err := ioutil.ReadAll(temp.Body)
if err != nil {
return nil, err
@@ -875,16 +880,15 @@ func htmlScrapeANX(htmlData *HTMLScrapingData) ([]string, error) {
// htmlScrapeExmo gets the check string for Exmo Exchange
func htmlScrapeExmo(htmlData *HTMLScrapingData) ([]string, error) {
temp, err := http.NewRequest(http.MethodGet, htmlData.Path, nil)
if err != nil {
return nil, err
}
temp.Header.Set("User-Agent", "GCT")
httpClient := &http.Client{}
httpResp, err := httpClient.Do(temp)
header := map[string]string{
"User-Agent": "GCT",
}
httpResp, err := sendHTTPGetRequest(htmlData.Path, header)
if err != nil {
return nil, err
}
defer httpResp.Body.Close()
a, err := ioutil.ReadAll(httpResp.Body)
if err != nil {
@@ -902,9 +906,9 @@ func htmlScrapeExmo(htmlData *HTMLScrapingData) ([]string, error) {
// htmlScrapePoloniex gets the check string for Poloniex Exchange
func htmlScrapePoloniex(htmlData *HTMLScrapingData) ([]string, error) {
var resp []string
temp, err := http.Get(htmlData.Path)
temp, err := sendHTTPGetRequest(htmlData.Path, nil)
if err != nil {
return resp, err
return nil, err
}
defer temp.Body.Close()
tokenizer := html.NewTokenizer(temp.Body)
@@ -955,9 +959,9 @@ loop:
// htmlScrapeItBit gets the check string for ItBit Exchange
func htmlScrapeItBit(htmlData *HTMLScrapingData) ([]string, error) {
var resp []string
temp, err := http.Get(htmlData.Path)
temp, err := sendHTTPGetRequest(htmlData.Path, nil)
if err != nil {
return resp, err
return nil, err
}
defer temp.Body.Close()
tokenizer := html.NewTokenizer(temp.Body)
@@ -989,11 +993,12 @@ loop:
// htmlScrapeBitstamp gets the check string for Bitstamp Exchange
func htmlScrapeBitstamp(htmlData *HTMLScrapingData) ([]string, error) {
temp, err := http.Get(htmlData.Path)
temp, err := sendHTTPGetRequest(htmlData.Path, nil)
if err != nil {
return nil, err
}
defer temp.Body.Close()
a, err := ioutil.ReadAll(temp.Body)
if err != nil {
return nil, err
@@ -1010,9 +1015,9 @@ func htmlScrapeBitstamp(htmlData *HTMLScrapingData) ([]string, error) {
// htmlScrapeAlphaPoint gets the check string for Kraken Exchange
func htmlScrapeAlphaPoint(htmlData *HTMLScrapingData) ([]string, error) {
var resp []string
temp, err := http.Get(htmlData.Path)
temp, err := sendHTTPGetRequest(htmlData.Path, nil)
if err != nil {
return resp, err
return nil, err
}
defer temp.Body.Close()
tokenizer := html.NewTokenizer(temp.Body)
@@ -1065,9 +1070,9 @@ loop:
// htmlScrapeYobit gets the check string for Yobit Exchange
func htmlScrapeYobit(htmlData *HTMLScrapingData) ([]string, error) {
var resp []string
temp, err := http.Get(htmlData.Path)
temp, err := sendHTTPGetRequest(htmlData.Path, nil)
if err != nil {
return resp, err
return nil, err
}
defer temp.Body.Close()
tokenizer := html.NewTokenizer(temp.Body)
@@ -1123,11 +1128,12 @@ loop:
// htmlScrapeLocalBitcoins gets the check string for Yobit Exchange
func htmlScrapeLocalBitcoins(htmlData *HTMLScrapingData) ([]string, error) {
temp, err := http.Get(htmlData.Path)
temp, err := sendHTTPGetRequest(htmlData.Path, nil)
if err != nil {
return nil, err
}
defer temp.Body.Close()
a, err := ioutil.ReadAll(temp.Body)
if err != nil {
return nil, err
@@ -1463,9 +1469,9 @@ func trelloCreateNewChecklist() error {
// htmlScrapeKraken gets the check string for Kraken Exchange
func htmlScrapeKraken(htmlData *HTMLScrapingData) ([]string, error) {
var resp []string
temp, err := http.Get(htmlData.Path)
temp, err := sendHTTPGetRequest(htmlData.Path, nil)
if err != nil {
return resp, err
return nil, err
}
defer temp.Body.Close()
tokenizer := html.NewTokenizer(temp.Body)
@@ -1520,9 +1526,9 @@ loop:
func htmlScrapeBitflyer(htmlData *HTMLScrapingData) ([]string, error) {
var resp []string
var tempArray []string
temp, err := http.Get(htmlData.Path)
temp, err := sendHTTPGetRequest(htmlData.Path, nil)
if err != nil {
return resp, err
return nil, err
}
defer temp.Body.Close()
tokenizer := html.NewTokenizer(temp.Body)
@@ -1571,7 +1577,7 @@ loop:
// htmlScrapeFTX gets the check string for FTX exchange
func htmlScrapeFTX(htmlData *HTMLScrapingData) ([]string, error) {
temp, err := http.Get(htmlData.Path)
temp, err := sendHTTPGetRequest(htmlData.Path, nil)
if err != nil {
return nil, err
}
@@ -1660,11 +1666,12 @@ loop:
// htmlScrapeBitfinex gets the check string for Bitfinex exchange
func htmlScrapeBitfinex(htmlData *HTMLScrapingData) ([]string, error) {
temp, err := http.Get(htmlData.Path)
temp, err := sendHTTPGetRequest(htmlData.Path, nil)
if err != nil {
return nil, err
}
defer temp.Body.Close()
a, err := ioutil.ReadAll(temp.Body)
if err != nil {
return nil, err
@@ -1693,11 +1700,12 @@ func htmlScrapeBitfinex(htmlData *HTMLScrapingData) ([]string, error) {
// htmlScrapeBinance gets checkstring for binance exchange
func htmlScrapeBinance(htmlData *HTMLScrapingData) ([]string, error) {
temp, err := http.Get(htmlData.Path)
temp, err := sendHTTPGetRequest(htmlData.Path, nil)
if err != nil {
return nil, err
}
defer temp.Body.Close()
tokenizer := html.NewTokenizer(temp.Body)
var resp []string
loop:
@@ -1744,3 +1752,18 @@ loop:
}
return resp, nil
}
func sendHTTPGetRequest(path string, headers map[string]string) (*http.Response, error) {
req, err := http.NewRequestWithContext(context.TODO(),
http.MethodGet,
path,
nil)
if err != nil {
return nil, err
}
for k, v := range headers {
req.Header.Set(k, v)
}
return http.DefaultClient.Do(req)
}

18
cmd/documentation/documentation.go
View File

@@ -1,6 +1,7 @@
package main
import (
"context"
"encoding/json"
"errors"
"flag"
@@ -8,6 +9,7 @@ import (
"html/template"
"io/ioutil"
"log"
"net/http"
"os"
"path/filepath"
"strings"
@@ -162,7 +164,7 @@ func main() {
if verbose {
fmt.Println("Fetching repository contributor list...")
}
contributors, err = GetContributorList(config.GithubRepo)
contributors, err = GetContributorList(config.GithubRepo, verbose)
if err != nil {
log.Fatalf("Documentation Generation Tool - GetContributorList error %s",
err)
@@ -432,9 +434,19 @@ func GetTemplateFiles() (*template.Template, error) {
// GetContributorList fetches a list of contributors from the github api
// endpoint
func GetContributorList(repo string) ([]Contributor, error) {
func GetContributorList(repo string, verbose bool) ([]Contributor, error) {
contents, err := common.SendHTTPRequest(context.TODO(),
http.MethodGet,
repo+GithubAPIEndpoint,
nil,
nil,
verbose)
if err != nil {
return nil, err
}
var resp []Contributor
return resp, common.SendHTTPGetRequest(repo+GithubAPIEndpoint, true, false, &resp)
return resp, json.Unmarshal(contents, &resp)
}
// GetDocumentationAttributes returns specific attributes for a file template

52
cmd/exchange_template/wrapper_file.tmpl
View File

@@ -214,14 +214,14 @@ func ({{.Variable}} *{{.CapitalName}}) Run() {
}
// FetchTradablePairs returns a list of the exchanges tradable pairs
func ({{.Variable}} *{{.CapitalName}}) FetchTradablePairs(asset asset.Item) ([]string, error) {
func ({{.Variable}} *{{.CapitalName}}) FetchTradablePairs(ctx context.Context, asset asset.Item) ([]string, error) {
// Implement fetching the exchange available pairs if supported
return nil, nil
}
// UpdateTradablePairs updates the exchanges available pairs and stores
// them in the exchanges config
func ({{.Variable}} *{{.CapitalName}}) UpdateTradablePairs(forceUpdate bool) error {
func ({{.Variable}} *{{.CapitalName}}) UpdateTradablePairs(ctx context.Context, forceUpdate bool) error {
pairs, err := {{.Variable}}.FetchTradablePairs(asset.Spot)
if err != nil {
return err
@@ -237,7 +237,7 @@ func ({{.Variable}} *{{.CapitalName}}) UpdateTradablePairs(forceUpdate bool) err
// UpdateTicker updates and returns the ticker for a currency pair
func ({{.Variable}} *{{.CapitalName}}) UpdateTicker(p currency.Pair, assetType asset.Item) (*ticker.Price, error) {
func ({{.Variable}} *{{.CapitalName}}) UpdateTicker(ctx context.Context, p currency.Pair, assetType asset.Item) (*ticker.Price, error) {
// NOTE: EXAMPLE FOR GETTING TICKER PRICE
/*
tickerPrice := new(ticker.Price)
@@ -298,7 +298,7 @@ func ({{.Variable}} *{{.CapitalName}}) UpdateTickers(assetType asset.Item) error
}
// FetchTicker returns the ticker for a currency pair
func ({{.Variable}} *{{.CapitalName}}) FetchTicker(p currency.Pair, assetType asset.Item) (*ticker.Price, error) {
func ({{.Variable}} *{{.CapitalName}}) FetchTicker(ctx context.Context, p currency.Pair, assetType asset.Item) (*ticker.Price, error) {
tickerNew, err := ticker.GetTicker({{.Variable}}.Name, p, assetType)
if err != nil {
return {{.Variable}}.UpdateTicker(p, assetType)
@@ -307,7 +307,7 @@ func ({{.Variable}} *{{.CapitalName}}) FetchTicker(p currency.Pair, assetType as
}
// FetchOrderbook returns orderbook base on the currency pair
func ({{.Variable}} *{{.CapitalName}}) FetchOrderbook(currency currency.Pair, assetType asset.Item) (*orderbook.Base, error) {
func ({{.Variable}} *{{.CapitalName}}) FetchOrderbook(ctx context.Context, c currency.Pair, assetType asset.Item) (*orderbook.Base, error) {
ob, err := orderbook.Get({{.Variable}}.Name, currency, assetType)
if err != nil {
return {{.Variable}}.UpdateOrderbook(currency, assetType)
@@ -316,7 +316,7 @@ func ({{.Variable}} *{{.CapitalName}}) FetchOrderbook(currency currency.Pair, as
}
// UpdateOrderbook updates and returns the orderbook for a currency pair
func ({{.Variable}} *{{.CapitalName}}) UpdateOrderbook(p currency.Pair, assetType asset.Item) (*orderbook.Base, error) {
func ({{.Variable}} *{{.CapitalName}}) UpdateOrderbook(ctx context.Context, p currency.Pair, assetType asset.Item) (*orderbook.Base, error) {
book := &orderbook.Base{
Exchange: {{.Variable}}.Name,
Pair: p,
@@ -355,28 +355,28 @@ func ({{.Variable}} *{{.CapitalName}}) UpdateOrderbook(p currency.Pair, assetTyp
}
// UpdateAccountInfo retrieves balances for all enabled currencies
func ({{.Variable}} *{{.CapitalName}}) UpdateAccountInfo(assetType asset.Item) (account.Holdings, error) {
func ({{.Variable}} *{{.CapitalName}}) UpdateAccountInfo(ctx context.Context, assetType asset.Item) (account.Holdings, error) {
return account.Holdings{}, common.ErrNotYetImplemented
}
// FetchAccountInfo retrieves balances for all enabled currencies
func ({{.Variable}} *{{.CapitalName}}) FetchAccountInfo(assetType asset.Item) (account.Holdings, error) {
func ({{.Variable}} *{{.CapitalName}}) FetchAccountInfo(ctx context.Context, assetType asset.Item) (account.Holdings, error) {
return account.Holdings{}, common.ErrNotYetImplemented
}
// GetFundingHistory returns funding history, deposits and
// withdrawals
func ({{.Variable}} *{{.CapitalName}}) GetFundingHistory() ([]exchange.FundHistory, error) {
func ({{.Variable}} *{{.CapitalName}}) GetFundingHistory(ctx context.Context) ([]exchange.FundHistory, error) {
return nil, common.ErrNotYetImplemented
}
// GetWithdrawalsHistory returns previous withdrawals data
func ({{.Variable}} *{{.CapitalName}}) GetWithdrawalsHistory(c currency.Code) (resp []exchange.WithdrawalHistory, err error) {
func ({{.Variable}} *{{.CapitalName}}) GetWithdrawalsHistory(ctx context.Context, c currency.Code) (resp []exchange.WithdrawalHistory, err error) {
return nil, common.ErrNotYetImplemented
}
// GetRecentTrades returns the most recent trades for a currency and asset
func ({{.Variable}} *{{.CapitalName}}) GetRecentTrades(p currency.Pair, assetType asset.Item) ([]trade.Data, error) {
func ({{.Variable}} *{{.CapitalName}}) GetRecentTrades(ctx context.Context, p currency.Pair, assetType asset.Item) ([]trade.Data, error) {
return nil, common.ErrNotYetImplemented
}
@@ -386,7 +386,7 @@ func ({{.Variable}} *{{.CapitalName}}) GetHistoricTrades (p currency.Pair, asset
}
// SubmitOrder submits a new order
func ({{.Variable}} *{{.CapitalName}}) SubmitOrder(s *order.Submit) (order.SubmitResponse, error) {
func ({{.Variable}} *{{.CapitalName}}) SubmitOrder(ctx context.Context, s *order.Submit) (order.SubmitResponse, error) {
var submitOrderResponse order.SubmitResponse
if err := s.Validate(); err != nil {
return submitOrderResponse, err
@@ -404,7 +404,7 @@ func ({{.Variable}} *{{.CapitalName}}) ModifyOrder(action *order.Modify) (string
}
// CancelOrder cancels an order by its corresponding ID number
func ({{.Variable}} *{{.CapitalName}}) CancelOrder(ord *order.Cancel) error {
func ({{.Variable}} *{{.CapitalName}}) CancelOrder(ctx context.Context, ord *order.Cancel) error {
// if err := ord.Validate(ord.StandardCancel()); err != nil {
// return err
// }
@@ -412,12 +412,12 @@ func ({{.Variable}} *{{.CapitalName}}) CancelOrder(ord *order.Cancel) error {
}
// CancelBatchOrders cancels orders by their corresponding ID numbers
func ({{.Variable}} *{{.CapitalName}}) CancelBatchOrders(orders []order.Cancel) (order.CancelBatchResponse, error) {
func ({{.Variable}} *{{.CapitalName}}) CancelBatchOrders(ctx context.Context, orders []order.Cancel) (order.CancelBatchResponse, error) {
return order.CancelBatchResponse{}, common.ErrNotYetImplemented
}
// CancelAllOrders cancels all orders associated with a currency pair
func ({{.Variable}} *{{.CapitalName}}) CancelAllOrders(orderCancellation *order.Cancel) (order.CancelAllResponse, error) {
func ({{.Variable}} *{{.CapitalName}}) CancelAllOrders(ctx context.Context, orderCancellation *order.Cancel) (order.CancelAllResponse, error) {
// if err := orderCancellation.Validate(); err != nil {
// return err
// }
@@ -425,18 +425,18 @@ func ({{.Variable}} *{{.CapitalName}}) CancelAllOrders(orderCancellation *order.
}
// GetOrderInfo returns order information based on order ID
func ({{.Variable}} *{{.CapitalName}}) GetOrderInfo(orderID string, pair currency.Pair, assetType asset.Item) (order.Detail, error) {
func ({{.Variable}} *{{.CapitalName}}) GetOrderInfo(ctx context.Context, orderID string, pair currency.Pair, assetType asset.Item) (order.Detail, error) {
return order.Detail{}, common.ErrNotYetImplemented
}
// GetDepositAddress returns a deposit address for a specified currency
func ({{.Variable}} *{{.CapitalName}}) GetDepositAddress(cryptocurrency currency.Code, accountID string) (string, error) {
func ({{.Variable}} *{{.CapitalName}}) GetDepositAddress(ctx context.Context, c currency.Code, accountID string) (string, error) {
return "", common.ErrNotYetImplemented
}
// WithdrawCryptocurrencyFunds returns a withdrawal ID when a withdrawal is
// submitted
func ({{.Variable}} *{{.CapitalName}}) WithdrawCryptocurrencyFunds(withdrawRequest *withdraw.Request) (*withdraw.ExchangeResponse, error) {
func ({{.Variable}} *{{.CapitalName}}) WithdrawCryptocurrencyFunds(ctx context.Context, withdrawRequest *withdraw.Request) (*withdraw.ExchangeResponse, error) {
// if err := withdrawRequest.Validate(); err != nil {
// return nil, err
// }
@@ -445,7 +445,7 @@ func ({{.Variable}} *{{.CapitalName}}) WithdrawCryptocurrencyFunds(withdrawReque
// WithdrawFiatFunds returns a withdrawal ID when a withdrawal is
// submitted
func ({{.Variable}} *{{.CapitalName}}) WithdrawFiatFunds(withdrawRequest *withdraw.Request) (*withdraw.ExchangeResponse, error) {
func ({{.Variable}} *{{.CapitalName}}) WithdrawFiatFunds(ctx context.Context, withdrawRequest *withdraw.Request) (*withdraw.ExchangeResponse, error) {
// if err := withdrawRequest.Validate(); err != nil {
// return nil, err
// }
@@ -454,7 +454,7 @@ func ({{.Variable}} *{{.CapitalName}}) WithdrawFiatFunds(withdrawRequest *withdr
// WithdrawFiatFundsToInternationalBank returns a withdrawal ID when a withdrawal is
// submitted
func ({{.Variable}} *{{.CapitalName}}) WithdrawFiatFundsToInternationalBank(withdrawRequest *withdraw.Request) (*withdraw.ExchangeResponse, error) {
func ({{.Variable}} *{{.CapitalName}}) WithdrawFiatFundsToInternationalBank(ctx context.Context, withdrawRequest *withdraw.Request) (*withdraw.ExchangeResponse, error) {
// if err := withdrawRequest.Validate(); err != nil {
// return nil, err
// }
@@ -462,7 +462,7 @@ func ({{.Variable}} *{{.CapitalName}}) WithdrawFiatFundsToInternationalBank(with
}
// GetActiveOrders retrieves any orders that are active/open
func ({{.Variable}} *{{.CapitalName}}) GetActiveOrders(getOrdersRequest *order.GetOrdersRequest) ([]order.Detail, error) {
func ({{.Variable}} *{{.CapitalName}}) GetActiveOrders(ctx context.Context, getOrdersRequest *order.GetOrdersRequest) ([]order.Detail, error) {
// if err := getOrdersRequest.Validate(); err != nil {
// return nil, err
// }
@@ -471,7 +471,7 @@ func ({{.Variable}} *{{.CapitalName}}) GetActiveOrders(getOrdersRequest *order.G
// GetOrderHistory retrieves account order information
// Can Limit response to specific order status
func ({{.Variable}} *{{.CapitalName}}) GetOrderHistory(getOrdersRequest *order.GetOrdersRequest) ([]order.Detail, error) {
func ({{.Variable}} *{{.CapitalName}}) GetOrderHistory(ctx context.Context, getOrdersRequest *order.GetOrdersRequest) ([]order.Detail, error) {
// if err := getOrdersRequest.Validate(); err != nil {
// return nil, err
// }
@@ -479,23 +479,23 @@ func ({{.Variable}} *{{.CapitalName}}) GetOrderHistory(getOrdersRequest *order.G
}
// GetFeeByType returns an estimate of fee based on the type of transaction
func ({{.Variable}} *{{.CapitalName}}) GetFeeByType(feeBuilder *exchange.FeeBuilder) (float64, error) {
func ({{.Variable}} *{{.CapitalName}}) GetFeeByType(ctx context.Context, feeBuilder *exchange.FeeBuilder) (float64, error) {
return 0, common.ErrNotYetImplemented
}
// ValidateCredentials validates current credentials used for wrapper
func ({{.Variable}} *{{.CapitalName}}) ValidateCredentials(assetType asset.Item) error {
func ({{.Variable}} *{{.CapitalName}}) ValidateCredentials(ctx context.Context, assetType asset.Item) error {
_, err := {{.Variable}}.UpdateAccountInfo(assetType)
return {{.Variable}}.CheckTransientError(err)
}
// GetHistoricCandles returns candles between a time period for a set time interval
func ({{.Variable}} *{{.CapitalName}}) GetHistoricCandles(pair currency.Pair, a asset.Item, start, end time.Time, interval kline.Interval) (kline.Item, error) {
func ({{.Variable}} *{{.CapitalName}}) GetHistoricCandles(ctx context.Context, pair currency.Pair, a asset.Item, start, end time.Time, interval kline.Interval) (kline.Item, error) {
return kline.Item{}, common.ErrNotYetImplemented
}
// GetHistoricCandlesExtended returns candles between a time period for a set time interval
func ({{.Variable}} *{{.CapitalName}}) GetHistoricCandlesExtended(pair currency.Pair, a asset.Item, start, end time.Time, interval kline.Interval) (kline.Item, error) {
func ({{.Variable}} *{{.CapitalName}}) GetHistoricCandlesExtended(ctx context.Context, pair currency.Pair, a asset.Item, start, end time.Time, interval kline.Interval) (kline.Item, error) {
return kline.Item{}, common.ErrNotYetImplemented
}

55
cmd/exchange_wrapper_coverage/main.go
View File

@@ -1,6 +1,7 @@
package main
import (
"context"
"errors"
"log"
"math/rand"
@@ -83,136 +84,136 @@ func testWrappers(e exchange.IBotExchange) []string {
var funcs []string
_, err := e.FetchTicker(p, assetType)
_, err := e.FetchTicker(context.TODO(), p, assetType)
if errors.Is(err, common.ErrNotYetImplemented) {
funcs = append(funcs, "FetchTicker")
}
_, err = e.UpdateTicker(p, assetType)
_, err = e.UpdateTicker(context.TODO(), p, assetType)
if errors.Is(err, common.ErrNotYetImplemented) {
funcs = append(funcs, "UpdateTicker")
}
_, err = e.FetchOrderbook(p, assetType)
_, err = e.FetchOrderbook(context.TODO(), p, assetType)
if errors.Is(err, common.ErrNotYetImplemented) {
funcs = append(funcs, "FetchOrderbook")
}
_, err = e.UpdateOrderbook(p, assetType)
_, err = e.UpdateOrderbook(context.TODO(), p, assetType)
if errors.Is(err, common.ErrNotYetImplemented) {
funcs = append(funcs, "UpdateOrderbook")
}
_, err = e.FetchTradablePairs(asset.Spot)
_, err = e.FetchTradablePairs(context.TODO(), asset.Spot)
if errors.Is(err, common.ErrNotYetImplemented) {
funcs = append(funcs, "FetchTradablePairs")
}
err = e.UpdateTradablePairs(false)
err = e.UpdateTradablePairs(context.TODO(), false)
if errors.Is(err, common.ErrNotYetImplemented) {
funcs = append(funcs, "UpdateTradablePairs")
}
_, err = e.FetchAccountInfo(assetType)
_, err = e.FetchAccountInfo(context.TODO(), assetType)
if errors.Is(err, common.ErrNotYetImplemented) {
funcs = append(funcs, "GetAccountInfo")
}
_, err = e.GetRecentTrades(p, assetType)
_, err = e.GetRecentTrades(context.TODO(), p, assetType)
if errors.Is(err, common.ErrNotYetImplemented) {
funcs = append(funcs, "GetRecentTrades")
}
_, err = e.GetHistoricTrades(p, assetType, time.Time{}, time.Time{})
_, err = e.GetHistoricTrades(context.TODO(), p, assetType, time.Time{}, time.Time{})
if errors.Is(err, common.ErrNotYetImplemented) {
funcs = append(funcs, "GetHistoricTrades")
}
_, err = e.GetFundingHistory()
_, err = e.GetFundingHistory(context.TODO())
if errors.Is(err, common.ErrNotYetImplemented) {
funcs = append(funcs, "GetFundingHistory")
}
_, err = e.SubmitOrder(nil)
_, err = e.SubmitOrder(context.TODO(), nil)
if errors.Is(err, common.ErrNotYetImplemented) {
funcs = append(funcs, "SubmitOrder")
}
_, err = e.ModifyOrder(nil)
_, err = e.ModifyOrder(context.TODO(), nil)
if errors.Is(err, common.ErrNotYetImplemented) {
funcs = append(funcs, "ModifyOrder")
}
err = e.CancelOrder(nil)
err = e.CancelOrder(context.TODO(), nil)
if errors.Is(err, common.ErrNotYetImplemented) {
funcs = append(funcs, "CancelOrder")
}
_, err = e.CancelBatchOrders(nil)
_, err = e.CancelBatchOrders(context.TODO(), nil)
if errors.Is(err, common.ErrNotYetImplemented) {
funcs = append(funcs, "CancelBatchOrders")
}
_, err = e.CancelAllOrders(nil)
_, err = e.CancelAllOrders(context.TODO(), nil)
if errors.Is(err, common.ErrNotYetImplemented) {
funcs = append(funcs, "CancelAllOrders")
}
_, err = e.GetOrderInfo("1", p, assetType)
_, err = e.GetOrderInfo(context.TODO(), "1", p, assetType)
if errors.Is(err, common.ErrNotYetImplemented) {
funcs = append(funcs, "GetOrderInfo")
}
_, err = e.GetOrderHistory(nil)
_, err = e.GetOrderHistory(context.TODO(), nil)
if errors.Is(err, common.ErrNotYetImplemented) {
funcs = append(funcs, "GetOrderHistory")
}
_, err = e.GetActiveOrders(nil)
_, err = e.GetActiveOrders(context.TODO(), nil)
if errors.Is(err, common.ErrNotYetImplemented) {
funcs = append(funcs, "GetActiveOrders")
}
_, err = e.GetDepositAddress(currency.BTC, "")
_, err = e.GetDepositAddress(context.TODO(), currency.BTC, "")
if errors.Is(err, common.ErrNotYetImplemented) {
funcs = append(funcs, "GetDepositAddress")
}
_, err = e.WithdrawCryptocurrencyFunds(nil)
_, err = e.WithdrawCryptocurrencyFunds(context.TODO(), nil)
if errors.Is(err, common.ErrNotYetImplemented) {
funcs = append(funcs, "WithdrawCryptocurrencyFunds")
}
_, err = e.WithdrawFiatFunds(nil)
_, err = e.WithdrawFiatFunds(context.TODO(), nil)
if errors.Is(err, common.ErrNotYetImplemented) {
funcs = append(funcs, "WithdrawFiatFunds")
}
_, err = e.WithdrawFiatFundsToInternationalBank(nil)
_, err = e.WithdrawFiatFundsToInternationalBank(context.TODO(), nil)
if errors.Is(err, common.ErrNotYetImplemented) {
funcs = append(funcs, "WithdrawFiatFundsToInternationalBank")
}
_, err = e.GetHistoricCandles(currency.Pair{}, asset.Spot, time.Unix(0, 0), time.Unix(0, 0), kline.OneDay)
_, err = e.GetHistoricCandles(context.TODO(), currency.Pair{}, asset.Spot, time.Unix(0, 0), time.Unix(0, 0), kline.OneDay)
if errors.Is(err, common.ErrNotYetImplemented) {
funcs = append(funcs, "GetHistoricCandles")
}
_, err = e.GetHistoricCandlesExtended(currency.Pair{}, asset.Spot, time.Unix(0, 0), time.Unix(0, 0), kline.OneDay)
_, err = e.GetHistoricCandlesExtended(context.TODO(), currency.Pair{}, asset.Spot, time.Unix(0, 0), time.Unix(0, 0), kline.OneDay)
if errors.Is(err, common.ErrNotYetImplemented) {
funcs = append(funcs, "GetHistoricCandlesExtended")
}
_, err = e.UpdateAccountInfo(assetType)
_, err = e.UpdateAccountInfo(context.TODO(), assetType)
if errors.Is(err, common.ErrNotYetImplemented) {
funcs = append(funcs, "UpdateAccountInfo")
}
_, err = e.GetFeeByType(&exchange.FeeBuilder{})
_, err = e.GetFeeByType(context.TODO(), &exchange.FeeBuilder{})
if errors.Is(err, common.ErrNotYetImplemented) {
funcs = append(funcs, "GetFeeByType")
}
err = e.UpdateOrderExecutionLimits(asset.DownsideProfitContract)
err = e.UpdateOrderExecutionLimits(context.TODO(), asset.DownsideProfitContract)
if errors.Is(err, common.ErrNotYetImplemented) {
funcs = append(funcs, "UpdateOrderExecutionLimits")
}

57
cmd/exchange_wrapper_issues/main.go
View File

@@ -1,6 +1,7 @@
package main
import (
"context"
"encoding/json"
"errors"
"flag"
@@ -342,7 +343,7 @@ func testWrappers(e exchange.IBotExchange, base *exchange.Base, config *Config)
if !authenticatedOnly {
var fetchTickerResponse *ticker.Price
fetchTickerResponse, err = e.FetchTicker(p, assetTypes[i])
fetchTickerResponse, err = e.FetchTicker(context.TODO(), p, assetTypes[i])
msg = ""
if err != nil {
msg = err.Error()
@@ -356,7 +357,7 @@ func testWrappers(e exchange.IBotExchange, base *exchange.Base, config *Config)
})
var updateTickerResponse *ticker.Price
updateTickerResponse, err = e.UpdateTicker(p, assetTypes[i])
updateTickerResponse, err = e.UpdateTicker(context.TODO(), p, assetTypes[i])
msg = ""
if err != nil {
msg = err.Error()
@@ -370,7 +371,7 @@ func testWrappers(e exchange.IBotExchange, base *exchange.Base, config *Config)
})
var fetchOrderbookResponse *orderbook.Base
fetchOrderbookResponse, err = e.FetchOrderbook(p, assetTypes[i])
fetchOrderbookResponse, err = e.FetchOrderbook(context.TODO(), p, assetTypes[i])
msg = ""
if err != nil {
msg = err.Error()
@@ -384,7 +385,7 @@ func testWrappers(e exchange.IBotExchange, base *exchange.Base, config *Config)
})
var updateOrderbookResponse *orderbook.Base
updateOrderbookResponse, err = e.UpdateOrderbook(p, assetTypes[i])
updateOrderbookResponse, err = e.UpdateOrderbook(context.TODO(), p, assetTypes[i])
msg = ""
if err != nil {
msg = err.Error()
@@ -398,7 +399,7 @@ func testWrappers(e exchange.IBotExchange, base *exchange.Base, config *Config)
})
var fetchTradablePairsResponse []string
fetchTradablePairsResponse, err = e.FetchTradablePairs(assetTypes[i])
fetchTradablePairsResponse, err = e.FetchTradablePairs(context.TODO(), assetTypes[i])
msg = ""
if err != nil {
msg = err.Error()
@@ -411,7 +412,7 @@ func testWrappers(e exchange.IBotExchange, base *exchange.Base, config *Config)
Response: jsonifyInterface([]interface{}{fetchTradablePairsResponse}),
})
// r6
err = e.UpdateTradablePairs(false)
err = e.UpdateTradablePairs(context.TODO(), false)
msg = ""
if err != nil {
msg = err.Error()
@@ -425,7 +426,7 @@ func testWrappers(e exchange.IBotExchange, base *exchange.Base, config *Config)
})
var getHistoricTradesResponse []trade.Data
getHistoricTradesResponse, err = e.GetHistoricTrades(p, assetTypes[i], time.Now().Add(-time.Hour), time.Now())
getHistoricTradesResponse, err = e.GetHistoricTrades(context.TODO(), p, assetTypes[i], time.Now().Add(-time.Hour), time.Now())
msg = ""
if err != nil {
msg = err.Error()
@@ -439,7 +440,7 @@ func testWrappers(e exchange.IBotExchange, base *exchange.Base, config *Config)
})
var getRecentTradesResponse []trade.Data
getRecentTradesResponse, err = e.GetRecentTrades(p, assetTypes[i])
getRecentTradesResponse, err = e.GetRecentTrades(context.TODO(), p, assetTypes[i])
msg = ""
if err != nil {
msg = err.Error()
@@ -454,7 +455,7 @@ func testWrappers(e exchange.IBotExchange, base *exchange.Base, config *Config)
var getHistoricCandlesResponse kline.Item
startTime, endTime := time.Now().AddDate(0, 0, -1), time.Now()
getHistoricCandlesResponse, err = e.GetHistoricCandles(p, assetTypes[i], startTime, endTime, kline.OneDay)
getHistoricCandlesResponse, err = e.GetHistoricCandles(context.TODO(), p, assetTypes[i], startTime, endTime, kline.OneDay)
msg = ""
if err != nil {
msg = err.Error()
@@ -468,7 +469,7 @@ func testWrappers(e exchange.IBotExchange, base *exchange.Base, config *Config)
})
var getHisotirCandlesExtendedResponse kline.Item
getHisotirCandlesExtendedResponse, err = e.GetHistoricCandlesExtended(p, assetTypes[i], startTime, endTime, kline.OneDay)
getHisotirCandlesExtendedResponse, err = e.GetHistoricCandlesExtended(context.TODO(), p, assetTypes[i], startTime, endTime, kline.OneDay)
msg = ""
if err != nil {
msg = err.Error()
@@ -481,7 +482,7 @@ func testWrappers(e exchange.IBotExchange, base *exchange.Base, config *Config)
SentParams: jsonifyInterface([]interface{}{p, assetTypes[i], startTime, endTime, kline.OneDay}),
})
err = e.UpdateOrderExecutionLimits(assetTypes[i])
err = e.UpdateOrderExecutionLimits(context.TODO(), assetTypes[i])
msg = ""
if err != nil {
msg = err.Error()
@@ -497,7 +498,7 @@ func testWrappers(e exchange.IBotExchange, base *exchange.Base, config *Config)
}
var fetchAccountInfoResponse account.Holdings
fetchAccountInfoResponse, err = e.FetchAccountInfo(assetTypes[i])
fetchAccountInfoResponse, err = e.FetchAccountInfo(context.TODO(), assetTypes[i])
msg = ""
if err != nil {
msg = err.Error()
@@ -510,7 +511,7 @@ func testWrappers(e exchange.IBotExchange, base *exchange.Base, config *Config)
})
var getFundingHistoryResponse []exchange.FundHistory
getFundingHistoryResponse, err = e.GetFundingHistory()
getFundingHistoryResponse, err = e.GetFundingHistory(context.TODO())
msg = ""
if err != nil {
msg = err.Error()
@@ -529,7 +530,7 @@ func testWrappers(e exchange.IBotExchange, base *exchange.Base, config *Config)
Amount: config.OrderSubmission.Amount,
}
var getFeeByTypeResponse float64
getFeeByTypeResponse, err = e.GetFeeByType(&feeType)
getFeeByTypeResponse, err = e.GetFeeByType(context.TODO(), &feeType)
msg = ""
if err != nil {
msg = err.Error()
@@ -552,7 +553,7 @@ func testWrappers(e exchange.IBotExchange, base *exchange.Base, config *Config)
AssetType: assetTypes[i],
}
var submitOrderResponse order.SubmitResponse
submitOrderResponse, err = e.SubmitOrder(s)
submitOrderResponse, err = e.SubmitOrder(context.TODO(), s)
msg = ""
if err != nil {
msg = err.Error()
@@ -573,7 +574,7 @@ func testWrappers(e exchange.IBotExchange, base *exchange.Base, config *Config)
Price: config.OrderSubmission.Price,
Amount: config.OrderSubmission.Amount,
}
modifyOrderResponse, err := e.ModifyOrder(&modifyRequest)
modifyOrderResponse, err := e.ModifyOrder(context.TODO(), &modifyRequest)
msg = ""
if err != nil {
msg = err.Error()
@@ -592,7 +593,7 @@ func testWrappers(e exchange.IBotExchange, base *exchange.Base, config *Config)
ID: config.OrderSubmission.OrderID,
AssetType: assetTypes[i],
}
err = e.CancelOrder(&cancelRequest)
err = e.CancelOrder(context.TODO(), &cancelRequest)
msg = ""
if err != nil {
msg = err.Error()
@@ -614,7 +615,7 @@ func testWrappers(e exchange.IBotExchange, base *exchange.Base, config *Config)
})
var CancelBatchOrdersResponse order.CancelBatchResponse
CancelBatchOrdersResponse, err = e.CancelBatchOrders(request)
CancelBatchOrdersResponse, err = e.CancelBatchOrders(context.TODO(), request)
msg = ""
if err != nil {
msg = err.Error()
@@ -628,7 +629,7 @@ func testWrappers(e exchange.IBotExchange, base *exchange.Base, config *Config)
})
var cancellAllOrdersResponse order.CancelAllResponse
cancellAllOrdersResponse, err = e.CancelAllOrders(&cancelRequest)
cancellAllOrdersResponse, err = e.CancelAllOrders(context.TODO(), &cancelRequest)
msg = ""
if err != nil {
msg = err.Error()
@@ -642,7 +643,7 @@ func testWrappers(e exchange.IBotExchange, base *exchange.Base, config *Config)
})
var r15 order.Detail
r15, err = e.GetOrderInfo(config.OrderSubmission.OrderID, p, assetTypes[i])
r15, err = e.GetOrderInfo(context.TODO(), config.OrderSubmission.OrderID, p, assetTypes[i])
msg = ""
if err != nil {
msg = err.Error()
@@ -661,7 +662,7 @@ func testWrappers(e exchange.IBotExchange, base *exchange.Base, config *Config)
Pairs: []currency.Pair{p},
}
var getOrderHistoryResponse []order.Detail
getOrderHistoryResponse, err = e.GetOrderHistory(&historyRequest)
getOrderHistoryResponse, err = e.GetOrderHistory(context.TODO(), &historyRequest)
msg = ""
if err != nil {
msg = err.Error()
@@ -680,7 +681,7 @@ func testWrappers(e exchange.IBotExchange, base *exchange.Base, config *Config)
Pairs: []currency.Pair{p},
}
var getActiveOrdersResponse []order.Detail
getActiveOrdersResponse, err = e.GetActiveOrders(&orderRequest)
getActiveOrdersResponse, err = e.GetActiveOrders(context.TODO(), &orderRequest)
msg = ""
if err != nil {
msg = err.Error()
@@ -694,7 +695,7 @@ func testWrappers(e exchange.IBotExchange, base *exchange.Base, config *Config)
})
var getDepositAddressResponse string
getDepositAddressResponse, err = e.GetDepositAddress(p.Base, "")
getDepositAddressResponse, err = e.GetDepositAddress(context.TODO(), p.Base, "")
msg = ""
if err != nil {
msg = err.Error()
@@ -714,7 +715,7 @@ func testWrappers(e exchange.IBotExchange, base *exchange.Base, config *Config)
Amount: config.OrderSubmission.Amount,
}
var GetFeeByTypeResponse float64
GetFeeByTypeResponse, err = e.GetFeeByType(&feeType)
GetFeeByTypeResponse, err = e.GetFeeByType(context.TODO(), &feeType)
msg = ""
if err != nil {
msg = err.Error()
@@ -740,7 +741,7 @@ func testWrappers(e exchange.IBotExchange, base *exchange.Base, config *Config)
msg = err.Error()
responseContainer.ErrorCount++
}
withdrawCryptocurrencyFundsResponse, err := e.WithdrawCryptocurrencyFunds(&withdrawRequest)
withdrawCryptocurrencyFundsResponse, err := e.WithdrawCryptocurrencyFunds(context.TODO(), &withdrawRequest)
if err != nil {
msg += ", " + err.Error()
responseContainer.ErrorCount++
@@ -761,7 +762,7 @@ func testWrappers(e exchange.IBotExchange, base *exchange.Base, config *Config)
BankTransactionType: exchange.WireTransfer,
}
var getFeeByTypeFiatResponse float64
getFeeByTypeFiatResponse, err = e.GetFeeByType(&feeType)
getFeeByTypeFiatResponse, err = e.GetFeeByType(context.TODO(), &feeType)
msg = ""
if err != nil {
msg = err.Error()
@@ -804,7 +805,7 @@ func testWrappers(e exchange.IBotExchange, base *exchange.Base, config *Config)
IntermediaryBankCode: config.BankDetails.IntermediaryBankCode,
},
}
withdrawFiatFundsResponse, err := e.WithdrawFiatFunds(&withdrawRequestFiat)
withdrawFiatFundsResponse, err := e.WithdrawFiatFunds(context.TODO(), &withdrawRequestFiat)
msg = ""
if err != nil {
msg = err.Error()
@@ -817,7 +818,7 @@ func testWrappers(e exchange.IBotExchange, base *exchange.Base, config *Config)
Response: withdrawFiatFundsResponse,
})
withdrawFiatFundsInternationalResponse, err := e.WithdrawFiatFundsToInternationalBank(&withdrawRequestFiat)
withdrawFiatFundsInternationalResponse, err := e.WithdrawFiatFundsToInternationalBank(context.TODO(), &withdrawRequestFiat)
msg = ""
if err != nil {
msg = err.Error()

423
cmd/gctcli/commands.go
View File

File diff suppressed because it is too large Load Diff

85
cmd/gctcli/data_history.go
View File

@@ -1,7 +1,6 @@
package main
import (
"context"
"errors"
"fmt"
"strings"
@@ -315,16 +314,12 @@ func getDataHistoryJob(c *cli.Context) error {
return errors.New("can only set 'id' OR 'nickname'")
}
conn, err := setupClient()
conn, cancel, err := setupClient(c)
if err != nil {
return err
}
defer func() {
err = conn.Close()
if err != nil {
fmt.Print(err)
}
}()
defer closeConn(conn, cancel)
client := gctrpc.NewGoCryptoTraderClient(conn)
request := &gctrpc.GetDataHistoryJobDetailsRequest{
Id: id,
@@ -334,7 +329,7 @@ func getDataHistoryJob(c *cli.Context) error {
request.FullDetails = true
}
result, err := client.GetDataHistoryJobDetails(context.Background(), request)
result, err := client.GetDataHistoryJobDetails(c.Context, request)
if err != nil {
return err
}
@@ -342,20 +337,15 @@ func getDataHistoryJob(c *cli.Context) error {
return nil
}
func getActiveDataHistoryJobs(_ *cli.Context) error {
conn, err := setupClient()
func getActiveDataHistoryJobs(c *cli.Context) error {
conn, cancel, err := setupClient(c)
if err != nil {
return err
}
defer func() {
err = conn.Close()
if err != nil {
fmt.Print(err)
}
}()
defer closeConn(conn, cancel)
client := gctrpc.NewGoCryptoTraderClient(conn)
result, err := client.GetActiveDataHistoryJobs(context.Background(),
result, err := client.GetActiveDataHistoryJobs(c.Context,
&gctrpc.GetInfoRequest{})
if err != nil {
return err
@@ -498,16 +488,12 @@ func upsertDataHistoryJob(c *cli.Context) error {
}
}
conn, err := setupClient()
conn, cancel, err := setupClient(c)
if err != nil {
return err
}
defer func() {
err = conn.Close()
if err != nil {
fmt.Print(err)
}
}()
defer closeConn(conn, cancel)
client := gctrpc.NewGoCryptoTraderClient(conn)
request := &gctrpc.UpsertDataHistoryJobRequest{
Nickname: nickname,
@@ -535,7 +521,7 @@ func upsertDataHistoryJob(c *cli.Context) error {
ReplaceOnIssue: replaceOnIssue,
}
result, err := client.UpsertDataHistoryJob(context.Background(), request)
result, err := client.UpsertDataHistoryJob(c.Context, request)
if err != nil {
return err
}
@@ -571,19 +557,14 @@ func getDataHistoryJobsBetween(c *cli.Context) error {
return errors.New("start cannot be after end")
}
conn, err := setupClient()
conn, cancel, err := setupClient(c)
if err != nil {
return err
}
defer func() {
err = conn.Close()
if err != nil {
fmt.Print(err)
}
}()
defer closeConn(conn, cancel)
client := gctrpc.NewGoCryptoTraderClient(conn)
result, err := client.GetDataHistoryJobsBetween(context.Background(),
result, err := client.GetDataHistoryJobsBetween(c.Context,
&gctrpc.GetDataHistoryJobsBetweenRequest{
StartDate: negateLocalOffset(s),
EndDate: negateLocalOffset(e),
@@ -628,16 +609,12 @@ func setDataHistoryJobStatus(c *cli.Context) error {
return fmt.Errorf("unable to modify data history job status, unrecognised command '%v'", c.Command.Name)
}
conn, err := setupClient()
conn, cancel, err := setupClient(c)
if err != nil {
return err
}
defer func() {
err = conn.Close()
if err != nil {
fmt.Print(err)
}
}()
defer closeConn(conn, cancel)
client := gctrpc.NewGoCryptoTraderClient(conn)
request := &gctrpc.SetDataHistoryJobStatusRequest{
Id: id,
@@ -645,7 +622,7 @@ func setDataHistoryJobStatus(c *cli.Context) error {
Status: status,
}
result, err := client.SetDataHistoryJobStatus(context.Background(), request)
result, err := client.SetDataHistoryJobStatus(c.Context, request)
if err != nil {
return err
}
@@ -665,22 +642,18 @@ func getDataHistoryJobSummary(c *cli.Context) error {
nickname = c.Args().First()
}
conn, err := setupClient()
conn, cancel, err := setupClient(c)
if err != nil {
return err
}
defer func() {
err = conn.Close()
if err != nil {
fmt.Print(err)
}
}()
defer closeConn(conn, cancel)
client := gctrpc.NewGoCryptoTraderClient(conn)
request := &gctrpc.GetDataHistoryJobDetailsRequest{
Nickname: nickname,
}
result, err := client.GetDataHistoryJobSummary(context.Background(), request)
result, err := client.GetDataHistoryJobSummary(c.Context, request)
if err != nil {
return err
}
@@ -711,23 +684,19 @@ func setPrerequisiteJob(c *cli.Context) error {
return errors.New("prerequisite required")
}
conn, err := setupClient()
conn, cancel, err := setupClient(c)
if err != nil {
return err
}
defer func() {
err = conn.Close()
if err != nil {
fmt.Print(err)
}
}()
defer closeConn(conn, cancel)
client := gctrpc.NewGoCryptoTraderClient(conn)
request := &gctrpc.UpdateDataHistoryJobPrerequisiteRequest{
PrerequisiteJobNickname: prerequisite,
Nickname: nickname,
}
result, err := client.UpdateDataHistoryJobPrerequisite(context.Background(), request)
result, err := client.UpdateDataHistoryJobPrerequisite(c.Context, request)
if err != nil {
return err
}

14
cmd/gctcli/helpers.go
View File

@@ -1,9 +1,13 @@
package main
import (
"context"
"fmt"
"os"
"os/exec"
"runtime"
"google.golang.org/grpc"
)
func clearScreen() error {
@@ -18,3 +22,13 @@ func clearScreen() error {
return cmd.Run()
}
}
func closeConn(conn *grpc.ClientConn, cancel context.CancelFunc) {
err := conn.Close()
if err != nil {
fmt.Println(err)
}
if cancel != nil {
cancel()
}
}

36
cmd/gctcli/main.go
View File

@@ -1,16 +1,19 @@
package main
import (
"context"
"encoding/json"
"fmt"
"log"
"os"
"path/filepath"
"runtime"
"time"
"github.com/thrasher-corp/gocryptotrader/common"
"github.com/thrasher-corp/gocryptotrader/core"
"github.com/thrasher-corp/gocryptotrader/gctrpc/auth"
"github.com/thrasher-corp/gocryptotrader/signaler"
"github.com/urfave/cli/v2"
"google.golang.org/grpc"
"google.golang.org/grpc/credentials"
@@ -22,8 +25,11 @@ var (
password string
pairDelimiter string
certPath string
timeout time.Duration
)
const defaultTimeout = time.Second * 30
func jsonOutput(in interface{}) {
j, err := json.MarshalIndent(in, "", " ")
if err != nil {
@@ -32,10 +38,10 @@ func jsonOutput(in interface{}) {
fmt.Print(string(j))
}
func setupClient() (*grpc.ClientConn, error) {
func setupClient(c *cli.Context) (*grpc.ClientConn, context.CancelFunc, error) {
creds, err := credentials.NewClientTLSFromFile(certPath, "")
if err != nil {
return nil, err
return nil, nil, err
}
opts := []grpc.DialOption{grpc.WithTransportCredentials(creds),
@@ -44,12 +50,11 @@ func setupClient() (*grpc.ClientConn, error) {
Password: password,
}),
}
conn, err := grpc.Dial(host, opts...)
if err != nil {
return nil, err
}
return conn, err
var cancel context.CancelFunc
c.Context, cancel = context.WithTimeout(c.Context, timeout)
conn, err := grpc.DialContext(c.Context, host, opts...)
return conn, cancel, err
}
func main() {
@@ -89,6 +94,12 @@ func main() {
Usage: "the path to TLS cert of the gRPC server",
Destination: &certPath,
},
&cli.DurationFlag{
Name: "timeout",
Value: defaultTimeout,
Usage: "the default context timeout value for requests",
Destination: &timeout,
},
}
app.Commands = []*cli.Command{
getInfoCommand,
@@ -152,7 +163,16 @@ func main() {
dataHistoryCommands,
}
err := app.Run(os.Args)
ctx, cancel := context.WithCancel(context.Background())
go func() {
// Capture cancel for interrupt
signaler.WaitForInterrupt()
cancel()
fmt.Println("rpc process interrupted")
os.Exit(1)
}()
err := app.RunContext(ctx, os.Args)
if err != nil {
log.Fatal(err)
}

37
cmd/gctcli/pair_management.go
View File

@@ -1,7 +1,6 @@
package main
import (
"context"
"strings"
"github.com/thrasher-corp/gocryptotrader/currency"
@@ -217,15 +216,15 @@ func enableDisableExchangePair(c *cli.Context) error {
})
}
conn, err := setupClient()
conn, cancel, err := setupClient(c)
if err != nil {
return err
}
defer conn.Close()
defer closeConn(conn, cancel)
client := gctrpc.NewGoCryptoTraderClient(conn)
result, err := client.SetExchangePair(context.Background(),
result, err := client.SetExchangePair(c.Context,
&gctrpc.SetExchangePairRequest{
Exchange: exchange,
Pairs: validPairs,
@@ -266,14 +265,14 @@ func getExchangePairs(c *cli.Context) error {
return errInvalidAsset
}
conn, err := setupClient()
conn, cancel, err := setupClient(c)
if err != nil {
return err
}
defer conn.Close()
defer closeConn(conn, cancel)
client := gctrpc.NewGoCryptoTraderClient(conn)
result, err := client.GetExchangePairs(context.Background(),
result, err := client.GetExchangePairs(c.Context,
&gctrpc.GetExchangePairsRequest{
Exchange: exchange,
Asset: asset,
@@ -315,14 +314,14 @@ func enableDisableExchangeAsset(c *cli.Context) error {
return errInvalidAsset
}
conn, err := setupClient()
conn, cancel, err := setupClient(c)
if err != nil {
return err
}
defer conn.Close()
defer closeConn(conn, cancel)
client := gctrpc.NewGoCryptoTraderClient(conn)
result, err := client.SetExchangeAsset(context.Background(),
result, err := client.SetExchangeAsset(c.Context,
&gctrpc.SetExchangeAssetRequest{
Exchange: exchange,
Asset: asset,
@@ -352,14 +351,14 @@ func enableDisableAllExchangePairs(c *cli.Context) error {
exchange = c.Args().First()
}
conn, err := setupClient()
conn, cancel, err := setupClient(c)
if err != nil {
return err
}
defer conn.Close()
defer closeConn(conn, cancel)
client := gctrpc.NewGoCryptoTraderClient(conn)
result, err := client.SetAllExchangePairs(context.Background(),
result, err := client.SetAllExchangePairs(c.Context,
&gctrpc.SetExchangeAllPairsRequest{
Exchange: exchange,
Enable: enable,
@@ -384,14 +383,14 @@ func updateExchangeSupportedPairs(c *cli.Context) error {
exchange = c.Args().First()
}
conn, err := setupClient()
conn, cancel, err := setupClient(c)
if err != nil {
return err
}
defer conn.Close()
defer closeConn(conn, cancel)
client := gctrpc.NewGoCryptoTraderClient(conn)
result, err := client.UpdateExchangeSupportedPairs(context.Background(),
result, err := client.UpdateExchangeSupportedPairs(c.Context,
&gctrpc.UpdateExchangeSupportedPairsRequest{
Exchange: exchange,
},
@@ -415,14 +414,14 @@ func getExchangeAssets(c *cli.Context) error {
exchange = c.Args().First()
}
conn, err := setupClient()
conn, cancel, err := setupClient(c)
if err != nil {
return err
}
defer conn.Close()
defer closeConn(conn, cancel)
client := gctrpc.NewGoCryptoTraderClient(conn)
result, err := client.GetExchangeAssets(context.Background(),
result, err := client.GetExchangeAssets(c.Context,
&gctrpc.GetExchangeAssetsRequest{
Exchange: exchange,
},

67
cmd/gctcli/trades.go
View File

@@ -1,7 +1,6 @@
package main
import (
"context"
"errors"
"fmt"
"strconv"
@@ -277,19 +276,14 @@ func findMissingSavedTradeIntervals(c *cli.Context) error {
return fmt.Errorf("invalid time format for end: %v", err)
}
conn, err := setupClient()
conn, cancel, err := setupClient(c)
if err != nil {
return err
}
defer func() {
err = conn.Close()
if err != nil {
fmt.Print(err)
}
}()
defer closeConn(conn, cancel)
client := gctrpc.NewGoCryptoTraderClient(conn)
result, err := client.FindMissingSavedTradeIntervals(context.Background(),
result, err := client.FindMissingSavedTradeIntervals(c.Context,
&gctrpc.FindMissingTradePeriodsRequest{
ExchangeName: exchangeName,
Pair: &gctrpc.CurrencyPair{
@@ -332,19 +326,14 @@ func setExchangeTradeProcessing(c *cli.Context) error {
}
}
conn, err := setupClient()
conn, cancel, err := setupClient(c)
if err != nil {
return err
}
defer func() {
err = conn.Close()
if err != nil {
fmt.Print(err)
}
}()
defer closeConn(conn, cancel)
client := gctrpc.NewGoCryptoTraderClient(conn)
result, err := client.SetExchangeTradeProcessing(context.Background(),
result, err := client.SetExchangeTradeProcessing(c.Context,
&gctrpc.SetExchangeTradeProcessingRequest{
Exchange: exchangeName,
Status: status,
@@ -420,19 +409,14 @@ func getSavedTrades(c *cli.Context) error {
return errors.New("start cannot be after end")
}
conn, err := setupClient()
conn, cancel, err := setupClient(c)
if err != nil {
return err
}
defer func() {
err = conn.Close()
if err != nil {
fmt.Print(err)
}
}()
defer closeConn(conn, cancel)
client := gctrpc.NewGoCryptoTraderClient(conn)
result, err := client.GetSavedTrades(context.Background(),
result, err := client.GetSavedTrades(c.Context,
&gctrpc.GetSavedTradesRequest{
Exchange: exchangeName,
Pair: &gctrpc.CurrencyPair{
@@ -489,19 +473,14 @@ func getRecentTrades(c *cli.Context) error {
return errInvalidAsset
}
conn, err := setupClient()
conn, cancel, err := setupClient(c)
if err != nil {
return err
}
defer func() {
err = conn.Close()
if err != nil {
fmt.Print(err)
}
}()
defer closeConn(conn, cancel)
client := gctrpc.NewGoCryptoTraderClient(conn)
result, err := client.GetRecentTrades(context.Background(),
result, err := client.GetRecentTrades(c.Context,
&gctrpc.GetSavedTradesRequest{
Exchange: exchangeName,
Pair: &gctrpc.CurrencyPair{
@@ -581,20 +560,15 @@ func getHistoricTrades(c *cli.Context) error {
return errors.New("start cannot be after end")
}
conn, err := setupClient()
conn, cancel, err := setupClient(c)
if err != nil {
return err
}
defer func() {
err = conn.Close()
if err != nil {
fmt.Print(err)
}
}()
defer closeConn(conn, cancel)
streamStartTime := time.Now()
client := gctrpc.NewGoCryptoTraderClient(conn)
result, err := client.GetHistoricTrades(context.Background(),
result, err := client.GetHistoricTrades(c.Context,
&gctrpc.GetSavedTradesRequest{
Exchange: exchangeName,
Pair: &gctrpc.CurrencyPair{
@@ -724,19 +698,14 @@ func convertSavedTradesToCandles(c *cli.Context) error {
return errors.New("start cannot be after end")
}
conn, err := setupClient()
conn, cancel, err := setupClient(c)
if err != nil {
return err
}
defer func() {
err = conn.Close()
if err != nil {
fmt.Print(err)
}
}()
defer closeConn(conn, cancel)
client := gctrpc.NewGoCryptoTraderClient(conn)
result, err := client.ConvertTradesToCandles(context.Background(),
result, err := client.ConvertTradesToCandles(c.Context,
&gctrpc.ConvertTradesToCandlesRequest{
Exchange: exchangeName,
Pair: &gctrpc.CurrencyPair{

32
cmd/gctcli/websocket_management.go
View File

@@ -1,8 +1,6 @@
package main
import (
"context"
"github.com/thrasher-corp/gocryptotrader/gctrpc"
"github.com/urfave/cli/v2"
)
@@ -106,14 +104,14 @@ func getwebsocketInfo(c *cli.Context) error {
exchange = c.Args().First()
}
conn, err := setupClient()
conn, cancel, err := setupClient(c)
if err != nil {
return err
}
defer conn.Close()
defer closeConn(conn, cancel)
client := gctrpc.NewGoCryptoTraderClient(conn)
result, err := client.WebsocketGetInfo(context.Background(),
result, err := client.WebsocketGetInfo(c.Context,
&gctrpc.WebsocketGetInfoRequest{Exchange: exchange})
if err != nil {
return err
@@ -135,14 +133,14 @@ func enableDisableWebsocket(c *cli.Context) error {
exchange = c.Args().First()
}
conn, err := setupClient()
conn, cancel, err := setupClient(c)
if err != nil {
return err
}
defer conn.Close()
defer closeConn(conn, cancel)
client := gctrpc.NewGoCryptoTraderClient(conn)
result, err := client.WebsocketSetEnabled(context.Background(),
result, err := client.WebsocketSetEnabled(c.Context,
&gctrpc.WebsocketSetEnabledRequest{Exchange: exchange, Enable: enable})
if err != nil {
return err
@@ -163,14 +161,14 @@ func getSubscriptions(c *cli.Context) error {
exchange = c.Args().First()
}
conn, err := setupClient()
conn, cancel, err := setupClient(c)
if err != nil {
return err
}
defer conn.Close()
defer closeConn(conn, cancel)
client := gctrpc.NewGoCryptoTraderClient(conn)
result, err := client.WebsocketGetSubscriptions(context.Background(),
result, err := client.WebsocketGetSubscriptions(c.Context,
&gctrpc.WebsocketGetSubscriptionsRequest{Exchange: exchange})
if err != nil {
return err
@@ -198,14 +196,14 @@ func setProxy(c *cli.Context) error {
proxy = c.Args().Get(1)
}
conn, err := setupClient()
conn, cancel, err := setupClient(c)
if err != nil {
return err
}
defer conn.Close()
defer closeConn(conn, cancel)
client := gctrpc.NewGoCryptoTraderClient(conn)
result, err := client.WebsocketSetProxy(context.Background(),
result, err := client.WebsocketSetProxy(c.Context,
&gctrpc.WebsocketSetProxyRequest{Exchange: exchange, Proxy: proxy})
if err != nil {
return err
@@ -233,14 +231,14 @@ func setURL(c *cli.Context) error {
url = c.Args().Get(1)
}
conn, err := setupClient()
conn, cancel, err := setupClient(c)
if err != nil {
return err
}
defer conn.Close()
defer closeConn(conn, cancel)
client := gctrpc.NewGoCryptoTraderClient(conn)
result, err := client.WebsocketSetURL(context.Background(),
result, err := client.WebsocketSetURL(c.Context,
&gctrpc.WebsocketSetURLRequest{Exchange: exchange, Url: url})
if err != nil {
return err

3
cmd/portfolio/portfolio.go
View File

@@ -1,6 +1,7 @@
package main
import (
"context"
"flag"
"fmt"
"log"
@@ -138,7 +139,7 @@ func main() {
bf.SetDefaults()
bf.Verbose = false
pair := "t" + y.Coin.String() + currency.USD.String()
ticker, errf := bf.GetTicker(pair)
ticker, errf := bf.GetTicker(context.TODO(), pair)
if errf != nil {
log.Println(errf)
} else {