j8a

type AboutResponse struct {
	J8a      string
	ServerID string
	Version  string
}

type AcceptEncoding []ContentEncoding

type Acme struct {
	// Acme Provider, currently supports letsencrypt
	Provider string

	// Domain
	Domains []string

	// Email for registration. Auto generated from domain.
	Email string
}

type AcmeHandler struct {
	Active   map[string]bool
	Domains  map[string]string
	KeyAuths map[string][]byte
}

type AcmeUser struct {
	Email        string
	Registration *registration.Resource
	// contains filtered or unexported fields
}

type Atmpt struct {
	URL             *URL
	Label           string
	Count           int
	StatusCode      int
	ContentEncoding ContentEncoding

	CompleteHeader chan struct{}
	CompleteBody   chan struct{}
	Aborted        <-chan struct{}
	AbortedFlag    bool
	CancelFunc     func()
	// contains filtered or unexported fields
}

type Config struct {
	Policies   map[string]Policy
	Routes     Routes
	Jwt        map[string]*Jwt
	Resources  map[string][]ResourceMapping
	Connection Connection
}

type Connection struct {
	Downstream Downstream
	Upstream   Upstream
}

type ContentEncoding string

type Down struct {
	Req            *http.Request
	Resp           Resp
	Method         string
	Path           string
	URI            string
	UserAgent      string
	AcceptEncoding AcceptEncoding
	Body           []byte
	Aborted        <-chan struct{}
	AbortedFlag    bool
	Timeout        <-chan struct{}
	TimeoutFlag    bool
	ReqTooLarge    bool

	HttpVer  string
	TlsVer   string
	Port     int
	Listener string
	// contains filtered or unexported fields
}

type Downstream struct {
	// ReadTimeoutSeconds is the maximum duration for reading the entire
	// request, including the body, the downstream user agent sends to us.
	ReadTimeoutSeconds int

	// WriteTimeoutSeconds is the maximum duration round trip time in seconds any
	// single request spends in the server, this includes the time to read the request,
	// processing upstream attempts and writing the response into downstream socket.
	RoundTripTimeoutSeconds int

	// IdleTimeoutSeconds is the maximum duration, a downstream idle socket connection is kept open
	// before the server hangs up on the downstream user agent.
	IdleTimeoutSeconds int

	// MaxBodyBytes is the maximum size of the incoming HTTP request body before it is rejected
	MaxBodyBytes int64

	// Http block. defaults to on
	Http Http

	// Tls block defaults to off
	Tls Tls
}

type HTTPClient interface {
	Do(req *http.Request) (*http.Response, error)
	Get(uri string) (*http.Response, error)
}

type HandlerDelegate struct{}

type Http struct {
	// Serving HTTP on this port
	Port int

	// Redirect HTTP to tls if set to "TLS". Only one value allowed.
	Redirecttls bool
}

type Jwt struct {
	Name string
	Alg  string
	// Jwt key supports pem encoding for public keys, certificates unencoded secrets for hmac.
	Key string
	// JwksUrl loads remotely.
	JwksUrl               string
	RSAPublic             KeySet
	ECDSAPublic           KeySet
	Secret                KeySet
	AcceptableSkewSeconds string
	Claims                []string
	// contains filtered or unexported fields
}

type KeySet []KidPair

type KidPair struct {
	Kid string
	Key interface{}
}

type LabelWeight struct {
	Label  string
	Weight float64
}

type PDuration time.Duration

type Policy []LabelWeight

type Proxy struct {
	XRequestID   string
	XRequestInfo bool
	Up           Up
	Dwn          Down
	Route        *Route
}

type ReloadableCert struct {
	Cert *tls.Certificate

	Init bool
	// contains filtered or unexported fields
}

type ResourceMapping struct {
	Name   string
	Labels []string
	URL    URL
}

type Resp struct {
	Writer          http.ResponseWriter
	StatusCode      int
	Message         string
	Body            *[]byte
	ContentLength   int64
	ContentEncoding ContentEncoding
}

type Route struct {
	Path      string
	PathRegex *regexp.Regexp
	Transform string
	Resource  string
	Policy    string
	Jwt       string
}

type Routes []Route

type Runtime struct {
	Config
	Start          time.Time
	Memory         []sample
	AcmeHandler    *AcmeHandler
	ReloadableCert *ReloadableCert
	// contains filtered or unexported fields
}

type StatusCodeResponse struct {
	AboutResponse
	Code    int
	Message string
}

type TLSType string

type Tls struct {
	// Serving on this port
	Port int

	// TLS x509 certificate
	Cert string

	// TLS secret key
	Key string

	// Acme config for TLS. Optional, but conflicts with Cert and Key
	Acme Acme
}

type TlsLink struct {
	// contains filtered or unexported fields
}

type URL struct {
	Scheme string
	Host   string
	Port   uint16
}

type Up struct {
	Atmpt  *Atmpt
	Atmpts []Atmpt
	Count  int
}

type Upstream struct {

	// PoolSize is the maximum size of the client socket connection pool for idle connections
	PoolSize int

	// IdleTimeoutSeconds is the total wait period in seconds before we hang up on an idle upstream connection.
	IdleTimeoutSeconds int

	// SocketTimeoutSeconds is the wait period to establish socket connection with an upstream server.
	// This setting controls roundtrip time for establishing simple TCP connections, combined with handshake time for TLS
	// if applicable.
	SocketTimeoutSeconds int

	// ReadTimeoutSeconds is the wait period to read the entire upstream response once connection was established
	// before an individual upstream request is aborted
	ReadTimeoutSeconds int

	// MaxAttempts is the maximum allowable number of request attempts to obtain a successful response for repeatable
	// HTTP requests.
	MaxAttempts int

	// TlsInsecureSkipVerify skips the host name validation and certificate chain verification of upstream connections
	// using TLS. Use this only for testing or if you know what you are doing. Defaults to false
	TlsInsecureSkipVerify bool
}

type WebsocketStatus struct {
	DwnOpCode ws.OpCode
	DwnExit   error
	UpOpCode  ws.OpCode
	UpExit    error
}

type WebsocketTx struct {
	UpBytesRead   int64
	UpBytesWrite  int64
	DwnBytesRead  int64
	DwnBytesWrite int64
}