afanasyev.aa/predictor
1
Fork 0
forked from gsn/predictor
Code Pull requests Activity

feat: refactor

Browse source
This commit is contained in:
Anatoly Antonov 2026-03-28 03:07:13 +09:00
parent 82ef1cb3b8
commit 51bbf3c579
44 changed files with 8589 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

318
pkg/rest/oas_cfg_gen.go Normal file
View file

@ -0,0 +1,318 @@
// Code generated by ogen, DO NOT EDIT.
package rest
import (
"net/http"
"strings"
ht "github.com/ogen-go/ogen/http"
"github.com/ogen-go/ogen/middleware"
"github.com/ogen-go/ogen/ogenerrors"
"github.com/ogen-go/ogen/otelogen"
"go.opentelemetry.io/otel"
"go.opentelemetry.io/otel/attribute"
"go.opentelemetry.io/otel/metric"
"go.opentelemetry.io/otel/trace"
)
var (
// Allocate option closure once.
clientSpanKind = trace.WithSpanKind(trace.SpanKindClient)
// Allocate option closure once.
serverSpanKind = trace.WithSpanKind(trace.SpanKindServer)
)
type (
optionFunc[C any] func(*C)
otelOptionFunc func(*otelConfig)
)
type otelConfig struct {
TracerProvider trace.TracerProvider
Tracer trace.Tracer
MeterProvider metric.MeterProvider
Meter metric.Meter
Attributes []attribute.KeyValue
}
func (cfg *otelConfig) initOTEL() {
if cfg.TracerProvider == nil {
cfg.TracerProvider = otel.GetTracerProvider()
}
if cfg.MeterProvider == nil {
cfg.MeterProvider = otel.GetMeterProvider()
}
cfg.Tracer = cfg.TracerProvider.Tracer(otelogen.Name,
trace.WithInstrumentationVersion(otelogen.SemVersion()),
)
cfg.Meter = cfg.MeterProvider.Meter(otelogen.Name,
metric.WithInstrumentationVersion(otelogen.SemVersion()),
)
}
// ErrorHandler is error handler.
type ErrorHandler = ogenerrors.ErrorHandler
type serverConfig struct {
otelConfig
NotFound http.HandlerFunc
MethodNotAllowed func(w http.ResponseWriter, r *http.Request, allowed string)
ErrorHandler ErrorHandler
Prefix string
Middleware Middleware
MaxMultipartMemory int64
}
// ServerOption is server config option.
type ServerOption interface {
applyServer(*serverConfig)
}
var _ ServerOption = (optionFunc[serverConfig])(nil)
func (o optionFunc[C]) applyServer(c *C) {
o(c)
}
var _ ServerOption = (otelOptionFunc)(nil)
func (o otelOptionFunc) applyServer(c *serverConfig) {
o(&c.otelConfig)
}
func newServerConfig(opts ...ServerOption) serverConfig {
cfg := serverConfig{
NotFound: http.NotFound,
MethodNotAllowed: nil,
ErrorHandler: ogenerrors.DefaultErrorHandler,
Middleware: nil,
MaxMultipartMemory: 32 << 20, // 32 MB
}
for _, opt := range opts {
opt.applyServer(&cfg)
}
cfg.initOTEL()
return cfg
}
type baseServer struct {
cfg serverConfig
requests metric.Int64Counter
errors metric.Int64Counter
duration metric.Float64Histogram
}
func (s baseServer) notFound(w http.ResponseWriter, r *http.Request) {
s.cfg.NotFound(w, r)
}
type notAllowedParams struct {
allowedMethods string
allowedHeaders map[string]string
acceptPost string
acceptPatch string
}
func (s baseServer) notAllowed(w http.ResponseWriter, r *http.Request, params notAllowedParams) {
h := w.Header()
isOptions := r.Method == "OPTIONS"
if isOptions {
h.Set("Access-Control-Allow-Methods", params.allowedMethods)
if params.allowedHeaders != nil {
m := r.Header.Get("Access-Control-Request-Method")
if m != "" {
allowedHeaders, ok := params.allowedHeaders[strings.ToUpper(m)]
if ok {
h.Set("Access-Control-Allow-Headers", allowedHeaders)
}
}
}
if params.acceptPost != "" {
h.Set("Accept-Post", params.acceptPost)
}
if params.acceptPatch != "" {
h.Set("Accept-Patch", params.acceptPatch)
}
}
if s.cfg.MethodNotAllowed != nil {
s.cfg.MethodNotAllowed(w, r, params.allowedMethods)
return
}
status := http.StatusNoContent
if !isOptions {
h.Set("Allow", params.allowedMethods)
status = http.StatusMethodNotAllowed
}
w.WriteHeader(status)
}
func (cfg serverConfig) baseServer() (s baseServer, err error) {
s = baseServer{cfg: cfg}
if s.requests, err = otelogen.ServerRequestCountCounter(s.cfg.Meter); err != nil {
return s, err
}
if s.errors, err = otelogen.ServerErrorsCountCounter(s.cfg.Meter); err != nil {
return s, err
}
if s.duration, err = otelogen.ServerDurationHistogram(s.cfg.Meter); err != nil {
return s, err
}
return s, nil
}
type clientConfig struct {
otelConfig
Client ht.Client
}
// ClientOption is client config option.
type ClientOption interface {
applyClient(*clientConfig)
}
var _ ClientOption = (optionFunc[clientConfig])(nil)
func (o optionFunc[C]) applyClient(c *C) {
o(c)
}
var _ ClientOption = (otelOptionFunc)(nil)
func (o otelOptionFunc) applyClient(c *clientConfig) {
o(&c.otelConfig)
}
func newClientConfig(opts ...ClientOption) clientConfig {
cfg := clientConfig{
Client: http.DefaultClient,
}
for _, opt := range opts {
opt.applyClient(&cfg)
}
cfg.initOTEL()
return cfg
}
type baseClient struct {
cfg clientConfig
requests metric.Int64Counter
errors metric.Int64Counter
duration metric.Float64Histogram
}
func (cfg clientConfig) baseClient() (c baseClient, err error) {
c = baseClient{cfg: cfg}
if c.requests, err = otelogen.ClientRequestCountCounter(c.cfg.Meter); err != nil {
return c, err
}
if c.errors, err = otelogen.ClientErrorsCountCounter(c.cfg.Meter); err != nil {
return c, err
}
if c.duration, err = otelogen.ClientDurationHistogram(c.cfg.Meter); err != nil {
return c, err
}
return c, nil
}
// Option is config option.
type Option interface {
ServerOption
ClientOption
}
// WithTracerProvider specifies a tracer provider to use for creating a tracer.
//
// If none is specified, the global provider is used.
func WithTracerProvider(provider trace.TracerProvider) Option {
return otelOptionFunc(func(cfg *otelConfig) {
if provider != nil {
cfg.TracerProvider = provider
}
})
}
// WithMeterProvider specifies a meter provider to use for creating a meter.
//
// If none is specified, the otel.GetMeterProvider() is used.
func WithMeterProvider(provider metric.MeterProvider) Option {
return otelOptionFunc(func(cfg *otelConfig) {
if provider != nil {
cfg.MeterProvider = provider
}
})
}
// WithAttributes specifies default otel attributes.
func WithAttributes(attributes ...attribute.KeyValue) Option {
return otelOptionFunc(func(cfg *otelConfig) {
cfg.Attributes = attributes
})
}
// WithClient specifies http client to use.
func WithClient(client ht.Client) ClientOption {
return optionFunc[clientConfig](func(cfg *clientConfig) {
if client != nil {
cfg.Client = client
}
})
}
// WithNotFound specifies Not Found handler to use.
func WithNotFound(notFound http.HandlerFunc) ServerOption {
return optionFunc[serverConfig](func(cfg *serverConfig) {
if notFound != nil {
cfg.NotFound = notFound
}
})
}
// WithMethodNotAllowed specifies Method Not Allowed handler to use.
func WithMethodNotAllowed(methodNotAllowed func(w http.ResponseWriter, r *http.Request, allowed string)) ServerOption {
return optionFunc[serverConfig](func(cfg *serverConfig) {
if methodNotAllowed != nil {
cfg.MethodNotAllowed = methodNotAllowed
}
})
}
// WithErrorHandler specifies error handler to use.
func WithErrorHandler(h ErrorHandler) ServerOption {
return optionFunc[serverConfig](func(cfg *serverConfig) {
if h != nil {
cfg.ErrorHandler = h
}
})
}
// WithPathPrefix specifies server path prefix.
func WithPathPrefix(prefix string) ServerOption {
return optionFunc[serverConfig](func(cfg *serverConfig) {
cfg.Prefix = prefix
})
}
// WithMiddleware specifies middlewares to use.
func WithMiddleware(m ...Middleware) ServerOption {
return optionFunc[serverConfig](func(cfg *serverConfig) {
switch len(m) {
case 0:
cfg.Middleware = nil
case 1:
cfg.Middleware = m[0]
default:
cfg.Middleware = middleware.ChainMiddlewares(m...)
}
})
}
// WithMaxMultipartMemory specifies limit of memory for storing file parts.
// File parts which can't be stored in memory will be stored on disk in temporary files.
func WithMaxMultipartMemory(max int64) ServerOption {
return optionFunc[serverConfig](func(cfg *serverConfig) {
if max > 0 {
cfg.MaxMultipartMemory = max
}
})
}

411
pkg/rest/oas_client_gen.go Normal file
View file

