gateway

package
v2.9.0-beta22-dl-apic+... Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: May 4, 2020 License: MPL-2.0 Imports: 122 Imported by: 0

Documentation

Overview

Tyk Gateway API

The code below describes the Tyk Gateway API Version: 2.8.0 

Schemes: https, http
Host: localhost
BasePath: /tyk/

Consumes:
- application/json

Produces:
- application/json

Security:
- api_key:

SecurityDefinitions:
api_key:
     type: apiKey
     name: X-Tyk-Authorization
     in: header

swagger:meta

Index

Constants

View Source 
const (
	LDAPStorageEngine apidef.StorageEngineCode = "ldap"
	RPCStorageEngine  apidef.StorageEngineCode = "rpc"
)
View Source 
const (
	EventQuotaExceeded        apidef.TykEvent = "QuotaExceeded"
	EventRateLimitExceeded    apidef.TykEvent = "RatelimitExceeded"
	EventAuthFailure          apidef.TykEvent = "AuthFailure"
	EventKeyExpired           apidef.TykEvent = "KeyExpired"
	EventVersionFailure       apidef.TykEvent = "VersionFailure"
	EventOrgQuotaExceeded     apidef.TykEvent = "OrgQuotaExceeded"
	EventOrgRateLimitExceeded apidef.TykEvent = "OrgRateLimitExceeded"
	EventTriggerExceeded      apidef.TykEvent = "TriggerExceeded"
	EventBreakerTriggered     apidef.TykEvent = "BreakerTriggered"
	EventHOSTDOWN             apidef.TykEvent = "HostDown"
	EventHOSTUP               apidef.TykEvent = "HostUp"
	EventTokenCreated         apidef.TykEvent = "TokenCreated"
	EventTokenUpdated         apidef.TykEvent = "TokenUpdated"
	EventTokenDeleted         apidef.TykEvent = "TokenDeleted"
)

Register new event types here, the string is the code used to hook at the Api Deifnititon JSON/BSON level

View Source 
const (
	UnHealthyHostMetaDataTargetKey = "target_url"
	UnHealthyHostMetaDataAPIKey    = "api_id"
	UnHealthyHostMetaDataHostKey   = "host_name"
	PollerCacheKey                 = "PollerActiveInstanceID"
	PoolerHostSentinelKeyPrefix    = "PollerCheckerInstance:"

	UptimeAnalytics_KEYNAME = "tyk-uptime-analytics"
)
View Source 
const (
	KID       = "kid"
	SUB       = "sub"
	HMACSign  = "hmac"
	RSASign   = "rsa"
	ECDSASign = "ecdsa"
)
View Source 
const (
	XRateLimitLimit     = "X-RateLimit-Limit"
	XRateLimitRemaining = "X-RateLimit-Remaining"
	XRateLimitReset     = "X-RateLimit-Reset"
)

Gateway's custom response headers

View Source 
const (
	QuotaKeyPrefix     = "quota-"
	RateLimitKeyPrefix = "rate-limit-"
)
View Source 
const (
	TestHttpGet = testHttpAny + "/get"

	MockOrgID = "507f1f77bcf86cd799439011"
)
View Source 
const BackupApiKeyBase = "node-definition-backup:"
View Source 
const BackupPolicyKeyBase = "node-policy-backup:"
View Source 
const (
	EH_CoProcessHandler apidef.TykEventHandlerName = "cp_dynamic_handler"
)
View Source 
const EH_JSVMHandler apidef.TykEventHandlerName = "eh_dynamic_handler"
View Source 
const EH_LogHandler apidef.TykEventHandlerName = "eh_log_handler"

The name for event handlers as defined in the API Definition JSON/BSON format

View Source 
const LEKeyPrefix = "le_ssl:"
View Source 
const LoopScheme = "tyk"
View Source 
const OIDPREFIX = "openid"
View Source 
const RPCKeyPrefix = "rpc:"
View Source 
const SAFE_METHODS = "SAFE_METHODS"

const used by cache middleware

View Source 
const VERSION = "v2.7.0"

Variables

View Source 
var (
	TykJWTAPIKeyEndpoint        = "/tyk/keys/"
	TykMiddlewareBundleNameHash = "c343271e0935000c0ea41f8d9822015c"
	TykBundles                  = "bundles"
	TykMiddlewareBundleName     = "bundle.zip"
	TykMiddlewareFile           = "middleware.py"
	TykManifest                 = "manifest.json"

	TykRoot  = "/data/tyk-gateway/"
	CertRoot = "/certs/"
	CfgRoot  = "/data/config/"

	TykCACert                    = CertRoot + "cacerts.crt"
	TykServerCrt                 = CertRoot + "server.crt"
	TykServerKey                 = CertRoot + "server.key"
	TykUpstreamPem               = CertRoot + "upstream.pem"
	SystemConfigFilePath         = CfgRoot + "systemconfig.yaml"
	TykMiddlewareRoot            = TykRoot + "/middleware/"
	TykMiddlewareSrcFile         = TykRoot + TykMiddlewareFile
	TykMiddlewareManifestSrcFile = TykRoot + TykManifest
	JWTDefinitionsSpec           = TykRoot + "/jwt_definition.json"
	TykConfFilePath              = TykRoot + "/tyk.conf"
	JWTApiKeySpec                = TykRoot + "/token_jwt.json"
	APITemplateOpenSpec          = TykRoot + "/api_template_open.json"
	APITemplateJWTSpec           = TykRoot + "/api_template_jwt.json"
	APIDefinitionRedis           = TykRoot + "/api_definitions.json"
	DynamicAPIConnTimeout        = 20000
	JWTKeyPrefix                 = "JWT-KEY-"
)

nolint

View Source 
var (
	// key session memory cache
	SessionCache = cache.New(10*time.Second, 5*time.Second)

	// org session memory cache
	ExpiryCache = cache.New(600*time.Second, 10*time.Minute)

	// memory cache to store arbitrary items
	UtilCache = cache.New(time.Hour, 10*time.Minute)
)
View Source 
var (
	GlobalEventsJSVM JSVM

	MainNotifier             RedisNotifier
	DefaultOrgStore          DefaultSessionManager
	DefaultQuotaStore        DefaultSessionManager
	FallbackKeySesionManager = SessionHandler(&DefaultSessionManager{})
	MonitoringHandler        config.TykEventHandler
	RPCListener              RPCStorageHandler
	DashService              DashboardServiceSender
	CertificateManager       *certs.CertificateManager
	NewRelicApplication      newrelic.Application

	LE_MANAGER  letsencrypt.Manager
	LE_FIRSTRUN bool

	NodeID string
)
View Source 
var (

	// to simulate time ticks for tests that do reloads
	ReloadTick = make(chan time.Time)

	EnableTestDNSMock = true
)
View Source 
var DRLManager = &drl.DRL{}
View Source 
var GlobalRate = ratecounter.NewRateCounter(1 * time.Second)
View Source 
var (
	HostCheckerClient = &http.Client{
		Timeout: 500 * time.Millisecond,
	}
)
View Source 
var JWKCache *cache.Cache
View Source 
var LoopHostRE = regexp.MustCompile("tyk://([^/]+)")
View Source 
var NonAlphaNumRE = regexp.MustCompile("[^A-Za-z0-9]+")
View Source 
var RPCGlobalCache = cache.New(30*time.Second, 15*time.Second)
View Source 
var RedisPool = newPool()
View Source 
var ServiceCache *cache.Cache
View Source 
var ServiceNonce string

Nonce to use when interacting with the dashboard service

Functions

func AddNewRelicInstrumentation 

func AddNewRelicInstrumentation(app newrelic.Application, r *mux.Router)

AddNewRelicInstrumentation adds NewRelic instrumentation to the router

func Append 

func Append(slice, data []byte) []byte

func AuthFailed 

func AuthFailed(m TykMiddleware, r *http.Request, token string)

func CoProcessInit 

func CoProcessInit() error

func Contains 

func Contains(a []string, x string) bool

func CreateJWKToken 

func CreateJWKToken(jGen ...func(*jwt.Token)) string

func CreatePolicy 

func CreatePolicy(pGen ...func(p *user.Policy)) string

func CreateSession deprecated 

func CreateSession(sGen ...func(s *user.SessionState)) string

Deprecated: Use Test.CreateSession instead.

func CreateStandardPolicy 

func CreateStandardPolicy() *user.Policy

func CreateStandardSession 

func CreateStandardSession() *user.SessionState

func DoCoprocessReload 

func DoCoprocessReload()

func EncodeRequestToEvent 

func EncodeRequestToEvent(r *http.Request) string

EncodeRequestToEvent will write the request out in wire protocol and encode it to base64 and store it in an Event object

func EnsureTransport 

func EnsureTransport(host string) string

func EventHandlerByName 

func EventHandlerByName(handlerConf apidef.EventHandlerTriggerConfig, spec *APISpec) (config.TykEventHandler, error)

EventHandlerByName is a convenience function to get event handler instances from an API Definition

func FireSystemEvent 

func FireSystemEvent(name apidef.TykEvent, meta interface{})

func GenerateTestBinaryData 

func GenerateTestBinaryData() (buf *bytes.Buffer)

func GetHTTPClient 

func GetHTTPClient() (*retryablehttp.Client, bool)

func GetLEState 

func GetLEState(m *letsencrypt.Manager)

func GetRedisConn 

func GetRedisConn() redis.Conn

func InitHostCheckManager 

func InitHostCheckManager(store storage.Handler)

func InitTestMain 

func InitTestMain(m *testing.M, genConf ...func(globalConf *config.Config)) int

func InstrumentationMW 

func InstrumentationMW(next http.Handler) http.Handler

InstrumentationMW will set basic instrumentation events, variables and timers on API jobs

func IsWebsocket 

func IsWebsocket(req *http.Request) bool

func JSONToFormValues 

func JSONToFormValues(r *http.Request) error

JSONToFormValues if r has header Content-Type set to application/json this will decode request body as json to map[string]string and adds the key/value pairs in r.Form.

func LoadPoliciesFromDashboard 

func LoadPoliciesFromDashboard(endpoint, secret string, allowExplicit bool) map[string]user.Policy

LoadPoliciesFromDashboard will connect and download Policies from a Tyk Dashboard instance.

func LoadPoliciesFromFile 

func LoadPoliciesFromFile(filePath string) map[string]user.Policy

func LoadPoliciesFromRPC 

func LoadPoliciesFromRPC(orgId string) (map[string]user.Policy, error)

func LoadPoliciesFromRPCBackup 

func LoadPoliciesFromRPCBackup() (map[string]user.Policy, error)

func MonitorApplicationInstrumentation 

func MonitorApplicationInstrumentation()

func NotifyCurrentServerStatus 

func NotifyCurrentServerStatus()

func ProxyHandler 

func ProxyHandler(p *ReverseProxy, apiSpec *APISpec) http.Handler

ProxyHandler Proxies requests through to their final destination, if they make it through the middleware chain.

func RegisterBundle 

func RegisterBundle(name string, files map[string]string) string

func RemoveDirContents 

func RemoveDirContents(dir string) error

func ResetTestConfig 

func ResetTestConfig()

func SetCheckerHostList 

func SetCheckerHostList()

func SetupNewRelic 

func SetupNewRelic() (app newrelic.Application)

SetupNewRelic creates new newrelic.Application instance

func Start 

func Start()

func StartPeriodicStateBackup 

func StartPeriodicStateBackup(m *letsencrypt.Manager)

func StoreLEState 

func StoreLEState(m *letsencrypt.Manager)

func TestReq 

func TestReq(t testing.TB, method, urlStr string, body interface{}) *http.Request

func TestReqBody 

func TestReqBody(t testing.TB, body interface{}) io.Reader

func UpdateAPIVersion 

func UpdateAPIVersion(spec *APISpec, name string, verGen func(version *apidef.VersionInfo))

func WrappedCharsetReader 

func WrappedCharsetReader(s string, i io.Reader) (io.Reader, error)

Types

type APIAllCertificates 

type APIAllCertificates struct {
	CertIDs []string `json:"certs"`
}

type APICertificateStatusMessage 

type APICertificateStatusMessage struct {
	CertID  string `json:"id"`
	Status  string `json:"status"`
	Message string `json:"message"`
}

type APIDefinition 

type APIDefinition struct {
	Name                       string                     `json:"name"`
	ListenPath                 string                     `json:"listen_path"`
	TargetURL                  string                     `json:"target_url"`
	AuthType                   string                     `json:"authtype"`
	EnablePythonMiddleware     bool                       `json:"enable_python_middleware"`
	EnableGolangMiddleware     bool                       `json:"enable_golang_middleware"`
	EnableMTLS                 bool                       `json:"enable_mtls"`
	UpdateTargetHost           bool                       `json:"update_target_host"`
	PythonMiddlewareConfigData PythonMiddlewareConfigData `json:"python_middleware_config_data"`
	GolangMiddlewareConfigData GolangMiddlewareConfigData `json:"golang_middleware_config_data"`
	URLRewrites                []URLRewrites              `json:"url_rewrites"`
	RemoveHeaders              []string                   `json:"remove_headers"`
	AuthCookieName             string                     `json:"auth_cookie_name"`
	EnableLoadBalancing        bool                       `json:"enable_load_balancing"`
	LoadBalancingConfigData    LoadBalancingConfigData    `json:"load_balancing_config_data"`
	SSLForceRootCACheck        bool                       `json:"ssl_force_rootca_check"`
	AppName                    string                     `json:"app_name"`
}

APIDefinition to store api definition

type APIDefinitionLoader 

type APIDefinitionLoader struct{}

APIDefinitionLoader will load an Api definition from a storage system.

func (APIDefinitionLoader) FromDashboardService 

func (a APIDefinitionLoader) FromDashboardService(endpoint, secret string) ([]*APISpec, error)

FromDashboardService will connect and download ApiDefintions from a Tyk Dashboard instance.

func (APIDefinitionLoader) FromDir 

func (a APIDefinitionLoader) FromDir(dir string) []*APISpec

FromDir will load APIDefinitions from a directory on the filesystem. Definitions need to be the JSON representation of APIDefinition object

func (APIDefinitionLoader) FromRPC 

func (a APIDefinitionLoader) FromRPC(orgId string) ([]*APISpec, error)

FromCloud will connect and download ApiDefintions from a Mongo DB instance.

func (APIDefinitionLoader) FromRedis 

func (a APIDefinitionLoader) FromRedis(db config.RedisDBAppConfOptionsConfig) ([]*APISpec, error)

FromCloud will connect and download ApiDefintions from a Mongo DB instance.

func (APIDefinitionLoader) MakeSpec 

func (a APIDefinitionLoader) MakeSpec(def *apidef.APIDefinition, logger *logrus.Entry) *APISpec

MakeSpec will generate a flattened URLSpec from and APIDefinitions' VersionInfo data. paths are keyed to the Api version name, which is determined during routing to speed up lookups

func (APIDefinitionLoader) ParseDefinition 

func (a APIDefinitionLoader) ParseDefinition(r io.Reader) *apidef.APIDefinition

type APIError 

type APIError struct {
	Message template.HTML
}

APIError is generic error object returned if there is something wrong with the request

type APISpec 

