interop

type CancellableRequest struct {
	Request *http.Request
}

type ClientError struct {
	model.ClientError
}

type Done struct {
	WaitForExit bool
	ErrorType   model.ErrorType
	Meta        DoneMetadata
}

type DoneFail struct {
	ErrorType model.ErrorType
	Meta      DoneMetadata
}

type DoneMetadata struct {
	NumActiveExtensions int
	ExtensionNames      string
	RuntimeRelease      string

	InvokeRequestReadTimeNs      int64
	InvokeRequestSizeBytes       int64
	InvokeCompletionTimeNs       int64
	InvokeReceivedTime           int64
	RuntimeReadyTime             int64
	RuntimeResponseLatencyMs     float64
	RuntimeTimeThrottledMs       int64
	RuntimeProducedBytes         int64
	RuntimeOutboundThroughputBps int64
	MetricsDimensions            DoneMetadataMetricsDimensions
}

type DoneMetadataMetricsDimensions struct {
	InvokeResponseMode InvokeResponseMode
}

type DurationMetricTimer interface {
	Done()
}

type EEStaticData struct {
	FunctionARN        string
	FunctionVersionID  string
	InitTimeout        time.Duration
	FunctionTimeout    time.Duration
	LogGroupName       string
	LogStreamName      string
	XRayTracingMode    intmodel.XrayTracingMode
	ArtefactType       intmodel.ArtefactType
	RuntimeVersion     string
	AmiId              string
	AvailabilityZoneId string
}

type EndData struct {
	InvokeID InvokeID `json:"requestId"`
}

type ErrInternalPlatformError struct{}

type ErrTruncatedResponse struct{}

type ErrorInvokeResponse struct {
	Headers       InvokeResponseHeaders
	Payload       []byte
	FunctionError model.FunctionError
}

type ErrorResponseTooLarge struct {
	MaxResponseSize int
	ResponseSize    int
}

type ErrorResponseTooLargeDI struct {
	ErrorResponseTooLarge
}

type EventsAPI interface {
	SendInitStart(InitStartData) error
	SendInitRuntimeDone(InitRuntimeDoneData) error
	SendInitReport(InitReportData) error
	SendExtensionInit(ExtensionInitData) error
	SendImageError(ImageErrorLogData)
	SendInternalXRayErrorCause(InternalXRayErrorCauseData) error
	SendInvokeStart(InvokeStartData) error
	SendReport(ReportData) error
	Flush()
}

type ExtensionInitData struct {
	AgentName     string   `json:"name"`
	State         string   `json:"state"`
	Subscriptions []string `json:"events"`
	ErrorType     string   `json:"errorType,omitempty"`
}

type FaultData struct {
	InvokeID  InvokeID
	Status    ResponseStatus
	ErrorType *rapidmodel.ErrorType
}

type FunctionResponseMode string

type HealthCheckResponse interface {
	// contains filtered or unexported methods
}

type HealthyContainerResponse struct{}

type ImageErrorLogData struct {
	ExecError  rapidmodel.RuntimeExecError
	ExecConfig rapidmodel.RuntimeExec
}

type InitExecutionData struct {
	ExtensionEnv                 intmodel.KVMap
	Runtime                      model.Runtime
	Credentials                  model.Credentials
	LogGroupName                 string
	LogStreamName                string
	FunctionMetadata             model.FunctionMetadata
	RuntimeManagedLoggingFormats []supvmodel.ManagedLoggingFormat
	StaticData                   EEStaticData
	TelemetrySubscriptionConfig  TelemetrySubscriptionConfig
}

type InitFailure struct {
	Error         model.AppError
	ErrorType     model.ErrorType
	ErrorCategory model.ErrorCategory
	ErrorMessage  error

	NumActiveExtensions   int
	RuntimeRelease        string
	Ack                   chan struct{}
	NumInternalExtensions int
	NumExternalExtensions int
	RuntimeInitDuration   time.Duration
}

