bfe_basic

type AiAuthInfo struct {
	RejectReason     string   // reason for rejection
	RejectQuotaPlans []string // quota plan IDs rejected due to insufficient quota
}

type AiBasicInfo struct {
	ClientApiKey string
	ClientModel  string
	TargetModel  string

	ApikeyTags    []ApikeyTag
	TokenTimeInfo TokenTimeInfo
	AiAuthInfo    AiAuthInfo
	// contains filtered or unexported fields
}

type AiError struct {
	Code    string         `json:"code"`
	Type    string         `json:"type"`
	Param   *string        `json:"param"`
	Message string         `json:"message"`
	Details *AiErrorDetail `json:"details"`
}

type AiErrorBody struct {
	Error AiError `json:"error"`
}

type AiErrorDetail struct {
	ApiKey            string `json:"api_key"`
	QuotaPlanId       string `json:"quota_plan_id"`
	LimitType         string `json:"limit_type"`
	Model             string `json:"model"`
	RetryAfterSeconds int    `json:"retry_after_seconds"`
}

type AiRateLimitHitInfo struct {
	HitPolicyDict map[string]*HitPolicyInfo `json:"hit_rate_limit_policys"` //limite policy id -> HitPolicyInfo
}

type ApikeyTag struct {
	TagName  string //eg entity.type
	TagValue string //eg entity.name
}

type BackendInfo struct {
	ClusterName    string // name of cluster
	SubclusterName string // name of sub-cluster
	BackendAddr    string // backend ip address
	BackendPort    uint32 // backend's port
	BackendName    string // backend name
}

type HitPolicyInfo struct {
	TpmRules      []string `json:"tpm_rules"` //name of limiter
	RpmRules      []string `json:"rpm_rules"` //name of limiter
	IsConcurrency bool     `json:"is_concurrency"`
	IsRedisError  string   `json:"is_redis_error"`
}

type OperationStage int

type RedirectInfo struct {
	Url    string          // URL
	Code   int             // HTTP status code
	Header bfe_http.Header // Extra header
}

type Request struct {
	Connection net.Conn
	Session    *Session

	RemoteAddr *net.TCPAddr // address of remote peer
	ClientAddr *net.TCPAddr // address of real client. Maybe nil if request is from

	HttpRequest  *bfe_http.Request  // incoming request
	OutRequest   *bfe_http.Request  // forwarded request
	HttpResponse *bfe_http.Response // corresponding response

	CookieMap bfe_http.CookieMap // cookie map
	Query     url.Values         // save url query

	LogId         string // log id for each request
	ReqBody       []byte // req body, size is limited
	ReqBodyPeeked bool   // whether req body has been peeked

	Route RequestRoute // for get backend cluster based on host/path/query/header/...

	Tags RequestTags // request tag info

	Trans RequestTransport // request transport

	BfeStatusCode int // request directly return by bfe

	ErrCode error  // error code for handling request
	ErrMsg  string // additional error msg

	Stat *RequestStat // time, data length, etc.

	RetryTime int         // times of retry
	Backend   BackendInfo // backend info

	Redirect RedirectInfo // redirect info

	SvrDataConf ServerDataConfInterface // interface for ServerDataConf

	// User context associated with this request
	Context map[interface{}]interface{}

	IsSse bool
}

type RequestRoute struct {
	Error       error  // error in request-route
	HostTag     string // tags
	Product     string // name of product
	ClusterName string // clustername req should route to
}

type RequestStat struct {
	// time stat
	ReadReqStart time.Time // after read first line of http request
	ReadReqEnd   time.Time // after read http request

	FindProStart time.Time // just before find product
	FindProEnd   time.Time // after find product

	LocateStart time.Time // just before find location
	LocateEnd   time.Time // after find location

	ClusterStart time.Time // just before connect backend cluster
	ClusterEnd   time.Time // after get response from backend cluster

	// info for last successful connected backend
	BackendStart time.Time // just before connect backend
	BackendEnd   time.Time // after get response from backend

	ResponseStart time.Time // before write response to client
	ResponseEnd   time.Time // after write response to client

	BackendFirst time.Time // just before connect backend, for first invoke (retry may exist)

	// data length
	HeaderLenIn  int // length of request header
	BodyLenIn    int // length of request body
	HeaderLenOut int // length of response header
	BodyLenOut   int // length of response body

	// some status
	IsCrossCluster bool // with cross-cluster retry?
}

type RequestTags struct {
	Error    error               // error in request-tag
	TagTable map[string][]string // type-tags pairs
}

type RequestTransport struct {
	Backend   *backend.BfeBackend   // destination backend for request
	Transport bfe_http.RoundTripper // transport to backend
}

type ServerDataConfInterface interface {
	ClusterTableLookup(clusterName string) (*bfe_cluster.BfeCluster, error)
	HostTableLookup(hostname string) (string, error)
}

type Session struct {
	SessionId string    // session id
	StartTime time.Time // time of accept the connection
	EndTime   time.Time // time of close connection
	Overhead  time.Duration

	Connection net.Conn
	RemoteAddr *net.TCPAddr // client address

	Use100Continue bool // "expect 100-continue" is used?

	Proto    string                   // protocol for the connection
	IsSecure bool                     // over tls connection?
	TlsState *bfe_tls.ConnectionState // tls state when using TLS

	Vip     net.IP // the virtual ip visited
	Vport   int    // vip virtual port visited
	Product string // product name of vip
	Rtt     uint32 // smoothed RTT for current connection (us)
	// contains filtered or unexported fields
}

type SessionStickyBackend struct {
	Addr       *string `json:"ip"`
	Port       *int    `json:"port"`
	SubCluster *string `json:"subcluster"`
	RenewTime  *int64  `json:"renewtime"`
}

type TokenTimeInfo struct {
	TReqEnd     int64 // Unix microsecond timestamp when the gateway finishes receiving the request body
	TFirstToken int64 // Unix microsecond timestamp when the gateway receives the first chunk with valid generated text
	TLastToken  int64 // Unix microsecond timestamp when the last token is read
	TTFT        int64 // Time to first token (microseconds), TFirstToken - TReqEnd
	TPOT        int64 // Average time per output token (microseconds), (TLastToken - TFirstToken) / (CompletionTokens - 1)
}

type TokenUsage struct {
	PromptTokens     int64 // number of tokens in the prompt
	CompletionTokens int64 // number of tokens in the completion
	UsedQuota        int64 // used quota for this request
}

type WafInfo struct {
	WafSpentTime int64  // in ms.
	WafStatus    int    // waf status, see bfe proto file for detail
	WafRuleName  string // not used
}