@ -0,0 +1,411 @@
// Code generated by ogen, DO NOT EDIT.
package rest
import (
"context"
"net/url"
"strings"
"time"
"github.com/go-faster/errors"
"github.com/ogen-go/ogen/conv"
ht "github.com/ogen-go/ogen/http"
"github.com/ogen-go/ogen/otelogen"
"github.com/ogen-go/ogen/uri"
"go.opentelemetry.io/otel/attribute"
"go.opentelemetry.io/otel/codes"
"go.opentelemetry.io/otel/metric"
semconv "go.opentelemetry.io/otel/semconv/v1.39.0"
"go.opentelemetry.io/otel/trace"
)
func trimTrailingSlashes(u *url.URL) {
u.Path = strings.TrimRight(u.Path, "/")
u.RawPath = strings.TrimRight(u.RawPath, "/")
}
// Invoker invokes operations described by OpenAPI v3 specification.
type Invoker interface {
// PerformPrediction invokes performPrediction operation.
//
// Perform prediction.
//
// GET /api/v1/prediction
PerformPrediction(ctx context.Context, params PerformPredictionParams) (*PredictionResponse, error)
// ReadinessCheck invokes readinessCheck operation.
//
// Readiness check.
//
// GET /ready
ReadinessCheck(ctx context.Context) (*ReadinessResponse, error)
}
// Client implements OAS client.
type Client struct {
serverURL *url.URL
baseClient
}
// NewClient initializes new Client defined by OAS.
func NewClient(serverURL string, opts ...ClientOption) (*Client, error) {
u, err := url.Parse(serverURL)
if err != nil {
return nil, err
}
trimTrailingSlashes(u)
c, err := newClientConfig(opts...).baseClient()
if err != nil {
return nil, err
}
return &Client{
serverURL: u,
baseClient: c,
}, nil
}
type serverURLKey struct{}
// WithServerURL sets context key to override server URL.
func WithServerURL(ctx context.Context, u *url.URL) context.Context {
return context.WithValue(ctx, serverURLKey{}, u)
}
func (c *Client) requestURL(ctx context.Context) *url.URL {
u, ok := ctx.Value(serverURLKey{}).(*url.URL)
if !ok {
return c.serverURL
}
return u
}
// PerformPrediction invokes performPrediction operation.
//
// Perform prediction.
//
// GET /api/v1/prediction
func (c *Client) PerformPrediction(ctx context.Context, params PerformPredictionParams) (*PredictionResponse, error) {
res, err := c.sendPerformPrediction(ctx, params)
return res, err
}
func (c *Client) sendPerformPrediction(ctx context.Context, params PerformPredictionParams) (res *PredictionResponse, err error) {
otelAttrs := []attribute.KeyValue{
otelogen.OperationID("performPrediction"),
semconv.HTTPRequestMethodKey.String("GET"),
semconv.URLTemplateKey.String("/api/v1/prediction"),
}
otelAttrs = append(otelAttrs, c.cfg.Attributes...)
// Run stopwatch.
startTime := time.Now()
defer func() {
// Use floating point division here for higher precision (instead of Millisecond method).
elapsedDuration := time.Since(startTime)
c.duration.Record(ctx, float64(elapsedDuration)/float64(time.Millisecond), metric.WithAttributes(otelAttrs...))
}()
// Increment request counter.
c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
// Start a span for this request.
ctx, span := c.cfg.Tracer.Start(ctx, PerformPredictionOperation,
trace.WithAttributes(otelAttrs...),
clientSpanKind,
)
// Track stage for error reporting.
var stage string
defer func() {
if err != nil {
span.RecordError(err)
span.SetStatus(codes.Error, stage)
c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
}
span.End()
}()
stage = "BuildURL"
u := uri.Clone(c.requestURL(ctx))
var pathParts [1]string
pathParts[0] = "/api/v1/prediction"
uri.AddPathParts(u, pathParts[:]...)
stage = "EncodeQueryParams"
q := uri.NewQueryEncoder()
{
// Encode "launch_latitude" parameter.
cfg := uri.QueryParameterEncodingConfig{
Name: "launch_latitude",
Style: uri.QueryStyleForm,
Explode: true,
}
if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
return e.EncodeValue(conv.Float64ToString(params.LaunchLatitude))
}); err != nil {
return res, errors.Wrap(err, "encode query")
}
}
{
// Encode "launch_longitude" parameter.
cfg := uri.QueryParameterEncodingConfig{
Name: "launch_longitude",
Style: uri.QueryStyleForm,
Explode: true,
}
if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
return e.EncodeValue(conv.Float64ToString(params.LaunchLongitude))
}); err != nil {
return res, errors.Wrap(err, "encode query")
}
}
{
// Encode "launch_datetime" parameter.
cfg := uri.QueryParameterEncodingConfig{
Name: "launch_datetime",
Style: uri.QueryStyleForm,
Explode: true,
}
if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
return e.EncodeValue(conv.DateTimeToString(params.LaunchDatetime))
}); err != nil {
return res, errors.Wrap(err, "encode query")
}
}
{
// Encode "launch_altitude" parameter.
cfg := uri.QueryParameterEncodingConfig{
Name: "launch_altitude",
Style: uri.QueryStyleForm,
Explode: true,
}
if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
if val, ok := params.LaunchAltitude.Get(); ok {
return e.EncodeValue(conv.Float64ToString(val))
}
return nil
}); err != nil {
return res, errors.Wrap(err, "encode query")
}
}
{
// Encode "profile" parameter.
cfg := uri.QueryParameterEncodingConfig{
Name: "profile",
Style: uri.QueryStyleForm,
Explode: true,
}
if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
if val, ok := params.Profile.Get(); ok {
return e.EncodeValue(conv.StringToString(string(val)))
}
return nil
}); err != nil {
return res, errors.Wrap(err, "encode query")
}
}
{
// Encode "ascent_rate" parameter.
cfg := uri.QueryParameterEncodingConfig{
Name: "ascent_rate",
Style: uri.QueryStyleForm,
Explode: true,
}
if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
if val, ok := params.AscentRate.Get(); ok {
return e.EncodeValue(conv.Float64ToString(val))
}
return nil
}); err != nil {
return res, errors.Wrap(err, "encode query")
}
}
{
// Encode "burst_altitude" parameter.
cfg := uri.QueryParameterEncodingConfig{
Name: "burst_altitude",
Style: uri.QueryStyleForm,
Explode: true,
}
if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
if val, ok := params.BurstAltitude.Get(); ok {
return e.EncodeValue(conv.Float64ToString(val))
}
return nil
}); err != nil {
return res, errors.Wrap(err, "encode query")
}
}
{
// Encode "descent_rate" parameter.
cfg := uri.QueryParameterEncodingConfig{
Name: "descent_rate",
Style: uri.QueryStyleForm,
Explode: true,
}
if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
if val, ok := params.DescentRate.Get(); ok {
return e.EncodeValue(conv.Float64ToString(val))
}
return nil
}); err != nil {
return res, errors.Wrap(err, "encode query")
}
}
{
// Encode "float_altitude" parameter.
cfg := uri.QueryParameterEncodingConfig{
Name: "float_altitude",
Style: uri.QueryStyleForm,
Explode: true,
}
if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
if val, ok := params.FloatAltitude.Get(); ok {
return e.EncodeValue(conv.Float64ToString(val))
}
return nil
}); err != nil {
return res, errors.Wrap(err, "encode query")
}
}
{
// Encode "stop_datetime" parameter.
cfg := uri.QueryParameterEncodingConfig{
Name: "stop_datetime",
Style: uri.QueryStyleForm,
Explode: true,
}
if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
if val, ok := params.StopDatetime.Get(); ok {
return e.EncodeValue(conv.DateTimeToString(val))
}
return nil
}); err != nil {
return res, errors.Wrap(err, "encode query")
}
}
{
// Encode "dataset" parameter.
cfg := uri.QueryParameterEncodingConfig{
Name: "dataset",
Style: uri.QueryStyleForm,
Explode: true,
}
if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
if val, ok := params.Dataset.Get(); ok {
return e.EncodeValue(conv.DateTimeToString(val))
}
return nil
}); err != nil {
return res, errors.Wrap(err, "encode query")
}
}
u.RawQuery = q.Values().Encode()
stage = "EncodeRequest"
r, err := ht.NewRequest(ctx, "GET", u)
if err != nil {
return res, errors.Wrap(err, "create request")
}
stage = "SendRequest"
resp, err := c.cfg.Client.Do(r)
if err != nil {
return res, errors.Wrap(err, "do request")
}
body := resp.Body
defer body.Close()
stage = "DecodeResponse"
result, err := decodePerformPredictionResponse(resp)
if err != nil {
return res, errors.Wrap(err, "decode response")
}
return result, nil
}
// ReadinessCheck invokes readinessCheck operation.
//
// Readiness check.
//
// GET /ready
func (c *Client) ReadinessCheck(ctx context.Context) (*ReadinessResponse, error) {
res, err := c.sendReadinessCheck(ctx)
return res, err
}
func (c *Client) sendReadinessCheck(ctx context.Context) (res *ReadinessResponse, err error) {
otelAttrs := []attribute.KeyValue{
otelogen.OperationID("readinessCheck"),
semconv.HTTPRequestMethodKey.String("GET"),
semconv.URLTemplateKey.String("/ready"),
}
otelAttrs = append(otelAttrs, c.cfg.Attributes...)
// Run stopwatch.
startTime := time.Now()
defer func() {
// Use floating point division here for higher precision (instead of Millisecond method).
elapsedDuration := time.Since(startTime)
c.duration.Record(ctx, float64(elapsedDuration)/float64(time.Millisecond), metric.WithAttributes(otelAttrs...))
}()
// Increment request counter.
c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
// Start a span for this request.
ctx, span := c.cfg.Tracer.Start(ctx, ReadinessCheckOperation,
trace.WithAttributes(otelAttrs...),
clientSpanKind,
)
// Track stage for error reporting.
var stage string
defer func() {
if err != nil {
span.RecordError(err)
span.SetStatus(codes.Error, stage)
c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
}
span.End()
}()
stage = "BuildURL"
u := uri.Clone(c.requestURL(ctx))
var pathParts [1]string
pathParts[0] = "/ready"
uri.AddPathParts(u, pathParts[:]...)
stage = "EncodeRequest"
r, err := ht.NewRequest(ctx, "GET", u)
if err != nil {
return res, errors.Wrap(err, "create request")
}
stage = "SendRequest"
resp, err := c.cfg.Client.Do(r)
if err != nil {
return res, errors.Wrap(err, "do request")
}
body := resp.Body
defer body.Close()
stage = "DecodeResponse"
result, err := decodeReadinessCheckResponse(resp)
if err != nil {
return res, errors.Wrap(err, "decode response")
}
return result, nil
}

363
pkg/rest/oas_handlers_gen.go Normal file
View file

