guardian

type BlacklistProvider interface {
	GetBlacklist() []net.IPNet
}

type CondRequestBlockerFunc func(context.Context, Request) (stop, blocked bool, remaining uint32, err error)

type Conditions struct {
	Path string `yaml:"path" json:"path"`
}

type Config struct {
	ConfigMetadata      `yaml:",inline"`
	GlobalRateLimitSpec *GlobalRateLimitSpec `yaml:"globalRateLimitSpec"`
	GlobalSettingsSpec  *GlobalSettingsSpec  `yaml:"globalSettingsSpec"`
	RateLimitSpec       *RateLimitSpec       `yaml:"rateLimitSpec"`
	JailSpec            *JailSpec            `yaml:"jailSpec"`
}

type ConfigKind string

type ConfigMetadata struct {
	// Version identifies the version of the configuration resource format
	Version string `yaml:"version" json:"version"`
	// Kind identifies the kind of the configuration resource
	Kind ConfigKind `yaml:"kind" json:"kind"`
	// Name uniquely identifies a configuration resource within the resource's Kind
	Name string `yaml:"name" json:"name"`
	// Description is a description to add context to a resource
	Description string `yaml:"description" json:"description"`
}

type Counter interface {

	// Incr increments key by count and sets the expiration to expireIn from now. The result of the incr, whether to force block,
	// and an error is returned
	Incr(context context.Context, key string, incryBy uint, maxBeforeBlock uint64, expireIn time.Duration) (uint64, bool, error)
}

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

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

type GenericRateLimiter struct {
	KeyFunc            func(req Request) string
	LimitProvider      LimitProvider
	Counter            Counter
	Logger             logrus.FieldLogger
	OnRateLimitHandled []RateLimitHook
}

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

type GlobalLimitStore interface {
	GetLimit() Limit
}

type GlobalRateLimitConfig struct {
	ConfigMetadata `yaml:",inline" json:",inline"`
	Spec           GlobalRateLimitSpec `yaml:"globalRateLimitSpec" json:"globalRateLimitSpec"`
}

type GlobalRateLimitSpec struct {
	Limit Limit `yaml:"limit" json:"limit"`
}

type GlobalSettingsConfig struct {
	ConfigMetadata `yaml:",inline" json:",inline"`
	Spec           GlobalSettingsSpec `yaml:"globalSettingsSpec" json:"globalSettingsSpec"`
}

type GlobalSettingsSpec struct {
	ReportOnly bool `yaml:"reportOnly" json:"reportOnly"`
}

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

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

type Jail struct {
	Limit       Limit         `yaml:"limit"" json:"limit"`
	BanDuration time.Duration `yaml:"banDuration" json:"banDuration"`
}

type JailConfig struct {
	ConfigMetadata `yaml:",inline" json:",inline"`
	Spec           JailSpec `yaml:"jailSpec" json:"jailSpec"`
}

type JailConfigDeprecated struct {
	Jails []JailConfigEntryDeprecated `yaml:"jails"`
}

type JailConfigEntryDeprecated struct {
	Route string `yaml:"route"`
	Jail  Jail   `yaml:"jail"`
}

type JailProvider interface {
	GetJail(req Request) Jail
}

type JailSpec struct {
	Jail       `yaml:",inline" json:",inline"`
	Conditions Conditions `yaml:"conditions" json:"conditions"`
}

type Jailer interface {
	IsBanned(ctx context.Context, request Request) (bool, error)
}

type Limit struct {
	Count    uint64
	Duration time.Duration
	Enabled  bool
}

type LimitProvider interface {
	// GetLimit can determine what the limit is based off the data provided in the request.
	// It is up to the limit provider to determine the characteristics of the requests it cares about.
	// For example, a simple IP rate limiter could ignore the request entirely.
	GetLimit(req Request) Limit
}

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

type MetricOptionSetter func(mo *MetricOption)

type MetricReporter interface {
	Duration(request Request, blocked bool, errorOccurred bool, duration time.Duration)
	HandledWhitelist(request Request, whitelisted bool, errorOccurred bool, duration time.Duration)
	HandledBlacklist(request Request, whitelisted bool, errorOccurred bool, duration time.Duration)
	HandledRatelimit(request Request, ratelimited bool, errorOccurred bool, duration time.Duration)
	HandledRatelimitWithRoute(request Request, ratelimited bool, errorOccurred bool, duration time.Duration)
	HandledJail(request Request, blocked bool, errorOccurred bool, duration time.Duration, setters ...MetricOptionSetter)
	HandledAddPrisoner(ip net.IP, jail Jail)
	RedisCounterIncr(duration time.Duration, errorOccurred bool)
	RedisCounterPruned(duration time.Duration, cacheSize float64, prunedCounted float64)
	RedisObtainLock(errorOccurred bool)
	RedisReleaseLock(duration time.Duration, errorOccurred bool)
	CurrentGlobalLimit(limit Limit)
	CurrentRouteLimit(route string, limit Limit)
	CurrentWhitelist(whitelist []net.IPNet)
	CurrentBlacklist(blacklist []net.IPNet)
	CurrentRouteJail(route string, jail Jail)
	CurrentPrisoners(numPrisoners int)
	CurrentReportOnlyMode(reportOnly bool)
}

type NullReporter struct{}

type Prisoner struct {
	IP     net.IP    `yaml:"ip" json:"ip"`
	Jail   Jail      `yaml:"jail" json:"jail"`
	Expiry time.Time `yaml:"expiry" json:"expiry"`
}

type PrisonerStore interface {
	IsPrisoner(remoteAddress string) bool
	AddPrisoner(remoteAddress string, jail Jail)
}

type RateLimitConfig struct {
	ConfigMetadata `yaml:",inline" json:",inline"`
	Spec           RateLimitSpec `yaml:"rateLimitSpec" json:"rateLimitSpec"`
}

type RateLimitHook func(req Request, limit Limit, rateLimited bool, dur time.Duration, err error)

type RateLimitSpec struct {
	Limit      Limit      `yaml:"limit" json:"limit"`
	Conditions Conditions `yaml:"conditions" json:"conditions"`
}

type RateLimiter interface {
	Limit(context.Context, Request) (bool, uint32, error)
}

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

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

type ReportOnlyProvider interface {
	GetReportOnly() bool
}

type Request struct {
	RemoteAddress string
	Authority     string
	Method        string
	Path          string
	Headers       map[string]string
}

type RequestBlockerFunc func(context.Context, Request) (bool, uint32, error)

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

type RouteJailStore interface {
	GetJail(u url.URL) Jail
}

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

type RouteRateLimitConfigDeprecated struct {
	RouteRateLimits []RouteRateLimitConfigEntryDeprecated `yaml:"route_rate_limits"`
}

type RouteRateLimitConfigEntryDeprecated struct {
	Route string `yaml:"route"`
	Limit Limit  `yaml:"limit"`
}

type RouteRateLimitStore interface {
	GetRouteRateLimit(url url.URL) Limit
}

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

type WhitelistProvider interface {
	GetWhitelist() []net.IPNet
}