type APISpec struct {
	*apidef.APIDefinition
	sync.RWMutex

	RxPaths          map[string][]URLSpec
	WhiteListEnabled map[string]bool

	AuthManager              AuthorisationHandler
	SessionManager           SessionHandler
	OAuthManager             *OAuthManager
	OrgSessionManager        SessionHandler
	EventPaths               map[apidef.TykEvent][]config.TykEventHandler
	Health                   HealthChecker
	JSVM                     JSVM
	ResponseChain            []TykResponseHandler
	RoundRobin               RoundRobin
	URLRewriteEnabled        bool
	CircuitBreakerEnabled    bool
	EnforcedTimeoutEnabled   bool
	LastGoodHostList         *apidef.HostList
	HasRun                   bool
	ServiceRefreshInProgress bool
	HTTPTransport            http.RoundTripper
	HTTPTransportCreated     time.Time
	WSTransport              http.RoundTripper
	WSTransportCreated       time.Time
	GlobalConfig             config.Config
	OrgHasNoSession          bool
	// contains filtered or unexported fields
}

APISpec represents a path specification for an API, to avoid enumerating multiple nested lists, a single flattened URL list is checked for matching paths and then it's status evaluated if found.

func BuildAPI 

func BuildAPI(apiGens ...func(spec *APISpec)) (specs []*APISpec)

func BuildAndLoadAPI 

func BuildAndLoadAPI(apiGens ...func(spec *APISpec)) (specs []*APISpec)

func CreateDefinitionFromString 

func CreateDefinitionFromString(defStr string) *APISpec

func CreateSpecTest 

func CreateSpecTest(t testing.TB, def string) *APISpec

func LoadAPI 

func LoadAPI(specs ...*APISpec) (out []*APISpec)

func LoadDefinitionsFromRPCBackup 

func LoadDefinitionsFromRPCBackup() ([]*APISpec, error)

func (*APISpec) CheckSpecMatchesStatus 

func (a *APISpec) CheckSpecMatchesStatus(r *http.Request, rxPaths []URLSpec, mode URLStatus) (bool, interface{})

CheckSpecMatchesStatus checks if a url spec has a specific status

func (*APISpec) FireEvent 

func (s *APISpec) FireEvent(name apidef.TykEvent, meta interface{})

func (*APISpec) Init 

func (a *APISpec) Init(authStore, sessionStore, healthStore, orgStore storage.Handler)

func (*APISpec) Release 

func (s *APISpec) Release()

Release re;leases all resources associated with API spec

func (*APISpec) RequestValid 

func (a *APISpec) RequestValid(r *http.Request) (bool, RequestStatus, interface{})

RequestValid will check if an incoming request has valid version data and return a RequestStatus that describes the status of the request

func (*APISpec) StopSessionManagerPool 

func (a *APISpec) StopSessionManagerPool()

func (*APISpec) URLAllowedAndIgnored 

func (a *APISpec) URLAllowedAndIgnored(r *http.Request, rxPaths []URLSpec, whiteListStatus bool) (RequestStatus, interface{})

URLAllowedAndIgnored checks if a url is allowed and ignored.

func (*APISpec) Version 

func (a *APISpec) Version(r *http.Request) (*apidef.VersionInfo, []URLSpec, bool, RequestStatus)

Version attempts to extract the version data from a request, depending on where it is stored in the request (currently only "header" is supported)

func (*APISpec) VersionExpired 

func (a *APISpec) VersionExpired(versionDef *apidef.VersionInfo) (bool, *time.Time)

VersionExpired checks if an API version (during a proxied request) is expired. If it isn't and the configured time was valid, it also returns the expiration time.

type AccessRightsCheck 

type AccessRightsCheck struct {
	BaseMiddleware
}

AccessRightsCheck is a middleware that will check if the key bing used to access the API has permission to access the specific version. If no permission data is in the user.SessionState, then it is assumed that the user can go through.

func (*AccessRightsCheck) Name 

func (a *AccessRightsCheck) Name() string

func (*AccessRightsCheck) ProcessRequest 

func (a *AccessRightsCheck) ProcessRequest(w http.ResponseWriter, r *http.Request, _ interface{}) (error, int)

ProcessRequest will run any checks on the request on the way through the system, return an error to have the chain fail

type AnalyticsRecord 

type AnalyticsRecord struct {
	Method        string
	Host          string
	Path          string // HTTP path, can be overriden by "track path" plugin
	RawPath       string // Original HTTP path
	ContentLength int64
	UserAgent     string
	Day           int
	Month         time.Month
	Year          int
	Hour          int
	ResponseCode  int
	APIKey        string
	TimeStamp     time.Time
	APIVersion    string
	APIName       string
	APIID         string
	OrgID         string
	OauthID       string
	RequestTime   int64
	RawRequest    string // Base64 encoded request data (if detailed recording turned on)
	RawResponse   string // ^ same but for response
	IPAddress     string
	Geo           GeoData
	Tags          []string
	Alias         string
	TrackPath     bool
	ExpireAt      time.Time `bson:"expireAt" json:"expireAt"`
}

AnalyticsRecord encodes the details of a request

func (*AnalyticsRecord) GetGeo 

func (a *AnalyticsRecord) GetGeo(ipStr string)

func (*AnalyticsRecord) NormalisePath 

func (a *AnalyticsRecord) NormalisePath(globalConfig *config.Config)

func (*AnalyticsRecord) SetExpiry 

func (a *AnalyticsRecord) SetExpiry(expiresInSeconds int64)

type AuthKey 

type AuthKey struct {
	BaseMiddleware
}

KeyExists will check if the key being used to access the API is in the request data, and then if the key is in the storage engine

func (*AuthKey) Name 

func (k *AuthKey) Name() string

func (*AuthKey) ProcessRequest 

func (k *AuthKey) ProcessRequest(w http.ResponseWriter, r *http.Request, _ interface{}) (error, int)

type AuthorisationHandler 

type AuthorisationHandler interface {
	Init(storage.Handler)
	KeyAuthorised(string) (user.SessionState, bool)
	KeyExpired(*user.SessionState) bool
}

AuthorisationHandler is used to validate a session key, implementing KeyAuthorised() to validate if a key exists or is valid in any way (e.g. cryptographic signing etc.). Returns a user.SessionState object (deserialised JSON)

type BaseExtractor 

type BaseExtractor struct {
	Config  *apidef.MiddlewareIdExtractor
	BaseMid BaseMiddleware
	Spec    *APISpec
}

BaseExtractor is the base structure for an ID extractor, it implements the IdExtractor interface. Other extractors may override some of its methods.

func (*BaseExtractor) Error 

func (e *BaseExtractor) Error(r *http.Request, err error, message string) (returnOverrides ReturnOverrides)