type InitMetrics interface {
	TriggerGetRequest()
	SetLogsAPIMetrics(TelemetrySubscriptionMetrics)
	SetExtensionsNumber(internal, external int)
	TriggerStartRequest()
	TriggerStartingRuntime()
	TriggerRuntimeDone()
	TriggerInitCustomerPhaseDone()
	TriggerInitDone(model.AppError)

	RunDuration() time.Duration
	SendMetrics() error
}

type InitPhase string

type InitReportData struct {
	InitializationType string            `json:"initializationType"`
	Metrics            InitReportMetrics `json:"metrics"`
	Phase              InitPhase         `json:"phase"`
	Tracing            *TracingCtx       `json:"tracing,omitempty"`
	Status             ResponseStatus    `json:"status"`
	ErrorType          *string           `json:"errorType,omitempty"`
}

type InitReportMetrics struct {
	DurationMs float64 `json:"durationMs"`
}

type InitResponse interface {
	// contains filtered or unexported methods
}

type InitRuntimeDoneData struct {
	InitializationType string         `json:"initializationType"`
	Status             ResponseStatus `json:"status"`
	Phase              InitPhase      `json:"phase"`
	ErrorType          *string        `json:"errorType,omitempty"`
	Tracing            *TracingCtx    `json:"tracing,omitempty"`
}

type InitStartData struct {
	InitializationType string      `json:"initializationType"`
	RuntimeVersion     string      `json:"runtimeVersion"`
	RuntimeVersionArn  string      `json:"runtimeVersionArn"`
	FunctionName       string      `json:"functionName"`
	FunctionVersion    string      `json:"functionVersion"`
	InstanceID         string      `json:"instanceId"`
	InstanceMaxMemory  uint64      `json:"instanceMaxMemory"`
	Phase              InitPhase   `json:"phase"`
	Tracing            *TracingCtx `json:"tracing,omitempty"`
}

type InitStaticDataProvider interface {
	FunctionARN() string
	FunctionVersion() string
	FunctionVersionID() string
	InitTimeout() time.Duration
	FunctionTimeout() time.Duration
	LogGroup() string
	LogStream() string
	XRayTracingMode() intmodel.XrayTracingMode
	MemorySizeMB() uint64
	ArtefactType() intmodel.ArtefactType
	AmiId() string
	RuntimeVersion() string
	AvailabilityZoneId() string
}

type InitSuccess struct {
	NumActiveExtensions   int
	ExtensionNames        string
	RuntimeRelease        string
	Ack                   chan struct{}
	NumInternalExtensions int
	NumExternalExtensions int
	RuntimeInitDuration   time.Duration
}

type InternalStateGetter func() statejson.InternalStateDescription

type InternalXRayErrorCauseData struct {
	InvokeID InvokeID `json:"requestId"`
	Cause    string   `json:"cause"`
}

type Invoke struct {
	TraceID               string
	LambdaSegmentID       string
	ID                    string
	InvokedFunctionArn    string
	CognitoIdentityID     string
	CognitoIdentityPoolID string
	Deadline              time.Time
	FunctionTimeout       time.Duration
	ClientContext         string
	ContentType           string
	Payload               io.Reader
	VersionID             string
	InvokeReceivedTime    time.Time
	InvokeResponseMetrics *InvokeResponseMetrics
	InvokeResponseMode    InvokeResponseMode
}

type InvokeErrorTraceData struct {
	InvokeID InvokeID `json:"requestId,omitempty"`

	ErrorCause json.RawMessage `json:"ErrorCause,omitempty"`
}

type InvokeFailure struct {
	ErrorType            model.ErrorType
	ErrorMessage         error
	RuntimeRelease       string
	NumActiveExtensions  int
	ExtensionsOverhead   time.Duration
	InvokeReceivedTime   time.Time
	ResponseMetrics      ResponseMetrics
	ExtensionNames       string
	DefaultErrorResponse *ErrorInvokeResponse
	InvokeResponseMode   InvokeResponseMode
}