@ -0,0 +1,363 @@
// Code generated by ogen, DO NOT EDIT.
package rest
import (
"context"
"net/http"
"time"
"github.com/go-faster/errors"
ht "github.com/ogen-go/ogen/http"
"github.com/ogen-go/ogen/middleware"
"github.com/ogen-go/ogen/ogenerrors"
"github.com/ogen-go/ogen/otelogen"
"go.opentelemetry.io/otel/attribute"
"go.opentelemetry.io/otel/codes"
"go.opentelemetry.io/otel/metric"
semconv "go.opentelemetry.io/otel/semconv/v1.39.0"
"go.opentelemetry.io/otel/trace"
)
type codeRecorder struct {
http.ResponseWriter
status int
}
func (c *codeRecorder) WriteHeader(status int) {
c.status = status
c.ResponseWriter.WriteHeader(status)
}
func (c *codeRecorder) Unwrap() http.ResponseWriter {
return c.ResponseWriter
}
// handlePerformPredictionRequest handles performPrediction operation.
//
// Perform prediction.
//
// GET /api/v1/prediction
func (s *Server) handlePerformPredictionRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) {
statusWriter := &codeRecorder{ResponseWriter: w}
w = statusWriter
otelAttrs := []attribute.KeyValue{
otelogen.OperationID("performPrediction"),
semconv.HTTPRequestMethodKey.String("GET"),
semconv.HTTPRouteKey.String("/api/v1/prediction"),
}
// Add attributes from config.
otelAttrs = append(otelAttrs, s.cfg.Attributes...)
// Start a span for this request.
ctx, span := s.cfg.Tracer.Start(r.Context(), PerformPredictionOperation,
trace.WithAttributes(otelAttrs...),
serverSpanKind,
)
defer span.End()
// Add Labeler to context.
labeler := &Labeler{attrs: otelAttrs}
ctx = contextWithLabeler(ctx, labeler)
// Run stopwatch.
startTime := time.Now()
defer func() {
elapsedDuration := time.Since(startTime)
attrSet := labeler.AttributeSet()
attrs := attrSet.ToSlice()
code := statusWriter.status
if code != 0 {
codeAttr := semconv.HTTPResponseStatusCode(code)
attrs = append(attrs, codeAttr)
span.SetAttributes(codeAttr)
}
attrOpt := metric.WithAttributes(attrs...)
// Increment request counter.
s.requests.Add(ctx, 1, attrOpt)
// Use floating point division here for higher precision (instead of Millisecond method).
s.duration.Record(ctx, float64(elapsedDuration)/float64(time.Millisecond), attrOpt)
}()
var (
recordError = func(stage string, err error) {
span.RecordError(err)
// https://opentelemetry.io/docs/specs/semconv/http/http-spans/#status
// Span Status MUST be left unset if HTTP status code was in the 1xx, 2xx or 3xx ranges,
// unless there was another error (e.g., network error receiving the response body; or 3xx codes with
// max redirects exceeded), in which case status MUST be set to Error.
code := statusWriter.status
if code < 100 || code >= 500 {
span.SetStatus(codes.Error, stage)
}
attrSet := labeler.AttributeSet()
attrs := attrSet.ToSlice()
if code != 0 {
attrs = append(attrs, semconv.HTTPResponseStatusCode(code))
}
s.errors.Add(ctx, 1, metric.WithAttributes(attrs...))
}
err error
opErrContext = ogenerrors.OperationContext{
Name: PerformPredictionOperation,
ID: "performPrediction",
}
)
params, err := decodePerformPredictionParams(args, argsEscaped, r)
if err != nil {
err = &ogenerrors.DecodeParamsError{
OperationContext: opErrContext,
Err: err,
}
defer recordError("DecodeParams", err)
s.cfg.ErrorHandler(ctx, w, r, err)
return
}
var rawBody []byte
var response *PredictionResponse
if m := s.cfg.Middleware; m != nil {
mreq := middleware.Request{
Context: ctx,
OperationName: PerformPredictionOperation,
OperationSummary: "Perform prediction",
OperationID: "performPrediction",
Body: nil,
RawBody: rawBody,
Params: middleware.Parameters{
{
Name: "launch_latitude",
In: "query",
}: params.LaunchLatitude,
{
Name: "launch_longitude",
In: "query",
}: params.LaunchLongitude,
{
Name: "launch_datetime",
In: "query",
}: params.LaunchDatetime,
{
Name: "launch_altitude",
In: "query",
}: params.LaunchAltitude,
{
Name: "profile",
In: "query",
}: params.Profile,
{
Name: "ascent_rate",
In: "query",
}: params.AscentRate,
{
Name: "burst_altitude",
In: "query",
}: params.BurstAltitude,
{
Name: "descent_rate",
In: "query",
}: params.DescentRate,
{
Name: "float_altitude",
In: "query",
}: params.FloatAltitude,
{
Name: "stop_datetime",
In: "query",
}: params.StopDatetime,
{
Name: "dataset",
In: "query",
}: params.Dataset,
},
Raw: r,
}
type (
Request = struct{}
Params = PerformPredictionParams
Response = *PredictionResponse
)
response, err = middleware.HookMiddleware[
Request,
Params,
Response,
](
m,
mreq,
unpackPerformPredictionParams,
func(ctx context.Context, request Request, params Params) (response Response, err error) {
response, err = s.h.PerformPrediction(ctx, params)
return response, err
},
)
} else {
response, err = s.h.PerformPrediction(ctx, params)
}
if err != nil {
if errRes, ok := errors.Into[*ErrorStatusCode](err); ok {
if err := encodeErrorResponse(errRes, w, span); err != nil {
defer recordError("Internal", err)
}
return
}
if errors.Is(err, ht.ErrNotImplemented) {
s.cfg.ErrorHandler(ctx, w, r, err)
return
}
if err := encodeErrorResponse(s.h.NewError(ctx, err), w, span); err != nil {
defer recordError("Internal", err)
}
return
}
if err := encodePerformPredictionResponse(response, w, span); err != nil {
defer recordError("EncodeResponse", err)
if !errors.Is(err, ht.ErrInternalServerErrorResponse) {
s.cfg.ErrorHandler(ctx, w, r, err)
}
return
}
}
// handleReadinessCheckRequest handles readinessCheck operation.
//
// Readiness check.
//
// GET /ready
func (s *Server) handleReadinessCheckRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) {
statusWriter := &codeRecorder{ResponseWriter: w}
w = statusWriter
otelAttrs := []attribute.KeyValue{
otelogen.OperationID("readinessCheck"),
semconv.HTTPRequestMethodKey.String("GET"),
semconv.HTTPRouteKey.String("/ready"),
}
// Add attributes from config.
otelAttrs = append(otelAttrs, s.cfg.Attributes...)
// Start a span for this request.
ctx, span := s.cfg.Tracer.Start(r.Context(), ReadinessCheckOperation,
trace.WithAttributes(otelAttrs...),
serverSpanKind,
)
defer span.End()
// Add Labeler to context.
labeler := &Labeler{attrs: otelAttrs}
ctx = contextWithLabeler(ctx, labeler)
// Run stopwatch.
startTime := time.Now()
defer func() {
elapsedDuration := time.Since(startTime)
attrSet := labeler.AttributeSet()
attrs := attrSet.ToSlice()
code := statusWriter.status
if code != 0 {
codeAttr := semconv.HTTPResponseStatusCode(code)
attrs = append(attrs, codeAttr)
span.SetAttributes(codeAttr)
}
attrOpt := metric.WithAttributes(attrs...)
// Increment request counter.
s.requests.Add(ctx, 1, attrOpt)
// Use floating point division here for higher precision (instead of Millisecond method).
s.duration.Record(ctx, float64(elapsedDuration)/float64(time.Millisecond), attrOpt)
}()
var (
recordError = func(stage string, err error) {
span.RecordError(err)
// https://opentelemetry.io/docs/specs/semconv/http/http-spans/#status
// Span Status MUST be left unset if HTTP status code was in the 1xx, 2xx or 3xx ranges,
// unless there was another error (e.g., network error receiving the response body; or 3xx codes with
// max redirects exceeded), in which case status MUST be set to Error.
code := statusWriter.status
if code < 100 || code >= 500 {
span.SetStatus(codes.Error, stage)
}
attrSet := labeler.AttributeSet()
attrs := attrSet.ToSlice()
if code != 0 {
attrs = append(attrs, semconv.HTTPResponseStatusCode(code))
}
s.errors.Add(ctx, 1, metric.WithAttributes(attrs...))
}
err error
)
var rawBody []byte
var response *ReadinessResponse
if m := s.cfg.Middleware; m != nil {
mreq := middleware.Request{
Context: ctx,
OperationName: ReadinessCheckOperation,
OperationSummary: "Readiness check",
OperationID: "readinessCheck",
Body: nil,
RawBody: rawBody,
Params: middleware.Parameters{},
Raw: r,
}
type (
Request = struct{}
Params = struct{}
Response = *ReadinessResponse
)
response, err = middleware.HookMiddleware[
Request,
Params,
Response,
](
m,
mreq,
nil,
func(ctx context.Context, request Request, params Params) (response Response, err error) {
response, err = s.h.ReadinessCheck(ctx)
return response, err
},
)
} else {
response, err = s.h.ReadinessCheck(ctx)
}
if err != nil {
if errRes, ok := errors.Into[*ErrorStatusCode](err); ok {
if err := encodeErrorResponse(errRes, w, span); err != nil {
defer recordError("Internal", err)
}
return
}
if errors.Is(err, ht.ErrNotImplemented) {
s.cfg.ErrorHandler(ctx, w, r, err)
return
}
if err := encodeErrorResponse(s.h.NewError(ctx, err), w, span); err != nil {
defer recordError("Internal", err)
}
return
}
if err := encodeReadinessCheckResponse(response, w, span); err != nil {
defer recordError("EncodeResponse", err)
if !errors.Is(err, ht.ErrInternalServerErrorResponse) {
s.cfg.ErrorHandler(ctx, w, r, err)
}
return
}
}

1398
pkg/rest/oas_json_gen.go Normal file
View file

File diff suppressed because it is too large Load diff

42
pkg/rest/oas_labeler_gen.go Normal file
View file

@ -0,0 +1,42 @@
// Code generated by ogen, DO NOT EDIT.
package rest
import (
"context"
"go.opentelemetry.io/otel/attribute"
)
// Labeler is used to allow adding custom attributes to the server request metrics.
type Labeler struct {
attrs []attribute.KeyValue
}
// Add attributes to the Labeler.
func (l *Labeler) Add(attrs ...attribute.KeyValue) {
l.attrs = append(l.attrs, attrs...)
}
// AttributeSet returns the attributes added to the Labeler as an attribute.Set.
func (l *Labeler) AttributeSet() attribute.Set {
return attribute.NewSet(l.attrs...)
}
type labelerContextKey struct{}
// LabelerFromContext retrieves the Labeler from the provided context, if present.
//
// If no Labeler was found in the provided context a new, empty Labeler is returned and the second
// return value is false. In this case it is safe to use the Labeler but any attributes added to
// it will not be used.
func LabelerFromContext(ctx context.Context) (*Labeler, bool) {
if l, ok := ctx.Value(labelerContextKey{}).(*Labeler); ok {
return l, true
}
return &Labeler{}, false
}
func contextWithLabeler(ctx context.Context, l *Labeler) context.Context {
return context.WithValue(ctx, labelerContextKey{}, l)
}

10
pkg/rest/oas_middleware_gen.go Normal file
View file

@ -0,0 +1,10 @@
// Code generated by ogen, DO NOT EDIT.
package rest
import (
"github.com/ogen-go/ogen/middleware"
)
// Middleware is middleware type.
type Middleware = middleware.Middleware

11
pkg/rest/oas_operations_gen.go Normal file
View file

@ -0,0 +1,11 @@
// Code generated by ogen, DO NOT EDIT.
package rest
// OperationName is the ogen operation name
type OperationName = string
const (
PerformPredictionOperation OperationName = "PerformPrediction"
ReadinessCheckOperation OperationName = "ReadinessCheck"
)

679
pkg/rest/oas_parameters_gen.go Normal file
View file