Error is a helper for logging the extractor errors. It always returns HTTP 400 (so we don't expose any details).

func (*BaseExtractor) ExtractAndCheck 

func (e *BaseExtractor) ExtractAndCheck(r *http.Request) (sessionID string, returnOverrides ReturnOverrides)

ExtractAndCheck is called from the CP middleware, if ID extractor is enabled for the current API.

func (*BaseExtractor) ExtractBody 

func (e *BaseExtractor) ExtractBody(r *http.Request) (string, error)

ExtractBody is used when BodySource is specified.

func (*BaseExtractor) ExtractForm 

func (e *BaseExtractor) ExtractForm(r *http.Request, paramName string) (formValue string, err error)

ExtractForm is used when a FormSource is specified.

func (*BaseExtractor) ExtractHeader 

func (e *BaseExtractor) ExtractHeader(r *http.Request) (headerValue string, err error)

ExtractHeader is used when a HeaderSource is specified.

func (*BaseExtractor) GenerateSessionID 

func (e *BaseExtractor) GenerateSessionID(input string, mw BaseMiddleware) (sessionID string)

GenerateSessionID is a helper for generating session IDs, it takes an input (usually the extractor output) and a middleware pointer.

type BaseMiddleware 

type BaseMiddleware struct {
	Spec  *APISpec
	Proxy ReturningHttpHandler
	// contains filtered or unexported fields
}

BaseMiddleware wraps up the ApiSpec and Proxy objects to be included in a middleware handler, this can probably be handled better.

func (BaseMiddleware) ApplyPolicies 

func (t BaseMiddleware) ApplyPolicies(session *user.SessionState) error

ApplyPolicies will check if any policies are loaded. If any are, it will overwrite the session state to use the policy values.

func (BaseMiddleware) Base 

func (t BaseMiddleware) Base() *BaseMiddleware

func (BaseMiddleware) CheckSessionAndIdentityForValidKey 

func (t BaseMiddleware) CheckSessionAndIdentityForValidKey(key string, r *http.Request) (user.SessionState, bool)

CheckSessionAndIdentityForValidKey will check first the Session store for a valid key, if not found, it will try the Auth Handler, if not found it will fail

func (BaseMiddleware) Config 

func (t BaseMiddleware) Config() (interface{}, error)

func (BaseMiddleware) EnabledForSpec 

func (t BaseMiddleware) EnabledForSpec() bool

func (BaseMiddleware) FireEvent 

func (t BaseMiddleware) FireEvent(name apidef.TykEvent, meta interface{})

FireEvent is added to the BaseMiddleware object so it is available across the entire stack

func (BaseMiddleware) Init 

func (t BaseMiddleware) Init()

func (BaseMiddleware) Logger 

func (t BaseMiddleware) Logger() (logger *logrus.Entry)

func (BaseMiddleware) OrgSession 

func (t BaseMiddleware) OrgSession(key string) (user.SessionState, bool)

func (BaseMiddleware) OrgSessionExpiry 

func (t BaseMiddleware) OrgSessionExpiry(orgid string) int64

func (*BaseMiddleware) SetName 

func (t *BaseMiddleware) SetName(name string)

func (BaseMiddleware) SetOrgExpiry 

func (t BaseMiddleware) SetOrgExpiry(orgid string, expiry int64)

func (*BaseMiddleware) SetRequestLogger 

func (t *BaseMiddleware) SetRequestLogger(r *http.Request)

func (BaseMiddleware) UpdateRequestSession 

func (t BaseMiddleware) UpdateRequestSession(r *http.Request) bool

type BasicAuthKeyIsValid 

type BasicAuthKeyIsValid struct {
	BaseMiddleware
	// contains filtered or unexported fields
}

BasicAuthKeyIsValid uses a username instead of

func (*BasicAuthKeyIsValid) EnabledForSpec 

func (k *BasicAuthKeyIsValid) EnabledForSpec() bool

EnabledForSpec checks if UseBasicAuth is set in the API definition.

func (*BasicAuthKeyIsValid) Name 

func (k *BasicAuthKeyIsValid) Name() string

func (*BasicAuthKeyIsValid) ProcessRequest 

func (k *BasicAuthKeyIsValid) ProcessRequest(w http.ResponseWriter, r *http.Request, _ interface{}) (error, int)

ProcessRequest will run any checks on the request on the way through the system, return an error to have the chain fail

type BatchReplyUnit 

type BatchReplyUnit struct {
	RelativeURL string      `json:"relative_url"`
	Code        int         `json:"code"`
	Headers     http.Header `json:"headers"`
	Body        string      `json:"body"`
}

BatchReplyUnit encodes a request suitable for replying to a batch request

type BatchRequestHandler 

type BatchRequestHandler struct {
	API *APISpec
}

BatchRequestHandler handles batch requests on /tyk/batch for any API Definition that has the feature enabled

func (*BatchRequestHandler) ConstructRequests 

func (b *BatchRequestHandler) ConstructRequests(batchRequest BatchRequestStructure, unsafe bool) ([]*http.Request, error)

func (*BatchRequestHandler) DecodeBatchRequest 

func (b *BatchRequestHandler) DecodeBatchRequest(r *http.Request) (BatchRequestStructure, error)

func (*BatchRequestHandler) HandleBatchRequest 

func (b *BatchRequestHandler) HandleBatchRequest(w http.ResponseWriter, r *http.Request)

HandleBatchRequest is the actual http handler for a batch request on an API definition

func (*BatchRequestHandler) MakeRequests 

func (b *BatchRequestHandler) MakeRequests(batchRequest BatchRequestStructure, requestSet []*http.Request) []BatchReplyUnit

func (*BatchRequestHandler) ManualBatchRequest 

func (b *BatchRequestHandler) ManualBatchRequest(requestObject []byte) ([]byte, error)

HandleBatchRequest is the actual http handler for a batch request on an API definition

type BatchRequestStructure 

type BatchRequestStructure struct {
	Requests                  []RequestDefinition `json:"requests"`
	SuppressParallelExecution bool                `json:"suppress_parallel_execution"`
}

BatchRequestStructure defines a batch request order

type Bundle 

type Bundle struct {
	Name     string
	Data     []byte
	Path     string
	Spec     *APISpec
	Manifest apidef.BundleManifest
}

Bundle is the basic bundle data structure, it holds the bundle name and the data.

func (*Bundle) AddToSpec 

func (b *Bundle) AddToSpec()

AddToSpec attaches the custom middleware settings to an API definition.

func (*Bundle) Verify 

func (b *Bundle) Verify() error

Verify performs a signature verification on the bundle file.

type BundleGetter 

type BundleGetter interface {
	Get() ([]byte, error)
}

BundleGetter is used for downloading bundle data, see HttpBundleGetter for reference.

type BundleSaver 

type BundleSaver interface {
	Save(*Bundle, string, *APISpec) error
}

BundleSaver is an interface used by bundle saver structures.

type CertificateCheckMW 

type CertificateCheckMW struct {
	BaseMiddleware
}

CertificateCheckMW is used if domain was not detected or multiple APIs bind on the same domain. In this case authentification check happens not on TLS side but on HTTP level using this middleware

func (*CertificateCheckMW) EnabledForSpec 

func (m *CertificateCheckMW) EnabledForSpec() bool

func (*CertificateCheckMW) Name 

func (m *CertificateCheckMW) Name() string

func (*CertificateCheckMW) ProcessRequest 

func (m *CertificateCheckMW) ProcessRequest(w http.ResponseWriter, r *http.Request, _ interface{}) (error, int)

type ChainObject 

type ChainObject struct {
	Domain         string
	ListenOn       string
	ThisHandler    http.Handler
	RateLimitChain http.Handler
	RateLimitPath  string
	Open           bool
	Index          int
	Skip           bool
	Subrouter      *mux.Router
}

type CoProcessEventHandler 

type CoProcessEventHandler struct {
	Spec *APISpec
}

func (*CoProcessEventHandler) HandleEvent 

func (l *CoProcessEventHandler) HandleEvent(em config.EventMessage)

func (*CoProcessEventHandler) Init 

func (l *CoProcessEventHandler) Init(handlerConf interface{}) error

type CoProcessMiddleware 

type CoProcessMiddleware struct {
	BaseMiddleware
	HookType         coprocess.HookType
	HookName         string
	MiddlewareDriver apidef.MiddlewareDriver
	RawBodyOnly      bool
	// contains filtered or unexported fields
}

func (*CoProcessMiddleware) EnabledForSpec 

func (m *CoProcessMiddleware) EnabledForSpec() bool

func (*CoProcessMiddleware) Name 

func (m *CoProcessMiddleware) Name() string

func (*CoProcessMiddleware) ProcessRequest 

func (m *CoProcessMiddleware) ProcessRequest(w http.ResponseWriter, r *http.Request, _ interface{}) (error, int)

type ConfigPayload 

type ConfigPayload struct {
	Configuration config.Config
	ForHostname   string
	ForNodeID     string
	TimeStamp     int64
}

type CustomMiddleware 

type CustomMiddleware struct {
	Post   []Post `json:"post"`
	Driver string `json:"driver"`
}

type DBAccessDefinition 

type DBAccessDefinition struct {
	APIName     string            `json:"apiname"`
	APIID       string            `json:"apiid"`
	Versions    []string          `json:"versions"`
	AllowedURLs []user.AccessSpec `bson:"allowed_urls" json:"allowed_urls"` // mapped string MUST be a valid regex
	Limit       *user.APILimit    `json:"limit"`
}

func (*DBAccessDefinition) ToRegularAD 

func (d *DBAccessDefinition) ToRegularAD() user.AccessDefinition

type DBPolicy 

type DBPolicy struct {
	user.Policy
	AccessRights map[string]DBAccessDefinition `bson:"access_rights" json:"access_rights"`
}

func (*DBPolicy) ToRegularPolicy 

func (d *DBPolicy) ToRegularPolicy() user.Policy

type DashboardServiceSender 

type DashboardServiceSender interface {
	Init() error
	Register() error
	DeRegister() error
	StartBeating() error
	StopBeating()
	NotifyDashboardOfEvent(interface{}) error
}

type DefRequest 

type DefRequest struct {
	OrgId string
	Tags  []string
}

type DefaultAuthorisationManager 

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

DefaultAuthorisationManager implements AuthorisationHandler, requires a storage.Handler to interact with key store

func (*DefaultAuthorisationManager) Init 

func (b *DefaultAuthorisationManager) Init(store storage.Handler)

func (*DefaultAuthorisationManager) KeyAuthorised 

func (b *DefaultAuthorisationManager) KeyAuthorised(keyName string) (user.SessionState, bool)

KeyAuthorised checks if key exists and can be read into a user.SessionState object

func (*DefaultAuthorisationManager) KeyExpired 

func (b *DefaultAuthorisationManager) KeyExpired(newSession *user.SessionState) bool

KeyExpired checks if a key has expired, if the value of user.SessionState.Expires is 0, it will be ignored

type DefaultHealthChecker 

type DefaultHealthChecker struct {
	APIID string
	// contains filtered or unexported fields
}

func (*DefaultHealthChecker) ApiHealthValues 

func (h *DefaultHealthChecker) ApiHealthValues() (HealthCheckValues, error)

func (*DefaultHealthChecker) CreateKeyName 

func (h *DefaultHealthChecker) CreateKeyName(subKey HealthPrefix) string

func (*DefaultHealthChecker) Init 

func (h *DefaultHealthChecker) Init(storeType storage.Handler)

func (*DefaultHealthChecker) StoreCounterVal 

func (h *DefaultHealthChecker) StoreCounterVal(counterType HealthPrefix, value string)

type DefaultKeyGenerator 

type DefaultKeyGenerator struct{}

func (DefaultKeyGenerator) GenerateAuthKey 

func (DefaultKeyGenerator) GenerateAuthKey(orgID string) string

GenerateAuthKey is a utility function for generating new auth keys. Returns the storage key name and the actual key

func (DefaultKeyGenerator) GenerateHMACSecret 

func (DefaultKeyGenerator) GenerateHMACSecret() string

GenerateHMACSecret is a utility function for generating new auth keys. Returns the storage key name and the actual key

type DefaultSessionManager 

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

func (*DefaultSessionManager) Init 

func (b *DefaultSessionManager) Init(store storage.Handler)

func (*DefaultSessionManager) RemoveSession 

func (b *DefaultSessionManager) RemoveSession(keyName string, hashed bool) bool

RemoveSession removes session from storage

func (*DefaultSessionManager) ResetQuota 

func (b *DefaultSessionManager) ResetQuota(keyName string, session *user.SessionState, isHashed bool)

func (*DefaultSessionManager) SessionDetail 

func (b *DefaultSessionManager) SessionDetail(keyName string, hashed bool) (user.SessionState, bool)

SessionDetail returns the session detail using the storage engine (either in memory or Redis)

func (*DefaultSessionManager) Sessions 

func (b *DefaultSessionManager) Sessions(filter string) []string

Sessions returns all sessions in the key store that match a filter key (a prefix)

func (*DefaultSessionManager) Stop 

func (b *DefaultSessionManager) Stop()

func (*DefaultSessionManager) Store 

func (b *DefaultSessionManager) Store() storage.Handler

func (*DefaultSessionManager) UpdateSession 

func (b *DefaultSessionManager) UpdateSession(keyName string, session *user.SessionState,
	resetTTLTo int64, hashed bool) error

UpdateSession updates the session state in the storage engine

type Dispatcher 

type Dispatcher interface {
	DispatchEvent([]byte)
	LoadModules()
	HandleMiddlewareCache(*apidef.BundleManifest, string)
	Reload()
}
var (
	GlobalDispatcher Dispatcher
	EnableCoProcess  = false
)

type DummyProxyHandler 

type DummyProxyHandler struct {
	SH SuccessHandler
}

func (*DummyProxyHandler) ServeHTTP 

func (d *DummyProxyHandler) ServeHTTP(w http.ResponseWriter, r *http.Request)

type DynamicMiddleware 

type DynamicMiddleware struct {
	BaseMiddleware
	MiddlewareClassName string
	Pre                 bool
	UseSession          bool
	Auth                bool
}

DynamicMiddleware is a generic middleware that will execute JS code before continuing

func (*DynamicMiddleware) Name 

func (d *DynamicMiddleware) Name() string

func (*DynamicMiddleware) ProcessRequest 

func (d *DynamicMiddleware) ProcessRequest(w http.ResponseWriter, r *http.Request, _ interface{}) (error, int)

ProcessRequest will run any checks on the request on the way through the system, return an error to have the chain fail

type EndPointCacheMeta 

type EndPointCacheMeta struct {
	Method        string
	CacheKeyRegex string
}

type ErrorHandler 

type ErrorHandler struct {
	BaseMiddleware
}

ErrorHandler is invoked whenever there is an issue with a proxied request, most middleware will invoke the ErrorHandler if something is wrong with the request and halt the request processing through the chain

func (*ErrorHandler) HandleError 

func (e *ErrorHandler) HandleError(w http.ResponseWriter, r *http.Request, errMsg string, errCode int, writeResponse bool)

HandleError is the actual error handler and will store the error details in analytics if analytics processing is enabled.

type Event 

type Event int
const (
	ADD    Event = 0
	DELETE Event = 1
)

type EventCurcuitBreakerMeta 

type EventCurcuitBreakerMeta struct {
	EventMetaDefault
	Path         string
	APIID        string
	CircuitEvent circuit.BreakerEvent
}

EventCurcuitBreakerMeta is the event status for a circuit breaker tripping

type EventHostStatusMeta 

type EventHostStatusMeta struct {
	EventMetaDefault
	HostInfo HostHealthReport
}

type EventKeyFailureMeta 

type EventKeyFailureMeta struct {
	EventMetaDefault
	Path   string
	Origin string
	Key    string
}

EventKeyFailureMeta is the metadata structure for any failure related to a key, such as quota or auth failures.

type EventMetaDefault 

type EventMetaDefault struct {
	Message            string
	OriginatingRequest string
}

EventMetaDefault is a standard embedded struct to be used with custom event metadata types, gives an interface for easily extending event metadata objects

type EventTokenMeta 

type EventTokenMeta struct {
	EventMetaDefault
	Org string
	Key string
}

type EventTriggerExceededMeta 

type EventTriggerExceededMeta struct {
	EventMetaDefault
	OrgID           string `json:"org_id"`
	Key             string `json:"key"`
	TriggerLimit    int64  `json:"trigger_limit"`
	UsagePercentage int64  `json:"usage_percentage"`
}

type EventVersionFailureMeta 

type EventVersionFailureMeta struct {
	EventMetaDefault
	Path   string
	Origin string
	Key    string
	Reason string
}

EventVersionFailureMeta is the metadata structure for an auth failure (EventKeyExpired)

type ExtendedCircuitBreakerMeta 

type ExtendedCircuitBreakerMeta struct {
	apidef.CircuitBreakerMeta
	CB *circuit.Breaker `json:"-"`
}

type ExtendedOsinClientInterface 

type ExtendedOsinClientInterface interface {
	osin.Client
	GetDescription() string
}

type ExtendedOsinStorageInterface 

type ExtendedOsinStorageInterface interface {
	osin.Storage

	// Create OAuth clients
	SetClient(id string, client osin.Client, ignorePrefix bool) error

	// Custom getter to handle prefixing issues in Redis
	GetClientNoPrefix(id string) (osin.Client, error)

	GetClientTokens(id string) ([]OAuthClientToken, error)
	GetPaginatedClientTokens(id string, page int) ([]OAuthClientToken, int, error)

	GetExtendedClient(id string) (ExtendedOsinClientInterface, error)

	// Custom getter to handle prefixing issues in Redis
	GetExtendedClientNoPrefix(id string) (ExtendedOsinClientInterface, error)

	GetClients(filter string, ignorePrefix bool) ([]ExtendedOsinClientInterface, error)

	DeleteClient(id string, ignorePrefix bool) error

	// GetUser retrieves a Basic Access user token type from the key store
	GetUser(string) (*user.SessionState, error)

	// SetUser updates a Basic Access user token type in the key store
	SetUser(string, *user.SessionState, int64) error
}

type GeoData 

type GeoData struct {
	Country struct {
		ISOCode string `maxminddb:"iso_code"`
	} `maxminddb:"country"`

	City struct {
		Names map[string]string `maxminddb:"names"`
	} `maxminddb:"city"`

	Location struct {
		Latitude  float64 `maxminddb:"latitude"`
		Longitude float64 `maxminddb:"longitude"`
		TimeZone  string  `maxminddb:"time_zone"`
	} `maxminddb:"location"`
}

type GetConfigPayload 

type GetConfigPayload struct {
	FromHostname string
	FromNodeID   string
	TimeStamp    int64
}

type GoPluginMiddleware 

type GoPluginMiddleware struct {
	BaseMiddleware
	Path       string // path to .so file
	SymbolName string // function symbol to look up
	// contains filtered or unexported fields
}

GoPluginMiddleware is a generic middleware that will execute Go-plugin code before continuing

func (*GoPluginMiddleware) EnabledForSpec 

func (m *GoPluginMiddleware) EnabledForSpec() bool

func (*GoPluginMiddleware) Name 

func (m *GoPluginMiddleware) Name() string

func (*GoPluginMiddleware) ProcessRequest 

func (m *GoPluginMiddleware) ProcessRequest(w http.ResponseWriter, r *http.Request, conf interface{}) (err error, respCode int)

type GolangManifest 

type GolangManifest struct {
	Checksum         string           `json:"checksum"`
	Signature        string           `json:"signature"`
	CustomMiddleware CustomMiddleware `json:"custom_middleware"`
}

type GolangMiddlewareConfigData 

type GolangMiddlewareConfigData struct {
	Path string `json:"path"`
	Name string `json:"name"`
}

Golang Middleware config data

type GranularAccessMiddleware 

type GranularAccessMiddleware struct {
	BaseMiddleware
}

GranularAccessMiddleware will check if a URL is specifically enabled for the key

func (*GranularAccessMiddleware) Name 

func (m *GranularAccessMiddleware) Name() string

func (*GranularAccessMiddleware) ProcessRequest 

func (m *GranularAccessMiddleware) ProcessRequest(w http.ResponseWriter, r *http.Request, _ interface{}) (error, int)

ProcessRequest will run any checks on the request on the way through the system, return an error to have the chain fail

type GroupKeySpaceRequest 

type GroupKeySpaceRequest struct {
	OrgID   string
	GroupID string
}

type GroupLoginRequest 

type GroupLoginRequest struct {
	UserKey string
	GroupID string
}

type HMACFieldValues 

type HMACFieldValues struct {
	KeyID     string
	Algorthm  string
	Headers   []string
	Signature string
}

type HMACMiddleware 

type HMACMiddleware struct {
	BaseMiddleware
	// contains filtered or unexported fields
}

HMACMiddleware will check if the request has a signature, and if the request is allowed through

func (*HMACMiddleware) EnabledForSpec 

func (k *HMACMiddleware) EnabledForSpec() bool

func (*HMACMiddleware) Init 

func (hm *HMACMiddleware) Init()

func (*HMACMiddleware) Name 

func (hm *HMACMiddleware) Name() string

func (*HMACMiddleware) ProcessRequest 

func (hm *HMACMiddleware) ProcessRequest(w http.ResponseWriter, r *http.Request, _ interface{}) (error, int)

type HTTPBundleGetter 

type HTTPBundleGetter struct {
	URL string
}

HTTPBundleGetter is a simple HTTP BundleGetter.

func (*HTTPBundleGetter) Get 

func (g *HTTPBundleGetter) Get() ([]byte, error)

Get performs an HTTP GET request.

type HTTPDashboardHandler 

type HTTPDashboardHandler struct {
	RegistrationEndpoint    string
	DeRegistrationEndpoint  string
	HeartBeatEndpoint       string
	KeyQuotaTriggerEndpoint string

	Secret string
	// contains filtered or unexported fields
}

func (*HTTPDashboardHandler) DeRegister 

func (h *HTTPDashboardHandler) DeRegister() error

func (*HTTPDashboardHandler) Init 

func (h *HTTPDashboardHandler) Init() error

func (*HTTPDashboardHandler) NotifyDashboardOfEvent 

func (h *HTTPDashboardHandler) NotifyDashboardOfEvent(event interface{}) error

NotifyDashboardOfEvent acts as a form of event which informs the dashboard of a key which has reached a certain usage quota

func (*HTTPDashboardHandler) Register 

func (h *HTTPDashboardHandler) Register() error

func (*HTTPDashboardHandler) StartBeating 

func (h *HTTPDashboardHandler) StartBeating() error

func (*HTTPDashboardHandler) StopBeating 

func (h *HTTPDashboardHandler) StopBeating()

type HeaderInjector 

type HeaderInjector struct {
	Spec *APISpec
	// contains filtered or unexported fields
}

func (*HeaderInjector) HandleResponse 

func (h *HeaderInjector) HandleResponse(rw http.ResponseWriter, res *http.Response, req *http.Request, ses *user.SessionState) error

func (*HeaderInjector) Init 

func (h *HeaderInjector) Init(c interface{}, spec *APISpec) error

func (HeaderInjector) Name 

func (HeaderInjector) Name() string

type HeaderInjectorOptions 

type HeaderInjectorOptions struct {
	AddHeaders    map[string]string `mapstructure:"add_headers" bson:"add_headers" json:"add_headers"`
	RemoveHeaders []string          `mapstructure:"remove_headers" bson:"remove_headers" json:"remove_headers"`
}

type HeaderTransform 

type HeaderTransform struct {
	Spec *APISpec
	// contains filtered or unexported fields
}

func (*HeaderTransform) HandleResponse 

func (h *HeaderTransform) HandleResponse(rw http.ResponseWriter,
	res *http.Response, req *http.Request, ses *user.SessionState) error

func (*HeaderTransform) Init 

func (h *HeaderTransform) Init(c interface{}, spec *APISpec) error

func (HeaderTransform) Name 

func (HeaderTransform) Name() string

type HeaderTransformOptions 

type HeaderTransformOptions struct {
	RevProxyTransform RevProxyTransform `mapstructure:"rev_proxy_header_cleanup" bson:"rev_proxy_header_cleanup" json:"rev_proxy_header_cleanup"`
}

type HealthCheckValues 

type HealthCheckValues struct {
	ThrottledRequestsPS float64 `bson:"throttle_reqests_per_second,omitempty" json:"throttle_reqests_per_second"`
	QuotaViolationsPS   float64 `bson:"quota_violations_per_second,omitempty" json:"quota_violations_per_second"`
	KeyFailuresPS       float64 `bson:"key_failures_per_second,omitempty" json:"key_failures_per_second"`
	AvgUpstreamLatency  float64 `bson:"average_upstream_latency,omitempty" json:"average_upstream_latency"`
	AvgRequestsPS       float64 `bson:"average_requests_per_second,omitempty" json:"average_requests_per_second"`
}

type HealthChecker 

type HealthChecker interface {
	Init(storage.Handler)
	ApiHealthValues() (HealthCheckValues, error)
	StoreCounterVal(HealthPrefix, string)
}

type HealthPrefix 

type HealthPrefix string
const (
	Throttle          HealthPrefix = "Throttle"
	QuotaViolation    HealthPrefix = "QuotaViolation"
	KeyFailure        HealthPrefix = "KeyFailure"
	RequestLog        HealthPrefix = "Request"
	BlockedRequestLog HealthPrefix = "BlockedRequest"
)

type HostCheckObject 

type HostCheckObject struct {
	CheckURL string            `json:"url"`
	Method   string            `json:"method"`
	Headers  map[string]string `json:"headers"`
	Body     string            `json:"body"`
}

type HostCheckerManager 

type HostCheckerManager struct {
	Id string
	// contains filtered or unexported fields
}
var GlobalHostChecker HostCheckerManager

func (*HostCheckerManager) AmIPolling 

func (hc *HostCheckerManager) AmIPolling() bool

func (*HostCheckerManager) CheckActivePollerLoop 

func (hc *HostCheckerManager) CheckActivePollerLoop()

func (*HostCheckerManager) DoServiceDiscoveryListUpdateForID 

func (hc *HostCheckerManager) DoServiceDiscoveryListUpdateForID(apiID string)

func (*HostCheckerManager) GenerateCheckerId 

func (hc *HostCheckerManager) GenerateCheckerId()

func (*HostCheckerManager) HostDown 

func (hc *HostCheckerManager) HostDown(urlStr string) bool

func (*HostCheckerManager) Init 

func (hc *HostCheckerManager) Init(store storage.Handler)

func (*HostCheckerManager) ListFromService 

func (hc *HostCheckerManager) ListFromService(apiID string) ([]HostData, error)

func (*HostCheckerManager) OnHostBackUp 

func (hc *HostCheckerManager) OnHostBackUp(report HostHealthReport)

func (*HostCheckerManager) OnHostDown 

func (hc *HostCheckerManager) OnHostDown(report HostHealthReport)

func (*HostCheckerManager) OnHostReport 

func (hc *HostCheckerManager) OnHostReport(report HostHealthReport)

func (*HostCheckerManager) PrepareTrackingHost 

func (hc *HostCheckerManager) PrepareTrackingHost(checkObject apidef.HostCheckObject, apiID string) (HostData, error)

func (*HostCheckerManager) RecordUptimeAnalytics 

func (hc *HostCheckerManager) RecordUptimeAnalytics(report HostHealthReport) error

RecordHit will store an AnalyticsRecord in Redis

func (*HostCheckerManager) Start 

func (hc *HostCheckerManager) Start()

func (*HostCheckerManager) StartPoller 

func (hc *HostCheckerManager) StartPoller()

func (*HostCheckerManager) StopPoller 

func (hc *HostCheckerManager) StopPoller()

func (*HostCheckerManager) UpdateTrackingList 

func (hc *HostCheckerManager) UpdateTrackingList(hd []HostData)

func (*HostCheckerManager) UpdateTrackingListByAPIID 

func (hc *HostCheckerManager) UpdateTrackingListByAPIID(hd []HostData, apiId string)

func (*HostCheckerManager) UptimePurgeLoop 

func (hc *HostCheckerManager) UptimePurgeLoop()

type HostData 

type HostData struct {
	CheckURL string
	Method   string
	Headers  map[string]string
	Body     string
	MetaData map[string]string
}

type HostHealthReport 

type HostHealthReport struct {
	HostData
	ResponseCode int
	Latency      float64
	IsTCPError   bool
}

type HostUptimeChecker 

type HostUptimeChecker struct {
	HostList map[string]HostData
	// contains filtered or unexported fields
}

func (*HostUptimeChecker) CheckHost 

func (h *HostUptimeChecker) CheckHost(toCheck HostData)

func (*HostUptimeChecker) HostCheckLoop 

func (h *HostUptimeChecker) HostCheckLoop()

func (*HostUptimeChecker) HostReporter 

func (h *HostUptimeChecker) HostReporter()

func (*HostUptimeChecker) Init 

func (h *HostUptimeChecker) Init(workers, triggerLimit, timeout int, hostList map[string]HostData, failureCallback func(HostHealthReport), upCallback func(HostHealthReport), pingCallback func(HostHealthReport))

func (*HostUptimeChecker) ResetList 

func (h *HostUptimeChecker) ResetList(hostList map[string]HostData)

func (*HostUptimeChecker) Start 

func (h *HostUptimeChecker) Start()

func (*HostUptimeChecker) Stop 

func (h *HostUptimeChecker) Stop()

type IPBlackListMiddleware 

type IPBlackListMiddleware struct {
	BaseMiddleware
}

IPBlackListMiddleware lets you define a list of IPs to block from upstream

func (*IPBlackListMiddleware) EnabledForSpec 

func (i *IPBlackListMiddleware) EnabledForSpec() bool

func (*IPBlackListMiddleware) Name 

func (i *IPBlackListMiddleware) Name() string

func (*IPBlackListMiddleware) ProcessRequest 

func (i *IPBlackListMiddleware) ProcessRequest(w http.ResponseWriter, r *http.Request, _ interface{}) (error, int)

ProcessRequest will run any checks on the request on the way through the system, return an error to have the chain fail

type IPWhiteListMiddleware 

type IPWhiteListMiddleware struct {
	BaseMiddleware
}

IPWhiteListMiddleware lets you define a list of IPs to allow upstream

func (*IPWhiteListMiddleware) EnabledForSpec 

func (i *IPWhiteListMiddleware) EnabledForSpec() bool

func (*IPWhiteListMiddleware) Name 

func (i *IPWhiteListMiddleware) Name() string

func (*IPWhiteListMiddleware) ProcessRequest 

func (i *IPWhiteListMiddleware) ProcessRequest(w http.ResponseWriter, r *http.Request, _ interface{}) (error, int)

ProcessRequest will run any checks on the request on the way through the system, return an error to have the chain fail

type IdExtractor 

type IdExtractor interface {
	ExtractAndCheck(*http.Request) (string, ReturnOverrides)
	GenerateSessionID(string, BaseMiddleware) string
}

IdExtractor is the base interface for an ID extractor.

type InboundData 

type InboundData struct {
	KeyName      string
	Value        string
	SessionState string
	Timeout      int64
	Per          int64
	Expire       int64
}

type InterfaceNotification 

type InterfaceNotification struct {
	Type      string
	Message   string
	OrgID     string
	Timestamp time.Time
}

type JSVM 

type JSVM struct {
	Spec    *APISpec
	VM      *otto.Otto
	Timeout time.Duration
	Log     *logrus.Entry  // logger used by the JS code
	RawLog  *logrus.Logger // logger used by `rawlog` func to avoid formatting
}

func (*JSVM) Init 

func (j *JSVM) Init(spec *APISpec, logger *logrus.Entry)

Init creates the JSVM with the core library and sets up a default timeout.

func (*JSVM) LoadJSPaths 

func (j *JSVM) LoadJSPaths(paths []string, prefix string)

LoadJSPaths will load JS classes and functionality in to the VM by file

func (*JSVM) LoadTykJSApi 

func (j *JSVM) LoadTykJSApi()

type JSVMContextGlobal 

type JSVMContextGlobal struct {
	APIID string
	OrgID string
}

type JSVMEventHandler 

type JSVMEventHandler struct {
	Spec     *APISpec
	SpecJSON string
	// contains filtered or unexported fields
}

JSVMEventHandler is a scriptable event handler

func (*JSVMEventHandler) HandleEvent 

func (l *JSVMEventHandler) HandleEvent(em config.EventMessage)

HandleEvent will be fired when the event handler instance is found in an APISpec EventPaths object during a request chain

func (*JSVMEventHandler) Init 

func (l *JSVMEventHandler) Init(handlerConf interface{}) error

New enables the intitialisation of event handler instances when they are created on ApiSpec creation

type JWK 

type JWK struct {
	Alg string   `json:"alg"`
	Kty string   `json:"kty"`
	Use string   `json:"use"`
	X5c []string `json:"x5c"`
	N   string   `json:"n"`
	E   string   `json:"e"`
	KID string   `json:"kid"`
	X5t string   `json:"x5t"`
}

type JWKs 

type JWKs struct {
	Keys []JWK `json:"keys"`
}

type JWTDefinition 

type JWTDefinition struct {
	AppName      string   `json:"app_name"`
	AppNameList  []string `json:"app_name_list"`
	JWTPublicKey string   `json:"jwt_public_key"`
	JWTAPIKey    string   `json:"jwt_api_key"`
}

JWTDefinitions to store JWTDefinition

type JWTMiddleware 

type JWTMiddleware struct {
	BaseMiddleware
}

func (*JWTMiddleware) EnabledForSpec 

func (k *JWTMiddleware) EnabledForSpec() bool

func (*JWTMiddleware) Name 

func (k *JWTMiddleware) Name() string

func (*JWTMiddleware) ProcessRequest 

func (k *JWTMiddleware) ProcessRequest(w http.ResponseWriter, r *http.Request, _ interface{}) (error, int)

type KeyExpired 

type KeyExpired struct {
	BaseMiddleware
}

KeyExpired middleware will check if the requesting key is expired or not. It makes use of the authManager to do so.

func (*KeyExpired) Name 

func (k *KeyExpired) Name() string

func (*KeyExpired) ProcessRequest 

func (k *KeyExpired) ProcessRequest(w http.ResponseWriter, r *http.Request, _ interface{}) (error, int)

ProcessRequest will run any checks on the request on the way through the system, return an error to have the chain fail

type KeysValuesPair 

type KeysValuesPair struct {
	Keys   []string
	Values []string
}

type LDAPStorageHandler 

type LDAPStorageHandler struct {
	LDAPServer           string
	LDAPPort             uint16
	BaseDN               string
	Attributes           []string
	SessionAttributeName string
	SearchString         string
	// contains filtered or unexported fields
}

LDAPStorageHandler implements storage.Handler, this is a read-only implementation to access keys from an LDAP service

func (LDAPStorageHandler) AddToSet 

func (l LDAPStorageHandler) AddToSet(keyName, value string)

func (LDAPStorageHandler) AddToSortedSet 

func (l LDAPStorageHandler) AddToSortedSet(keyName, value string, score float64)

func (LDAPStorageHandler) AppendToSet 

func (l LDAPStorageHandler) AppendToSet(keyName, value string)

func (*LDAPStorageHandler) AppendToSetPipelined 

func (r *LDAPStorageHandler) AppendToSetPipelined(key string, values []string)

func (*LDAPStorageHandler) Connect 

func (l *LDAPStorageHandler) Connect() bool

func (*LDAPStorageHandler) Decrement 

func (l *LDAPStorageHandler) Decrement(keyName string)

func (*LDAPStorageHandler) DeleteKey 

func (l *LDAPStorageHandler) DeleteKey(cn string) bool

func (*LDAPStorageHandler) DeleteKeys 

func (l *LDAPStorageHandler) DeleteKeys(keys []string) bool

func (*LDAPStorageHandler) DeleteRawKey 

func (l *LDAPStorageHandler) DeleteRawKey(cn string) bool

func (LDAPStorageHandler) DeleteScanMatch 

func (l LDAPStorageHandler) DeleteScanMatch(pattern string) bool

func (LDAPStorageHandler) GetAndDeleteSet 

func (l LDAPStorageHandler) GetAndDeleteSet(keyName string) []interface{}

func (*LDAPStorageHandler) GetExp 

func (l *LDAPStorageHandler) GetExp(cn string) (int64, error)

func (*LDAPStorageHandler) GetKey 

func (l *LDAPStorageHandler) GetKey(filter string) (string, error)

func (LDAPStorageHandler) GetKeyPrefix 

func (l LDAPStorageHandler) GetKeyPrefix() string

func (*LDAPStorageHandler) GetKeys 

func (l *LDAPStorageHandler) GetKeys(filter string) []string

func (*LDAPStorageHandler) GetKeysAndValues 

func (l *LDAPStorageHandler) GetKeysAndValues() map[string]string

func (*LDAPStorageHandler) GetKeysAndValuesWithFilter 

func (l *LDAPStorageHandler) GetKeysAndValuesWithFilter(filter string) map[string]string

func (*LDAPStorageHandler) GetRawKey 

func (l *LDAPStorageHandler) GetRawKey(filter string) (string, error)

func (*LDAPStorageHandler) GetRollingWindow 

func (l *LDAPStorageHandler) GetRollingWindow(keyName string, per int64, pipeline bool) (int, []interface{})

func (LDAPStorageHandler) GetSet 

func (l LDAPStorageHandler) GetSet(keyName string) (map[string]string, error)

func (LDAPStorageHandler) GetSortedSetRange 

func (l LDAPStorageHandler) GetSortedSetRange(keyName, scoreFrom, scoreTo string) ([]string, []float64, error)

func (*LDAPStorageHandler) IncrememntWithExpire 

func (l *LDAPStorageHandler) IncrememntWithExpire(keyName string, timeout int64) int64

func (*LDAPStorageHandler) LoadConfFromMeta 

func (l *LDAPStorageHandler) LoadConfFromMeta(meta map[string]interface{})

func (LDAPStorageHandler) RemoveFromSet 

func (l LDAPStorageHandler) RemoveFromSet(keyName, value string)

func (LDAPStorageHandler) RemoveSortedSetRange 

func (l LDAPStorageHandler) RemoveSortedSetRange(keyName, scoreFrom, scoreTo string) error

func (*LDAPStorageHandler) SetExp 

func (l *LDAPStorageHandler) SetExp(cn string, exp int64) error

func (*LDAPStorageHandler) SetKey 

func (l *LDAPStorageHandler) SetKey(cn, session string, timeout int64) error

func (*LDAPStorageHandler) SetRawKey 

func (l *LDAPStorageHandler) SetRawKey(cn, session string, timeout int64) error

func (*LDAPStorageHandler) SetRollingWindow 

func (l *LDAPStorageHandler) SetRollingWindow(keyName string, per int64, val string, pipeline bool) (int, []interface{})

type LE_ServerInfo 

type LE_ServerInfo struct {
	HostName string
	ID       string
}

type LoadBalancingConfigData 

type LoadBalancingConfigData struct {
	CheckList []HostCheckObject `json:"check_list"`
	Config    struct {
		ExpireUptimeAnalyticsAfter int64                         `json:"expire_utime_after"`
		ServiceDiscovery           ServiceDiscoveryConfiguration `json:"service_discovery"`
		RecheckWait                int                           `json:"recheck_wait"`
	}
}

type LogMessageEventHandler 

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

LogMessageEventHandler is a sample Event Handler

func (*LogMessageEventHandler) HandleEvent 

func (l *LogMessageEventHandler) HandleEvent(em config.EventMessage)

HandleEvent will be fired when the event handler instance is found in an APISpec EventPaths object during a request chain

func (*LogMessageEventHandler) Init 

func (l *LogMessageEventHandler) Init(handlerConf interface{}) error

New enables the intitialisation of event handler instances when they are created on ApiSpec creation

type MethodNotAllowedHandler 

type MethodNotAllowedHandler struct{}

func (MethodNotAllowedHandler) ServeHTTP 

func (m MethodNotAllowedHandler) ServeHTTP(w http.ResponseWriter, r *http.Request)

type MiddlewareContextVars 

type MiddlewareContextVars struct {
	BaseMiddleware
}

func (*MiddlewareContextVars) EnabledForSpec 

func (m *MiddlewareContextVars) EnabledForSpec() bool

func (*MiddlewareContextVars) Name 

func (m *MiddlewareContextVars) Name() string

func (*MiddlewareContextVars) ProcessRequest 

func (m *MiddlewareContextVars) ProcessRequest(w http.ResponseWriter, r *http.Request, _ interface{}) (error, int)

ProcessRequest will run any checks on the request on the way through the system, return an error to have the chain fail

type MiniRequestObject 

type MiniRequestObject struct {
	Headers         map[string][]string
	SetHeaders      map[string]string
	DeleteHeaders   []string
	Body            []byte
	URL             string
	Params          map[string][]string
	AddParams       map[string]string
	ExtendedParams  map[string][]string
	DeleteParams    []string
	ReturnOverrides ReturnOverrides
	IgnoreBody      bool
	Method          string
	RequestURI      string
	Scheme          string
}

MiniRequestObject is marshalled to JSON string and passed into JSON middleware

type Monitor 

type Monitor struct{}

func (Monitor) Check 

func (m Monitor) Check(sessionData *user.SessionState, key string)

func (Monitor) Enabled 

func (Monitor) Enabled() bool

func (Monitor) Fire 

func (Monitor) Fire(sessionData *user.SessionState, key string, triggerLimit, usagePercentage float64)

type MultiTargetProxy 

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

func NewMultiTargetProxy 

func NewMultiTargetProxy(spec *APISpec) *MultiTargetProxy

func (*MultiTargetProxy) CopyResponse 

func (m *MultiTargetProxy) CopyResponse(dst io.Writer, src io.Reader)

func (*MultiTargetProxy) ServeHTTP 

func (m *MultiTargetProxy) ServeHTTP(w http.ResponseWriter, r *http.Request) *http.Response

func (*MultiTargetProxy) ServeHTTPForCache 

func (m *MultiTargetProxy) ServeHTTPForCache(w http.ResponseWriter, r *http.Request) *http.Response

type NewClientRequest 

type NewClientRequest struct {
	ClientID          string      `json:"client_id"`
	ClientRedirectURI string      `json:"redirect_uri"`
	APIID             string      `json:"api_id,omitempty"`
	PolicyID          string      `json:"policy_id,omitempty"`
	ClientSecret      string      `json:"secret"`
	MetaData          interface{} `json:"meta_data"`
	Description       string      `json:"description"`
}

NewClientRequest is an outward facing JSON object translated from osin OAuthClients

swagger:model NewClientRequest

type NewOAuthNotification 

type NewOAuthNotification struct {
	AuthCode         string                `json:"auth_code"`
	NewOAuthToken    string                `json:"new_oauth_token"`
	RefreshToken     string                `json:"refresh_token"`
	OldRefreshToken  string                `json:"old_refresh_token"`
	NotificationType OAuthNotificationType `json:"notification_type"`
}

NewOAuthNotification is a notification sent to a web-hook when an access request or a refresh request comes in.

type NodeResponseOK 

type NodeResponseOK struct {
	Status  string
	Message map[string]string
	Nonce   string
}

type Notification 

type Notification struct {
	Command   NotificationCommand `json:"command"`
	Payload   string              `json:"payload"`
	Signature string              `json:"signature"`
}

Notification is a type that encodes a message published to a pub sub channel (shared between implementations)

type NotificationCommand 

type NotificationCommand string
const (
	RedisPubSubChannel = "tyk.cluster.notifications"

	NoticeApiUpdated             NotificationCommand = "ApiUpdated"
	NoticeApiRemoved             NotificationCommand = "ApiRemoved"
	NoticeApiAdded               NotificationCommand = "ApiAdded"
	NoticeGroupReload            NotificationCommand = "GroupReload"
	NoticePolicyChanged          NotificationCommand = "PolicyChanged"
	NoticeConfigUpdate           NotificationCommand = "NoticeConfigUpdated"
	NoticeDashboardZeroConf      NotificationCommand = "NoticeDashboardZeroConf"
	NoticeDashboardConfigRequest NotificationCommand = "NoticeDashboardConfigRequest"
	NoticeGatewayConfigResponse  NotificationCommand = "NoticeGatewayConfigResponse"
	NoticeGatewayDRLNotification NotificationCommand = "NoticeGatewayDRLNotification"
	NoticeGatewayLENotification  NotificationCommand = "NoticeGatewayLENotification"
	KeySpaceUpdateNotification   NotificationCommand = "KeySpaceUpdateNotification"
)

type OAuthClient 

type OAuthClient struct {
	ClientID          string      `json:"id"`
	ClientSecret      string      `json:"secret"`
	ClientRedirectURI string      `json:"redirecturi"`
	MetaData          interface{} `json:"meta_data,omitempty"`
	PolicyID          string      `json:"policyid"`
	Description       string      `json:"description"`
}

OAuthClient is a representation within an APISpec of a client

func (*OAuthClient) GetDescription 

func (oc *OAuthClient) GetDescription() string

func (*OAuthClient) GetId 

func (oc *OAuthClient) GetId() string

func (*OAuthClient) GetPolicyID 

func (oc *OAuthClient) GetPolicyID() string

func (*OAuthClient) GetRedirectUri 

func (oc *OAuthClient) GetRedirectUri() string

func (*OAuthClient) GetSecret 

func (oc *OAuthClient) GetSecret() string

func (*OAuthClient) GetUserData 

func (oc *OAuthClient) GetUserData() interface{}

type OAuthClientToken 

type OAuthClientToken struct {
	Token   string `json:"code"`
	Expires int64  `json:"expires"`
}

swagger:model

type OAuthHandlers 

type OAuthHandlers struct {
	Manager OAuthManager
}

OAuthHandlers are the HTTP Handlers that manage the Tyk OAuth flow

func (*OAuthHandlers) HandleAccessRequest 

func (o *OAuthHandlers) HandleAccessRequest(w http.ResponseWriter, r *http.Request)

HandleAccessRequest handles the OAuth 2.0 token or refresh access request, and wraps Tyk's own and Osin's OAuth handlers, returns a response to the client and notifies the provider of the access request (in order to track identity against OAuth tokens without revealing tokens before they are requested).

func (*OAuthHandlers) HandleAuthorizePassthrough 

func (o *OAuthHandlers) HandleAuthorizePassthrough(w http.ResponseWriter, r *http.Request)

HandleAuthorizePassthrough handles a Client Auth request, first it checks if the client is OK (otherwise it blocks the request), then it forwards on to the resource providers approval URI

func (*OAuthHandlers) HandleGenerateAuthCodeData 

func (o *OAuthHandlers) HandleGenerateAuthCodeData(w http.ResponseWriter, r *http.Request)

HandleGenerateAuthCodeData handles a resource provider approving an OAuth request from a client

type OAuthManager 

type OAuthManager struct {
	API        *APISpec
	OsinServer *TykOsinServer
}

OAuthManager handles and wraps osin OAuth2 functions to handle authorise and access requests

func (*OAuthManager) HandleAccess 

func (o *OAuthManager) HandleAccess(r *http.Request) *osin.Response

HandleAccess wraps an access request with osin's primitives

func (*OAuthManager) HandleAuthorisation 

func (o *OAuthManager) HandleAuthorisation(r *http.Request, complete bool, session string) *osin.Response

HandleAuthorisation creates the authorisation data for the request

type OAuthNotificationType 

type OAuthNotificationType string

OAuthNotificationType const to reduce risk of collisions

type Oauth2KeyExists 

type Oauth2KeyExists struct {
	BaseMiddleware
}

Oauth2KeyExists will check if the key being used to access the API is in the request data, and then if the key is in the storage engine

func (*Oauth2KeyExists) EnabledForSpec 

func (k *Oauth2KeyExists) EnabledForSpec() bool

func (*Oauth2KeyExists) Name 

func (k *Oauth2KeyExists) Name() string

func (*Oauth2KeyExists) ProcessRequest 

func (k *Oauth2KeyExists) ProcessRequest(w http.ResponseWriter, r *http.Request, _ interface{}) (error, int)

ProcessRequest will run any checks on the request on the way through the system, return an error to have the chain fail

type OpenIDMW 

type OpenIDMW struct {
	BaseMiddleware
	// contains filtered or unexported fields
}

func (*OpenIDMW) EnabledForSpec 

func (k *OpenIDMW) EnabledForSpec() bool

func (*OpenIDMW) Init 

func (k *OpenIDMW) Init()

func (*OpenIDMW) Name 

func (k *OpenIDMW) Name() string

func (*OpenIDMW) ProcessRequest 

func (k *OpenIDMW) ProcessRequest(w http.ResponseWriter, r *http.Request, _ interface{}) (error, int)

type OrganizationMonitor 

type OrganizationMonitor struct {
	BaseMiddleware
	// contains filtered or unexported fields
}

RateLimitAndQuotaCheck will check the incoming request and key whether it is within it's quota and within it's rate limit, it makes use of the SessionLimiter object to do this

func (*OrganizationMonitor) AllowAccessNext 

func (k *OrganizationMonitor) AllowAccessNext(
	orgChan chan bool,
	path string,
	IP string,
	r *http.Request,
	session *user.SessionState)

func (*OrganizationMonitor) EnabledForSpec 

func (k *OrganizationMonitor) EnabledForSpec() bool

func (*OrganizationMonitor) Name 

func (k *OrganizationMonitor) Name() string

func (*OrganizationMonitor) ProcessRequest 

func (k *OrganizationMonitor) ProcessRequest(w http.ResponseWriter, r *http.Request, conf interface{}) (error, int)

func (*OrganizationMonitor) ProcessRequestLive 

func (k *OrganizationMonitor) ProcessRequestLive(r *http.Request, orgSession user.SessionState) (error, int)

ProcessRequest will run any checks on the request on the way through the system, return an error to have the chain fail

func (*OrganizationMonitor) ProcessRequestOffThread 

func (k *OrganizationMonitor) ProcessRequestOffThread(r *http.Request, orgSession user.SessionState) (error, int)

func (*OrganizationMonitor) SetOrgSentinel 

func (k *OrganizationMonitor) SetOrgSentinel(orgChan chan bool, orgId string)

type PolicyUpdateObj 

type PolicyUpdateObj struct {
	Policy string `json:"policy"`
}

type Post 

type Post struct {
	Name           string `json:"name"`
	Path           string `json:"path"`
	RequireSession bool   `json:"require_session"`
}

type PublicSession 

type PublicSession struct {
	Quota struct {
		QuotaMax       int64 `json:"quota_max"`
		QuotaRemaining int64 `json:"quota_remaining"`
		QuotaRenews    int64 `json:"quota_renews"`
	} `json:"quota"`
	RateLimit struct {
		Rate float64 `json:"requests"`
		Per  float64 `json:"per_unit"`
	} `json:"rate_limit"`
}

type Purger 

type Purger interface {
	PurgeCache()
	PurgeLoop(<-chan time.Time)
}

Purger is an interface that will define how the in-memory store will be purged of analytics data to prevent it growing too large

type PythonMiddlewareConfigData 

type PythonMiddlewareConfigData struct {
	InjectK8sAuthHeader bool   `json:"inject_k8s_auth_header"`
	InjectJwtHeader     bool   `json:"inject_jwt_headers"`
	K8sAuthTokenPath    string `json:"k8s_auth_token_path"`
	InjectSecureToken   bool   `json:"inject_secure_token"`
	SecureTokenPath     string `json:"secure_token_path"`
}

Middleware config data

type RPCStorageHandler 

type RPCStorageHandler struct {
	KeyPrefix        string
	HashKeys         bool
	SuppressRegister bool
}

RPCStorageHandler is a storage manager that uses the redis database.

func (RPCStorageHandler) AddToSet 

func (r RPCStorageHandler) AddToSet(keyName, value string)

func (*RPCStorageHandler) AddToSortedSet 

func (r *RPCStorageHandler) AddToSortedSet(keyName, value string, score float64)

func (*RPCStorageHandler) AppendToSet 

func (r *RPCStorageHandler) AppendToSet(keyName, value string)

func (*RPCStorageHandler) AppendToSetPipelined 

func (r *RPCStorageHandler) AppendToSetPipelined(key string, values []string)

func (*RPCStorageHandler) CheckForKeyspaceChanges 

func (r *RPCStorageHandler) CheckForKeyspaceChanges(orgId string)

CheckForKeyspaceChanges will poll for keysace changes

func (*RPCStorageHandler) CheckForReload 

func (r *RPCStorageHandler) CheckForReload(orgId string)

CheckForReload will start a long poll

func (*RPCStorageHandler) Connect 

func (r *RPCStorageHandler) Connect() bool

Connect will establish a connection to the RPC

func (*RPCStorageHandler) Decrement 

func (r *RPCStorageHandler) Decrement(keyName string)

Decrement will decrement a key in redis

func (*RPCStorageHandler) DeleteKey 

func (r *RPCStorageHandler) DeleteKey(keyName string) bool

DeleteKey will remove a key from the database

func (*RPCStorageHandler) DeleteKeys 

func (r *RPCStorageHandler) DeleteKeys(keys []string) bool

DeleteKeys will remove a group of keys in bulk

func (*RPCStorageHandler) DeleteRawKey 

func (r *RPCStorageHandler) DeleteRawKey(keyName string) bool

DeleteKey will remove a key from the database without prefixing, assumes user knows what they are doing

func (*RPCStorageHandler) DeleteScanMatch 

func (r *RPCStorageHandler) DeleteScanMatch(pattern string) bool

func (*RPCStorageHandler) GetAndDeleteSet 

func (r *RPCStorageHandler) GetAndDeleteSet(keyName string) []interface{}

func (*RPCStorageHandler) GetApiDefinitions 

func (r *RPCStorageHandler) GetApiDefinitions(orgId string, tags []string) string

GetAPIDefinitions will pull API definitions from the RPC server

func (*RPCStorageHandler) GetExp 

func (r *RPCStorageHandler) GetExp(keyName string) (int64, error)

func (*RPCStorageHandler) GetKey 

func (r *RPCStorageHandler) GetKey(keyName string) (string, error)

GetKey will retrieve a key from the database

func (*RPCStorageHandler) GetKeyPrefix 

func (r *RPCStorageHandler) GetKeyPrefix() string

func (*RPCStorageHandler) GetKeys 

func (r *RPCStorageHandler) GetKeys(filter string) []string

GetKeys will return all keys according to the filter (filter is a prefix - e.g. tyk.keys.*)

func (*RPCStorageHandler) GetKeysAndValues 

func (r *RPCStorageHandler) GetKeysAndValues() map[string]string

GetKeysAndValues will return all keys and their values - not to be used lightly

func (*RPCStorageHandler) GetKeysAndValuesWithFilter 

func (r *RPCStorageHandler) GetKeysAndValuesWithFilter(filter string) map[string]string

GetKeysAndValuesWithFilter will return all keys and their values with a filter

func (*RPCStorageHandler) GetPolicies 

func (r *RPCStorageHandler) GetPolicies(orgId string) string

GetPolicies will pull Policies from the RPC server

func (*RPCStorageHandler) GetRawKey 

func (r *RPCStorageHandler) GetRawKey(keyName string) (string, error)

func (*RPCStorageHandler) GetRollingWindow 

func (r *RPCStorageHandler) GetRollingWindow(keyName string, per int64, pipeline bool) (int, []interface{})

func (RPCStorageHandler) GetSet 

func (r RPCStorageHandler) GetSet(keyName string) (map[string]string, error)

func (*RPCStorageHandler) GetSortedSetRange 

func (r *RPCStorageHandler) GetSortedSetRange(keyName, scoreFrom, scoreTo string) ([]string, []float64, error)

func (*RPCStorageHandler) IncrememntWithExpire 

func (r *RPCStorageHandler) IncrememntWithExpire(keyName string, expire int64) int64

IncrementWithExpire will increment a key in redis

func (RPCStorageHandler) IsAccessError 

func (r RPCStorageHandler) IsAccessError(err error) bool

func (*RPCStorageHandler) ProcessKeySpaceChanges 

func (r *RPCStorageHandler) ProcessKeySpaceChanges(keys []string)

func (*RPCStorageHandler) Publish 

func (r *RPCStorageHandler) Publish(channel, message string) error

func (RPCStorageHandler) RemoveFromSet 

func (r RPCStorageHandler) RemoveFromSet(keyName, value string)

func (*RPCStorageHandler) RemoveSortedSetRange 

func (r *RPCStorageHandler) RemoveSortedSetRange(keyName, scoreFrom, scoreTo string) error

func (*RPCStorageHandler) SetExp 

func (r *RPCStorageHandler) SetExp(keyName string, timeout int64) error

func (*RPCStorageHandler) SetKey 

func (r *RPCStorageHandler) SetKey(keyName, session string, timeout int64) error

SetKey will create (or update) a key value in the store

func (*RPCStorageHandler) SetRawKey 

func (r *RPCStorageHandler) SetRawKey(keyName, session string, timeout int64) error

func (*RPCStorageHandler) SetRollingWindow 

func (r *RPCStorageHandler) SetRollingWindow(keyName string, per int64, val string, pipeline bool) (int, []interface{})

SetScrollingWindow is used in the rate limiter to handle rate limits fairly.

func (*RPCStorageHandler) StartPubSubHandler 

func (r *RPCStorageHandler) StartPubSubHandler(channel string, callback func(redis.Message)) error

StartPubSubHandler will listen for a signal and run the callback with the message

func (*RPCStorageHandler) StartRPCKeepaliveWatcher 

func (r *RPCStorageHandler) StartRPCKeepaliveWatcher()

func (*RPCStorageHandler) StartRPCLoopCheck 

func (r *RPCStorageHandler) StartRPCLoopCheck(orgId string)

type RateCheckMW 

type RateCheckMW struct {
	BaseMiddleware
}

func (*RateCheckMW) Name 

func (m *RateCheckMW) Name() string

func (*RateCheckMW) ProcessRequest 

func (m *RateCheckMW) ProcessRequest(w http.ResponseWriter, r *http.Request, _ interface{}) (error, int)

type RateLimitAndQuotaCheck 

type RateLimitAndQuotaCheck struct {
	BaseMiddleware
}

RateLimitAndQuotaCheck will check the incomming request and key whether it is within it's quota and within it's rate limit, it makes use of the SessionLimiter object to do this

func (*RateLimitAndQuotaCheck) EnabledForSpec 

func (k *RateLimitAndQuotaCheck) EnabledForSpec() bool

func (*RateLimitAndQuotaCheck) Name 

func (k *RateLimitAndQuotaCheck) Name() string

func (*RateLimitAndQuotaCheck) ProcessRequest 

func (k *RateLimitAndQuotaCheck) ProcessRequest(w http.ResponseWriter, r *http.Request, _ interface{}) (error, int)

ProcessRequest will run any checks on the request on the way through the system, return an error to have the chain fail

type RateLimitForAPI 

type RateLimitForAPI struct {
	BaseMiddleware
	// contains filtered or unexported fields
}

RateLimitAndQuotaCheck will check the incoming request and key whether it is within it's quota and within it's rate limit, it makes use of the SessionLimiter object to do this

func (*RateLimitForAPI) EnabledForSpec 

func (k *RateLimitForAPI) EnabledForSpec() bool

func (*RateLimitForAPI) Name 

func (k *RateLimitForAPI) Name() string

func (*RateLimitForAPI) ProcessRequest 

func (k *RateLimitForAPI) ProcessRequest(w http.ResponseWriter, r *http.Request, _ interface{}) (error, int)

ProcessRequest will run any checks on the request on the way through the system, return an error to have the chain fail

type RedisAnalyticsHandler 

type RedisAnalyticsHandler struct {
	Store   storage.Handler
	Clean   Purger
	GeoIPDB *maxminddb.Reader
	// contains filtered or unexported fields
}

RedisAnalyticsHandler will record analytics data to a redis back end as defined in the Config object

func (*RedisAnalyticsHandler) Init 

func (r *RedisAnalyticsHandler) Init(globalConf config.Config)

func (*RedisAnalyticsHandler) RecordHit 

func (r *RedisAnalyticsHandler) RecordHit(record *AnalyticsRecord) error

RecordHit will store an AnalyticsRecord in Redis

func (*RedisAnalyticsHandler) Stop 

func (r *RedisAnalyticsHandler) Stop()

type RedisCacheMiddleware 

type RedisCacheMiddleware struct {
	BaseMiddleware
	CacheStore storage.Handler
	// contains filtered or unexported fields
}

RedisCacheMiddleware is a caching middleware that will pull data from Redis instead of the upstream proxy

func (*RedisCacheMiddleware) CreateCheckSum 

func (m *RedisCacheMiddleware) CreateCheckSum(req *http.Request, keyName string, regex string) (string, error)

func (*RedisCacheMiddleware) EnabledForSpec 

func (m *RedisCacheMiddleware) EnabledForSpec() bool

func (*RedisCacheMiddleware) Init 

func (m *RedisCacheMiddleware) Init()

func (*RedisCacheMiddleware) Name 

func (m *RedisCacheMiddleware) Name() string

func (*RedisCacheMiddleware) ProcessRequest 

func (m *RedisCacheMiddleware) ProcessRequest(w http.ResponseWriter, r *http.Request, _ interface{}) (error, int)

ProcessRequest will run any checks on the request on the way through the system, return an error to have the chain fail

type RedisNotifier 

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

RedisNotifier will use redis pub/sub channels to send notifications

func (*RedisNotifier) Notify 

func (r *RedisNotifier) Notify(notif interface{}) bool

Notify will send a notification to a channel

type RedisOsinStorageInterface 

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

TODO: Refactor this to move prefix handling into a checker method, then it can be an unexported setting in the struct. RedisOsinStorageInterface implements osin.Storage interface to use Tyk's own storage mechanism

func (*RedisOsinStorageInterface) Clone 

func (r *RedisOsinStorageInterface) Clone() osin.Storage

func (*RedisOsinStorageInterface) Close 

func (r *RedisOsinStorageInterface) Close()

func (*RedisOsinStorageInterface) DeleteClient 

func (r *RedisOsinStorageInterface) DeleteClient(id string, ignorePrefix bool) error

DeleteClient Removes a client from the system

func (*RedisOsinStorageInterface) GetClient 

func (r *RedisOsinStorageInterface) GetClient(id string) (osin.Client, error)

GetClient will retrieve client data

func (*RedisOsinStorageInterface) GetClientNoPrefix 

func (r *RedisOsinStorageInterface) GetClientNoPrefix(id string) (osin.Client, error)

GetClientNoPrefix will retrieve client data, but not assign a prefix - this is an unfortunate hack, but we don't want to change the signature in Osin for GetClient to support the odd Redis prefixing

func (*RedisOsinStorageInterface) GetClientTokens 

func (r *RedisOsinStorageInterface) GetClientTokens(id string) ([]OAuthClientToken, error)

func (*RedisOsinStorageInterface) GetClients 

func (r *RedisOsinStorageInterface) GetClients(filter string, ignorePrefix bool) ([]ExtendedOsinClientInterface, error)

GetClients will retrieve a list of clients for a prefix

func (*RedisOsinStorageInterface) GetExtendedClient 

func (r *RedisOsinStorageInterface) GetExtendedClient(id string) (ExtendedOsinClientInterface, error)

func (*RedisOsinStorageInterface) GetExtendedClientNoPrefix 

func (r *RedisOsinStorageInterface) GetExtendedClientNoPrefix(id string) (ExtendedOsinClientInterface, error)

GetExtendedClientNoPrefix custom getter to handle prefixing issues in Redis,

func (*RedisOsinStorageInterface) GetPaginatedClientTokens 

func (r *RedisOsinStorageInterface) GetPaginatedClientTokens(id string, page int) ([]OAuthClientToken, int, error)

GetPaginatedClientTokens returns all tokens associated with the given id. It returns the tokens, the total number of pages of the tokens after pagination and an error if any

func (*RedisOsinStorageInterface) GetUser 

func (r *RedisOsinStorageInterface) GetUser(username string) (*user.SessionState, error)

LoadRefresh will load access data from Redis

func (*RedisOsinStorageInterface) LoadAccess 

func (r *RedisOsinStorageInterface) LoadAccess(token string) (*osin.AccessData, error)

LoadAccess will load access data from redis

func (*RedisOsinStorageInterface) LoadAuthorize 

func (r *RedisOsinStorageInterface) LoadAuthorize(code string) (*osin.AuthorizeData, error)

LoadAuthorize loads auth data from redis

func (*RedisOsinStorageInterface) LoadRefresh 

func (r *RedisOsinStorageInterface) LoadRefresh(token string) (*osin.AccessData, error)

LoadRefresh will load access data from Redis

func (*RedisOsinStorageInterface) RemoveAccess 

func (r *RedisOsinStorageInterface) RemoveAccess(token string) error

RemoveAccess will remove access data from Redis

func (*RedisOsinStorageInterface) RemoveAuthorize 

func (r *RedisOsinStorageInterface) RemoveAuthorize(code string) error

RemoveAuthorize removes authorisation keys from redis

func (*RedisOsinStorageInterface) RemoveRefresh 

func (r *RedisOsinStorageInterface) RemoveRefresh(token string) error

RemoveRefresh will remove a refresh token from redis

func (*RedisOsinStorageInterface) SaveAccess 

func (r *RedisOsinStorageInterface) SaveAccess(accessData *osin.AccessData) error

SaveAccess will save a token and it's access data to redis

func (*RedisOsinStorageInterface) SaveAuthorize 

func (r *RedisOsinStorageInterface) SaveAuthorize(authData *osin.AuthorizeData) error

SaveAuthorize saves authorisation data to Redis

func (*RedisOsinStorageInterface) SetClient 

func (r *RedisOsinStorageInterface) SetClient(id string, client osin.Client, ignorePrefix bool) error

SetClient creates client data

func (*RedisOsinStorageInterface) SetUser 

func (r *RedisOsinStorageInterface) SetUser(username string, session *user.SessionState, timeout int64) error

type RedisPurger 

type RedisPurger struct {
	Store storage.Handler
}

func (*RedisPurger) PurgeCache 

func (r *RedisPurger) PurgeCache()

func (RedisPurger) PurgeLoop 

func (r RedisPurger) PurgeLoop(ticker <-chan time.Time)

type RegexExtractor 

type RegexExtractor struct {
	BaseExtractor
	// contains filtered or unexported fields
}

func (*RegexExtractor) ExtractAndCheck 

func (e *RegexExtractor) ExtractAndCheck(r *http.Request) (SessionID string, returnOverrides ReturnOverrides)

type RegexExtractorConfig 

type RegexExtractorConfig struct {
	HeaderName      string `mapstructure:"header_name" bson:"header_name" json:"header_name"`
	RegexExpression string `mapstructure:"regex_expression" bson:"regex_expression" json:"regex_expression"`
	RegexMatchIndex int    `mapstructure:"regex_match_index" bson:"regex_match_index" json:"regex_match_index"`
	FormParamName   string `mapstructure:"param_name" bson:"param_name" json:"param_name"`
}

type RequestDefinition 

type RequestDefinition struct {
	Method      string            `json:"method"`
	Headers     map[string]string `json:"headers"`
	Body        string            `json:"body"`
	RelativeURL string            `json:"relative_url"`
}

RequestDefinition defines a batch request

type RequestObject 

type RequestObject struct {
	Headers map[string][]string
	Body    string
	URL     string
	Params  map[string][]string
	Scheme  string
}

RequestObject is marshalled to JSON string and passed into JSON middleware

type RequestSigning 

type RequestSigning struct {
	BaseMiddleware
}

func (*RequestSigning) EnabledForSpec 

func (s *RequestSigning) EnabledForSpec() bool

func (*RequestSigning) Name 

func (s *RequestSigning) Name() string

func (*RequestSigning) ProcessRequest 

func (s *RequestSigning) ProcessRequest(w http.ResponseWriter, r *http.Request, _ interface{}) (error, int)

type RequestSizeLimitMiddleware 

type RequestSizeLimitMiddleware struct {
	BaseMiddleware
}

TransformMiddleware is a middleware that will apply a template to a request body to transform it's contents ready for an upstream API

func (*RequestSizeLimitMiddleware) EnabledForSpec 

func (t *RequestSizeLimitMiddleware) EnabledForSpec() bool

func (*RequestSizeLimitMiddleware) Name 

func (t *RequestSizeLimitMiddleware) Name() string

func (*RequestSizeLimitMiddleware) ProcessRequest 

func (t *RequestSizeLimitMiddleware) ProcessRequest(w http.ResponseWriter, r *http.Request, _ interface{}) (error, int)

RequestSizeLimit will check a request for maximum request size, this can be a global limit or a matched limit.

type RequestStatus 

type RequestStatus string

RequestStatus is a custom type to avoid collisions 

const (
	VersionNotFound                RequestStatus = "Version information not found"
	VersionDoesNotExist            RequestStatus = "This API version does not seem to exist"
	VersionWhiteListStatusNotFound RequestStatus = "WhiteListStatus for path not found"
	VersionExpired                 RequestStatus = "Api Version has expired, please check documentation or contact administrator"
	EndPointNotAllowed             RequestStatus = "Requested endpoint is forbidden"
	StatusOkAndIgnore              RequestStatus = "Everything OK, passing and not filtering"
	StatusOk                       RequestStatus = "Everything OK, passing"
	StatusCached                   RequestStatus = "Cached path"
	StatusTransform                RequestStatus = "Transformed path"
	StatusTransformResponse        RequestStatus = "Transformed response"
	StatusTransformJQ              RequestStatus = "Transformed path with JQ"
	StatusTransformJQResponse      RequestStatus = "Transformed response with JQ"
	StatusHeaderInjected           RequestStatus = "Header injected"
	StatusMethodTransformed        RequestStatus = "Method Transformed"
	StatusHeaderInjectedResponse   RequestStatus = "Header injected on response"
	StatusRedirectFlowByReply      RequestStatus = "Exceptional action requested, redirecting flow!"
	StatusHardTimeout              RequestStatus = "Hard Timeout enforced on path"
	StatusCircuitBreaker           RequestStatus = "Circuit breaker enforced"
	StatusURLRewrite               RequestStatus = "URL Rewritten"
	StatusVirtualPath              RequestStatus = "Virtual Endpoint"
	StatusRequestSizeControlled    RequestStatus = "Request Size Limited"
	StatusRequestTracked           RequestStatus = "Request Tracked"
	StatusRequestNotTracked        RequestStatus = "Request Not Tracked"
	StatusValidateJSON             RequestStatus = "Validate JSON"
	StatusInternal                 RequestStatus = "Internal path"
)

Statuses of the request, all are false-y except StatusOk and StatusOkAndIgnore

type ResponseObject 

type ResponseObject struct {
	Body    string
	Headers map[string]string
	Code    int
}

type ResponseTransformJQMiddleware 

type ResponseTransformJQMiddleware struct {
	Spec *APISpec
}

func (*ResponseTransformJQMiddleware) HandleResponse 

func (h *ResponseTransformJQMiddleware) HandleResponse(rw http.ResponseWriter, res *http.Response, req *http.Request, ses *user.SessionState) error

func (*ResponseTransformJQMiddleware) Init 

func (h *ResponseTransformJQMiddleware) Init(c interface{}, spec *APISpec) error

func (ResponseTransformJQMiddleware) Name 

func (ResponseTransformJQMiddleware) Name() string

type ResponseTransformMiddleware 

type ResponseTransformMiddleware struct {
	Spec *APISpec
}

func (*ResponseTransformMiddleware) HandleResponse 

func (h *ResponseTransformMiddleware) HandleResponse(rw http.ResponseWriter, res *http.Response, req *http.Request, ses *user.SessionState) error

func (*ResponseTransformMiddleware) Init 

func (h *ResponseTransformMiddleware) Init(c interface{}, spec *APISpec) error

func (ResponseTransformMiddleware) Name 

func (ResponseTransformMiddleware) Name() string

type ReturnConfigPayload 

type ReturnConfigPayload struct {
	FromHostname  string
	FromNodeID    string
	Configuration map[string]interface{}
	TimeStamp     int64
}

type ReturnOverrides 

type ReturnOverrides struct {
	ResponseCode    int
	ResponseError   string
	ResponseHeaders map[string]string
}

Lets the user override and return a response from middleware

type ReturningHttpHandler 

type ReturningHttpHandler interface {
	ServeHTTP(http.ResponseWriter, *http.Request) *http.Response
	ServeHTTPForCache(http.ResponseWriter, *http.Request) *http.Response
	CopyResponse(io.Writer, io.Reader)
}

type RevProxyTransform 

type RevProxyTransform struct {
	Headers     []string // List of HTTP headers to be modified
	Target_host string   // Target host for reverse proxy
}

type ReverseProxy 

type ReverseProxy struct {
	// Director must be a function which modifies
	// the request into a new request to be sent
	// using Transport. Its response is then copied
	// back to the original client unmodified.
	Director func(*http.Request)

	// The transport used to perform proxy requests.
	// If nil, http.DefaultTransport is used.
	Transport http.RoundTripper

	// FlushInterval specifies the flush interval
	// to flush to the client while copying the
	// response body.
	// If zero, no periodic flushing is done.
	FlushInterval time.Duration

	// TLSClientConfig specifies the TLS configuration to use for 'wss'.
	// If nil, the default configuration is used.
	TLSClientConfig *tls.Config

	TykAPISpec   *APISpec
	ErrorHandler ErrorHandler
}

ReverseProxy is an HTTP Handler that takes an incoming request and sends it to another server, proxying the response back to the client.

func TykNewSingleHostReverseProxy 

func TykNewSingleHostReverseProxy(target *url.URL, spec *APISpec) *ReverseProxy

TykNewSingleHostReverseProxy returns a new ReverseProxy that rewrites URLs to the scheme, host, and base path provided in target. If the target's path is "/base" and the incoming request was for "/dir", the target request will be for /base/dir. This version modifies the stdlib version by also setting the host to the target, this allows us to work with heroku and other such providers

func (*ReverseProxy) CheckCircuitBreakerEnforced 

func (p *ReverseProxy) CheckCircuitBreakerEnforced(spec *APISpec, req *http.Request) (bool, *ExtendedCircuitBreakerMeta)

func (*ReverseProxy) CheckHardTimeoutEnforced 

func (p *ReverseProxy) CheckHardTimeoutEnforced(spec *APISpec, req *http.Request) (bool, float64)

func (*ReverseProxy) CheckHeaderInRemoveList 

func (p *ReverseProxy) CheckHeaderInRemoveList(hdr string, spec *APISpec, req *http.Request) bool

func (*ReverseProxy) CopyResponse 

func (p *ReverseProxy) CopyResponse(dst io.Writer, src io.Reader)

func (*ReverseProxy) HandleResponse 

func (p *ReverseProxy) HandleResponse(rw http.ResponseWriter, res *http.Response, ses *user.SessionState) error

func (*ReverseProxy) ServeHTTP 

func (p *ReverseProxy) ServeHTTP(rw http.ResponseWriter, req *http.Request) *http.Response

func (*ReverseProxy) ServeHTTPForCache 

func (p *ReverseProxy) ServeHTTPForCache(rw http.ResponseWriter, req *http.Request) *http.Response

func (*ReverseProxy) WrappedServeHTTP 

func (p *ReverseProxy) WrappedServeHTTP(rw http.ResponseWriter, req *http.Request, withCache bool) *http.Response

type RoundRobin 

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

func (*RoundRobin) WithLen 

func (r *RoundRobin) WithLen(len int) int

type ServiceAPIS 

type ServiceAPIS map[string][]APIDefinition

type ServiceDiscovery 

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

func (*ServiceDiscovery) Hostname 

func (s *ServiceDiscovery) Hostname(item *gabs.Container) string

func (*ServiceDiscovery) Init 

func (s *ServiceDiscovery) Init(spec *apidef.ServiceDiscoveryConfiguration)

func (*ServiceDiscovery) NestedObject 

func (s *ServiceDiscovery) NestedObject(item *gabs.Container) string

func (*ServiceDiscovery) Object 

func (s *ServiceDiscovery) Object(item *gabs.Container) string

func (*ServiceDiscovery) ParseObject 

func (s *ServiceDiscovery) ParseObject(contents string, jsonParsed *gabs.Container) error

func (*ServiceDiscovery) ProcessRawData 

func (s *ServiceDiscovery) ProcessRawData(rawData string) (*apidef.HostList, error)

func (*ServiceDiscovery) SubObject 

func (s *ServiceDiscovery) SubObject(obj *gabs.Container) string

func (*ServiceDiscovery) SubObjectFromList 

func (s *ServiceDiscovery) SubObjectFromList(objList *gabs.Container) []string

func (*ServiceDiscovery) Target 

func (s *ServiceDiscovery) Target(serviceURL string) (*apidef.HostList, error)

type ServiceDiscoveryConfiguration 

type ServiceDiscoveryConfiguration struct {
	UseDiscoveryService bool   `json:"use_discovery_service"`
	QueryEndpoint       string `json:"query_endpoint"`
	UseNestedQuery      bool   `json:"use_nested_query"`
	ParentDataPath      string `json:"parent_data_path"`
	DataPath            string `json:"data_path"`
	PortDataPath        string `json:"port_data_path"`
	TargetPath          string `json:"target_path"`
	UseTargetList       bool   `json:"use_target_list"`
	CacheTimeout        int64  `json:"cache_timeout"`
	EndpointReturnsList bool   `json:"endpoint_returns_list"`
}

type SessionHandler 

type SessionHandler interface {
	Init(store storage.Handler)
	UpdateSession(keyName string, session *user.SessionState, resetTTLTo int64, hashed bool) error
	RemoveSession(keyName string, hashed bool) bool
	SessionDetail(keyName string, hashed bool) (user.SessionState, bool)
	Sessions(filter string) []string
	Store() storage.Handler
	ResetQuota(string, *user.SessionState, bool)
	Stop()
}

SessionHandler handles all update/create/access session functions and deals exclusively with user.SessionState objects, not identity

type SessionLimiter 

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

SessionLimiter is the rate limiter for the API, use ForwardMessage() to check if a message should pass through or not

func (*SessionLimiter) ForwardMessage 

func (l *SessionLimiter) ForwardMessage(r *http.Request, currentSession *user.SessionState, key string, store storage.Handler, enableRL, enableQ bool, globalConf *config.Config, apiID string, dryRun bool) sessionFailReason

ForwardMessage will enforce rate limiting, returning a non-zero sessionFailReason if session limits have been exceeded. Key values to manage rate are Rate and Per, e.g. Rate of 10 messages Per 10 seconds

func (*SessionLimiter) RedisQuotaExceeded 

func (l *SessionLimiter) RedisQuotaExceeded(r *http.Request, currentSession *user.SessionState, key string, store storage.Handler, apiID string) bool

type SessionUpdate 

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

type StatsDSink 

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

func NewStatsDSink 

func NewStatsDSink(addr string, options *StatsDSinkOptions) (*StatsDSink, error)

func (*StatsDSink) Drain 

func (s *StatsDSink) Drain()

func (*StatsDSink) EmitComplete 

func (s *StatsDSink) EmitComplete(job string, status health.CompletionStatus, nanos int64, kvs map[string]string)

func (*StatsDSink) EmitEvent 

func (s *StatsDSink) EmitEvent(job, event string, kvs map[string]string)

func (*StatsDSink) EmitEventErr 

func (s *StatsDSink) EmitEventErr(job, event string, inputErr error, kvs map[string]string)

func (*StatsDSink) EmitGauge 

func (s *StatsDSink) EmitGauge(job, event string, value float64, kvs map[string]string)

func (*StatsDSink) EmitTiming 

func (s *StatsDSink) EmitTiming(job, event string, nanos int64, kvs map[string]string)

func (*StatsDSink) Stop 

func (s *StatsDSink) Stop()

type StatsDSinkOptions 

type StatsDSinkOptions struct {
	// Prefix is something like "metroid"
	// Events emitted to StatsD would be metroid.myevent.wat
	// Eg, don't include a trailing dot in the prefix.
	// It can be "", that's fine.
	Prefix string

	// SanitizationFunc sanitizes jobs and events before sending them to statsd
	SanitizationFunc StatsDSinkSanitizationFunc

	// SkipNestedEvents will skip {events,timers,gauges} from sending the job.event version
	// and will only send the event version.
	SkipNestedEvents bool

	// SkipTopLevelEvents will skip {events,timers,gauges} from sending the event version
	// and will only send the job.event version.
	SkipTopLevelEvents bool
}

type StatsDSinkSanitizationFunc 

type StatsDSinkSanitizationFunc func(*bytes.Buffer, string)

type StripAuth 

type StripAuth struct {
	BaseMiddleware
}

func (*StripAuth) EnabledForSpec 

func (sa *StripAuth) EnabledForSpec() bool

func (*StripAuth) Name 

func (sa *StripAuth) Name() string

func (*StripAuth) ProcessRequest 

func (sa *StripAuth) ProcessRequest(w http.ResponseWriter, r *http.Request, _ interface{}) (error, int)

type SuccessHandler 

type SuccessHandler struct {
	BaseMiddleware
}

SuccessHandler represents the final ServeHTTP() request for a proxied API request

func (*SuccessHandler) RecordHit 

func (s *SuccessHandler) RecordHit(r *http.Request, timing int64, code int, responseCopy *http.Response)

func (*SuccessHandler) ServeHTTP 

func (s *SuccessHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) *http.Response

ServeHTTP will store the request details in the analytics store if necessary and proxy the request to it's final destination, this is invoked by the ProxyHandler or right at the start of a request chain if the URL Spec states the path is Ignored

func (*SuccessHandler) ServeHTTPWithCache 

func (s *SuccessHandler) ServeHTTPWithCache(w http.ResponseWriter, r *http.Request) *http.Response

ServeHTTPWithCache will store the request details in the analytics store if necessary and proxy the request to it's final destination, this is invoked by the ProxyHandler or right at the start of a request chain if the URL Spec states the path is Ignored Itwill also return a response object for the cache

type Test 

type Test struct {
	URL string

	GlobalConfig config.Config
	// contains filtered or unexported fields
}

func StartTest 

func StartTest(config ...TestConfig) Test

func (*Test) Close 

func (s *Test) Close()

func (*Test) CreateSession 

func (s *Test) CreateSession(sGen ...func(s *user.SessionState)) (*user.SessionState, string)

func (*Test) Do 

func (s *Test) Do(tc test.TestCase) (*http.Response, error)

func (*Test) Run 

func (s *Test) Run(t testing.TB, testCases ...test.TestCase) (*http.Response, error)

func (*Test) RunExt 

func (s *Test) RunExt(t testing.TB, testCases ...test.TestCase)

func (*Test) Start 

func (s *Test) Start()

type TestConfig 

type TestConfig struct {
	Delay     time.Duration
	HotReload bool

	CoprocessConfig config.CoProcessConfig
	// contains filtered or unexported fields
}

type TestHttpResponse 

type TestHttpResponse struct {
	Method  string
	URI     string
	Url     string
	Body    string
	Headers map[string]string
	Form    map[string]string
}

type TokenAccessRights 

type TokenAccessRights struct {
	APIID       string   `json:"api_id"`
	APIName     string   `json:"api_name"`
	Versions    []string `json:"versions"`
	AllowedURLS []string `json:"allowed_urls"`
	Limit       *string  `json:"limit"`
}

TokenAccessRights to store token api access rights

type TraceMiddleware 

type TraceMiddleware struct {
	TykMiddleware
}

func (TraceMiddleware) ProcessRequest 

func (tr TraceMiddleware) ProcessRequest(w http.ResponseWriter, r *http.Request, conf interface{}) (error, int)

type TrackEndpointMiddleware 

type TrackEndpointMiddleware struct {
	BaseMiddleware
}

TrackEndpointMiddleware sets context variables to enable or disable whether Tyk should record analytitcs for a specific path.

func (*TrackEndpointMiddleware) EnabledForSpec 

func (t *TrackEndpointMiddleware) EnabledForSpec() bool

func (*TrackEndpointMiddleware) Name 

func (t *TrackEndpointMiddleware) Name() string

func (*TrackEndpointMiddleware) ProcessRequest 

func (t *TrackEndpointMiddleware) ProcessRequest(w http.ResponseWriter, r *http.Request, _ interface{}) (error, int)

ProcessRequest will run any checks on the request on the way through the system, return an error to have the chain fail

type TransformHeaders 

type TransformHeaders struct {
	BaseMiddleware
}

TransformMiddleware is a middleware that will apply a template to a request body to transform it's contents ready for an upstream API

func (*TransformHeaders) EnabledForSpec 

func (t *TransformHeaders) EnabledForSpec() bool

func (*TransformHeaders) Name 

func (t *TransformHeaders) Name() string

func (*TransformHeaders) ProcessRequest 

func (t *TransformHeaders) ProcessRequest(w http.ResponseWriter, r *http.Request, _ interface{}) (error, int)

ProcessRequest will run any checks on the request on the way through the system, return an error to have the chain fail

type TransformJQMiddleware 

type TransformJQMiddleware struct {
	BaseMiddleware
}

func (*TransformJQMiddleware) EnabledForSpec 

func (t *TransformJQMiddleware) EnabledForSpec() bool

func (*TransformJQMiddleware) Name 

func (t *TransformJQMiddleware) Name() string

func (*TransformJQMiddleware) ProcessRequest 

func (t *TransformJQMiddleware) ProcessRequest(w http.ResponseWriter, r *http.Request, _ interface{}) (error, int)

ProcessRequest will run any checks on the request on the way through the system, return an error to have the chain fail

type TransformJQSpec 

type TransformJQSpec struct {
	apidef.TransformJQMeta
}

type TransformMethod 

type TransformMethod struct {
	BaseMiddleware
}

TransformMiddleware is a middleware that will apply a template to a request body to transform it's contents ready for an upstream API

func (*TransformMethod) EnabledForSpec 

func (t *TransformMethod) EnabledForSpec() bool

func (*TransformMethod) Name 

func (t *TransformMethod) Name() string

func (*TransformMethod) ProcessRequest 

func (t *TransformMethod) ProcessRequest(w http.ResponseWriter, r *http.Request, _ interface{}) (error, int)

ProcessRequest will run any checks on the request on the way through the system, return an error to have the chain fail

type TransformMiddleware 

type TransformMiddleware struct {
	BaseMiddleware
}

TransformMiddleware is a middleware that will apply a template to a request body to transform it's contents ready for an upstream API

func (*TransformMiddleware) EnabledForSpec 

func (t *TransformMiddleware) EnabledForSpec() bool

func (*TransformMiddleware) Name 

func (t *TransformMiddleware) Name() string

func (*TransformMiddleware) ProcessRequest 

func (t *TransformMiddleware) ProcessRequest(w http.ResponseWriter, r *http.Request, _ interface{}) (error, int)

ProcessRequest will run any checks on the request on the way through the system, return an error to have the chain fail

type TransformSpec 

type TransformSpec struct {
	apidef.TemplateMeta
	Template *template.Template
}

type TykJSHttpRequest 

type TykJSHttpRequest struct {
	Method   string
	Body     string
	Headers  map[string]string
	Domain   string
	Resource string
	FormData map[string]string
}

type TykJSHttpResponse 

type TykJSHttpResponse struct {
	Code    int
	Body    string
	Headers map[string][]string

	// Make this compatible with BatchReplyUnit
	CodeComp    int                 `json:"code"`
	BodyComp    string              `json:"body"`
	HeadersComp map[string][]string `json:"headers"`
}

type TykMiddleware 

type TykMiddleware interface {
	Init()
	Base() *BaseMiddleware
	SetName(string)
	SetRequestLogger(*http.Request)
	Logger() *logrus.Entry
	Config() (interface{}, error)
	ProcessRequest(w http.ResponseWriter, r *http.Request, conf interface{}) (error, int) // Handles request
	EnabledForSpec() bool
	Name() string
}

type TykOsinServer 

type TykOsinServer struct {
	osin.Server
	Config            *osin.ServerConfig
	Storage           ExtendedOsinStorageInterface
	AuthorizeTokenGen osin.AuthorizeTokenGen
	AccessTokenGen    osin.AccessTokenGen
}

TykOsinServer subclasses osin.Server so we can add the SetClient method without wrecking the lbrary

func TykOsinNewServer 

func TykOsinNewServer(config *osin.ServerConfig, storage ExtendedOsinStorageInterface) *TykOsinServer

TykOsinNewServer creates a new server instance, but uses an extended interface so we can SetClient() too.

type TykResponseHandler 

type TykResponseHandler interface {
	Init(interface{}, *APISpec) error
	Name() string
	HandleResponse(http.ResponseWriter, *http.Response, *http.Request, *user.SessionState) error
}

type URLRewriteMiddleware 

type URLRewriteMiddleware struct {
	BaseMiddleware
}

URLRewriteMiddleware Will rewrite an inbund URL to a matching outbound one, it can also handle dynamic variable substitution

func (*URLRewriteMiddleware) CheckHostRewrite 

func (m *URLRewriteMiddleware) CheckHostRewrite(oldPath, newTarget string, r *http.Request)

func (*URLRewriteMiddleware) EnabledForSpec 

func (m *URLRewriteMiddleware) EnabledForSpec() bool

func (*URLRewriteMiddleware) InitTriggerRx 

func (m *URLRewriteMiddleware) InitTriggerRx()

func (*URLRewriteMiddleware) Name 

func (m *URLRewriteMiddleware) Name() string

func (*URLRewriteMiddleware) ProcessRequest 

func (m *URLRewriteMiddleware) ProcessRequest(w http.ResponseWriter, r *http.Request, _ interface{}) (error, int)

ProcessRequest will run any checks on the request on the way through the system, return an error to have the chain fail

type URLRewrites 

type URLRewrites struct {
	Path         string   `json:"path"`
	Method       string   `json:"method"`
	MatchPattern string   `json:"match_pattern"`
	RewriteTo    string   `json:"rewrite_to"`
	Triggers     []string `json:"triggers"`
	MatchRegexp  string   `json:"match_regexp"`
}

URLRewrite struct to store URLRewrite

type URLSpec 

type URLSpec struct {
	Spec                      *regexp.Regexp
	Status                    URLStatus
	MethodActions             map[string]apidef.EndpointMethodMeta
	CacheConfig               EndPointCacheMeta
	TransformAction           TransformSpec
	TransformResponseAction   TransformSpec
	TransformJQAction         TransformJQSpec
	TransformJQResponseAction TransformJQSpec
	InjectHeaders             apidef.HeaderInjectionMeta
	InjectHeadersResponse     apidef.HeaderInjectionMeta
	HardTimeout               apidef.HardTimeoutMeta
	CircuitBreaker            ExtendedCircuitBreakerMeta
	URLRewrite                *apidef.URLRewriteMeta
	VirtualPathSpec           apidef.VirtualMeta
	RequestSize               apidef.RequestSizeMeta
	MethodTransform           apidef.MethodTransformMeta
	TrackEndpoint             apidef.TrackEndpointMeta
	DoNotTrackEndpoint        apidef.TrackEndpointMeta
	ValidatePathMeta          apidef.ValidatePathMeta
	Internal                  apidef.InternalMeta
}

URLSpec represents a flattened specification for URLs, used to check if a proxy URL path is on any of the white, black or ignored lists. This is generated as part of the configuration init

type URLStatus 

type URLStatus int

URLStatus is a custom enum type to avoid collisions 

const (
	Ignored URLStatus
	WhiteList
	BlackList
	Cached
	Transformed
	TransformedJQ
	HeaderInjected
	HeaderInjectedResponse
	TransformedResponse
	TransformedJQResponse
	HardTimeout
	CircuitBreaker
	URLRewrite
	VirtualPath
	RequestSizeLimit
	MethodTransformed
	RequestTracked
	RequestNotTracked
	ValidateJSONRequest
	Internal
)

Enums representing the various statuses for a VersionInfo Path match during a proxy request

type UptimeReportData 

type UptimeReportData struct {
	URL          string
	RequestTime  int64
	ResponseCode int
	TCPError     bool
	ServerError  bool
	Day          int
	Month        time.Month
	Year         int
	Hour         int
	Minute       int
	TimeStamp    time.Time
	ExpireAt     time.Time `bson:"expireAt" json:"expireAt"`
	APIID        string
	OrgID        string
}

func (*UptimeReportData) SetExpiry 

func (u *UptimeReportData) SetExpiry(expiresInSeconds int64)

type VMResponseObject 

type VMResponseObject struct {
	Response    ResponseObject
	SessionMeta map[string]string
}

type VMReturnObject 

type VMReturnObject struct {
	Request     MiniRequestObject
	SessionMeta map[string]string
	Session     user.SessionState
	AuthValue   string
}

type ValidateJSON 

type ValidateJSON struct {
	BaseMiddleware
}

func (*ValidateJSON) EnabledForSpec 

func (k *ValidateJSON) EnabledForSpec() bool

func (*ValidateJSON) Name 

func (k *ValidateJSON) Name() string

func (*ValidateJSON) ProcessRequest 

func (k *ValidateJSON) ProcessRequest(w http.ResponseWriter, r *http.Request, _ interface{}) (error, int)

ProcessRequest will run any checks on the request on the way through the system, return an error to have the chain fail

type ValueExtractor 

type ValueExtractor struct {
	BaseExtractor
	// contains filtered or unexported fields
}

func (*ValueExtractor) Extract 

func (e *ValueExtractor) Extract(input interface{}) string

func (*ValueExtractor) ExtractAndCheck 

func (e *ValueExtractor) ExtractAndCheck(r *http.Request) (sessionID string, returnOverrides ReturnOverrides)

type ValueExtractorConfig 

type ValueExtractorConfig struct {
	HeaderName    string `mapstructure:"header_name" bson:"header_name" json:"header_name"`
	FormParamName string `mapstructure:"param_name" bson:"param_name" json:"param_name"`
}

type VersionCheck 

type VersionCheck struct {
	BaseMiddleware
	// contains filtered or unexported fields
}

VersionCheck will check whether the version of the requested API the request is accessing has any restrictions on URL endpoints

func (*VersionCheck) DoMockReply 

func (v *VersionCheck) DoMockReply(w http.ResponseWriter, meta interface{})

func (*VersionCheck) Init 

func (v *VersionCheck) Init()

func (*VersionCheck) Name 

func (v *VersionCheck) Name() string

func (*VersionCheck) ProcessRequest 

func (v *VersionCheck) ProcessRequest(w http.ResponseWriter, r *http.Request, _ interface{}) (error, int)

ProcessRequest will run any checks on the request on the way through the system, return an error to have the chain fail

type VirtualEndpoint 

type VirtualEndpoint struct {
	BaseMiddleware
	// contains filtered or unexported fields
}

DynamicMiddleware is a generic middleware that will execute JS code before continuing

func (*VirtualEndpoint) EnabledForSpec 

func (d *VirtualEndpoint) EnabledForSpec() bool

func (*VirtualEndpoint) HandleResponse 

func (d *VirtualEndpoint) HandleResponse(rw http.ResponseWriter, res *http.Response, ses *user.SessionState)

func (*VirtualEndpoint) Init 

func (d *VirtualEndpoint) Init()

func (*VirtualEndpoint) Name 

func (d *VirtualEndpoint) Name() string

func (*VirtualEndpoint) ProcessRequest 

func (d *VirtualEndpoint) ProcessRequest(w http.ResponseWriter, r *http.Request, _ interface{}) (error, int)

ProcessRequest will run any checks on the request on the way through the system, return an error to have the chain fail

func (*VirtualEndpoint) ServeHTTPForCache 

func (d *VirtualEndpoint) ServeHTTPForCache(w http.ResponseWriter, r *http.Request, vmeta *apidef.VirtualMeta) *http.Response

type WSDialer 

type WSDialer struct {
	*http.Transport
	RW        http.ResponseWriter
	TLSConfig *tls.Config
}

func (*WSDialer) RoundTrip 

func (ws *WSDialer) RoundTrip(req *http.Request) (*http.Response, error)

type WebHookHandler 

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

WebHookHandler is an event handler that triggers web hooks

func (*WebHookHandler) BuildRequest 

func (w *WebHookHandler) BuildRequest(reqBody string) (*http.Request, error)

func (*WebHookHandler) Checksum 

func (w *WebHookHandler) Checksum(reqBody string) (string, error)

func (*WebHookHandler) CreateBody 

func (w *WebHookHandler) CreateBody(em config.EventMessage) (string, error)

func (*WebHookHandler) HandleEvent 

func (w *WebHookHandler) HandleEvent(em config.EventMessage)

HandleEvent will be fired when the event handler instance is found in an APISpec EventPaths object during a request chain

func (*WebHookHandler) Init 

func (w *WebHookHandler) Init(handlerConf interface{}) error

Init enables the init of event handler instances when they are created on ApiSpec creation

func (*WebHookHandler) WasHookFired 

func (w *WebHookHandler) WasHookFired(checksum string) bool

hookFired checks if an event has been fired within the EventTimeout setting

type WebHookRequestMethod 

type WebHookRequestMethod string
const (
	WH_GET    WebHookRequestMethod = "GET"
	WH_PUT    WebHookRequestMethod = "PUT"
	WH_POST   WebHookRequestMethod = "POST"
	WH_DELETE WebHookRequestMethod = "DELETE"
	WH_PATCH  WebHookRequestMethod = "PATCH"

	// Define the Event Handler name so we can register it
	EH_WebHook apidef.TykEventHandlerName = "eh_web_hook_handler"
)

type XPathExtractor 

type XPathExtractor struct {
	BaseExtractor
	// contains filtered or unexported fields
}

func (*XPathExtractor) ExtractAndCheck 

func (e *XPathExtractor) ExtractAndCheck(r *http.Request) (SessionID string, returnOverrides ReturnOverrides)

type XPathExtractorConfig 

type XPathExtractorConfig struct {
	HeaderName      string `mapstructure:"header_name" bson:"header_name" json:"header_name"`
	RegexExpression string `mapstructure:"regex_expression" bson:"regex_expression" json:"regex_expression"`
	RegexMatchIndex int    `mapstructure:"regex_match_index" bson:"regex_match_index" json:"regex_match_index"`
	FormParamName   string `mapstructure:"param_name" bson:"param_name" json:"param_name"`
}

type ZipBundleSaver 

type ZipBundleSaver struct{}

ZipBundleSaver is a BundleSaver for ZIP files.

func (ZipBundleSaver) Save 

func (ZipBundleSaver) Save(bundle *Bundle, bundlePath string, spec *APISpec) error

Save implements the main method of the BundleSaver interface. It makes use of archive/zip.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.