1673 lines
45 KiB
Go
1673 lines
45 KiB
Go
// 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 {
|
|
// CancelDatasetJob invokes cancelDatasetJob operation.
|
|
//
|
|
// Cancel a running download job.
|
|
//
|
|
// DELETE /api/v1/admin/jobs/{id}
|
|
CancelDatasetJob(ctx context.Context, params CancelDatasetJobParams) error
|
|
// CancelPredictionJob invokes cancelPredictionJob operation.
|
|
//
|
|
// Cancel a queued prediction job.
|
|
//
|
|
// DELETE /api/v1/predictions/{id}
|
|
CancelPredictionJob(ctx context.Context, params CancelPredictionJobParams) error
|
|
// CreatePredictionJob invokes createPredictionJob operation.
|
|
//
|
|
// Enqueue an asynchronous prediction.
|
|
//
|
|
// POST /api/v1/predictions
|
|
CreatePredictionJob(ctx context.Context, request *PredictionV2Request) (*PredictionJob, error)
|
|
// DeleteDataset invokes deleteDataset operation.
|
|
//
|
|
// Delete a stored dataset by filename.
|
|
//
|
|
// DELETE /api/v1/admin/datasets/{name}
|
|
DeleteDataset(ctx context.Context, params DeleteDatasetParams) error
|
|
// GetDatasetJob invokes getDatasetJob operation.
|
|
//
|
|
// Get a dataset download job.
|
|
//
|
|
// GET /api/v1/admin/jobs/{id}
|
|
GetDatasetJob(ctx context.Context, params GetDatasetJobParams) (*DownloadJob, error)
|
|
// GetPredictionJob invokes getPredictionJob operation.
|
|
//
|
|
// Poll an asynchronous prediction job.
|
|
//
|
|
// GET /api/v1/predictions/{id}
|
|
GetPredictionJob(ctx context.Context, params GetPredictionJobParams) (*PredictionJob, error)
|
|
// GetServiceStatus invokes getServiceStatus operation.
|
|
//
|
|
// Service status summary.
|
|
//
|
|
// GET /api/v1/admin/status
|
|
GetServiceStatus(ctx context.Context) (*StatusResponse, error)
|
|
// GetWindField invokes getWindField operation.
|
|
//
|
|
// Wind-field velocity grid (leaflet-velocity / wind-layer format).
|
|
//
|
|
// GET /api/v1/wind/field
|
|
GetWindField(ctx context.Context, params GetWindFieldParams) ([]WindComponent, error)
|
|
// GetWindMeta invokes getWindMeta operation.
|
|
//
|
|
// Wind-field visualization metadata.
|
|
//
|
|
// GET /api/v1/wind/meta
|
|
GetWindMeta(ctx context.Context) (*WindMeta, error)
|
|
// ListDatasetJobs invokes listDatasetJobs operation.
|
|
//
|
|
// List dataset download jobs.
|
|
//
|
|
// GET /api/v1/admin/jobs
|
|
ListDatasetJobs(ctx context.Context) ([]DownloadJob, error)
|
|
// ListDatasets invokes listDatasets operation.
|
|
//
|
|
// List stored datasets.
|
|
//
|
|
// GET /api/v1/admin/datasets
|
|
ListDatasets(ctx context.Context) (*DatasetList, error)
|
|
// PerformPrediction invokes performPrediction operation.
|
|
//
|
|
// Tawhiri-compatible prediction.
|
|
//
|
|
// GET /api/v1/prediction
|
|
PerformPrediction(ctx context.Context, params PerformPredictionParams) (*PredictionResponse, error)
|
|
// PerformPredictionV2 invokes performPredictionV2 operation.
|
|
//
|
|
// Profile-driven prediction (synchronous).
|
|
//
|
|
// POST /api/v2/prediction
|
|
PerformPredictionV2(ctx context.Context, request *PredictionV2Request) (*PredictionV2Response, error)
|
|
// ReadinessCheck invokes readinessCheck operation.
|
|
//
|
|
// Readiness check.
|
|
//
|
|
// GET /ready
|
|
ReadinessCheck(ctx context.Context) (*ReadinessResponse, error)
|
|
// TriggerDatasetDownload invokes triggerDatasetDownload operation.
|
|
//
|
|
// Trigger a dataset download.
|
|
//
|
|
// POST /api/v1/admin/datasets
|
|
TriggerDatasetDownload(ctx context.Context, request *DownloadRequest) (*DownloadAccepted, 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
|
|
}
|
|
|
|
// CancelDatasetJob invokes cancelDatasetJob operation.
|
|
//
|
|
// Cancel a running download job.
|
|
//
|
|
// DELETE /api/v1/admin/jobs/{id}
|
|
func (c *Client) CancelDatasetJob(ctx context.Context, params CancelDatasetJobParams) error {
|
|
_, err := c.sendCancelDatasetJob(ctx, params)
|
|
return err
|
|
}
|
|
|
|
func (c *Client) sendCancelDatasetJob(ctx context.Context, params CancelDatasetJobParams) (res *CancelDatasetJobNoContent, err error) {
|
|
otelAttrs := []attribute.KeyValue{
|
|
otelogen.OperationID("cancelDatasetJob"),
|
|
semconv.HTTPRequestMethodKey.String("DELETE"),
|
|
semconv.URLTemplateKey.String("/api/v1/admin/jobs/{id}"),
|
|
}
|
|
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, CancelDatasetJobOperation,
|
|
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 [2]string
|
|
pathParts[0] = "/api/v1/admin/jobs/"
|
|
{
|
|
// Encode "id" parameter.
|
|
e := uri.NewPathEncoder(uri.PathEncoderConfig{
|
|
Param: "id",
|
|
Style: uri.PathStyleSimple,
|
|
Explode: false,
|
|
})
|
|
if err := func() error {
|
|
return e.EncodeValue(conv.StringToString(params.ID))
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "encode path")
|
|
}
|
|
encoded, err := e.Result()
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "encode path")
|
|
}
|
|
pathParts[1] = encoded
|
|
}
|
|
uri.AddPathParts(u, pathParts[:]...)
|
|
|
|
stage = "EncodeRequest"
|
|
r, err := ht.NewRequest(ctx, "DELETE", 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 := decodeCancelDatasetJobResponse(resp)
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "decode response")
|
|
}
|
|
|
|
return result, nil
|
|
}
|
|
|
|
// CancelPredictionJob invokes cancelPredictionJob operation.
|
|
//
|
|
// Cancel a queued prediction job.
|
|
//
|
|
// DELETE /api/v1/predictions/{id}
|
|
func (c *Client) CancelPredictionJob(ctx context.Context, params CancelPredictionJobParams) error {
|
|
_, err := c.sendCancelPredictionJob(ctx, params)
|
|
return err
|
|
}
|
|
|
|
func (c *Client) sendCancelPredictionJob(ctx context.Context, params CancelPredictionJobParams) (res *CancelPredictionJobNoContent, err error) {
|
|
otelAttrs := []attribute.KeyValue{
|
|
otelogen.OperationID("cancelPredictionJob"),
|
|
semconv.HTTPRequestMethodKey.String("DELETE"),
|
|
semconv.URLTemplateKey.String("/api/v1/predictions/{id}"),
|
|
}
|
|
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, CancelPredictionJobOperation,
|
|
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 [2]string
|
|
pathParts[0] = "/api/v1/predictions/"
|
|
{
|
|
// Encode "id" parameter.
|
|
e := uri.NewPathEncoder(uri.PathEncoderConfig{
|
|
Param: "id",
|
|
Style: uri.PathStyleSimple,
|
|
Explode: false,
|
|
})
|
|
if err := func() error {
|
|
return e.EncodeValue(conv.StringToString(params.ID))
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "encode path")
|
|
}
|
|
encoded, err := e.Result()
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "encode path")
|
|
}
|
|
pathParts[1] = encoded
|
|
}
|
|
uri.AddPathParts(u, pathParts[:]...)
|
|
|
|
stage = "EncodeRequest"
|
|
r, err := ht.NewRequest(ctx, "DELETE", 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 := decodeCancelPredictionJobResponse(resp)
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "decode response")
|
|
}
|
|
|
|
return result, nil
|
|
}
|
|
|
|
// CreatePredictionJob invokes createPredictionJob operation.
|
|
//
|
|
// Enqueue an asynchronous prediction.
|
|
//
|
|
// POST /api/v1/predictions
|
|
func (c *Client) CreatePredictionJob(ctx context.Context, request *PredictionV2Request) (*PredictionJob, error) {
|
|
res, err := c.sendCreatePredictionJob(ctx, request)
|
|
return res, err
|
|
}
|
|
|
|
func (c *Client) sendCreatePredictionJob(ctx context.Context, request *PredictionV2Request) (res *PredictionJob, err error) {
|
|
otelAttrs := []attribute.KeyValue{
|
|
otelogen.OperationID("createPredictionJob"),
|
|
semconv.HTTPRequestMethodKey.String("POST"),
|
|
semconv.URLTemplateKey.String("/api/v1/predictions"),
|
|
}
|
|
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, CreatePredictionJobOperation,
|
|
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/predictions"
|
|
uri.AddPathParts(u, pathParts[:]...)
|
|
|
|
stage = "EncodeRequest"
|
|
r, err := ht.NewRequest(ctx, "POST", u)
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "create request")
|
|
}
|
|
if err := encodeCreatePredictionJobRequest(request, r); err != nil {
|
|
return res, errors.Wrap(err, "encode 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 := decodeCreatePredictionJobResponse(resp)
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "decode response")
|
|
}
|
|
|
|
return result, nil
|
|
}
|
|
|
|
// DeleteDataset invokes deleteDataset operation.
|
|
//
|
|
// Delete a stored dataset by filename.
|
|
//
|
|
// DELETE /api/v1/admin/datasets/{name}
|
|
func (c *Client) DeleteDataset(ctx context.Context, params DeleteDatasetParams) error {
|
|
_, err := c.sendDeleteDataset(ctx, params)
|
|
return err
|
|
}
|
|
|
|
func (c *Client) sendDeleteDataset(ctx context.Context, params DeleteDatasetParams) (res *DeleteDatasetNoContent, err error) {
|
|
otelAttrs := []attribute.KeyValue{
|
|
otelogen.OperationID("deleteDataset"),
|
|
semconv.HTTPRequestMethodKey.String("DELETE"),
|
|
semconv.URLTemplateKey.String("/api/v1/admin/datasets/{name}"),
|
|
}
|
|
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, DeleteDatasetOperation,
|
|
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 [2]string
|
|
pathParts[0] = "/api/v1/admin/datasets/"
|
|
{
|
|
// Encode "name" parameter.
|
|
e := uri.NewPathEncoder(uri.PathEncoderConfig{
|
|
Param: "name",
|
|
Style: uri.PathStyleSimple,
|
|
Explode: false,
|
|
})
|
|
if err := func() error {
|
|
return e.EncodeValue(conv.StringToString(params.Name))
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "encode path")
|
|
}
|
|
encoded, err := e.Result()
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "encode path")
|
|
}
|
|
pathParts[1] = encoded
|
|
}
|
|
uri.AddPathParts(u, pathParts[:]...)
|
|
|
|
stage = "EncodeRequest"
|
|
r, err := ht.NewRequest(ctx, "DELETE", 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 := decodeDeleteDatasetResponse(resp)
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "decode response")
|
|
}
|
|
|
|
return result, nil
|
|
}
|
|
|
|
// GetDatasetJob invokes getDatasetJob operation.
|
|
//
|
|
// Get a dataset download job.
|
|
//
|
|
// GET /api/v1/admin/jobs/{id}
|
|
func (c *Client) GetDatasetJob(ctx context.Context, params GetDatasetJobParams) (*DownloadJob, error) {
|
|
res, err := c.sendGetDatasetJob(ctx, params)
|
|
return res, err
|
|
}
|
|
|
|
func (c *Client) sendGetDatasetJob(ctx context.Context, params GetDatasetJobParams) (res *DownloadJob, err error) {
|
|
otelAttrs := []attribute.KeyValue{
|
|
otelogen.OperationID("getDatasetJob"),
|
|
semconv.HTTPRequestMethodKey.String("GET"),
|
|
semconv.URLTemplateKey.String("/api/v1/admin/jobs/{id}"),
|
|
}
|
|
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, GetDatasetJobOperation,
|
|
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 [2]string
|
|
pathParts[0] = "/api/v1/admin/jobs/"
|
|
{
|
|
// Encode "id" parameter.
|
|
e := uri.NewPathEncoder(uri.PathEncoderConfig{
|
|
Param: "id",
|
|
Style: uri.PathStyleSimple,
|
|
Explode: false,
|
|
})
|
|
if err := func() error {
|
|
return e.EncodeValue(conv.StringToString(params.ID))
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "encode path")
|
|
}
|
|
encoded, err := e.Result()
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "encode path")
|
|
}
|
|
pathParts[1] = encoded
|
|
}
|
|
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 := decodeGetDatasetJobResponse(resp)
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "decode response")
|
|
}
|
|
|
|
return result, nil
|
|
}
|
|
|
|
// GetPredictionJob invokes getPredictionJob operation.
|
|
//
|
|
// Poll an asynchronous prediction job.
|
|
//
|
|
// GET /api/v1/predictions/{id}
|
|
func (c *Client) GetPredictionJob(ctx context.Context, params GetPredictionJobParams) (*PredictionJob, error) {
|
|
res, err := c.sendGetPredictionJob(ctx, params)
|
|
return res, err
|
|
}
|
|
|
|
func (c *Client) sendGetPredictionJob(ctx context.Context, params GetPredictionJobParams) (res *PredictionJob, err error) {
|
|
otelAttrs := []attribute.KeyValue{
|
|
otelogen.OperationID("getPredictionJob"),
|
|
semconv.HTTPRequestMethodKey.String("GET"),
|
|
semconv.URLTemplateKey.String("/api/v1/predictions/{id}"),
|
|
}
|
|
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, GetPredictionJobOperation,
|
|
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 [2]string
|
|
pathParts[0] = "/api/v1/predictions/"
|
|
{
|
|
// Encode "id" parameter.
|
|
e := uri.NewPathEncoder(uri.PathEncoderConfig{
|
|
Param: "id",
|
|
Style: uri.PathStyleSimple,
|
|
Explode: false,
|
|
})
|
|
if err := func() error {
|
|
return e.EncodeValue(conv.StringToString(params.ID))
|
|
}(); err != nil {
|
|
return res, errors.Wrap(err, "encode path")
|
|
}
|
|
encoded, err := e.Result()
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "encode path")
|
|
}
|
|
pathParts[1] = encoded
|
|
}
|
|
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 := decodeGetPredictionJobResponse(resp)
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "decode response")
|
|
}
|
|
|
|
return result, nil
|
|
}
|
|
|
|
// GetServiceStatus invokes getServiceStatus operation.
|
|
//
|
|
// Service status summary.
|
|
//
|
|
// GET /api/v1/admin/status
|
|
func (c *Client) GetServiceStatus(ctx context.Context) (*StatusResponse, error) {
|
|
res, err := c.sendGetServiceStatus(ctx)
|
|
return res, err
|
|
}
|
|
|
|
func (c *Client) sendGetServiceStatus(ctx context.Context) (res *StatusResponse, err error) {
|
|
otelAttrs := []attribute.KeyValue{
|
|
otelogen.OperationID("getServiceStatus"),
|
|
semconv.HTTPRequestMethodKey.String("GET"),
|
|
semconv.URLTemplateKey.String("/api/v1/admin/status"),
|
|
}
|
|
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, GetServiceStatusOperation,
|
|
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/admin/status"
|
|
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 := decodeGetServiceStatusResponse(resp)
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "decode response")
|
|
}
|
|
|
|
return result, nil
|
|
}
|
|
|
|
// GetWindField invokes getWindField operation.
|
|
//
|
|
// Wind-field velocity grid (leaflet-velocity / wind-layer format).
|
|
//
|
|
// GET /api/v1/wind/field
|
|
func (c *Client) GetWindField(ctx context.Context, params GetWindFieldParams) ([]WindComponent, error) {
|
|
res, err := c.sendGetWindField(ctx, params)
|
|
return res, err
|
|
}
|
|
|
|
func (c *Client) sendGetWindField(ctx context.Context, params GetWindFieldParams) (res []WindComponent, err error) {
|
|
otelAttrs := []attribute.KeyValue{
|
|
otelogen.OperationID("getWindField"),
|
|
semconv.HTTPRequestMethodKey.String("GET"),
|
|
semconv.URLTemplateKey.String("/api/v1/wind/field"),
|
|
}
|
|
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, GetWindFieldOperation,
|
|
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/wind/field"
|
|
uri.AddPathParts(u, pathParts[:]...)
|
|
|
|
stage = "EncodeQueryParams"
|
|
q := uri.NewQueryEncoder()
|
|
{
|
|
// Encode "time" parameter.
|
|
cfg := uri.QueryParameterEncodingConfig{
|
|
Name: "time",
|
|
Style: uri.QueryStyleForm,
|
|
Explode: true,
|
|
}
|
|
|
|
if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
|
|
if val, ok := params.Time.Get(); ok {
|
|
return e.EncodeValue(conv.DateTimeToString(val))
|
|
}
|
|
return nil
|
|
}); err != nil {
|
|
return res, errors.Wrap(err, "encode query")
|
|
}
|
|
}
|
|
{
|
|
// Encode "altitude" parameter.
|
|
cfg := uri.QueryParameterEncodingConfig{
|
|
Name: "altitude",
|
|
Style: uri.QueryStyleForm,
|
|
Explode: true,
|
|
}
|
|
|
|
if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
|
|
if val, ok := params.Altitude.Get(); ok {
|
|
return e.EncodeValue(conv.Float64ToString(val))
|
|
}
|
|
return nil
|
|
}); err != nil {
|
|
return res, errors.Wrap(err, "encode query")
|
|
}
|
|
}
|
|
{
|
|
// Encode "min_lat" parameter.
|
|
cfg := uri.QueryParameterEncodingConfig{
|
|
Name: "min_lat",
|
|
Style: uri.QueryStyleForm,
|
|
Explode: true,
|
|
}
|
|
|
|
if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
|
|
if val, ok := params.MinLat.Get(); ok {
|
|
return e.EncodeValue(conv.Float64ToString(val))
|
|
}
|
|
return nil
|
|
}); err != nil {
|
|
return res, errors.Wrap(err, "encode query")
|
|
}
|
|
}
|
|
{
|
|
// Encode "max_lat" parameter.
|
|
cfg := uri.QueryParameterEncodingConfig{
|
|
Name: "max_lat",
|
|
Style: uri.QueryStyleForm,
|
|
Explode: true,
|
|
}
|
|
|
|
if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
|
|
if val, ok := params.MaxLat.Get(); ok {
|
|
return e.EncodeValue(conv.Float64ToString(val))
|
|
}
|
|
return nil
|
|
}); err != nil {
|
|
return res, errors.Wrap(err, "encode query")
|
|
}
|
|
}
|
|
{
|
|
// Encode "min_lng" parameter.
|
|
cfg := uri.QueryParameterEncodingConfig{
|
|
Name: "min_lng",
|
|
Style: uri.QueryStyleForm,
|
|
Explode: true,
|
|
}
|
|
|
|
if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
|
|
if val, ok := params.MinLng.Get(); ok {
|
|
return e.EncodeValue(conv.Float64ToString(val))
|
|
}
|
|
return nil
|
|
}); err != nil {
|
|
return res, errors.Wrap(err, "encode query")
|
|
}
|
|
}
|
|
{
|
|
// Encode "max_lng" parameter.
|
|
cfg := uri.QueryParameterEncodingConfig{
|
|
Name: "max_lng",
|
|
Style: uri.QueryStyleForm,
|
|
Explode: true,
|
|
}
|
|
|
|
if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
|
|
if val, ok := params.MaxLng.Get(); ok {
|
|
return e.EncodeValue(conv.Float64ToString(val))
|
|
}
|
|
return nil
|
|
}); err != nil {
|
|
return res, errors.Wrap(err, "encode query")
|
|
}
|
|
}
|
|
{
|
|
// Encode "step" parameter.
|
|
cfg := uri.QueryParameterEncodingConfig{
|
|
Name: "step",
|
|
Style: uri.QueryStyleForm,
|
|
Explode: true,
|
|
}
|
|
|
|
if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
|
|
if val, ok := params.Step.Get(); ok {
|
|
return e.EncodeValue(conv.Float64ToString(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 := decodeGetWindFieldResponse(resp)
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "decode response")
|
|
}
|
|
|
|
return result, nil
|
|
}
|
|
|
|
// GetWindMeta invokes getWindMeta operation.
|
|
//
|
|
// Wind-field visualization metadata.
|
|
//
|
|
// GET /api/v1/wind/meta
|
|
func (c *Client) GetWindMeta(ctx context.Context) (*WindMeta, error) {
|
|
res, err := c.sendGetWindMeta(ctx)
|
|
return res, err
|
|
}
|
|
|
|
func (c *Client) sendGetWindMeta(ctx context.Context) (res *WindMeta, err error) {
|
|
otelAttrs := []attribute.KeyValue{
|
|
otelogen.OperationID("getWindMeta"),
|
|
semconv.HTTPRequestMethodKey.String("GET"),
|
|
semconv.URLTemplateKey.String("/api/v1/wind/meta"),
|
|
}
|
|
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, GetWindMetaOperation,
|
|
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/wind/meta"
|
|
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 := decodeGetWindMetaResponse(resp)
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "decode response")
|
|
}
|
|
|
|
return result, nil
|
|
}
|
|
|
|
// ListDatasetJobs invokes listDatasetJobs operation.
|
|
//
|
|
// List dataset download jobs.
|
|
//
|
|
// GET /api/v1/admin/jobs
|
|
func (c *Client) ListDatasetJobs(ctx context.Context) ([]DownloadJob, error) {
|
|
res, err := c.sendListDatasetJobs(ctx)
|
|
return res, err
|
|
}
|
|
|
|
func (c *Client) sendListDatasetJobs(ctx context.Context) (res []DownloadJob, err error) {
|
|
otelAttrs := []attribute.KeyValue{
|
|
otelogen.OperationID("listDatasetJobs"),
|
|
semconv.HTTPRequestMethodKey.String("GET"),
|
|
semconv.URLTemplateKey.String("/api/v1/admin/jobs"),
|
|
}
|
|
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, ListDatasetJobsOperation,
|
|
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/admin/jobs"
|
|
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 := decodeListDatasetJobsResponse(resp)
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "decode response")
|
|
}
|
|
|
|
return result, nil
|
|
}
|
|
|
|
// ListDatasets invokes listDatasets operation.
|
|
//
|
|
// List stored datasets.
|
|
//
|
|
// GET /api/v1/admin/datasets
|
|
func (c *Client) ListDatasets(ctx context.Context) (*DatasetList, error) {
|
|
res, err := c.sendListDatasets(ctx)
|
|
return res, err
|
|
}
|
|
|
|
func (c *Client) sendListDatasets(ctx context.Context) (res *DatasetList, err error) {
|
|
otelAttrs := []attribute.KeyValue{
|
|
otelogen.OperationID("listDatasets"),
|
|
semconv.HTTPRequestMethodKey.String("GET"),
|
|
semconv.URLTemplateKey.String("/api/v1/admin/datasets"),
|
|
}
|
|
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, ListDatasetsOperation,
|
|
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/admin/datasets"
|
|
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 := decodeListDatasetsResponse(resp)
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "decode response")
|
|
}
|
|
|
|
return result, nil
|
|
}
|
|
|
|
// PerformPrediction invokes performPrediction operation.
|
|
//
|
|
// Tawhiri-compatible 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
|
|
}
|
|
|
|
// PerformPredictionV2 invokes performPredictionV2 operation.
|
|
//
|
|
// Profile-driven prediction (synchronous).
|
|
//
|
|
// POST /api/v2/prediction
|
|
func (c *Client) PerformPredictionV2(ctx context.Context, request *PredictionV2Request) (*PredictionV2Response, error) {
|
|
res, err := c.sendPerformPredictionV2(ctx, request)
|
|
return res, err
|
|
}
|
|
|
|
func (c *Client) sendPerformPredictionV2(ctx context.Context, request *PredictionV2Request) (res *PredictionV2Response, err error) {
|
|
otelAttrs := []attribute.KeyValue{
|
|
otelogen.OperationID("performPredictionV2"),
|
|
semconv.HTTPRequestMethodKey.String("POST"),
|
|
semconv.URLTemplateKey.String("/api/v2/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, PerformPredictionV2Operation,
|
|
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/v2/prediction"
|
|
uri.AddPathParts(u, pathParts[:]...)
|
|
|
|
stage = "EncodeRequest"
|
|
r, err := ht.NewRequest(ctx, "POST", u)
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "create request")
|
|
}
|
|
if err := encodePerformPredictionV2Request(request, r); err != nil {
|
|
return res, errors.Wrap(err, "encode 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 := decodePerformPredictionV2Response(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
|
|
}
|
|
|
|
// TriggerDatasetDownload invokes triggerDatasetDownload operation.
|
|
//
|
|
// Trigger a dataset download.
|
|
//
|
|
// POST /api/v1/admin/datasets
|
|
func (c *Client) TriggerDatasetDownload(ctx context.Context, request *DownloadRequest) (*DownloadAccepted, error) {
|
|
res, err := c.sendTriggerDatasetDownload(ctx, request)
|
|
return res, err
|
|
}
|
|
|
|
func (c *Client) sendTriggerDatasetDownload(ctx context.Context, request *DownloadRequest) (res *DownloadAccepted, err error) {
|
|
otelAttrs := []attribute.KeyValue{
|
|
otelogen.OperationID("triggerDatasetDownload"),
|
|
semconv.HTTPRequestMethodKey.String("POST"),
|
|
semconv.URLTemplateKey.String("/api/v1/admin/datasets"),
|
|
}
|
|
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, TriggerDatasetDownloadOperation,
|
|
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/admin/datasets"
|
|
uri.AddPathParts(u, pathParts[:]...)
|
|
|
|
stage = "EncodeRequest"
|
|
r, err := ht.NewRequest(ctx, "POST", u)
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "create request")
|
|
}
|
|
if err := encodeTriggerDatasetDownloadRequest(request, r); err != nil {
|
|
return res, errors.Wrap(err, "encode 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 := decodeTriggerDatasetDownloadResponse(resp)
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "decode response")
|
|
}
|
|
|
|
return result, nil
|
|
}
|