@ -0,0 +1,679 @@
// Code generated by ogen, DO NOT EDIT.
package rest
import (
"net/http"
"time"
"github.com/go-faster/errors"
"github.com/ogen-go/ogen/conv"
"github.com/ogen-go/ogen/middleware"
"github.com/ogen-go/ogen/ogenerrors"
"github.com/ogen-go/ogen/uri"
"github.com/ogen-go/ogen/validate"
)
// PerformPredictionParams is parameters of performPrediction operation.
type PerformPredictionParams struct {
LaunchLatitude float64
LaunchLongitude float64
LaunchDatetime time.Time
LaunchAltitude OptFloat64 `json:",omitempty,omitzero"`
Profile OptPerformPredictionProfile `json:",omitempty,omitzero"`
AscentRate OptFloat64 `json:",omitempty,omitzero"`
BurstAltitude OptFloat64 `json:",omitempty,omitzero"`
DescentRate OptFloat64 `json:",omitempty,omitzero"`
FloatAltitude OptFloat64 `json:",omitempty,omitzero"`
StopDatetime OptDateTime `json:",omitempty,omitzero"`
Dataset OptDateTime `json:",omitempty,omitzero"`
}
func unpackPerformPredictionParams(packed middleware.Parameters) (params PerformPredictionParams) {
{
key := middleware.ParameterKey{
Name: "launch_latitude",
In: "query",
}
params.LaunchLatitude = packed[key].(float64)
}
{
key := middleware.ParameterKey{
Name: "launch_longitude",
In: "query",
}
params.LaunchLongitude = packed[key].(float64)
}
{
key := middleware.ParameterKey{
Name: "launch_datetime",
In: "query",
}
params.LaunchDatetime = packed[key].(time.Time)
}
{
key := middleware.ParameterKey{
Name: "launch_altitude",
In: "query",
}
if v, ok := packed[key]; ok {
params.LaunchAltitude = v.(OptFloat64)
}
}
{
key := middleware.ParameterKey{
Name: "profile",
In: "query",
}
if v, ok := packed[key]; ok {
params.Profile = v.(OptPerformPredictionProfile)
}
}
{
key := middleware.ParameterKey{
Name: "ascent_rate",
In: "query",
}
if v, ok := packed[key]; ok {
params.AscentRate = v.(OptFloat64)
}
}
{
key := middleware.ParameterKey{
Name: "burst_altitude",
In: "query",
}
if v, ok := packed[key]; ok {
params.BurstAltitude = v.(OptFloat64)
}
}
{
key := middleware.ParameterKey{
Name: "descent_rate",
In: "query",
}
if v, ok := packed[key]; ok {
params.DescentRate = v.(OptFloat64)
}
}
{
key := middleware.ParameterKey{
Name: "float_altitude",
In: "query",
}
if v, ok := packed[key]; ok {
params.FloatAltitude = v.(OptFloat64)
}
}
{
key := middleware.ParameterKey{
Name: "stop_datetime",
In: "query",
}
if v, ok := packed[key]; ok {
params.StopDatetime = v.(OptDateTime)
}
}
{
key := middleware.ParameterKey{
Name: "dataset",
In: "query",
}
if v, ok := packed[key]; ok {
params.Dataset = v.(OptDateTime)
}
}
return params
}
func decodePerformPredictionParams(args [0]string, argsEscaped bool, r *http.Request) (params PerformPredictionParams, _ error) {
q := uri.NewQueryDecoder(r.URL.Query())
// Decode query: launch_latitude.
if err := func() error {
cfg := uri.QueryParameterDecodingConfig{
Name: "launch_latitude",
Style: uri.QueryStyleForm,
Explode: true,
}
if err := q.HasParam(cfg); err == nil {
if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
val, err := d.DecodeValue()
if err != nil {
return err
}
c, err := conv.ToFloat64(val)
if err != nil {
return err
}
params.LaunchLatitude = c
return nil
}); err != nil {
return err
}
if err := func() error {
if err := (validate.Float{}).Validate(float64(params.LaunchLatitude)); err != nil {
return errors.Wrap(err, "float")
}
return nil
}(); err != nil {
return err
}
} else {
return err
}
return nil
}(); err != nil {
return params, &ogenerrors.DecodeParamError{
Name: "launch_latitude",
In: "query",
Err: err,
}
}
// Decode query: launch_longitude.
if err := func() error {
cfg := uri.QueryParameterDecodingConfig{
Name: "launch_longitude",
Style: uri.QueryStyleForm,
Explode: true,
}
if err := q.HasParam(cfg); err == nil {
if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
val, err := d.DecodeValue()
if err != nil {
return err
}
c, err := conv.ToFloat64(val)
if err != nil {
return err
}
params.LaunchLongitude = c
return nil
}); err != nil {
return err
}
if err := func() error {
if err := (validate.Float{}).Validate(float64(params.LaunchLongitude)); err != nil {
return errors.Wrap(err, "float")
}
return nil
}(); err != nil {
return err
}
} else {
return err
}
return nil
}(); err != nil {
return params, &ogenerrors.DecodeParamError{
Name: "launch_longitude",
In: "query",
Err: err,
}
}
// Decode query: launch_datetime.
if err := func() error {
cfg := uri.QueryParameterDecodingConfig{
Name: "launch_datetime",
Style: uri.QueryStyleForm,
Explode: true,
}
if err := q.HasParam(cfg); err == nil {
if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
val, err := d.DecodeValue()
if err != nil {
return err
}
c, err := conv.ToDateTime(val)
if err != nil {
return err
}
params.LaunchDatetime = c
return nil
}); err != nil {
return err
}
} else {
return err
}
return nil
}(); err != nil {
return params, &ogenerrors.DecodeParamError{
Name: "launch_datetime",
In: "query",
Err: err,
}
}
// Decode query: launch_altitude.
if err := func() error {
cfg := uri.QueryParameterDecodingConfig{
Name: "launch_altitude",
Style: uri.QueryStyleForm,
Explode: true,
}
if err := q.HasParam(cfg); err == nil {
if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
var paramsDotLaunchAltitudeVal float64
if err := func() error {
val, err := d.DecodeValue()
if err != nil {
return err
}
c, err := conv.ToFloat64(val)
if err != nil {
return err
}
paramsDotLaunchAltitudeVal = c
return nil
}(); err != nil {
return err
}
params.LaunchAltitude.SetTo(paramsDotLaunchAltitudeVal)
return nil
}); err != nil {
return err
}
if err := func() error {
if value, ok := params.LaunchAltitude.Get(); ok {
if err := func() error {
if err := (validate.Float{}).Validate(float64(value)); err != nil {
return errors.Wrap(err, "float")
}
return nil
}(); err != nil {
return err
}
}
return nil
}(); err != nil {
return err
}
}
return nil
}(); err != nil {
return params, &ogenerrors.DecodeParamError{
Name: "launch_altitude",
In: "query",
Err: err,
}
}
// Set default value for query: profile.
{
val := PerformPredictionProfile("standard_profile")
params.Profile.SetTo(val)
}
// Decode query: profile.
if err := func() error {
cfg := uri.QueryParameterDecodingConfig{
Name: "profile",
Style: uri.QueryStyleForm,
Explode: true,
}
if err := q.HasParam(cfg); err == nil {
if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
var paramsDotProfileVal PerformPredictionProfile
if err := func() error {
val, err := d.DecodeValue()
if err != nil {
return err
}
c, err := conv.ToString(val)
if err != nil {
return err
}
paramsDotProfileVal = PerformPredictionProfile(c)
return nil
}(); err != nil {
return err
}
params.Profile.SetTo(paramsDotProfileVal)
return nil
}); err != nil {
return err
}
if err := func() error {
if value, ok := params.Profile.Get(); ok {
if err := func() error {
if err := value.Validate(); err != nil {
return err
}
return nil
}(); err != nil {
return err
}
}
return nil
}(); err != nil {
return err
}
}
return nil
}(); err != nil {
return params, &ogenerrors.DecodeParamError{
Name: "profile",
In: "query",
Err: err,
}
}
// Decode query: ascent_rate.
if err := func() error {
cfg := uri.QueryParameterDecodingConfig{
Name: "ascent_rate",
Style: uri.QueryStyleForm,
Explode: true,
}
if err := q.HasParam(cfg); err == nil {
if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
var paramsDotAscentRateVal float64
if err := func() error {
val, err := d.DecodeValue()
if err != nil {
return err
}
c, err := conv.ToFloat64(val)
if err != nil {
return err
}
paramsDotAscentRateVal = c
return nil
}(); err != nil {
return err
}
params.AscentRate.SetTo(paramsDotAscentRateVal)
return nil
}); err != nil {
return err
}
if err := func() error {
if value, ok := params.AscentRate.Get(); ok {
if err := func() error {
if err := (validate.Float{}).Validate(float64(value)); err != nil {
return errors.Wrap(err, "float")
}
return nil
}(); err != nil {
return err
}
}
return nil
}(); err != nil {
return err
}
}
return nil
}(); err != nil {
return params, &ogenerrors.DecodeParamError{
Name: "ascent_rate",
In: "query",
Err: err,
}
}
// Decode query: burst_altitude.
if err := func() error {
cfg := uri.QueryParameterDecodingConfig{
Name: "burst_altitude",
Style: uri.QueryStyleForm,
Explode: true,
}
if err := q.HasParam(cfg); err == nil {
if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
var paramsDotBurstAltitudeVal float64
if err := func() error {
val, err := d.DecodeValue()
if err != nil {
return err
}
c, err := conv.ToFloat64(val)
if err != nil {
return err
}
paramsDotBurstAltitudeVal = c
return nil
}(); err != nil {
return err
}
params.BurstAltitude.SetTo(paramsDotBurstAltitudeVal)
return nil
}); err != nil {
return err
}
if err := func() error {
if value, ok := params.BurstAltitude.Get(); ok {
if err := func() error {
if err := (validate.Float{}).Validate(float64(value)); err != nil {
return errors.Wrap(err, "float")
}
return nil
}(); err != nil {
return err
}
}
return nil
}(); err != nil {
return err
}
}
return nil
}(); err != nil {
return params, &ogenerrors.DecodeParamError{
Name: "burst_altitude",
In: "query",
Err: err,
}
}
// Decode query: descent_rate.
if err := func() error {
cfg := uri.QueryParameterDecodingConfig{
Name: "descent_rate",
Style: uri.QueryStyleForm,
Explode: true,
}
if err := q.HasParam(cfg); err == nil {
if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
var paramsDotDescentRateVal float64
if err := func() error {
val, err := d.DecodeValue()
if err != nil {
return err
}
c, err := conv.ToFloat64(val)
if err != nil {
return err
}
paramsDotDescentRateVal = c
return nil
}(); err != nil {
return err
}
params.DescentRate.SetTo(paramsDotDescentRateVal)
return nil
}); err != nil {
return err
}
if err := func() error {
if value, ok := params.DescentRate.Get(); ok {
if err := func() error {
if err := (validate.Float{}).Validate(float64(value)); err != nil {
return errors.Wrap(err, "float")
}
return nil
}(); err != nil {
return err
}
}
return nil
}(); err != nil {
return err
}
}
return nil
}(); err != nil {
return params, &ogenerrors.DecodeParamError{
Name: "descent_rate",
In: "query",
Err: err,
}
}
// Decode query: float_altitude.
if err := func() error {
cfg := uri.QueryParameterDecodingConfig{
Name: "float_altitude",
Style: uri.QueryStyleForm,
Explode: true,
}
if err := q.HasParam(cfg); err == nil {
if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
var paramsDotFloatAltitudeVal float64
if err := func() error {
val, err := d.DecodeValue()
if err != nil {
return err
}
c, err := conv.ToFloat64(val)
if err != nil {
return err
}
paramsDotFloatAltitudeVal = c
return nil
}(); err != nil {
return err
}
params.FloatAltitude.SetTo(paramsDotFloatAltitudeVal)
return nil
}); err != nil {
return err
}
if err := func() error {
if value, ok := params.FloatAltitude.Get(); ok {
if err := func() error {
if err := (validate.Float{}).Validate(float64(value)); err != nil {
return errors.Wrap(err, "float")
}
return nil
}(); err != nil {
return err
}
}
return nil
}(); err != nil {
return err
}
}
return nil
}(); err != nil {
return params, &ogenerrors.DecodeParamError{
Name: "float_altitude",
In: "query",
Err: err,
}
}
// Decode query: stop_datetime.
if err := func() error {
cfg := uri.QueryParameterDecodingConfig{
Name: "stop_datetime",
Style: uri.QueryStyleForm,
Explode: true,
}
if err := q.HasParam(cfg); err == nil {
if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
var paramsDotStopDatetimeVal time.Time
if err := func() error {
val, err := d.DecodeValue()
if err != nil {
return err
}
c, err := conv.ToDateTime(val)
if err != nil {
return err
}
paramsDotStopDatetimeVal = c
return nil
}(); err != nil {
return err
}
params.StopDatetime.SetTo(paramsDotStopDatetimeVal)
return nil
}); err != nil {
return err
}
}
return nil
}(); err != nil {
return params, &ogenerrors.DecodeParamError{
Name: "stop_datetime",
In: "query",
Err: err,
}
}
// Decode query: dataset.
if err := func() error {
cfg := uri.QueryParameterDecodingConfig{
Name: "dataset",
Style: uri.QueryStyleForm,
Explode: true,
}
if err := q.HasParam(cfg); err == nil {
if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
var paramsDotDatasetVal time.Time
if err := func() error {
val, err := d.DecodeValue()
if err != nil {
return err
}
c, err := conv.ToDateTime(val)
if err != nil {
return err
}
paramsDotDatasetVal = c
return nil
}(); err != nil {
return err
}
params.Dataset.SetTo(paramsDotDatasetVal)
return nil
}); err != nil {
return err
}
}
return nil
}(); err != nil {
return params, &ogenerrors.DecodeParamError{
Name: "dataset",
In: "query",
Err: err,
}
}
return params, nil
}

