httpaux

type Busy struct {
	// Limiter is the concurrent request limiting strategy.  If this field is unset,
	// then no limiting is done.
	Limiter Limiter

	// OnBusy is the optional http.Handler to invoke when the maximum number
	// concurrent requests has been exceeded.  ConstantHandler is a useful choice
	// for this field, as it allows one to tailor not only the status code but also
	// the headers and body.
	//
	// If this field is nil, this middleware simply returns http.StatusServiceUnavailable.
	OnBusy http.Handler
}

type ConstantHandler struct {
	// StatusCode is the response code to pass to http.ResponseWriter.WriteHeader.
	// If this value is less than 100 (which also includes being unset), then no
	// response code is written which will trigger the default of http.StatusOK.
	StatusCode int

	// Header is the set of headers added to every response
	Header Header

	// ContentType is the MIME type of the Body.  This will override anything written by
	// the Headers closure.  This field has no effect if Body is not also set.  If Body is
	// set and this field is unset, then no Content-Type header is written by this handler.
	// A Content-Type may still be written by other infrastructure or by the Headers closure, however.
	ContentType string

	// Body is the optional HTTP entity body.  If unset, nothing is written for the response body.
	// A Content-Length header will be explicitly set if this field is set.
	Body []byte
}

type Error struct {
	// Err is the cause of this error.  This field is required.
	//
	// Typically, this field is set to the service-layer error or other error
	// that occurred below the presentation layer.
	Err error

	// Message is the optional message to associate with this error
	Message string

	// Code is the response code to use for this error.  If unset, http.StatusInternalServerError
	// is used instead.
	Code int

	// Header is the optional set of HTTP headers to associate with this error
	Header http.Header
}

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

type GateClosedError struct {
	// Gate is the gate instance that was closed at the time the attempt
	// to make a request was made.  Note that after this error returns, the
	// gate may be open.
	Gate *Gate
}

type GateOptions struct {
	// Name is an optional identifier for this gate.  The Gate itself does not make
	// use of this value.  It's purely for distinguishing gates when an application
	// uses more than one (1) gate.
	Name string

	// ClosedHandler is the optional http.Handler that handles requests when
	// the gate is closed.  If this field is unset, then the only response information
	// written is a status code of http.StatusServiceUnavailable.
	ClosedHandler http.Handler

	// InitiallyClosed indicates the state of a Gate when it is created.  The default
	// is to create a Gate that is open.  If this field is true, the Gate is created
	// in the closed state.
	InitiallyClosed bool

	// OnOpen is the set of callbacks to invoke when a gate's state changes to open.
	// These callbacks will also be invoked when a Gate is created if the Gate is
	// initially open.
	OnOpen []func(*Gate)

	// OnClosed is the set of callbacks to invoke when a gate's state changes to closed.
	// These callbacks will also be invoked when a Gate is created if the Gate is
	// initially closed.
	OnClosed []func(*Gate)
}

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

type Limiter interface {
	// Check enforces a concurrent request limit, possibly using information
	// from the given HTTP request.  If this method returns true, it indicates
	// that the request is allowed.  In that case, the RequestDone must be non-nil
	// and must be invoked by calling code to update the Limiter's state.
	//
	// If this method returns false, the request should not proceed.  The
	// RequestDone should be ignored.
	//
	// The RequestDone returned by this method is not guaranteed to be idempotent.
	// Callers must take care to invoke it exactly once for any given request.
	Check(*http.Request) (RequestDone, bool)
}

type MaxRequestLimiter struct {
	// MaxRequests is the maximum number of concurrent HTTP requests.  If this
	// is nonpositive, then all requests are allowed.
	MaxRequests int64
	// contains filtered or unexported fields
}

type ObservableWriter interface {
	http.ResponseWriter
	StatusCoder
	ResponseBody

	// OnWriteHeader appends callbacks that are invoked when WriteHeader is called, whether
	// explicitly or implicitly due to calling methods like Flush.
	//
	// If the status code for the response has already been established, these callbacks
	// are invoked immediately.
	OnWriteHeader(...OnWriteHeader)
}

type OnWriteHeader func(int)

type RequestDone func()

type ResponseBody interface {
	// ContentLength returns the count of bytes actually written with Write.  It does
	// not consult the Content-Length header.
	//
	// The count of bytes returned by this method is simply the current count of bytes
	// written so far.  If Write is called after this method, this method will return
	// a different value.
	ContentLength() int64
}

type RoundTripperFunc func(*http.Request) (*http.Response, error)

type StatusCoder interface {
	// StatusCode returns the response code reported through WriteHeader.  Certain
	// methods cause WriteHeader to be called implicitly, with a status of http.StatusOK.
	//
	// If no status code has been written yet, this method returns zero (0).
	StatusCode() int
}