type InvokeID = string

type InvokeMetadataHeader string

type InvokeMetrics interface {
	TriggerGetRequest()
	AttachInvokeRequest(InvokeRequest)
	AttachDependencies(InitStaticDataProvider, EventsAPI)
	UpdateConcurrencyMetrics(inflightInvokes, idleRuntimesCount int)
	TriggerStartRequest()
	TriggerSentRequest(bytes int64, requestPayloadReadDuration, requestPayloadWriteDuration time.Duration)
	TriggerGetResponse()
	TriggerSentResponse(runtimeResponseSent bool, responseErr model.AppError, streamingMetrics *InvokeResponseMetrics, errorPayloadSizeBytes int)

	TriggerInvokeDone() (totalMs time.Duration, runMs *time.Duration, initData InitStaticDataProvider)

	SendInvokeStartEvent(*TracingCtx) error
	SendInvokeFinishedEvent(tracingCtx *TracingCtx, xrayErrorCause json.RawMessage) error
	SendMetrics(model.AppError) error
}

type InvokeRequest interface {
	ContentType() string
	InvokeID() InvokeID
	Deadline() time.Time
	TraceId() string
	ClientContext() string
	CognitoId() string
	CognitoPoolId() string
	ResponseBandwidthRate() int64
	ResponseBandwidthBurstRate() int64
	MaxPayloadSize() int64
	ResponseMode() string

	BodyReader() io.Reader
	ResponseWriter() http.ResponseWriter

	SetResponseHeader(string, string)
	AddResponseHeader(string, string)
	WriteResponseHeaders(int)

	UpdateFromInitData(InitStaticDataProvider) model.AppError
	FunctionVersionID() string
}

type InvokeResponse interface {
	// contains filtered or unexported methods
}

type InvokeResponseHeaders struct {
	ContentType          string
	FunctionResponseMode string
}

type InvokeResponseMetrics struct {
	StartReadingResponseTime time.Time

	FinishReadingResponseTime time.Time
	TimeShaped                time.Duration
	ProducedBytes             int64
	OutboundThroughputBps     int64
	FunctionResponseMode      FunctionResponseMode
	RuntimeCalledResponse     bool

	TransferError error

	Interrupted bool

	ResponsePayloadReadDuration time.Duration

	ResponsePayloadWriteDuration time.Duration
}

type InvokeResponseMode string

type InvokeResponseSender interface {
	SendResponse(invokeID InvokeID, response *StreamableInvokeResponse) (*InvokeResponseMetrics, error)

	SendErrorResponse(invokeID InvokeID, response *ErrorInvokeResponse) (*InvokeResponseMetrics, error)
}

type InvokeRuntimeDoneData struct {
	InvokeID        InvokeID                  `json:"requestId"`
	Status          ResponseStatus            `json:"status"`
	Metrics         *RuntimeDoneInvokeMetrics `json:"metrics,omitempty"`
	Tracing         *TracingCtx               `json:"tracing,omitempty"`
	Spans           []Span                    `json:"spans,omitempty"`
	ErrorType       *string                   `json:"errorType,omitempty"`
	InternalMetrics *InvokeResponseMetrics    `json:"-"`
}

type InvokeStartData struct {
	InvokeID    InvokeID    `json:"requestId"`
	Version     string      `json:"version,omitempty"`
	FunctionARN string      `json:"functionArn,omitempty"`
	Tracing     *TracingCtx `json:"tracing,omitempty"`
}

type InvokeSuccess struct {
	RuntimeRelease       string
	NumActiveExtensions  int
	ExtensionNames       string
	ExtensionsOverhead   time.Duration
	InvokeCompletionTime time.Duration
	InvokeReceivedTime   time.Time
	ResponseMetrics      ResponseMetrics
	InvokeResponseMode   InvokeResponseMode
}

type LifecyclePhase int