3
pkg/rest/oas_request_decoders_gen.go Normal file
View file

@ -0,0 +1,3 @@
// Code generated by ogen, DO NOT EDIT.
package rest

3
pkg/rest/oas_request_encoders_gen.go Normal file
View file

@ -0,0 +1,3 @@
// Code generated by ogen, DO NOT EDIT.
package rest

198
pkg/rest/oas_response_decoders_gen.go Normal file
View file

@ -0,0 +1,198 @@
// Code generated by ogen, DO NOT EDIT.
package rest
import (
"io"
"mime"
"net/http"
"github.com/go-faster/errors"
"github.com/go-faster/jx"
"github.com/ogen-go/ogen/ogenerrors"
"github.com/ogen-go/ogen/validate"
)
func decodePerformPredictionResponse(resp *http.Response) (res *PredictionResponse, _ error) {
switch resp.StatusCode {
case 200:
// Code 200.
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
if err != nil {
return res, errors.Wrap(err, "parse media type")
}
switch {
case ct == "application/json":
buf, err := io.ReadAll(resp.Body)
if err != nil {
return res, err
}
d := jx.DecodeBytes(buf)
var response PredictionResponse
if err := func() error {
if err := response.Decode(d); err != nil {
return err
}
if err := d.Skip(); err != io.EOF {
return errors.New("unexpected trailing data")
}
return nil
}(); err != nil {
err = &ogenerrors.DecodeBodyError{
ContentType: ct,
Body: buf,
Err: err,
}
return res, err
}
// Validate response.
if err := func() error {
if err := response.Validate(); err != nil {
return err
}
return nil
}(); err != nil {
return res, errors.Wrap(err, "validate")
}
return &response, nil
default:
return res, validate.InvalidContentType(ct)
}
}
// Convenient error response.
defRes, err := func() (res *ErrorStatusCode, err error) {
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
if err != nil {
return res, errors.Wrap(err, "parse media type")
}
switch {
case ct == "application/json":
buf, err := io.ReadAll(resp.Body)
if err != nil {
return res, err
}
d := jx.DecodeBytes(buf)
var response Error
if err := func() error {
if err := response.Decode(d); err != nil {
return err
}
if err := d.Skip(); err != io.EOF {
return errors.New("unexpected trailing data")
}
return nil
}(); err != nil {
err = &ogenerrors.DecodeBodyError{
ContentType: ct,
Body: buf,
Err: err,
}
return res, err
}
return &ErrorStatusCode{
StatusCode: resp.StatusCode,
Response: response,
}, nil
default:
return res, validate.InvalidContentType(ct)
}
}()
if err != nil {
return res, errors.Wrapf(err, "default (code %d)", resp.StatusCode)
}
return res, errors.Wrap(defRes, "error")
}
func decodeReadinessCheckResponse(resp *http.Response) (res *ReadinessResponse, _ error) {
switch resp.StatusCode {
case 200:
// Code 200.
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
if err != nil {
return res, errors.Wrap(err, "parse media type")
}
switch {
case ct == "application/json":
buf, err := io.ReadAll(resp.Body)
if err != nil {
return res, err
}
d := jx.DecodeBytes(buf)
var response ReadinessResponse
if err := func() error {
if err := response.Decode(d); err != nil {
return err
}
if err := d.Skip(); err != io.EOF {
return errors.New("unexpected trailing data")
}
return nil
}(); err != nil {
err = &ogenerrors.DecodeBodyError{
ContentType: ct,
Body: buf,
Err: err,
}
return res, err
}
// Validate response.
if err := func() error {
if err := response.Validate(); err != nil {
return err
}
return nil
}(); err != nil {
return res, errors.Wrap(err, "validate")
}
return &response, nil
default:
return res, validate.InvalidContentType(ct)
}
}
// Convenient error response.
defRes, err := func() (res *ErrorStatusCode, err error) {
ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
if err != nil {
return res, errors.Wrap(err, "parse media type")
}
switch {
case ct == "application/json":
buf, err := io.ReadAll(resp.Body)
if err != nil {
return res, err
}
d := jx.DecodeBytes(buf)
var response Error
if err := func() error {
if err := response.Decode(d); err != nil {
return err
}
if err := d.Skip(); err != io.EOF {
return errors.New("unexpected trailing data")
}
return nil
}(); err != nil {
err = &ogenerrors.DecodeBodyError{
ContentType: ct,
Body: buf,
Err: err,
}
return res, err
}
return &ErrorStatusCode{
StatusCode: resp.StatusCode,
Response: response,
}, nil
default:
return res, validate.InvalidContentType(ct)
}
}()
if err != nil {
return res, errors.Wrapf(err, "default (code %d)", resp.StatusCode)
}
return res, errors.Wrap(defRes, "error")
}

68
pkg/rest/oas_response_encoders_gen.go Normal file
View file

@ -0,0 +1,68 @@
// Code generated by ogen, DO NOT EDIT.
package rest
import (
"net/http"
"github.com/go-faster/errors"
"github.com/go-faster/jx"
ht "github.com/ogen-go/ogen/http"
"go.opentelemetry.io/otel/codes"
"go.opentelemetry.io/otel/trace"
)
func encodePerformPredictionResponse(response *PredictionResponse, w http.ResponseWriter, span trace.Span) error {
w.Header().Set("Content-Type", "application/json; charset=utf-8")
w.WriteHeader(200)
span.SetStatus(codes.Ok, http.StatusText(200))
e := new(jx.Encoder)
response.Encode(e)
if _, err := e.WriteTo(w); err != nil {
return errors.Wrap(err, "write")
}
return nil
}
func encodeReadinessCheckResponse(response *ReadinessResponse, w http.ResponseWriter, span trace.Span) error {
w.Header().Set("Content-Type", "application/json; charset=utf-8")
w.WriteHeader(200)
span.SetStatus(codes.Ok, http.StatusText(200))
e := new(jx.Encoder)
response.Encode(e)
if _, err := e.WriteTo(w); err != nil {
return errors.Wrap(err, "write")
}
return nil
}
func encodeErrorResponse(response *ErrorStatusCode, w http.ResponseWriter, span trace.Span) error {
w.Header().Set("Content-Type", "application/json; charset=utf-8")
code := response.StatusCode
if code == 0 {
// Set default status code.
code = http.StatusOK
}
w.WriteHeader(code)
if st := http.StatusText(code); code >= http.StatusBadRequest {
span.SetStatus(codes.Error, st)
} else {
span.SetStatus(codes.Ok, st)
}
e := new(jx.Encoder)
response.Response.Encode(e)
if _, err := e.WriteTo(w); err != nil {
return errors.Wrap(err, "write")
}
if code >= http.StatusInternalServerError {
return errors.Wrapf(ht.ErrInternalServerErrorResponse, "code: %d, message: %s", code, http.StatusText(code))
}
return nil
}

268
pkg/rest/oas_router_gen.go Normal file
View file

@ -0,0 +1,268 @@
// Code generated by ogen, DO NOT EDIT.
package rest
import (
"net/http"
"net/url"
"strings"
"github.com/ogen-go/ogen/uri"
)
func (s *Server) cutPrefix(path string) (string, bool) {
prefix := s.cfg.Prefix
if prefix == "" {
return path, true
}
if !strings.HasPrefix(path, prefix) {
// Prefix doesn't match.
return "", false
}
// Cut prefix from the path.
return strings.TrimPrefix(path, prefix), true
}
// ServeHTTP serves http request as defined by OpenAPI v3 specification,
// calling handler that matches the path or returning not found error.
func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
elem := r.URL.Path
elemIsEscaped := false
if rawPath := r.URL.RawPath; rawPath != "" {
if normalized, ok := uri.NormalizeEscapedPath(rawPath); ok {
elem = normalized
elemIsEscaped = strings.ContainsRune(elem, '%')
}
}
elem, ok := s.cutPrefix(elem)
if !ok || len(elem) == 0 {
s.notFound(w, r)
return
}
// Static code generated router with unwrapped path search.
switch {
default:
if len(elem) == 0 {
break
}
switch elem[0] {
case '/': // Prefix: "/"
if l := len("/"); len(elem) >= l && elem[0:l] == "/" {
elem = elem[l:]
} else {
break
}
if len(elem) == 0 {
break
}
switch elem[0] {
case 'a': // Prefix: "api/v1/prediction"
if l := len("api/v1/prediction"); len(elem) >= l && elem[0:l] == "api/v1/prediction" {
elem = elem[l:]
} else {
break
}
if len(elem) == 0 {
// Leaf node.
switch r.Method {
case "GET":
s.handlePerformPredictionRequest([0]string{}, elemIsEscaped, w, r)
default:
s.notAllowed(w, r, notAllowedParams{
allowedMethods: "GET",
allowedHeaders: nil,
acceptPost: "",
acceptPatch: "",
})
}
return
}
case 'r': // Prefix: "ready"
if l := len("ready"); len(elem) >= l && elem[0:l] == "ready" {
elem = elem[l:]
} else {
break
}
if len(elem) == 0 {
// Leaf node.
switch r.Method {
case "GET":
s.handleReadinessCheckRequest([0]string{}, elemIsEscaped, w, r)
default:
s.notAllowed(w, r, notAllowedParams{
allowedMethods: "GET",
allowedHeaders: nil,
acceptPost: "",
acceptPatch: "",
})
}
return
}
}
}
}
s.notFound(w, r)
}
// Route is route object.
type Route struct {
name string
summary string
operationID string
operationGroup string
pathPattern string
count int
args [0]string
}
// Name returns ogen operation name.
//
// It is guaranteed to be unique and not empty.
func (r Route) Name() string {
return r.name
}
// Summary returns OpenAPI summary.
func (r Route) Summary() string {
return r.summary
}
// OperationID returns OpenAPI operationId.
func (r Route) OperationID() string {
return r.operationID
}
// OperationGroup returns the x-ogen-operation-group value.
func (r Route) OperationGroup() string {
return r.operationGroup
}
// PathPattern returns OpenAPI path.
func (r Route) PathPattern() string {
return r.pathPattern
}
// Args returns parsed arguments.
func (r Route) Args() []string {
return r.args[:r.count]
}
// FindRoute finds Route for given method and path.
//
// Note: this method does not unescape path or handle reserved characters in path properly. Use FindPath instead.
func (s *Server) FindRoute(method, path string) (Route, bool) {
return s.FindPath(method, &url.URL{Path: path})
}
// FindPath finds Route for given method and URL.
func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) {
var (
elem = u.Path
args = r.args
)
if rawPath := u.RawPath; rawPath != "" {
if normalized, ok := uri.NormalizeEscapedPath(rawPath); ok {
elem = normalized
}
defer func() {
for i, arg := range r.args[:r.count] {
if unescaped, err := url.PathUnescape(arg); err == nil {
r.args[i] = unescaped
}
}
}()
}
elem, ok := s.cutPrefix(elem)
if !ok {
return r, false
}
// Static code generated router with unwrapped path search.
switch {
default:
if len(elem) == 0 {
break
}
switch elem[0] {
case '/': // Prefix: "/"
if l := len("/"); len(elem) >= l && elem[0:l] == "/" {
elem = elem[l:]
} else {
break
}
if len(elem) == 0 {
break
}
switch elem[0] {
case 'a': // Prefix: "api/v1/prediction"
if l := len("api/v1/prediction"); len(elem) >= l && elem[0:l] == "api/v1/prediction" {
elem = elem[l:]
} else {
break
}
if len(elem) == 0 {
// Leaf node.
switch method {
case "GET":
r.name = PerformPredictionOperation
r.summary = "Perform prediction"
r.operationID = "performPrediction"
r.operationGroup = ""
r.pathPattern = "/api/v1/prediction"
r.args = args
r.count = 0
return r, true
default:
return
}
}
case 'r': // Prefix: "ready"
if l := len("ready"); len(elem) >= l && elem[0:l] == "ready" {
elem = elem[l:]
} else {
break
}
if len(elem) == 0 {
// Leaf node.
switch method {
case "GET":
r.name = ReadinessCheckOperation
r.summary = "Readiness check"
r.operationID = "readinessCheck"
r.operationGroup = ""
r.pathPattern = "/ready"
r.args = args
r.count = 0
return r, true
default:
return
}
}
}
}
}
return r, false
}

