toki
bdbfe8228e
- Add parser_map for market data refresh configuration propagation (cli/worker/api) - Implement refresh status model with SQLite persistence (status_store.go) - Add scheduler refresh status headless output to CLI operator - Extend backfill scheduler with status tracking (start/complete/fail) - Add socket events for scheduler refresh status (start/complete/fail) - Update proto definitions for refresh status - Add generated PB files for client
535 lines
19 KiB
Go
535 lines
19 KiB
Go
package socket
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
protoSocket "git.toki-labs.com/toki/proto-socket/go"
|
|
|
|
altv1 "git.toki-labs.com/toki/alt/packages/contracts/gen/go/alt/v1"
|
|
"git.toki-labs.com/toki/alt/packages/domain/market"
|
|
"git.toki-labs.com/toki/alt/services/worker/internal/marketdata/importer"
|
|
"git.toki-labs.com/toki/alt/services/worker/internal/scheduler"
|
|
"git.toki-labs.com/toki/alt/services/worker/internal/storage"
|
|
)
|
|
|
|
// importDateLayout matches the YYYYMMDD date fields the import command carries,
|
|
// mirroring the job payload date contract so the same dates reach the provider.
|
|
const importDateLayout = "20060102"
|
|
|
|
// unixMilliMs converts a time.Time to Unix milliseconds. Zero times return 0
|
|
// to avoid negative epoch values that would mislead CLI output or client UI.
|
|
func unixMilliMs(t time.Time) int64 {
|
|
if t.IsZero() {
|
|
return 0
|
|
}
|
|
return t.UnixMilli()
|
|
}
|
|
|
|
// validImportTimeframes defines the set of timeframes accepted for import_daily_bars.
|
|
// Currently only daily is supported; minute values are intentionally rejected.
|
|
var validImportTimeframes = map[string]bool{
|
|
"daily": true,
|
|
"minute_1": true,
|
|
"minute_5": true,
|
|
"monthly": true,
|
|
}
|
|
|
|
const (
|
|
marketErrorInvalidRequest = "invalid_request"
|
|
marketErrorUnavailable = "unavailable"
|
|
marketErrorNotFound = "not_found"
|
|
marketErrorTimeout = "timeout"
|
|
marketErrorInternal = "internal"
|
|
)
|
|
|
|
func marketHandlers(deps Deps) []sessionHandler {
|
|
handlers := []sessionHandler{
|
|
{
|
|
requestType: protoSocket.TypeNameOf(&altv1.ListInstrumentsRequest{}),
|
|
register: func(client *protoSocket.WsClient) {
|
|
protoSocket.AddRequestListenerTyped[*altv1.ListInstrumentsRequest, *altv1.ListInstrumentsResponse](
|
|
&client.Communicator,
|
|
func(req *altv1.ListInstrumentsRequest) (*altv1.ListInstrumentsResponse, error) {
|
|
return handleListInstruments(deps, req)
|
|
},
|
|
)
|
|
},
|
|
},
|
|
{
|
|
requestType: protoSocket.TypeNameOf(&altv1.ListBarsRequest{}),
|
|
register: func(client *protoSocket.WsClient) {
|
|
protoSocket.AddRequestListenerTyped[*altv1.ListBarsRequest, *altv1.ListBarsResponse](
|
|
&client.Communicator,
|
|
func(req *altv1.ListBarsRequest) (*altv1.ListBarsResponse, error) {
|
|
return handleListBars(deps, req)
|
|
},
|
|
)
|
|
},
|
|
},
|
|
{
|
|
requestType: protoSocket.TypeNameOf(&altv1.ImportDailyBarsRequest{}),
|
|
register: func(client *protoSocket.WsClient) {
|
|
protoSocket.AddRequestListenerTyped[*altv1.ImportDailyBarsRequest, *altv1.ImportDailyBarsResponse](
|
|
&client.Communicator,
|
|
func(req *altv1.ImportDailyBarsRequest) (*altv1.ImportDailyBarsResponse, error) {
|
|
return handleImportDailyBars(deps, req)
|
|
},
|
|
)
|
|
},
|
|
},
|
|
}
|
|
if deps.MonthlyAggregator != nil {
|
|
handlers = append(handlers, sessionHandler{
|
|
requestType: protoSocket.TypeNameOf(&altv1.AggregateMonthlyBarsRequest{}),
|
|
register: func(client *protoSocket.WsClient) {
|
|
protoSocket.AddRequestListenerTyped[*altv1.AggregateMonthlyBarsRequest, *altv1.AggregateMonthlyBarsResponse](
|
|
&client.Communicator,
|
|
func(req *altv1.AggregateMonthlyBarsRequest) (*altv1.AggregateMonthlyBarsResponse, error) {
|
|
return handleAggregateMonthlyBars(deps, req)
|
|
},
|
|
)
|
|
},
|
|
})
|
|
}
|
|
if deps.RefreshStatus != nil {
|
|
handlers = append(handlers, sessionHandler{
|
|
requestType: protoSocket.TypeNameOf(&altv1.SchedulerRefreshStatusRequest{}),
|
|
register: func(client *protoSocket.WsClient) {
|
|
protoSocket.AddRequestListenerTyped[*altv1.SchedulerRefreshStatusRequest, *altv1.SchedulerRefreshStatusResponse](
|
|
&client.Communicator,
|
|
func(req *altv1.SchedulerRefreshStatusRequest) (*altv1.SchedulerRefreshStatusResponse, error) {
|
|
return handleSchedulerRefreshStatus(deps, req)
|
|
},
|
|
)
|
|
},
|
|
})
|
|
}
|
|
return handlers
|
|
}
|
|
|
|
// importTimeframeNormalise resolves the proto Timeframe into a string accepted
|
|
// by the provider layer. Unspecified defaults to "daily"; known enum names are
|
|
// mapped explicitly. Unknown enum values return ("", unknownTimeframeErr) so
|
|
// that the caller can reject them as a typed invalid_request error instead of
|
|
// panicking on slice operations.
|
|
func importTimeframeNormalise(tf altv1.Timeframe) (string, error) {
|
|
if tf == altv1.Timeframe_TIMEFRAME_UNSPECIFIED {
|
|
return "daily", nil
|
|
}
|
|
// Map known proto enum values to their lowercase name (without TIMEFRAME_ prefix).
|
|
switch tf {
|
|
case altv1.Timeframe_TIMEFRAME_DAILY:
|
|
return "daily", nil
|
|
case altv1.Timeframe_TIMEFRAME_MINUTE_1:
|
|
return "minute_1", nil
|
|
case altv1.Timeframe_TIMEFRAME_MINUTE_5:
|
|
return "minute_5", nil
|
|
case altv1.Timeframe_TIMEFRAME_MONTHLY:
|
|
return "monthly", nil
|
|
default:
|
|
// Unknown enum value: return the raw string name (if available) so the
|
|
// caller can produce a stable error message. Do NOT panic on slice.
|
|
name := tf.String()
|
|
if strings.HasPrefix(name, "TIMEFRAME_") {
|
|
return strings.ToLower(name[len("TIMEFRAME_"):]), fmt.Errorf("unsupported timeframe %q", strings.ToLower(name[len("TIMEFRAME_"):]))
|
|
}
|
|
return strings.ToLower(name), fmt.Errorf("unsupported timeframe %q", strings.ToLower(name))
|
|
}
|
|
}
|
|
|
|
// handleImportDailyBars validates the import command, converts it into the
|
|
// importer request, and runs the import. The worker owns provider fetch and
|
|
// persistence; counts come back so the operator surface can confirm what landed.
|
|
func handleImportDailyBars(deps Deps, req *altv1.ImportDailyBarsRequest) (*altv1.ImportDailyBarsResponse, error) {
|
|
if req.GetProvider() == "" {
|
|
return &altv1.ImportDailyBarsResponse{Error: marketInvalidRequest("provider is required")}, nil
|
|
}
|
|
if req.GetSelectorKind() == "" {
|
|
return &altv1.ImportDailyBarsResponse{Error: marketInvalidRequest("selector_kind is required")}, nil
|
|
}
|
|
if len(req.GetSymbols()) == 0 {
|
|
return &altv1.ImportDailyBarsResponse{Error: marketInvalidRequest("symbols is required")}, nil
|
|
}
|
|
|
|
// Normalise/validate the import timeframe. Daily (unspecified) is the only
|
|
// accepted value for import_daily_bars at this stage; minute values are
|
|
// rejected as a typed invalid_request so the operator sees a stable error.
|
|
tfStr, tfErr := importTimeframeNormalise(req.GetTimeframe())
|
|
if tfErr != nil {
|
|
return &altv1.ImportDailyBarsResponse{
|
|
Error: marketInvalidRequest(tfErr.Error()),
|
|
}, nil
|
|
}
|
|
if !validImportTimeframes[tfStr] {
|
|
return &altv1.ImportDailyBarsResponse{
|
|
Error: marketInvalidRequest(fmt.Sprintf("import_daily_bars supports timeframe daily; got %s", tfStr)),
|
|
}, nil
|
|
}
|
|
if tfStr != "daily" {
|
|
return &altv1.ImportDailyBarsResponse{
|
|
Error: marketInvalidRequest(fmt.Sprintf("import_daily_bars supports timeframe daily; got %s", tfStr)),
|
|
}, nil
|
|
}
|
|
|
|
mkt, _, err := marketFilterFromProto(req.GetMarket())
|
|
if err != nil {
|
|
return &altv1.ImportDailyBarsResponse{Error: marketInvalidRequest(err.Error())}, nil
|
|
}
|
|
venue, err := venueFromProto(req.GetVenue())
|
|
if err != nil {
|
|
return &altv1.ImportDailyBarsResponse{Error: marketInvalidRequest(err.Error())}, nil
|
|
}
|
|
from, to, err := parseImportDateRange(req.GetFromYyyymmdd(), req.GetToYyyymmdd())
|
|
if err != nil {
|
|
return &altv1.ImportDailyBarsResponse{Error: marketInvalidRequest(err.Error())}, nil
|
|
}
|
|
if deps.DailyBarImporter == nil {
|
|
return &altv1.ImportDailyBarsResponse{Error: marketUnavailableError("daily bar import is not available")}, nil
|
|
}
|
|
|
|
ctx, cancel := context.WithTimeout(context.Background(), handlerTimeout)
|
|
defer cancel()
|
|
|
|
result, err := deps.DailyBarImporter.ImportDailyBars(ctx, importer.DailyBarRequest{
|
|
Provider: market.Provider(req.GetProvider()),
|
|
Selector: market.UniverseSelector{
|
|
Kind: market.UniverseSelectorKind(req.GetSelectorKind()),
|
|
Market: mkt,
|
|
Venue: venue,
|
|
Symbols: req.GetSymbols(),
|
|
Name: req.GetName(),
|
|
},
|
|
From: from,
|
|
To: to,
|
|
})
|
|
if err != nil {
|
|
return &altv1.ImportDailyBarsResponse{Error: marketBackendErrorInfo(err)}, nil
|
|
}
|
|
return &altv1.ImportDailyBarsResponse{
|
|
Provider: req.GetProvider(),
|
|
InstrumentCount: int32(result.Instruments),
|
|
BarCount: int32(result.Bars),
|
|
}, nil
|
|
}
|
|
|
|
// parseImportDateRange requires both endpoints of the import date range and
|
|
// returns them parsed for the importer request. The live KIS importer requires
|
|
// a bounded from/to range and rejects an inverted range, so the worker closes
|
|
// those operator-input errors here as invalid_request before reaching the
|
|
// importer instead of letting them surface as an internal backend failure.
|
|
func parseImportDateRange(fromValue, toValue string) (time.Time, time.Time, error) {
|
|
if fromValue == "" {
|
|
return time.Time{}, time.Time{}, errors.New("from_yyyymmdd is required")
|
|
}
|
|
if toValue == "" {
|
|
return time.Time{}, time.Time{}, errors.New("to_yyyymmdd is required")
|
|
}
|
|
from, err := time.Parse(importDateLayout, fromValue)
|
|
if err != nil {
|
|
return time.Time{}, time.Time{}, errors.New("from_yyyymmdd must be YYYYMMDD")
|
|
}
|
|
to, err := time.Parse(importDateLayout, toValue)
|
|
if err != nil {
|
|
return time.Time{}, time.Time{}, errors.New("to_yyyymmdd must be YYYYMMDD")
|
|
}
|
|
if from.After(to) {
|
|
return time.Time{}, time.Time{}, errors.New("from_yyyymmdd cannot be after to_yyyymmdd")
|
|
}
|
|
return from.UTC(), to.UTC(), nil
|
|
}
|
|
|
|
func handleListInstruments(deps Deps, req *altv1.ListInstrumentsRequest) (*altv1.ListInstrumentsResponse, error) {
|
|
marketFilter, hasMarketFilter, err := marketFilterFromProto(req.GetMarket())
|
|
if err != nil {
|
|
return &altv1.ListInstrumentsResponse{Error: marketInvalidRequest(err.Error())}, nil
|
|
}
|
|
if deps.Instruments == nil {
|
|
return &altv1.ListInstrumentsResponse{Error: marketUnavailableError("instrument store is not available")}, nil
|
|
}
|
|
|
|
ctx, cancel := context.WithTimeout(context.Background(), handlerTimeout)
|
|
defer cancel()
|
|
|
|
insts, err := deps.Instruments.ListInstruments(ctx)
|
|
if err != nil {
|
|
return &altv1.ListInstrumentsResponse{Error: marketBackendErrorInfo(err)}, nil
|
|
}
|
|
filtered := filterInstruments(insts, marketFilter, hasMarketFilter, req.GetProvider())
|
|
return &altv1.ListInstrumentsResponse{Instruments: instrumentsToProto(filtered)}, nil
|
|
}
|
|
|
|
func handleListBars(deps Deps, req *altv1.ListBarsRequest) (*altv1.ListBarsResponse, error) {
|
|
if req.GetInstrumentId() == "" {
|
|
return &altv1.ListBarsResponse{Error: marketInvalidRequest("instrument_id is required")}, nil
|
|
}
|
|
timeframe, err := timeframeFromProto(req.GetTimeframe())
|
|
if err != nil {
|
|
return &altv1.ListBarsResponse{Error: marketInvalidRequest(err.Error())}, nil
|
|
}
|
|
if req.GetFromUnixMs() == 0 {
|
|
return &altv1.ListBarsResponse{Error: marketInvalidRequest("from_unix_ms is required")}, nil
|
|
}
|
|
if req.GetToUnixMs() == 0 {
|
|
return &altv1.ListBarsResponse{Error: marketInvalidRequest("to_unix_ms is required")}, nil
|
|
}
|
|
if req.GetFromUnixMs() > req.GetToUnixMs() {
|
|
return &altv1.ListBarsResponse{Error: marketInvalidRequest("from_unix_ms cannot be after to_unix_ms")}, nil
|
|
}
|
|
if deps.Bars == nil {
|
|
return &altv1.ListBarsResponse{Error: marketUnavailableError("bar store is not available")}, nil
|
|
}
|
|
|
|
ctx, cancel := context.WithTimeout(context.Background(), handlerTimeout)
|
|
defer cancel()
|
|
|
|
from := time.UnixMilli(req.GetFromUnixMs()).UTC()
|
|
to := time.UnixMilli(req.GetToUnixMs()).UTC()
|
|
bars, err := deps.Bars.GetBars(ctx, market.InstrumentID(req.GetInstrumentId()), timeframe, from, to)
|
|
if err != nil {
|
|
return &altv1.ListBarsResponse{Error: marketBackendErrorInfo(err)}, nil
|
|
}
|
|
return &altv1.ListBarsResponse{Bars: barsToProto(bars)}, nil
|
|
}
|
|
|
|
func marketFilterFromProto(m altv1.Market) (market.Market, bool, error) {
|
|
switch m {
|
|
case altv1.Market_MARKET_UNSPECIFIED:
|
|
return "", false, nil
|
|
case altv1.Market_MARKET_KR, altv1.Market_MARKET_US:
|
|
converted, err := marketFromProto(m)
|
|
return converted, true, err
|
|
default:
|
|
return "", false, errors.New("market filter is unsupported")
|
|
}
|
|
}
|
|
|
|
func filterInstruments(insts []market.Instrument, marketFilter market.Market, hasMarketFilter bool, provider string) []market.Instrument {
|
|
if !hasMarketFilter && provider == "" {
|
|
return insts
|
|
}
|
|
out := make([]market.Instrument, 0, len(insts))
|
|
for _, inst := range insts {
|
|
if hasMarketFilter && inst.Market != marketFilter {
|
|
continue
|
|
}
|
|
if provider != "" && inst.ProviderSymbols[provider] == "" {
|
|
continue
|
|
}
|
|
out = append(out, inst)
|
|
}
|
|
return out
|
|
}
|
|
|
|
func marketInvalidRequest(reason string) *altv1.ErrorInfo {
|
|
return errorInfo(marketErrorInvalidRequest, "invalid market request: "+reason)
|
|
}
|
|
|
|
func marketUnavailableError(message string) *altv1.ErrorInfo {
|
|
return errorInfo(marketErrorUnavailable, message)
|
|
}
|
|
|
|
func handleSchedulerRefreshStatus(deps Deps, req *altv1.SchedulerRefreshStatusRequest) (*altv1.SchedulerRefreshStatusResponse, error) {
|
|
var statuses []scheduler.RefreshStatus
|
|
if name := req.GetScheduleName(); name != "" {
|
|
s, ok := deps.RefreshStatus.Get(name)
|
|
if ok {
|
|
s = enrichWithNextRun(s, deps.RefreshStatus)
|
|
statuses = []scheduler.RefreshStatus{s}
|
|
}
|
|
} else {
|
|
all := deps.RefreshStatus.All()
|
|
for _, s := range all {
|
|
s = enrichWithNextRun(s, deps.RefreshStatus)
|
|
statuses = append(statuses, s)
|
|
}
|
|
}
|
|
|
|
entries := make([]*altv1.SchedulerRefreshStatusEntry, 0, len(statuses))
|
|
for _, s := range statuses {
|
|
entries = append(entries, &altv1.SchedulerRefreshStatusEntry{
|
|
Schedule: s.Schedule,
|
|
Status: s.Status,
|
|
LastSuccessUnixMs: unixMilliMs(s.LastSuccess),
|
|
LastError: s.LastError,
|
|
NextRunUnixMs: unixMilliMs(s.NextRun),
|
|
ImportedBarCount: int32(s.ImportedBarCount),
|
|
MissingCount: int32(s.MissingCount),
|
|
GapCount: int32(s.GapCount),
|
|
DuplicateCount: int32(s.DuplicateCount),
|
|
ProviderDelayDays: int32(s.ProviderDelay),
|
|
})
|
|
}
|
|
return &altv1.SchedulerRefreshStatusResponse{Entries: entries}, nil
|
|
}
|
|
|
|
// enrichWithNextRun computes the next_run time from the stored schedule config
|
|
// for the given status. If the config is not set or the schedule is not found,
|
|
// NextRun is left as zero (rendered as 0 / "NONE").
|
|
func enrichWithNextRun(s scheduler.RefreshStatus, qr RefreshStatusQuerier) scheduler.RefreshStatus {
|
|
// The store implements ScheduleConfig() via the underlying *RefreshStatusStore.
|
|
type configStore interface {
|
|
ScheduleConfig() scheduler.Config
|
|
}
|
|
if cs, ok := qr.(configStore); ok {
|
|
cfg := cs.ScheduleConfig()
|
|
for _, sc := range cfg.Schedules {
|
|
if sc.Name != s.Schedule {
|
|
continue
|
|
}
|
|
loc, err := time.LoadLocation(sc.Timezone)
|
|
if err != nil {
|
|
return s
|
|
}
|
|
cadence, err := parseWindowDuration(sc.Cadence)
|
|
if err != nil {
|
|
return s
|
|
}
|
|
next := nextWindowForStatus(s, loc, cadence)
|
|
if !next.IsZero() && next.After(s.NextRun) {
|
|
s.NextRun = next
|
|
}
|
|
return s
|
|
}
|
|
}
|
|
return s
|
|
}
|
|
|
|
// parseWindowDuration converts a cadence string like "daily", "7d", or a Go
|
|
// duration string into time.Duration. Mirrors scheduler.parseWindow.
|
|
func parseWindowDuration(value string) (time.Duration, error) {
|
|
trimmed := strings.TrimSpace(strings.ToLower(value))
|
|
if trimmed == "daily" {
|
|
return 24 * time.Hour, nil
|
|
}
|
|
if strings.HasSuffix(trimmed, "d") && len(trimmed) > 1 {
|
|
days, err := strconv.Atoi(strings.TrimSuffix(trimmed, "d"))
|
|
if err != nil || days <= 0 {
|
|
return 0, fmt.Errorf("expected positive day count")
|
|
}
|
|
return time.Duration(days) * 24 * time.Hour, nil
|
|
}
|
|
d, err := time.ParseDuration(trimmed)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
if d <= 0 {
|
|
return 0, fmt.Errorf("expected positive duration")
|
|
}
|
|
return d, nil
|
|
}
|
|
|
|
// nextWindowForStatus computes the next run window based on the last success
|
|
// time. If LastSuccess is zero, it uses the current now (passed via opts).
|
|
func nextWindowForStatus(s scheduler.RefreshStatus, loc *time.Location, cadence time.Duration) time.Time {
|
|
if s.LastSuccess.IsZero() {
|
|
// First run: next window from now
|
|
return computeNextWindow(time.Now(), loc, cadence)
|
|
}
|
|
// Subsequent runs: next window after last success
|
|
return computeNextWindow(s.LastSuccess, loc, cadence)
|
|
}
|
|
|
|
func computeNextWindow(now time.Time, loc *time.Location, cadence time.Duration) time.Time {
|
|
localNow := now.In(loc)
|
|
dayStart := time.Date(localNow.Year(), localNow.Month(), localNow.Day(), 0, 0, 0, 0, loc)
|
|
if !localNow.After(dayStart) {
|
|
return dayStart
|
|
}
|
|
elapsed := localNow.Sub(dayStart)
|
|
steps := elapsed/cadence + 1
|
|
return dayStart.Add(steps * cadence)
|
|
}
|
|
|
|
func marketBackendErrorInfo(err error) *altv1.ErrorInfo {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
switch {
|
|
case errors.Is(err, storage.ErrInstrumentNotFound):
|
|
return errorInfo(marketErrorNotFound, err.Error())
|
|
case errors.Is(err, ErrMonthlySourceBarsNotFound):
|
|
return errorInfo(marketErrorNotFound, err.Error())
|
|
case errors.Is(err, context.DeadlineExceeded):
|
|
return errorInfo(marketErrorTimeout, err.Error())
|
|
default:
|
|
return errorInfo(marketErrorInternal, err.Error())
|
|
}
|
|
}
|
|
|
|
// handleAggregateMonthlyBars validates the aggregation request, converts it
|
|
// into an AggregateMonthlyRequest and delegates to the MonthlyBarAggregator.
|
|
// The response carries instrument counts, source daily bar counts, monthly bar
|
|
// counts, and per-instrument provenance entries.
|
|
func handleAggregateMonthlyBars(deps Deps, req *altv1.AggregateMonthlyBarsRequest) (*altv1.AggregateMonthlyBarsResponse, error) {
|
|
if req.GetProvider() == "" {
|
|
return &altv1.AggregateMonthlyBarsResponse{Error: marketInvalidRequest("provider is required")}, nil
|
|
}
|
|
if req.GetSelectorKind() == "" {
|
|
return &altv1.AggregateMonthlyBarsResponse{Error: marketInvalidRequest("selector_kind is required")}, nil
|
|
}
|
|
if len(req.GetSymbols()) == 0 {
|
|
return &altv1.AggregateMonthlyBarsResponse{Error: marketInvalidRequest("symbols is required")}, nil
|
|
}
|
|
|
|
mkt, _, err := marketFilterFromProto(req.GetMarket())
|
|
if err != nil {
|
|
return &altv1.AggregateMonthlyBarsResponse{Error: marketInvalidRequest(err.Error())}, nil
|
|
}
|
|
venue, err := venueFromProto(req.GetVenue())
|
|
if err != nil {
|
|
return &altv1.AggregateMonthlyBarsResponse{Error: marketInvalidRequest(err.Error())}, nil
|
|
}
|
|
from, to, err := parseImportDateRange(req.GetFromYyyymmdd(), req.GetToYyyymmdd())
|
|
if err != nil {
|
|
return &altv1.AggregateMonthlyBarsResponse{Error: marketInvalidRequest(err.Error())}, nil
|
|
}
|
|
if deps.MonthlyAggregator == nil {
|
|
return &altv1.AggregateMonthlyBarsResponse{Error: marketUnavailableError("monthly aggregation is not available")}, nil
|
|
}
|
|
|
|
ctx, cancel := context.WithTimeout(context.Background(), handlerTimeout)
|
|
defer cancel()
|
|
|
|
result, err := deps.MonthlyAggregator.AggregateMonthlyBars(ctx, AggregateMonthlyRequest{
|
|
Provider: market.Provider(req.GetProvider()),
|
|
Selector: market.UniverseSelector{
|
|
Kind: market.UniverseSelectorKind(req.GetSelectorKind()),
|
|
Market: mkt,
|
|
Venue: venue,
|
|
Symbols: req.GetSymbols(),
|
|
Name: req.GetName(),
|
|
},
|
|
From: from,
|
|
To: to,
|
|
})
|
|
if err != nil {
|
|
return &altv1.AggregateMonthlyBarsResponse{Error: marketBackendErrorInfo(err)}, nil
|
|
}
|
|
|
|
provenance := make([]*altv1.MonthlyProvenance, 0, len(result.Provenance))
|
|
for _, p := range result.Provenance {
|
|
provenance = append(provenance, &altv1.MonthlyProvenance{
|
|
InstrumentId: string(p.InstrumentID),
|
|
SourceDailyBarCount: int32(p.SourceDailyCount),
|
|
MonthlyBarCount: int32(p.MonthlyBarCount),
|
|
SourceStartYyyymmdd: p.SourceStart.Format(importDateLayout),
|
|
SourceEndYyyymmdd: p.SourceEnd.Format(importDateLayout),
|
|
AggregationRuleId: p.AggregationRuleID,
|
|
SourceTimeframe: altv1.Timeframe_TIMEFRAME_DAILY,
|
|
TargetTimeframe: altv1.Timeframe_TIMEFRAME_MONTHLY,
|
|
})
|
|
}
|
|
|
|
return &altv1.AggregateMonthlyBarsResponse{
|
|
Provider: req.GetProvider(),
|
|
InstrumentCount: int32(result.Instruments),
|
|
SourceDailyBarCount: int32(result.SourceDailyCount),
|
|
MonthlyBarCount: int32(result.MonthlyBarCount),
|
|
Provenance: provenance,
|
|
}, nil
|
|
}
|