type Message interface{}

type MockDurationMetricTimer struct {
	mock.Mock
}

type MockEventsAPI struct {
	mock.Mock
}

type MockHealthCheckResponse struct {
	mock.Mock
}

type MockInitMetrics struct {
	mock.Mock
}

type MockInitResponse struct {
	mock.Mock
}

type MockInitStaticDataProvider struct {
	mock.Mock
}

type MockInternalStateGetter struct {
	mock.Mock
}

type MockInvokeMetrics struct {
	mock.Mock
}

type MockInvokeRequest struct {
	mock.Mock
}

type MockInvokeResponse struct {
	mock.Mock
}

type MockInvokeResponseSender struct {
	mock.Mock
}

type MockMessage struct {
	mock.Mock
}

type MockRapidContext struct {
	mock.Mock
}

type MockServer struct {
	mock.Mock
}

type MockShutdownMetrics struct {
	mock.Mock
}

type MockShutdownResponse struct {
	mock.Mock
}

type PlatformError struct {
	model.PlatformError
	RuntimeRelease string
}

type RapidContext interface {
	HandleInit(ctx context.Context, initData InitExecutionData, initMetrics InitMetrics) (err model.AppError)

	HandleShutdown(shutdownCause model.AppError, metrics ShutdownMetrics) model.AppError
	HandleInvoke(ctx context.Context, invokeRequest InvokeRequest, invokeMetrics InvokeMetrics) (err model.AppError, wasResponseSent bool)
	RuntimeAPIAddrPort() netip.AddrPort

	ProcessTerminationNotifier() <-chan model.AppError
}

type ReportData struct {
	InvokeID  InvokeID              `json:"requestId"`
	Status    ResponseStatus        `json:"status"`
	Metrics   ReportMetrics         `json:"metrics"`
	Tracing   *TracingCtx           `json:"tracing,omitempty"`
	Spans     []Span                `json:"spans,omitempty"`
	ErrorType *rapidmodel.ErrorType `json:"errorType,omitempty"`
}

type ReportDurationMs float64

type ReportMetrics struct {
	DurationMs ReportDurationMs `json:"durationMs"`
}

type ResponseMetrics struct {
	RuntimeOutboundThroughputBps int64
	RuntimeProducedBytes         int64
	RuntimeResponseLatency       time.Duration
	RuntimeTimeThrottled         time.Duration
}

type ResponseMode string

type ResponseStatus = string

type RuntimeDoneInvokeMetrics struct {
	ProducedBytes int64   `json:"producedBytes"`
	DurationMs    float64 `json:"durationMs"`
}

type RuntimeInitMetrics struct {
	Duration time.Duration
	Error    error
}

type Server interface {
	SendInitErrorResponse(response *ErrorInvokeResponse) (*InvokeResponseMetrics, error)
}

type Shutdown struct {
	DeadlineNs int64
}

type ShutdownMetrics interface {
	CreateDurationMetric(name string) DurationMetricTimer
	AddMetric(metric servicelogs.Metric)

	SetAgentCount(internal, external int)

	SendMetrics(error model.AppError)
}

type ShutdownResponse interface {
	// contains filtered or unexported methods
}

type ShutdownSuccess struct{}

type Span struct {
	Name       string  `json:"name"`
	Start      string  `json:"start"`
	DurationMs float64 `json:"durationMs"`
}

type StreamableInvokeResponse struct {
	Headers  map[string]string
	Payload  io.Reader
	Trailers http.Header
	Request  *CancellableRequest
}

type TelemetrySubscriptionConfig struct {
	Passphrase string
	APIAddr    netip.AddrPort
}

type TelemetrySubscriptionMetrics map[string]int

type TracingCtx struct {
	SpanID string            `json:"spanId,omitempty"`
	Type   model.TracingType `json:"type"`
	Value  string            `json:"value"`
}

type UnhealthyContainerResponse struct {
	ErrorType model.ErrorType
}