789
pkg/rest/oas_schemas_gen.go Normal file
View file

@ -0,0 +1,789 @@
// Code generated by ogen, DO NOT EDIT.
package rest
import (
"fmt"
"time"
"github.com/go-faster/errors"
"github.com/go-faster/jx"
)
func (s *ErrorStatusCode) Error() string {
return fmt.Sprintf("code %d: %+v", s.StatusCode, s.Response)
}
// Ref: #/components/schemas/Error
type Error struct {
Error ErrorError `json:"error"`
}
// GetError returns the value of Error.
func (s *Error) GetError() ErrorError {
return s.Error
}
// SetError sets the value of Error.
func (s *Error) SetError(val ErrorError) {
s.Error = val
}
type ErrorError struct {
Type string `json:"type"`
Description string `json:"description"`
}
// GetType returns the value of Type.
func (s *ErrorError) GetType() string {
return s.Type
}
// GetDescription returns the value of Description.
func (s *ErrorError) GetDescription() string {
return s.Description
}
// SetType sets the value of Type.
func (s *ErrorError) SetType(val string) {
s.Type = val
}
// SetDescription sets the value of Description.
func (s *ErrorError) SetDescription(val string) {
s.Description = val
}
// ErrorStatusCode wraps Error with StatusCode.
type ErrorStatusCode struct {
StatusCode int
Response Error
}
// GetStatusCode returns the value of StatusCode.
func (s *ErrorStatusCode) GetStatusCode() int {
return s.StatusCode
}
// GetResponse returns the value of Response.
func (s *ErrorStatusCode) GetResponse() Error {
return s.Response
}
// SetStatusCode sets the value of StatusCode.
func (s *ErrorStatusCode) SetStatusCode(val int) {
s.StatusCode = val
}
// SetResponse sets the value of Response.
func (s *ErrorStatusCode) SetResponse(val Error) {
s.Response = val
}
// NewOptDateTime returns new OptDateTime with value set to v.
func NewOptDateTime(v time.Time) OptDateTime {
return OptDateTime{
Value: v,
Set: true,
}
}
// OptDateTime is optional time.Time.
type OptDateTime struct {
Value time.Time
Set bool
}
// IsSet returns true if OptDateTime was set.
func (o OptDateTime) IsSet() bool { return o.Set }
// Reset unsets value.
func (o *OptDateTime) Reset() {
var v time.Time
o.Value = v
o.Set = false
}
// SetTo sets value to v.
func (o *OptDateTime) SetTo(v time.Time) {
o.Set = true
o.Value = v
}
// Get returns value and boolean that denotes whether value was set.
func (o OptDateTime) Get() (v time.Time, ok bool) {
if !o.Set {
return v, false
}
return o.Value, true
}
// Or returns value if set, or given parameter if does not.
func (o OptDateTime) Or(d time.Time) time.Time {
if v, ok := o.Get(); ok {
return v
}
return d
}
// NewOptFloat64 returns new OptFloat64 with value set to v.
func NewOptFloat64(v float64) OptFloat64 {
return OptFloat64{
Value: v,
Set: true,
}
}
// OptFloat64 is optional float64.
type OptFloat64 struct {
Value float64
Set bool
}
// IsSet returns true if OptFloat64 was set.
func (o OptFloat64) IsSet() bool { return o.Set }
// Reset unsets value.
func (o *OptFloat64) Reset() {
var v float64
o.Value = v
o.Set = false
}
// SetTo sets value to v.
func (o *OptFloat64) SetTo(v float64) {
o.Set = true
o.Value = v
}
// Get returns value and boolean that denotes whether value was set.
func (o OptFloat64) Get() (v float64, ok bool) {
if !o.Set {
return v, false
}
return o.Value, true
}
// Or returns value if set, or given parameter if does not.
func (o OptFloat64) Or(d float64) float64 {
if v, ok := o.Get(); ok {
return v
}
return d
}
// NewOptPerformPredictionProfile returns new OptPerformPredictionProfile with value set to v.
func NewOptPerformPredictionProfile(v PerformPredictionProfile) OptPerformPredictionProfile {
return OptPerformPredictionProfile{
Value: v,
Set: true,
}
}
// OptPerformPredictionProfile is optional PerformPredictionProfile.
type OptPerformPredictionProfile struct {
Value PerformPredictionProfile
Set bool
}
// IsSet returns true if OptPerformPredictionProfile was set.
func (o OptPerformPredictionProfile) IsSet() bool { return o.Set }
// Reset unsets value.
func (o *OptPerformPredictionProfile) Reset() {
var v PerformPredictionProfile
o.Value = v
o.Set = false
}
// SetTo sets value to v.
func (o *OptPerformPredictionProfile) SetTo(v PerformPredictionProfile) {
o.Set = true
o.Value = v
}
// Get returns value and boolean that denotes whether value was set.
func (o OptPerformPredictionProfile) Get() (v PerformPredictionProfile, ok bool) {
if !o.Set {
return v, false
}
return o.Value, true
}
// Or returns value if set, or given parameter if does not.
func (o OptPerformPredictionProfile) Or(d PerformPredictionProfile) PerformPredictionProfile {
if v, ok := o.Get(); ok {
return v
}
return d
}
// NewOptPredictionResponseRequest returns new OptPredictionResponseRequest with value set to v.
func NewOptPredictionResponseRequest(v PredictionResponseRequest) OptPredictionResponseRequest {
return OptPredictionResponseRequest{
Value: v,
Set: true,
}
}
// OptPredictionResponseRequest is optional PredictionResponseRequest.
type OptPredictionResponseRequest struct {
Value PredictionResponseRequest
Set bool
}
// IsSet returns true if OptPredictionResponseRequest was set.
func (o OptPredictionResponseRequest) IsSet() bool { return o.Set }
// Reset unsets value.
func (o *OptPredictionResponseRequest) Reset() {
var v PredictionResponseRequest
o.Value = v
o.Set = false
}
// SetTo sets value to v.
func (o *OptPredictionResponseRequest) SetTo(v PredictionResponseRequest) {
o.Set = true
o.Value = v
}
// Get returns value and boolean that denotes whether value was set.
func (o OptPredictionResponseRequest) Get() (v PredictionResponseRequest, ok bool) {
if !o.Set {
return v, false
}
return o.Value, true
}
// Or returns value if set, or given parameter if does not.
func (o OptPredictionResponseRequest) Or(d PredictionResponseRequest) PredictionResponseRequest {
if v, ok := o.Get(); ok {
return v
}
return d
}
// NewOptPredictionResponseWarnings returns new OptPredictionResponseWarnings with value set to v.
func NewOptPredictionResponseWarnings(v PredictionResponseWarnings) OptPredictionResponseWarnings {
return OptPredictionResponseWarnings{
Value: v,
Set: true,
}
}
// OptPredictionResponseWarnings is optional PredictionResponseWarnings.
type OptPredictionResponseWarnings struct {
Value PredictionResponseWarnings
Set bool
}
// IsSet returns true if OptPredictionResponseWarnings was set.
func (o OptPredictionResponseWarnings) IsSet() bool { return o.Set }
// Reset unsets value.
func (o *OptPredictionResponseWarnings) Reset() {
var v PredictionResponseWarnings
o.Value = v
o.Set = false
}
// SetTo sets value to v.
func (o *OptPredictionResponseWarnings) SetTo(v PredictionResponseWarnings) {
o.Set = true
o.Value = v
}
// Get returns value and boolean that denotes whether value was set.
func (o OptPredictionResponseWarnings) Get() (v PredictionResponseWarnings, ok bool) {
if !o.Set {
return v, false
}
return o.Value, true
}
// Or returns value if set, or given parameter if does not.
func (o OptPredictionResponseWarnings) Or(d PredictionResponseWarnings) PredictionResponseWarnings {
if v, ok := o.Get(); ok {
return v
}
return d
}
// NewOptString returns new OptString with value set to v.
func NewOptString(v string) OptString {
return OptString{
Value: v,
Set: true,
}
}
// OptString is optional string.
type OptString struct {
Value string
Set bool
}
// IsSet returns true if OptString was set.
func (o OptString) IsSet() bool { return o.Set }
// Reset unsets value.
func (o *OptString) Reset() {
var v string
o.Value = v
o.Set = false
}
// SetTo sets value to v.
func (o *OptString) SetTo(v string) {
o.Set = true
o.Value = v
}
// Get returns value and boolean that denotes whether value was set.
func (o OptString) Get() (v string, ok bool) {
if !o.Set {
return v, false
}
return o.Value, true
}
// Or returns value if set, or given parameter if does not.
func (o OptString) Or(d string) string {
if v, ok := o.Get(); ok {
return v
}
return d
}
type PerformPredictionProfile string
const (
PerformPredictionProfileStandardProfile PerformPredictionProfile = "standard_profile"
PerformPredictionProfileFloatProfile PerformPredictionProfile = "float_profile"
)
// AllValues returns all PerformPredictionProfile values.
func (PerformPredictionProfile) AllValues() []PerformPredictionProfile {
return []PerformPredictionProfile{
PerformPredictionProfileStandardProfile,
PerformPredictionProfileFloatProfile,
}
}
// MarshalText implements encoding.TextMarshaler.
func (s PerformPredictionProfile) MarshalText() ([]byte, error) {
switch s {
case PerformPredictionProfileStandardProfile:
return []byte(s), nil
case PerformPredictionProfileFloatProfile:
return []byte(s), nil
default:
return nil, errors.Errorf("invalid value: %q", s)
}
}
// UnmarshalText implements encoding.TextUnmarshaler.
func (s *PerformPredictionProfile) UnmarshalText(data []byte) error {
switch PerformPredictionProfile(data) {
case PerformPredictionProfileStandardProfile:
*s = PerformPredictionProfileStandardProfile
return nil
case PerformPredictionProfileFloatProfile:
*s = PerformPredictionProfileFloatProfile
return nil
default:
return errors.Errorf("invalid value: %q", data)
}
}
// Ref: #/components/schemas/PredictionResponse
type PredictionResponse struct {
Request OptPredictionResponseRequest `json:"request"`
Prediction []PredictionResponsePredictionItem `json:"prediction"`
Metadata PredictionResponseMetadata `json:"metadata"`
Warnings OptPredictionResponseWarnings `json:"warnings"`
}
// GetRequest returns the value of Request.
func (s *PredictionResponse) GetRequest() OptPredictionResponseRequest {
return s.Request
}
// GetPrediction returns the value of Prediction.
func (s *PredictionResponse) GetPrediction() []PredictionResponsePredictionItem {
return s.Prediction
}
// GetMetadata returns the value of Metadata.
func (s *PredictionResponse) GetMetadata() PredictionResponseMetadata {
return s.Metadata
}
// GetWarnings returns the value of Warnings.
func (s *PredictionResponse) GetWarnings() OptPredictionResponseWarnings {
return s.Warnings
}
// SetRequest sets the value of Request.
func (s *PredictionResponse) SetRequest(val OptPredictionResponseRequest) {
s.Request = val
}
// SetPrediction sets the value of Prediction.
func (s *PredictionResponse) SetPrediction(val []PredictionResponsePredictionItem) {
s.Prediction = val
}
// SetMetadata sets the value of Metadata.
func (s *PredictionResponse) SetMetadata(val PredictionResponseMetadata) {
s.Metadata = val
}
// SetWarnings sets the value of Warnings.
func (s *PredictionResponse) SetWarnings(val OptPredictionResponseWarnings) {
s.Warnings = val
}
type PredictionResponseMetadata struct {
StartDatetime time.Time `json:"start_datetime"`
CompleteDatetime time.Time `json:"complete_datetime"`
}
// GetStartDatetime returns the value of StartDatetime.
func (s *PredictionResponseMetadata) GetStartDatetime() time.Time {
return s.StartDatetime
}
// GetCompleteDatetime returns the value of CompleteDatetime.
func (s *PredictionResponseMetadata) GetCompleteDatetime() time.Time {
return s.CompleteDatetime
}
// SetStartDatetime sets the value of StartDatetime.
func (s *PredictionResponseMetadata) SetStartDatetime(val time.Time) {
s.StartDatetime = val
}
// SetCompleteDatetime sets the value of CompleteDatetime.
func (s *PredictionResponseMetadata) SetCompleteDatetime(val time.Time) {
s.CompleteDatetime = val
}
type PredictionResponsePredictionItem struct {
Stage PredictionResponsePredictionItemStage `json:"stage"`
Trajectory []PredictionResponsePredictionItemTrajectoryItem `json:"trajectory"`
}
// GetStage returns the value of Stage.
func (s *PredictionResponsePredictionItem) GetStage() PredictionResponsePredictionItemStage {
return s.Stage
}
// GetTrajectory returns the value of Trajectory.
func (s *PredictionResponsePredictionItem) GetTrajectory() []PredictionResponsePredictionItemTrajectoryItem {
return s.Trajectory
}
// SetStage sets the value of Stage.
func (s *PredictionResponsePredictionItem) SetStage(val PredictionResponsePredictionItemStage) {
s.Stage = val
}
// SetTrajectory sets the value of Trajectory.
func (s *PredictionResponsePredictionItem) SetTrajectory(val []PredictionResponsePredictionItemTrajectoryItem) {
s.Trajectory = val
}
type PredictionResponsePredictionItemStage string
const (
PredictionResponsePredictionItemStageAscent PredictionResponsePredictionItemStage = "ascent"
PredictionResponsePredictionItemStageDescent PredictionResponsePredictionItemStage = "descent"
PredictionResponsePredictionItemStageFloat PredictionResponsePredictionItemStage = "float"
)
// AllValues returns all PredictionResponsePredictionItemStage values.
func (PredictionResponsePredictionItemStage) AllValues() []PredictionResponsePredictionItemStage {
return []PredictionResponsePredictionItemStage{
PredictionResponsePredictionItemStageAscent,
PredictionResponsePredictionItemStageDescent,
PredictionResponsePredictionItemStageFloat,
}
}
// MarshalText implements encoding.TextMarshaler.
func (s PredictionResponsePredictionItemStage) MarshalText() ([]byte, error) {
switch s {
case PredictionResponsePredictionItemStageAscent:
return []byte(s), nil
case PredictionResponsePredictionItemStageDescent:
return []byte(s), nil
case PredictionResponsePredictionItemStageFloat:
return []byte(s), nil
default:
return nil, errors.Errorf("invalid value: %q", s)
}
}
// UnmarshalText implements encoding.TextUnmarshaler.
func (s *PredictionResponsePredictionItemStage) UnmarshalText(data []byte) error {
switch PredictionResponsePredictionItemStage(data) {
case PredictionResponsePredictionItemStageAscent:
*s = PredictionResponsePredictionItemStageAscent
return nil
case PredictionResponsePredictionItemStageDescent:
*s = PredictionResponsePredictionItemStageDescent
return nil
case PredictionResponsePredictionItemStageFloat:
*s = PredictionResponsePredictionItemStageFloat
return nil
default:
return errors.Errorf("invalid value: %q", data)
}
}
type PredictionResponsePredictionItemTrajectoryItem struct {
Datetime time.Time `json:"datetime"`
Latitude float64 `json:"latitude"`
Longitude float64 `json:"longitude"`
Altitude float64 `json:"altitude"`
}
// GetDatetime returns the value of Datetime.
func (s *PredictionResponsePredictionItemTrajectoryItem) GetDatetime() time.Time {
return s.Datetime
}
// GetLatitude returns the value of Latitude.
func (s *PredictionResponsePredictionItemTrajectoryItem) GetLatitude() float64 {
return s.Latitude
}
// GetLongitude returns the value of Longitude.
func (s *PredictionResponsePredictionItemTrajectoryItem) GetLongitude() float64 {
return s.Longitude
}
// GetAltitude returns the value of Altitude.
func (s *PredictionResponsePredictionItemTrajectoryItem) GetAltitude() float64 {
return s.Altitude
}
// SetDatetime sets the value of Datetime.
func (s *PredictionResponsePredictionItemTrajectoryItem) SetDatetime(val time.Time) {
s.Datetime = val
}
// SetLatitude sets the value of Latitude.
func (s *PredictionResponsePredictionItemTrajectoryItem) SetLatitude(val float64) {
s.Latitude = val
}
// SetLongitude sets the value of Longitude.
func (s *PredictionResponsePredictionItemTrajectoryItem) SetLongitude(val float64) {
s.Longitude = val
}
// SetAltitude sets the value of Altitude.
func (s *PredictionResponsePredictionItemTrajectoryItem) SetAltitude(val float64) {
s.Altitude = val
}
type PredictionResponseRequest struct {
Dataset OptString `json:"dataset"`
LaunchLatitude OptFloat64 `json:"launch_latitude"`
LaunchLongitude OptFloat64 `json:"launch_longitude"`
LaunchDatetime OptString `json:"launch_datetime"`
LaunchAltitude OptFloat64 `json:"launch_altitude"`
Profile OptString `json:"profile"`
AscentRate OptFloat64 `json:"ascent_rate"`
BurstAltitude OptFloat64 `json:"burst_altitude"`
DescentRate OptFloat64 `json:"descent_rate"`
}
// GetDataset returns the value of Dataset.
func (s *PredictionResponseRequest) GetDataset() OptString {
return s.Dataset
}
// GetLaunchLatitude returns the value of LaunchLatitude.
func (s *PredictionResponseRequest) GetLaunchLatitude() OptFloat64 {
return s.LaunchLatitude
}
// GetLaunchLongitude returns the value of LaunchLongitude.
func (s *PredictionResponseRequest) GetLaunchLongitude() OptFloat64 {
return s.LaunchLongitude
}
// GetLaunchDatetime returns the value of LaunchDatetime.
func (s *PredictionResponseRequest) GetLaunchDatetime() OptString {
return s.LaunchDatetime
}
// GetLaunchAltitude returns the value of LaunchAltitude.
func (s *PredictionResponseRequest) GetLaunchAltitude() OptFloat64 {
return s.LaunchAltitude
}
// GetProfile returns the value of Profile.
func (s *PredictionResponseRequest) GetProfile() OptString {
return s.Profile
}
// GetAscentRate returns the value of AscentRate.
func (s *PredictionResponseRequest) GetAscentRate() OptFloat64 {
return s.AscentRate
}
// GetBurstAltitude returns the value of BurstAltitude.
func (s *PredictionResponseRequest) GetBurstAltitude() OptFloat64 {
return s.BurstAltitude
}
// GetDescentRate returns the value of DescentRate.
func (s *PredictionResponseRequest) GetDescentRate() OptFloat64 {
return s.DescentRate
}
// SetDataset sets the value of Dataset.
func (s *PredictionResponseRequest) SetDataset(val OptString) {
s.Dataset = val
}
// SetLaunchLatitude sets the value of LaunchLatitude.
func (s *PredictionResponseRequest) SetLaunchLatitude(val OptFloat64) {
s.LaunchLatitude = val
}
// SetLaunchLongitude sets the value of LaunchLongitude.
func (s *PredictionResponseRequest) SetLaunchLongitude(val OptFloat64) {
s.LaunchLongitude = val
}
// SetLaunchDatetime sets the value of LaunchDatetime.
func (s *PredictionResponseRequest) SetLaunchDatetime(val OptString) {
s.LaunchDatetime = val
}
// SetLaunchAltitude sets the value of LaunchAltitude.
func (s *PredictionResponseRequest) SetLaunchAltitude(val OptFloat64) {
s.LaunchAltitude = val
}
// SetProfile sets the value of Profile.
func (s *PredictionResponseRequest) SetProfile(val OptString) {
s.Profile = val
}
// SetAscentRate sets the value of AscentRate.
func (s *PredictionResponseRequest) SetAscentRate(val OptFloat64) {
s.AscentRate = val
}
// SetBurstAltitude sets the value of BurstAltitude.
func (s *PredictionResponseRequest) SetBurstAltitude(val OptFloat64) {
s.BurstAltitude = val
}
// SetDescentRate sets the value of DescentRate.
func (s *PredictionResponseRequest) SetDescentRate(val OptFloat64) {
s.DescentRate = val
}
type PredictionResponseWarnings map[string]jx.Raw
func (s *PredictionResponseWarnings) init() PredictionResponseWarnings {
m := *s
if m == nil {
m = map[string]jx.Raw{}
*s = m
}
return m
}
// Ref: #/components/schemas/ReadinessResponse
type ReadinessResponse struct {
Status ReadinessResponseStatus `json:"status"`
DatasetTime OptDateTime `json:"dataset_time"`
ErrorMessage OptString `json:"error_message"`
}
// GetStatus returns the value of Status.
func (s *ReadinessResponse) GetStatus() ReadinessResponseStatus {
return s.Status
}
// GetDatasetTime returns the value of DatasetTime.
func (s *ReadinessResponse) GetDatasetTime() OptDateTime {
return s.DatasetTime
}
// GetErrorMessage returns the value of ErrorMessage.
func (s *ReadinessResponse) GetErrorMessage() OptString {
return s.ErrorMessage
}
// SetStatus sets the value of Status.
func (s *ReadinessResponse) SetStatus(val ReadinessResponseStatus) {
s.Status = val
}
// SetDatasetTime sets the value of DatasetTime.
func (s *ReadinessResponse) SetDatasetTime(val OptDateTime) {
s.DatasetTime = val
}
// SetErrorMessage sets the value of ErrorMessage.
func (s *ReadinessResponse) SetErrorMessage(val OptString) {
s.ErrorMessage = val
}
type ReadinessResponseStatus string
const (
ReadinessResponseStatusOk ReadinessResponseStatus = "ok"
ReadinessResponseStatusNotReady ReadinessResponseStatus = "not_ready"
ReadinessResponseStatusError ReadinessResponseStatus = "error"
)
// AllValues returns all ReadinessResponseStatus values.
func (ReadinessResponseStatus) AllValues() []ReadinessResponseStatus {
return []ReadinessResponseStatus{
ReadinessResponseStatusOk,
ReadinessResponseStatusNotReady,
ReadinessResponseStatusError,
}
}
// MarshalText implements encoding.TextMarshaler.
func (s ReadinessResponseStatus) MarshalText() ([]byte, error) {
switch s {
case ReadinessResponseStatusOk:
return []byte(s), nil
case ReadinessResponseStatusNotReady:
return []byte(s), nil
case ReadinessResponseStatusError:
return []byte(s), nil
default:
return nil, errors.Errorf("invalid value: %q", s)
}
}
// UnmarshalText implements encoding.TextUnmarshaler.
func (s *ReadinessResponseStatus) UnmarshalText(data []byte) error {
switch ReadinessResponseStatus(data) {
case ReadinessResponseStatusOk:
*s = ReadinessResponseStatusOk
return nil
case ReadinessResponseStatusNotReady:
*s = ReadinessResponseStatusNotReady
return nil
case ReadinessResponseStatusError:
*s = ReadinessResponseStatusError
return nil
default:
return errors.Errorf("invalid value: %q", data)
}
}

46
pkg/rest/oas_server_gen.go Normal file
View file

@ -0,0 +1,46 @@
// Code generated by ogen, DO NOT EDIT.
package rest
import (
"context"
)
// Handler handles operations described by OpenAPI v3 specification.
type Handler interface {
// PerformPrediction implements performPrediction operation.
//
// Perform prediction.
//
// GET /api/v1/prediction
PerformPrediction(ctx context.Context, params PerformPredictionParams) (*PredictionResponse, error)
// ReadinessCheck implements readinessCheck operation.
//
// Readiness check.
//
// GET /ready
ReadinessCheck(ctx context.Context) (*ReadinessResponse, error)
// NewError creates *ErrorStatusCode from error returned by handler.
//
// Used for common default response.
NewError(ctx context.Context, err error) *ErrorStatusCode
}
// Server implements http server based on OpenAPI v3 specification and
// calls Handler to handle requests.
type Server struct {
h Handler
baseServer
}
// NewServer creates new Server.
func NewServer(h Handler, opts ...ServerOption) (*Server, error) {
s, err := newServerConfig(opts...).baseServer()
if err != nil {
return nil, err
}
return &Server{
h: h,
baseServer: s,
}, nil
}

40
pkg/rest/oas_unimplemented_gen.go Normal file
View file

@ -0,0 +1,40 @@
// Code generated by ogen, DO NOT EDIT.
package rest
import (
"context"
ht "github.com/ogen-go/ogen/http"
)
// UnimplementedHandler is no-op Handler which returns http.ErrNotImplemented.
type UnimplementedHandler struct{}
var _ Handler = UnimplementedHandler{}
// PerformPrediction implements performPrediction operation.
//
// Perform prediction.
//
// GET /api/v1/prediction
func (UnimplementedHandler) PerformPrediction(ctx context.Context, params PerformPredictionParams) (r *PredictionResponse, _ error) {
return r, ht.ErrNotImplemented
}
// ReadinessCheck implements readinessCheck operation.
//
// Readiness check.
//
// GET /ready
func (UnimplementedHandler) ReadinessCheck(ctx context.Context) (r *ReadinessResponse, _ error) {
return r, ht.ErrNotImplemented
}
// NewError creates *ErrorStatusCode from error returned by handler.
//
// Used for common default response.
func (UnimplementedHandler) NewError(ctx context.Context, err error) (r *ErrorStatusCode) {
r = new(ErrorStatusCode)
return r
}

344
pkg/rest/oas_validators_gen.go Normal file
View file

@ -0,0 +1,344 @@
// Code generated by ogen, DO NOT EDIT.
package rest
import (
"fmt"
"github.com/go-faster/errors"
"github.com/ogen-go/ogen/validate"
)
func (s PerformPredictionProfile) Validate() error {
switch s {
case "standard_profile":
return nil
case "float_profile":
return nil
default:
return errors.Errorf("invalid value: %v", s)
}
}
func (s *PredictionResponse) Validate() error {
if s == nil {
return validate.ErrNilPointer
}
var failures []validate.FieldError
if err := func() error {
if value, ok := s.Request.Get(); ok {
if err := func() error {
if err := value.Validate(); err != nil {
return err
}
return nil
}(); err != nil {
return err
}
}
return nil
}(); err != nil {
failures = append(failures, validate.FieldError{
Name: "request",
Error: err,
})
}
if err := func() error {
if s.Prediction == nil {
return errors.New("nil is invalid value")
}
var failures []validate.FieldError
for i, elem := range s.Prediction {
if err := func() error {
if err := elem.Validate(); err != nil {
return err
}
return nil
}(); err != nil {
failures = append(failures, validate.FieldError{
Name: fmt.Sprintf("[%d]", i),
Error: err,
})
}
}
if len(failures) > 0 {
return &validate.Error{Fields: failures}
}
return nil
}(); err != nil {
failures = append(failures, validate.FieldError{
Name: "prediction",
Error: err,
})
}
if len(failures) > 0 {
return &validate.Error{Fields: failures}
}
return nil
}
func (s *PredictionResponsePredictionItem) Validate() error {
if s == nil {
return validate.ErrNilPointer
}
var failures []validate.FieldError
if err := func() error {
if err := s.Stage.Validate(); err != nil {
return err
}
return nil
}(); err != nil {
failures = append(failures, validate.FieldError{
Name: "stage",
Error: err,
})
}
if err := func() error {
if s.Trajectory == nil {
return errors.New("nil is invalid value")
}
var failures []validate.FieldError
for i, elem := range s.Trajectory {
if err := func() error {
if err := elem.Validate(); err != nil {
return err
}
return nil
}(); err != nil {
failures = append(failures, validate.FieldError{
Name: fmt.Sprintf("[%d]", i),
Error: err,
})
}
}
if len(failures) > 0 {
return &validate.Error{Fields: failures}
}
return nil
}(); err != nil {
failures = append(failures, validate.FieldError{
Name: "trajectory",
Error: err,
})
}
if len(failures) > 0 {
return &validate.Error{Fields: failures}
}
return nil
}
func (s PredictionResponsePredictionItemStage) Validate() error {
switch s {
case "ascent":
return nil
case "descent":
return nil
case "float":
return nil
default:
return errors.Errorf("invalid value: %v", s)
}
}
func (s *PredictionResponsePredictionItemTrajectoryItem) Validate() error {
if s == nil {
return validate.ErrNilPointer
}
var failures []validate.FieldError
if err := func() error {
if err := (validate.Float{}).Validate(float64(s.Latitude)); err != nil {
return errors.Wrap(err, "float")
}
return nil
}(); err != nil {
failures = append(failures, validate.FieldError{
Name: "latitude",
Error: err,
})
}
if err := func() error {
if err := (validate.Float{}).Validate(float64(s.Longitude)); err != nil {
return errors.Wrap(err, "float")
}
return nil
}(); err != nil {
failures = append(failures, validate.FieldError{
Name: "longitude",
Error: err,
})
}
if err := func() error {
if err := (validate.Float{}).Validate(float64(s.Altitude)); err != nil {
return errors.Wrap(err, "float")
}
return nil
}(); err != nil {
failures = append(failures, validate.FieldError{
Name: "altitude",
Error: err,
})
}
if len(failures) > 0 {
return &validate.Error{Fields: failures}
}
return nil
}
func (s *PredictionResponseRequest) Validate() error {
if s == nil {
return validate.ErrNilPointer
}
var failures []validate.FieldError
if err := func() error {
if value, ok := s.LaunchLatitude.Get(); ok {
if err := func() error {
if err := (validate.Float{}).Validate(float64(value)); err != nil {
return errors.Wrap(err, "float")
}
return nil
}(); err != nil {
return err
}
}
return nil
}(); err != nil {
failures = append(failures, validate.FieldError{
Name: "launch_latitude",
Error: err,
})
}
if err := func() error {
if value, ok := s.LaunchLongitude.Get(); ok {
if err := func() error {
if err := (validate.Float{}).Validate(float64(value)); err != nil {
return errors.Wrap(err, "float")
}
return nil
}(); err != nil {
return err
}
}
return nil
}(); err != nil {
failures = append(failures, validate.FieldError{
Name: "launch_longitude",
Error: err,
})
}
if err := func() error {
if value, ok := s.LaunchAltitude.Get(); ok {
if err := func() error {
if err := (validate.Float{}).Validate(float64(value)); err != nil {
return errors.Wrap(err, "float")
}
return nil
}(); err != nil {
return err
}
}
return nil
}(); err != nil {
failures = append(failures, validate.FieldError{
Name: "launch_altitude",
Error: err,
})
}
if err := func() error {
if value, ok := s.AscentRate.Get(); ok {
if err := func() error {
if err := (validate.Float{}).Validate(float64(value)); err != nil {
return errors.Wrap(err, "float")
}
return nil
}(); err != nil {
return err
}
}
return nil
}(); err != nil {
failures = append(failures, validate.FieldError{
Name: "ascent_rate",
Error: err,
})
}
if err := func() error {
if value, ok := s.BurstAltitude.Get(); ok {
if err := func() error {
if err := (validate.Float{}).Validate(float64(value)); err != nil {
return errors.Wrap(err, "float")
}
return nil
}(); err != nil {
return err
}
}
return nil
}(); err != nil {
failures = append(failures, validate.FieldError{
Name: "burst_altitude",
Error: err,
})
}
if err := func() error {
if value, ok := s.DescentRate.Get(); ok {
if err := func() error {
if err := (validate.Float{}).Validate(float64(value)); err != nil {
return errors.Wrap(err, "float")
}
return nil
}(); err != nil {
return err
}
}
return nil
}(); err != nil {
failures = append(failures, validate.FieldError{
Name: "descent_rate",
Error: err,
})
}
if len(failures) > 0 {
return &validate.Error{Fields: failures}
}
return nil
}
func (s *ReadinessResponse) Validate() error {
if s == nil {
return validate.ErrNilPointer
}
var failures []validate.FieldError
if err := func() error {
if err := s.Status.Validate(); err != nil {
return err
}
return nil
}(); err != nil {
failures = append(failures, validate.FieldError{
Name: "status",
Error: err,
})
}
if len(failures) > 0 {
return &validate.Error{Fields: failures}
}
return nil
}
func (s ReadinessResponseStatus) Validate() error {
switch s {
case "ok":
return nil
case "not_ready":
return nil
case "error":
return nil
default:
return errors.Errorf("invalid value: %v", s)
}
}